@tangle-network/traces 0.9.18 → 0.9.19

package/dist/{chunk-F2OEMHVZ.js → chunk-WCJVRJD5.js}

@@ -165,11 +165,11 @@ function serializeSpans(spans) {
 `;
 }
 async function writeOtlpFile(spans, outPath) {
-  const { mkdtemp: mkdtemp7, writeFile: writeFile8 } = await import("fs/promises");
+  const { mkdtemp: mkdtemp8, writeFile: writeFile9 } = await import("fs/promises");
   const { tmpdir: tmpdir7 } = await import("os");
-  const { join: join22 } = await import("path");
-  const path = outPath ?? join22(await mkdtemp7(join22(tmpdir7(), "traces-")), "spans.otlp.jsonl");
-  await writeFile8(path, serializeSpans(spans), "utf8");
+  const { join: join25 } = await import("path");
+  const path = outPath ?? join25(await mkdtemp8(join25(tmpdir7(), "traces-")), "spans.otlp.jsonl");
+  await writeFile9(path, serializeSpans(spans), "utf8");
   return path;
 }
 
@@ -291,6 +291,855 @@ function stampSessionIdentity(spans, fallbackSessionId) {
   }
 }
 
+// src/chat-trajectory.ts
+import { createHash } from "crypto";
+function isChatTrajectoryMessage(value) {
+  return isObject(value) && typeof value.role === "string" && typeof value.content === "string";
+}
+function isChatTrajectory(value) {
+  return isObject(value) && Array.isArray(value.messages) && value.messages.length > 0 && value.messages.every(isChatTrajectoryMessage);
+}
+function chatTrajectoryToSpans(input, options = {}) {
+  const trajectory = Array.isArray(input) ? { messages: input } : input;
+  if (trajectory.messages.length === 0) throw new Error("chat trajectory contains no messages");
+  if (!trajectory.messages.every(isChatTrajectoryMessage)) {
+    throw new TypeError("chat trajectory messages require string role and content fields");
+  }
+  const traceId = options.traceId ?? trajectoryId(trajectory);
+  const service = options.service ?? trajectory.trajectory_format ?? "chat-trajectory";
+  const stepMode = options.stepMode ?? "assistant";
+  const times = messageTimes(trajectory.messages);
+  const actionCount = trajectory.messages.filter((message) => messageKind(message.role) === "LLM").length;
+  const root = span({
+    traceId,
+    spanId: "root",
+    name: "trajectory",
+    kind: "AGENT",
+    startTime: times[0],
+    endTime: times.at(-1),
+    service,
+    costUsd: finiteNumber(trajectory.info?.model_stats, "instance_cost"),
+    extra: compactAttributes({
+      "traces.source_format": "chat-trajectory",
+      "trajectory.format": trajectory.trajectory_format,
+      "trajectory.message_count": trajectory.messages.length,
+      "trajectory.action_count": actionCount,
+      "trajectory.source_path": options.sourcePath,
+      "trajectory.api_calls": finiteNumber(trajectory.info?.model_stats, "api_calls"),
+      "trajectory.timestamps_synthetic": trajectory.messages.some(
+        (message) => message.timestamp === void 0
+      )
+    })
+  });
+  const spans = [root];
+  let assistantStep = 0;
+  for (const [index, message] of trajectory.messages.entries()) {
+    const kind = messageKind(message.role);
+    if (kind === "LLM") assistantStep += 1;
+    const step = stepMode === "message" ? index + 1 : kind === "LLM" ? assistantStep : void 0;
+    const spanId = step === void 0 ? `message-${index + 1}` : `step-${step}`;
+    const response = isObject(message.extra?.response) ? message.extra.response : void 0;
+    const usage = isObject(response?.usage) ? response.usage : void 0;
+    const completionDetails = isObject(usage?.completion_tokens_details) ? usage.completion_tokens_details : void 0;
+    const promptDetails = isObject(usage?.prompt_tokens_details) ? usage.prompt_tokens_details : void 0;
+    spans.push(
+      span({
+        traceId,
+        spanId,
+        parentSpanId: "root",
+        name: messageName(kind, message),
+        kind,
+        startTime: times[index],
+        service,
+        agent: messageAgent(message.role),
+        model: stringValue(response?.model),
+        inputTokens: finiteNumber(usage, "prompt_tokens"),
+        outputTokens: finiteNumber(usage, "completion_tokens"),
+        reasoningTokens: finiteNumber(completionDetails, "reasoning_tokens"),
+        cachedInputTokens: finiteNumber(promptDetails, "cached_tokens"),
+        step,
+        content: capText(message.content),
+        extra: compactAttributes({
+          "traces.source_format": "chat-trajectory",
+          "trajectory.message_index": index + 1,
+          "trajectory.action_index": kind === "LLM" ? assistantStep : void 0,
+          "trajectory.role": message.role
+        })
+      })
+    );
+  }
+  return validateOtlpSpans(spans, "chat trajectory output");
+}
+function trajectoryId(trajectory) {
+  const value = trajectory.trajectory_id ?? trajectory.traj_id ?? trajectory.instance_id;
+  if (typeof value === "string" && value.trim()) return value;
+  if (typeof value === "number" && Number.isSafeInteger(value)) return String(value);
+  return `trajectory-${createHash("sha256").update(JSON.stringify(trajectory.messages)).digest("hex").slice(0, 24)}`;
+}
+function messageKind(role) {
+  const normalized = role.trim().toLowerCase();
+  if (normalized === "assistant" || normalized === "agent") return "LLM";
+  if (normalized === "tool" || normalized === "function" || normalized === "observation") {
+    return "TOOL";
+  }
+  return "CHAIN";
+}
+function messageName(kind, message) {
+  if (kind === "LLM") return "message.assistant";
+  if (kind === "TOOL") return `tool.${message.name?.trim() || "result"}`;
+  const role = message.role.trim().toLowerCase();
+  if (role === "system") return "system.prompt";
+  if (role === "user" || role === "human") return "user.prompt";
+  return "message.other";
+}
+function messageAgent(role) {
+  const normalized = role.trim().toLowerCase();
+  return ["system", "user", "human", "tool", "function", "observation"].includes(normalized) ? void 0 : role.trim();
+}
+function messageTimes(messages) {
+  const supplied = messages.filter((message) => message.timestamp !== void 0).length;
+  if (supplied === 0) return messages.map((_, index) => new Date(index).toISOString());
+  if (supplied !== messages.length) {
+    throw new TypeError("chat trajectory timestamps must be present on every message or none");
+  }
+  const times = messages.map((message, index) => messageTime(message.timestamp, index));
+  for (let index = 1; index < times.length; index += 1) {
+    if (Date.parse(times[index]) < Date.parse(times[index - 1])) {
+      throw new RangeError(
+        `chat trajectory message ${index + 1} timestamp precedes message ${index}`
+      );
+    }
+  }
+  return times;
+}
+function messageTime(value, index) {
+  const parsed = parseTime(value);
+  if (!parsed) {
+    throw new TypeError(`chat trajectory message ${index + 1} has an invalid timestamp`);
+  }
+  return parsed;
+}
+function parseTime(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const millis2 = value < 1e10 ? value * 1e3 : value;
+    const date = new Date(millis2);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+  }
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const millis = Date.parse(value);
+  return Number.isFinite(millis) ? new Date(millis).toISOString() : void 0;
+}
+function finiteNumber(value, key) {
+  if (!isObject(value)) return void 0;
+  const number = value[key];
+  return typeof number === "number" && Number.isFinite(number) ? number : void 0;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function compactAttributes(values) {
+  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/codetracebench.ts
+import {
+  mkdir as mkdir2,
+  mkdtemp,
+  readFile as readFile3,
+  rm as rm2
+} from "fs/promises";
+import { basename as basename2, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+
+// src/codetracebench-files.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import {
+  link,
+  lstat,
+  mkdir,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  rmdir,
+  stat,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { hostname } from "os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
+async function claimImportLock(input) {
+  const claimId = randomUUID();
+  const path = `${input.outputDirectory}.lock`;
+  const temporary = join(
+    dirname(path),
+    `.${basename(path)}.${claimId}.tmp`
+  );
+  const metadata = {
+    kind: "traces.codetracebench-import-lock",
+    claimId,
+    pid: process.pid,
+    hostname: hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    revision: input.revision,
+    rowsPath: input.rowsPath,
+    trajectoryDirectory: input.trajectoryDirectory,
+    outputDirectory: input.outputDirectory
+  };
+  try {
+    await writeFile(temporary, `${JSON.stringify(metadata, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384,
+      signal: input.signal
+    });
+    input.signal?.throwIfAborted();
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
+  }
+  try {
+    await link(temporary, path);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    if (isErrno(error, "EEXIST")) {
+      throw await importLockConflictError(path, input.outputDirectory);
+    }
+    throw error;
+  }
+  try {
+    await rm(temporary, { force: true });
+  } catch (error) {
+    await unlink(path);
+    throw error;
+  }
+  return { path, claimId };
+}
+async function importLockConflictError(path, outputDirectory) {
+  let owner = "owner metadata is unreadable";
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (isObject2(parsed) && typeof parsed.pid === "number" && typeof parsed.hostname === "string" && typeof parsed.startedAt === "string" && typeof parsed.revision === "string") {
+      owner = `PID ${parsed.pid} on ${parsed.hostname}, started ${parsed.startedAt}, revision ${parsed.revision}`;
+    }
+  } catch {
+  }
+  return new Error(
+    `CodeTraceBench import already in progress for ${outputDirectory}. Lock: ${path}. Owner: ${owner}. Wait for it to finish, or remove the lock only after confirming that process is no longer running.`
+  );
+}
+async function releaseImportLock(lock) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(lock.path, "utf8"));
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return;
+    throw new Error(`Could not read CodeTraceBench import lock: ${lock.path}`, {
+      cause: error
+    });
+  }
+  if (!isObject2(parsed) || parsed.claimId !== lock.claimId) {
+    throw new Error(
+      `CodeTraceBench import lock owner changed; refusing to remove ${lock.path}`
+    );
+  }
+  await unlink(lock.path);
+}
+async function publishStagedFiles(stagingDirectory, outputDirectory, files, signal) {
+  signal.throwIfAborted();
+  try {
+    await mkdir(outputDirectory);
+  } catch (error) {
+    if (isErrno(error, "EEXIST")) {
+      throw new Error(
+        `CodeTraceBench output directory appeared while import was running; refusing to replace it: ${outputDirectory}`
+      );
+    }
+    throw error;
+  }
+  const published = [];
+  try {
+    for (const file of files) {
+      signal.throwIfAborted();
+      const destination = join(outputDirectory, file);
+      await link(join(stagingDirectory, file), destination);
+      published.push(destination);
+    }
+  } catch (error) {
+    for (const path of published.reverse()) {
+      await rm(path, { force: true });
+    }
+    try {
+      await rmdir(outputDirectory);
+    } catch (cleanupError) {
+      if (!isErrno(cleanupError, "ENOENT") && !isErrno(cleanupError, "ENOTEMPTY")) {
+        throw new AggregateError(
+          [error, cleanupError],
+          `CodeTraceBench import failed and could not clean ${outputDirectory}`
+        );
+      }
+    }
+    throw error;
+  }
+}
+async function containedDirectory(path) {
+  const resolved = resolve(path);
+  let canonical;
+  try {
+    canonical = await realpath(resolved);
+  } catch (error) {
+    throw new Error(`CodeTraceBench trajectory directory is unavailable: ${resolved}`, {
+      cause: error
+    });
+  }
+  const info = await stat(canonical);
+  if (!info.isDirectory()) {
+    throw new TypeError(`CodeTraceBench trajectory path is not a directory: ${canonical}`);
+  }
+  return canonical;
+}
+async function containedFile(root, candidate, label) {
+  const path = await optionalContainedFile(root, candidate);
+  if (!path) throw new Error(`${label} is missing`);
+  return path;
+}
+async function optionalContainedFile(root, candidate) {
+  let canonical;
+  try {
+    canonical = await realpath(candidate);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return void 0;
+    throw error;
+  }
+  const fromRoot = relative(root, canonical);
+  if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+    throw new Error(`CodeTraceBench trajectory file escapes its input directory: ${candidate}`);
+  }
+  const info = await stat(canonical);
+  if (!info.isFile()) {
+    throw new TypeError(`CodeTraceBench trajectory path is not a file: ${candidate}`);
+  }
+  return canonical;
+}
+async function assertPathMissing(path) {
+  try {
+    await lstat(path);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return;
+    throw error;
+  }
+  throw new Error(`CodeTraceBench output directory already exists: ${path}`);
+}
+async function atomicWriteFile(path, content, signal) {
+  signal.throwIfAborted();
+  const temporary = join(
+    dirname(path),
+    `.${basename(path)}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(temporary, content, {
+      encoding: "utf8",
+      flag: "wx",
+      signal
+    });
+    signal.throwIfAborted();
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function isObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isErrno(error, code) {
+  return isObject2(error) && error.code === code;
+}
+
+// src/codetracebench-trajectory.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var TRAJECTORY_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,254}$/;
+var LABEL_KEY = /\\?["'](?:incorrect_stages|incorrect_step_ids|unuseful_step_ids|annotation_relpath|incorrect_error_stage_count)\\?["']\s*:/i;
+var LABEL_ARRAY = /\\?["']labels\\?["']\s*:\s*\[[^\]]*\\?["'](?:incorrect|unuseful)\\?["']/i;
+var ANNOTATION_PATH = /(?:agent_failure_analysis|step_annotations(?:_all)?|merged_cleaned_step\d*)[\\/]/i;
+async function importTrajectory(input) {
+  const { index, row, trajectoryDirectory, stagingDirectory, signal } = input;
+  const caseDirectory = join2(trajectoryDirectory, row.trajId);
+  const stepsPath = await containedFile(
+    trajectoryDirectory,
+    join2(caseDirectory, "steps.json"),
+    `${row.trajId}: steps.json`
+  );
+  signal.throwIfAborted();
+  const stepsBytes = await readFile2(stepsPath, { signal });
+  const steps = parseSteps(stepsBytes.toString("utf8"), row);
+  const task = await readOptionalTask(trajectoryDirectory, caseDirectory, row, signal);
+  const messages = trajectoryMessages(row, steps, task.content);
+  const spans = chatTrajectoryToSpans(messages, {
+    traceId: row.trajId,
+    service: "codetracebench",
+    sourcePath: `${row.trajId}/steps.json`
+  }).map((item) => ({
+    ...item,
+    attributes: {
+      ...item.attributes,
+      "benchmark.name": "CodeTraceBench",
+      "trajectory.id": row.trajId,
+      ...item.attributes["openinference.span.kind"] === "LLM" ? { "agent.name": row.agent } : {}
+    }
+  }));
+  const actionSpans = spans.filter(
+    (item) => item.attributes["openinference.span.kind"] === "LLM"
+  );
+  if (actionSpans.length !== row.stepCount) {
+    throw new Error(
+      `${row.trajId}: generated ${actionSpans.length} action spans for ${row.stepCount} steps`
+    );
+  }
+  for (const [stepIndex, item] of actionSpans.entries()) {
+    const expectedSpanId = `step-${stepIndex + 1}`;
+    if (item.span_id !== expectedSpanId) {
+      throw new Error(
+        `${row.trajId}: generated action span '${item.span_id}', expected '${expectedSpanId}'`
+      );
+    }
+  }
+  assertNoLabelLeak(spans, row);
+  const serialized = serializeSpans(spans);
+  assertNoLabelLeakInText(serialized, row, `${row.trajId}: serialized OTLP`);
+  const outputFile = `${row.trajId}.otlp.jsonl`;
+  await atomicWriteFile(join2(stagingDirectory, outputFile), serialized, signal);
+  return {
+    index,
+    traceId: row.trajId,
+    stepCount: row.stepCount,
+    spanCount: spans.length,
+    taskSource: task.source,
+    input: {
+      stepsPath: `${row.trajId}/steps.json`,
+      stepsSha256: sha256(stepsBytes),
+      stepsBytes: stepsBytes.byteLength,
+      ...task.path ? {
+        taskPath: `${row.trajId}/task.md`,
+        taskSha256: sha256(task.bytes),
+        taskBytes: task.bytes.byteLength
+      } : {}
+    },
+    output: {
+      path: outputFile,
+      sha256: sha256(serialized),
+      bytes: Buffer.byteLength(serialized)
+    }
+  };
+}
+function trajectoryMessages(row, steps, task) {
+  return [
+    { role: "user", content: task },
+    ...steps.flatMap((step) => {
+      const action = {
+        role: "assistant",
+        content: [step.thinking, step.action].filter(
+          (value) => typeof value === "string" && value.length > 0
+        ).join("\n"),
+        extra: { response: { model: row.model } }
+      };
+      if (step.observation === null) return [action];
+      return [
+        action,
+        {
+          role: "observation",
+          content: step.observation,
+          ...step.tool_type ? { name: step.tool_type } : {}
+        }
+      ];
+    })
+  ];
+}
+function parseRows(text2, path) {
+  const trimmed = text2.trim();
+  if (!trimmed) throw new Error(`CodeTraceBench rows file is empty: ${path}`);
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return parsed;
+    if (isObject2(parsed)) return [parsed];
+    throw new TypeError("JSON must be an object or array");
+  } catch (error) {
+    if (!/\r?\n/.test(trimmed)) {
+      throw new Error(`${path}: invalid JSON: ${errorMessage(error)}`);
+    }
+  }
+  return trimmed.split(/\r?\n/).flatMap((line, index) => {
+    if (!line.trim()) return [];
+    try {
+      return [JSON.parse(line)];
+    } catch (error) {
+      throw new Error(`${path}:${index + 1}: invalid JSON: ${errorMessage(error)}`);
+    }
+  });
+}
+function validateRows(rows, path) {
+  if (rows.length === 0) throw new Error(`CodeTraceBench rows file is empty: ${path}`);
+  const ids = /* @__PURE__ */ new Set();
+  return rows.map((value, index) => {
+    if (!isObject2(value)) {
+      throw new TypeError(`${path}:${index + 1}: CodeTraceBench row must be an object`);
+    }
+    const trajId = requiredString(value.traj_id, `${path}:${index + 1} traj_id`);
+    if (!TRAJECTORY_ID.test(trajId)) {
+      throw new TypeError(
+        `${path}:${index + 1}: traj_id must contain only letters, digits, dot, underscore, or hyphen`
+      );
+    }
+    if (ids.has(trajId)) {
+      throw new TypeError(`${path}:${index + 1}: duplicate traj_id '${trajId}'`);
+    }
+    ids.add(trajId);
+    const stepCount = positiveInteger(
+      value.step_count,
+      `${path}:${index + 1} step_count`
+    );
+    const annotationRelpath = value.annotation_relpath === void 0 || value.annotation_relpath === null ? void 0 : requiredString(
+      value.annotation_relpath,
+      `${path}:${index + 1} annotation_relpath`
+    );
+    return {
+      trajId,
+      agent: requiredString(value.agent, `${path}:${index + 1} agent`),
+      model: requiredString(value.model, `${path}:${index + 1} model`),
+      taskName: requiredString(value.task_name, `${path}:${index + 1} task_name`),
+      stepCount,
+      ...annotationRelpath ? { annotationRelpath } : {},
+      ...value.incorrect_stages === void 0 ? {} : { incorrectStages: value.incorrect_stages }
+    };
+  });
+}
+function parseSteps(text2, row) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch (error) {
+    throw new Error(`${row.trajId}/steps.json: invalid JSON: ${errorMessage(error)}`);
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new TypeError(`${row.trajId}/steps.json must contain a non-empty array`);
+  }
+  if (parsed.length !== row.stepCount) {
+    throw new Error(
+      `${row.trajId}: steps.json contains ${parsed.length} steps, row declares ${row.stepCount}`
+    );
+  }
+  return parsed.map((value, index) => {
+    const label = `${row.trajId}/steps.json[${index}]`;
+    if (!isObject2(value)) throw new TypeError(`${label} must be an object`);
+    const stepId = positiveInteger(value.step_id, `${label}.step_id`);
+    if (stepId !== index + 1) {
+      throw new Error(`${label}.step_id is ${stepId}; expected ${index + 1}`);
+    }
+    if (!Object.hasOwn(value, "observation")) {
+      throw new TypeError(`${label}.observation is required and may be null`);
+    }
+    const observation = value.observation;
+    if (observation !== null && typeof observation !== "string") {
+      throw new TypeError(`${label}.observation must be a string or null`);
+    }
+    return {
+      step_id: stepId,
+      action: requiredString(value.action, `${label}.action`),
+      observation,
+      ...value.thinking === void 0 ? {} : { thinking: requiredString(value.thinking, `${label}.thinking`) },
+      ...value.parallel_group === void 0 ? {} : {
+        parallel_group: nonNegativeInteger(
+          value.parallel_group,
+          `${label}.parallel_group`
+        )
+      },
+      ...value.tool_type === void 0 ? {} : { tool_type: requiredString(value.tool_type, `${label}.tool_type`) },
+      action_ref: fileRef(value.action_ref, `${label}.action_ref`),
+      observation_ref: fileRef(value.observation_ref, `${label}.observation_ref`)
+    };
+  });
+}
+function fileRef(value, label) {
+  if (value === null) return null;
+  if (!isObject2(value)) throw new TypeError(`${label} must be an object or null`);
+  const lineStart = positiveInteger(value.line_start, `${label}.line_start`);
+  const lineEnd = positiveInteger(value.line_end, `${label}.line_end`);
+  if (lineEnd < lineStart) {
+    throw new RangeError(`${label}.line_end must not precede line_start`);
+  }
+  return {
+    path: requiredString(value.path, `${label}.path`),
+    line_start: lineStart,
+    line_end: lineEnd,
+    content: stringField(value.content, `${label}.content`)
+  };
+}
+async function readOptionalTask(trajectoryDirectory, caseDirectory, row, signal) {
+  const candidate = join2(caseDirectory, "task.md");
+  const path = await optionalContainedFile(trajectoryDirectory, candidate);
+  if (!path) {
+    return {
+      source: "task_name",
+      content: `Task: ${row.taskName}`
+    };
+  }
+  const bytes = await readFile2(path, { signal });
+  const content = bytes.toString("utf8").trim();
+  if (!content) throw new Error(`${row.trajId}/task.md is empty`);
+  return { source: "task.md", content, path, bytes };
+}
+function assertNoLabelLeak(spans, row) {
+  for (const item of spans) {
+    const content = item.attributes.content;
+    if (typeof content === "string") {
+      assertNoLabelLeakInText(content, row, `${row.trajId}/${item.span_id} content`);
+    }
+  }
+}
+function assertNoLabelLeakInText(text2, row, context) {
+  if (LABEL_KEY.test(text2) || LABEL_ARRAY.test(text2) || ANNOTATION_PATH.test(text2)) {
+    throw new Error(`${context}: generated trace contains CodeTraceBench annotation data`);
+  }
+  const annotationPath = row.annotationRelpath?.replaceAll("\\", "/").toLowerCase();
+  if (annotationPath && text2.replaceAll("\\", "/").toLowerCase().includes(annotationPath)) {
+    throw new Error(`${context}: generated trace contains annotation path`);
+  }
+  const labels = normalizedLabels(row.incorrectStages);
+  if (labels && compact(text2).includes(labels)) {
+    throw new Error(`${context}: generated trace contains serialized CodeTraceBench labels`);
+  }
+}
+function normalizedLabels(value) {
+  if (value === void 0 || value === null) return void 0;
+  let parsed = value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "[]") return void 0;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      parsed = trimmed;
+    }
+  }
+  const serialized = JSON.stringify(parsed);
+  if (!serialized || serialized === "[]" || serialized === '""') return void 0;
+  return compact(serialized);
+}
+function compact(value) {
+  return value.replace(/\s+/g, "");
+}
+function positiveInteger(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError(`${label} must be a positive integer`);
+  }
+  return value;
+}
+function nonNegativeInteger(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${label} must be a non-negative integer`);
+  }
+  return value;
+}
+function requiredString(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function stringField(value, label) {
+  if (typeof value !== "string") throw new TypeError(`${label} must be a string`);
+  return value;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/codetracebench.ts
+var DEFAULT_CONCURRENCY = 4;
+var MAX_CONCURRENCY = 64;
+var IMMUTABLE_REVISION = /^(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})$/;
+async function importCodeTraceBench(options) {
+  const concurrency = validateConcurrency(options.concurrency ?? DEFAULT_CONCURRENCY);
+  const revision = validateRevision(options.revision);
+  const rowsPath = resolve2(options.rowsPath);
+  const trajectoryPath = resolve2(options.trajectoryDir);
+  const outputDirectory = resolve2(options.outDir);
+  const outputBase = basename2(outputDirectory);
+  if (!outputBase || outputDirectory === dirname2(outputDirectory)) {
+    throw new Error("CodeTraceBench output directory must not be a filesystem root");
+  }
+  options.signal?.throwIfAborted();
+  await mkdir2(dirname2(outputDirectory), { recursive: true });
+  const lock = await claimImportLock({
+    rowsPath,
+    trajectoryDirectory: trajectoryPath,
+    outputDirectory,
+    revision,
+    signal: options.signal
+  });
+  try {
+    return await runCodeTraceBenchImport({
+      concurrency,
+      revision,
+      rowsPath,
+      trajectoryPath,
+      outputDirectory,
+      outputBase,
+      signal: options.signal
+    });
+  } finally {
+    await releaseImportLock(lock);
+  }
+}
+async function runCodeTraceBenchImport(input) {
+  const {
+    concurrency,
+    revision,
+    rowsPath,
+    trajectoryPath,
+    outputDirectory,
+    outputBase,
+    signal: outerSignal
+  } = input;
+  outerSignal?.throwIfAborted();
+  await assertPathMissing(outputDirectory);
+  const trajectoryDirectory = await containedDirectory(trajectoryPath);
+  const rowsBytes = await readFile3(rowsPath, { signal: outerSignal });
+  const rows = parseRows(rowsBytes.toString("utf8"), rowsPath);
+  const sourceRows = validateRows(rows, rowsPath);
+  const stagingDirectory = await mkdtemp(
+    join3(dirname2(outputDirectory), `.${outputBase}.tmp-`)
+  );
+  const stop = new AbortController();
+  const signal = outerSignal ? AbortSignal.any([outerSignal, stop.signal]) : stop.signal;
+  const imported = new Array(sourceRows.length);
+  let nextIndex = 0;
+  try {
+    const workerCount = Math.min(concurrency, sourceRows.length);
+    const workerResults = await Promise.allSettled(
+      Array.from({ length: workerCount }, async () => {
+        while (true) {
+          signal.throwIfAborted();
+          const index = nextIndex;
+          nextIndex += 1;
+          if (index >= sourceRows.length) return;
+          try {
+            imported[index] = await importTrajectory({
+              index,
+              row: sourceRows[index],
+              trajectoryDirectory,
+              stagingDirectory,
+              signal
+            });
+          } catch (error) {
+            stop.abort(error);
+            throw error;
+          }
+        }
+      })
+    );
+    const workerFailure = workerResults.find(
+      (result) => result.status === "rejected"
+    );
+    if (workerFailure) throw workerFailure.reason;
+    signal.throwIfAborted();
+    const rowsSha256 = sha256(rowsBytes);
+    const inputSha256 = sha256(
+      JSON.stringify({
+        revision,
+        rowsSha256,
+        traces: imported.map((item) => ({
+          traceId: item.traceId,
+          stepsSha256: item.input.stepsSha256,
+          taskSha256: item.input.taskSha256 ?? null
+        }))
+      })
+    );
+    const outputSha256 = sha256(
+      JSON.stringify(
+        imported.map((item) => ({
+          traceId: item.traceId,
+          sha256: item.output.sha256
+        }))
+      )
+    );
+    const receipt = {
+      kind: "traces.codetracebench-import",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      input: {
+        revision,
+        rowsFile: basename2(rowsPath),
+        rowsSha256,
+        rowsBytes: rowsBytes.byteLength,
+        trajectoryDirectory: basename2(trajectoryDirectory),
+        sha256: inputSha256
+      },
+      settings: {
+        concurrency,
+        outputLayout: "<traj_id>.otlp.jsonl"
+      },
+      counts: {
+        rows: sourceRows.length,
+        traces: imported.length,
+        steps: imported.reduce((sum, item) => sum + item.stepCount, 0),
+        spans: imported.reduce((sum, item) => sum + item.spanCount, 0)
+      },
+      safety: {
+        labelLeakScan: "passed",
+        outputDirectoryCreatedExclusively: true,
+        filesPublishedAtomically: true
+      },
+      traces: imported,
+      outputSha256
+    };
+    const receiptFile = "codetracebench-import.json";
+    await atomicWriteFile(
+      join3(stagingDirectory, receiptFile),
+      `${JSON.stringify(receipt, null, 2)}
+`,
+      signal
+    );
+    signal.throwIfAborted();
+    await publishStagedFiles(
+      stagingDirectory,
+      outputDirectory,
+      [...imported.map((item) => item.output.path), receiptFile],
+      signal
+    );
+    await rm2(stagingDirectory, { recursive: true, force: true });
+    return {
+      directory: outputDirectory,
+      receiptPath: join3(outputDirectory, receiptFile),
+      receipt
+    };
+  } catch (error) {
+    await rm2(stagingDirectory, { recursive: true, force: true });
+    throw error;
+  }
+}
+function validateConcurrency(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_CONCURRENCY) {
+    throw new RangeError(
+      `CodeTraceBench concurrency must be an integer from 1 to ${MAX_CONCURRENCY}`
+    );
+  }
+  return value;
+}
+function validateRevision(value) {
+  if (typeof value !== "string" || !IMMUTABLE_REVISION.test(value)) {
+    throw new TypeError(
+      "CodeTraceBench revision must be a full 40- or 64-character hexadecimal commit or digest"
+    );
+  }
+  return value;
+}
+
 // src/execution.ts
 import {
   summarizeExecution
@@ -324,7 +1173,7 @@ function summarizeSpanExecution(spans, opts = {}) {
 import { InMemoryTraceStore } from "@tangle-network/agent-eval";
 
 // src/adapters/tool-io.ts
-import { createHash } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var TOOL_IO_VALUE_MAX_BYTES = 16 * 1024;
 var TOOL_IO_VALUE_KEYS = ["input.value", "output.value"];
 var TOOL_IO_SIDES = ["input", "output"];
@@ -380,14 +1229,14 @@ function valueAttributes(side, raw) {
   const serialized = serialize(raw);
   if (!serialized) return {};
   const bytes = Buffer.byteLength(serialized.value);
-  const sha256 = createHash("sha256").update(serialized.value).digest("hex");
+  const sha2562 = createHash3("sha256").update(serialized.value).digest("hex");
   const truncated = bytes > TOOL_IO_VALUE_MAX_BYTES;
   const value = truncated ? truncatedValue(serialized.value, bytes) : serialized.value;
   return {
     [`${side}.value`]: value,
     [`${side}.mime_type`]: serialized.mimeType,
     [`traces.${side}.bytes`]: bytes,
-    [`traces.${side}.sha256`]: sha256,
+    [`traces.${side}.sha256`]: sha2562,
     [`traces.${side}.truncated`]: truncated
   };
 }
@@ -431,7 +1280,7 @@ function normalizeToolIoAttributes(attributes) {
     }
     attributes[valueKey] = value;
     attributes[bytesKey] = Buffer.byteLength(value);
-    attributes[digestKey] = createHash("sha256").update(value).digest("hex");
+    attributes[digestKey] = createHash3("sha256").update(value).digest("hex");
     attributes[truncatedKey] = truncated;
   }
 }
@@ -529,7 +1378,7 @@ async function runPipelines(spans, opts = {}) {
 }
 
 // src/integrity.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var receiptStates = /* @__PURE__ */ new WeakMap();
 function receiptIdentity(receipt) {
   return [
@@ -588,7 +1437,7 @@ function sessionIntegrityAttributes(ref) {
   };
 }
 function corruptionDigest(receipts) {
-  const hash2 = createHash2("sha256");
+  const hash2 = createHash4("sha256");
   for (const receipt of receipts) {
     hash2.update(JSON.stringify(receiptIdentity(receipt)));
     hash2.update("\n");
@@ -596,7 +1445,7 @@ function corruptionDigest(receipts) {
   return `sha256:${hash2.digest("hex")}`;
 }
 function receiptSpanId(parentSpanId, receipt) {
-  const digest = createHash2("sha256").update(JSON.stringify(receiptIdentity(receipt))).digest("hex");
+  const digest = createHash4("sha256").update(JSON.stringify(receiptIdentity(receipt))).digest("hex");
   return `${parentSpanId}:corruption:${digest}`;
 }
 function stampSessionIntegrity(ref, spans) {
@@ -641,7 +1490,7 @@ function stampSessionIntegrity(ref, spans) {
 }
 
 // src/json.ts
-import { readdir, readFile } from "fs/promises";
+import { readdir, readFile as readFile4 } from "fs/promises";
 var JsonSourceError = class extends Error {
   sourcePath;
   kind;
@@ -676,7 +1525,7 @@ function isMissingJsonSource(error) {
 async function readJsonFile(path) {
   let raw;
   try {
-    raw = await readFile(path, "utf8");
+    raw = await readFile4(path, "utf8");
   } catch (error) {
     throw new JsonSourceError(path, "read", error);
   }
@@ -695,9 +1544,9 @@ async function listJsonFiles(path) {
 }
 
 // src/adapters/amp.ts
-import { readdir as readdir2, stat } from "fs/promises";
+import { readdir as readdir2, stat as stat2 } from "fs/promises";
 import { homedir } from "os";
-import { basename, join } from "path";
+import { basename as basename3, join as join4 } from "path";
 var SERVICE = "amp";
 function textOf(content) {
   if (typeof content === "string") return content.slice(0, CONTENT_CAP);
@@ -708,8 +1557,8 @@ function textOf(content) {
 var AmpAdapter = class {
   harness = "amp";
   threadsRoot() {
-    const base = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-    return join(base, "amp", "threads");
+    const base = process.env.XDG_DATA_HOME ?? join4(homedir(), ".local", "share");
+    return join4(base, "amp", "threads");
   }
   async locate(opts = {}) {
     let files;
@@ -722,17 +1571,17 @@ var AmpAdapter = class {
     const refs = [];
     for (const f of files) {
       if (!f.startsWith("T-") || !f.endsWith(".json")) continue;
-      const path = join(this.threadsRoot(), f);
+      const path = join4(this.threadsRoot(), f);
       let st;
       try {
-        st = await stat(path);
+        st = await stat2(path);
       } catch (error) {
         if (isMissingPathError(error)) continue;
         throw error;
       }
       if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
       if (opts.cwd) continue;
-      refs.push({ harness: this.harness, sessionId: basename(f, ".json"), path, cwd: null, mtimeMs: st.mtimeMs });
+      refs.push({ harness: this.harness, sessionId: basename3(f, ".json"), path, cwd: null, mtimeMs: st.mtimeMs });
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
@@ -823,7 +1672,7 @@ var AmpAdapter = class {
 
 // src/jsonl.ts
 import { isUtf8 } from "buffer";
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { createReadStream } from "fs";
 var JsonlParseError = class extends SyntaxError {
   sourcePath;
@@ -852,7 +1701,7 @@ function corruptionReceipt(rawLine, path, lineNumber, byteOffset) {
     lineNumber,
     byteOffset,
     byteLength: rawLine.length,
-    sha256: createHash3("sha256").update(rawLine).digest("hex"),
+    sha256: createHash5("sha256").update(rawLine).digest("hex"),
     rawBytes: "local_source_only"
   };
 }
@@ -1044,10 +1893,10 @@ function classifyReaction(text2) {
 var CORRECTIVE_REACTIONS = ["correction", "frustration", "jargon", "structure"];
 
 // src/adapters/claude.ts
-import { createHash as createHash4 } from "crypto";
-import { readdir as readdir4, stat as stat2 } from "fs/promises";
+import { createHash as createHash6 } from "crypto";
+import { readdir as readdir4, stat as stat3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { basename as basename4, join as join3, relative as relative3 } from "path";
+import { basename as basename6, join as join6, relative as relative4 } from "path";
 import {
   applyLlmSpanOtlpAttributes as applyLlmSpanOtlpAttributes2,
   LLM_CACHED_TOKENS,
@@ -1057,12 +1906,12 @@ import {
 } from "@tangle-network/agent-eval/trace-attributes";
 
 // src/adapters/claude-subagent-sources.ts
-import { readdir as readdir3, realpath } from "fs/promises";
+import { readdir as readdir3, realpath as realpath2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "path";
+import { basename as basename5, dirname as dirname4, isAbsolute as isAbsolute3, join as join5, relative as relative3, resolve as resolve4 } from "path";
 
 // src/adapters/claude-workflow.ts
-import { basename as basename2, dirname, isAbsolute, relative, resolve } from "path";
+import { basename as basename4, dirname as dirname3, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "path";
 var ClaudeTaskScopeError = class extends Error {
   constructor(message) {
     super(message);
@@ -1073,8 +1922,8 @@ function validWorkflowRunReference(runId, transcriptDir) {
   if (typeof runId !== "string" || typeof transcriptDir !== "string") return void 0;
   const cleanRunId = runId.trim();
   const cleanTranscriptDir = transcriptDir.trim();
-  const resolvedTranscriptDir = resolve(cleanTranscriptDir);
-  if (!cleanRunId || cleanRunId === "." || cleanRunId === ".." || cleanRunId.includes("/") || cleanRunId.includes("\\") || !isAbsolute(cleanTranscriptDir) || basename2(resolvedTranscriptDir) !== cleanRunId || basename2(dirname(resolvedTranscriptDir)) !== "workflows" || basename2(dirname(dirname(resolvedTranscriptDir))) !== "subagents") {
+  const resolvedTranscriptDir = resolve3(cleanTranscriptDir);
+  if (!cleanRunId || cleanRunId === "." || cleanRunId === ".." || cleanRunId.includes("/") || cleanRunId.includes("\\") || !isAbsolute2(cleanTranscriptDir) || basename4(resolvedTranscriptDir) !== cleanRunId || basename4(dirname3(resolvedTranscriptDir)) !== "workflows" || basename4(dirname3(dirname3(resolvedTranscriptDir))) !== "subagents") {
     return void 0;
   }
   return { runId: cleanRunId, transcriptDir: cleanTranscriptDir };
@@ -1097,7 +1946,7 @@ function workflowRunFromText(text2) {
   return validWorkflowRunReference(runIds[0], transcriptDirs[0]);
 }
 function sameWorkflowRun(left, right) {
-  return left.runId === right.runId && resolve(left.transcriptDir) === resolve(right.transcriptDir);
+  return left.runId === right.runId && resolve3(left.transcriptDir) === resolve3(right.transcriptDir);
 }
 function resolveWorkflowRunReference(toolUseId, outputText, structured) {
   const text2 = workflowRunFromText(outputText);
@@ -1151,7 +2000,7 @@ function bindWorkflowRuns(index) {
   return bindings;
 }
 function workflowRunIdForSubagent(subDir, file) {
-  const parts = relative(subDir, file).split(/[\\/]/);
+  const parts = relative2(subDir, file).split(/[\\/]/);
   if (parts[0] !== "workflows") return void 0;
   if (parts.length !== 3 || !parts[1] || !/^agent-.*\.jsonl$/.test(parts[2] ?? "")) {
     throw new ClaudeTaskScopeError(
@@ -1167,14 +2016,14 @@ function bindWorkflowSubagent(file, runId, transcriptDir, bindings) {
       `Cannot link Claude Workflow subagent ${file}: parent result has no run ${runId}`
     );
   }
-  const expectedDir = resolve(transcriptDir);
-  if (resolve(dirname(file)) !== expectedDir) {
+  const expectedDir = resolve3(transcriptDir);
+  if (resolve3(dirname3(file)) !== expectedDir) {
     throw new ClaudeTaskScopeError(
       `Cannot link Claude Workflow run ${runId}: transcript directory does not match ${expectedDir}`
     );
   }
   const localBindings = runBindings.filter(
-    (binding) => resolve(binding.transcriptDir) === expectedDir
+    (binding) => resolve3(binding.transcriptDir) === expectedDir
   );
   if (localBindings.length === 0) {
     throw new ClaudeTaskScopeError(
@@ -1240,7 +2089,7 @@ async function listSubagentFiles(root, signal) {
     }
     signal?.throwIfAborted();
     for (const entry of entries) {
-      const path = join2(dir, entry.name);
+      const path = join5(dir, entry.name);
       if (entry.isDirectory()) {
         pending.push(path);
       } else if (entry.isFile() && /^agent-.*\.jsonl$/.test(entry.name)) {
@@ -1251,20 +2100,20 @@ async function listSubagentFiles(root, signal) {
   return files.sort();
 }
 function pathIsWithin(root, target) {
-  const path = relative2(resolve2(root), resolve2(target));
-  return path === "" || path !== ".." && !path.startsWith("../") && !path.startsWith("..\\") && !isAbsolute2(path);
+  const path = relative3(resolve4(root), resolve4(target));
+  return path === "" || path !== ".." && !path.startsWith("../") && !path.startsWith("..\\") && !isAbsolute3(path);
 }
 function workflowStorageRoot(ref) {
-  const nativeRoot = resolve2(homedir2(), ".claude", "projects");
-  return pathIsWithin(nativeRoot, ref.path) ? nativeRoot : dirname2(resolve2(ref.path));
+  const nativeRoot = resolve4(homedir2(), ".claude", "projects");
+  return pathIsWithin(nativeRoot, ref.path) ? nativeRoot : dirname4(resolve4(ref.path));
 }
 async function workflowTranscriptDirectories(ref, bindings) {
   const allowedRoot = workflowStorageRoot(ref);
-  const allowedRealRoot = await realpath(allowedRoot);
+  const allowedRealRoot = await realpath2(allowedRoot);
   const directories = /* @__PURE__ */ new Map();
   for (const runBindings of bindings.values()) {
     for (const binding of runBindings) {
-      const directory = resolve2(binding.transcriptDir);
+      const directory = resolve4(binding.transcriptDir);
       if (!pathIsWithin(allowedRoot, directory)) {
         throw new ClaudeTaskScopeError(
           `Claude Workflow transcript directory escapes ${allowedRoot}: ${directory}`
@@ -1272,7 +2121,7 @@ async function workflowTranscriptDirectories(ref, bindings) {
       }
       let realDirectory;
       try {
-        realDirectory = await realpath(directory);
+        realDirectory = await realpath2(directory);
       } catch (error) {
         if (isMissingPathError(error)) continue;
         throw error;
@@ -1288,28 +2137,28 @@ async function workflowTranscriptDirectories(ref, bindings) {
   return [...directories.values()].sort();
 }
 async function collectClaudeSubagentSources(ref, bindings, signal) {
-  const subDir = join2(ref.path.replace(/\.jsonl$/, ""), "subagents");
+  const subDir = join5(ref.path.replace(/\.jsonl$/, ""), "subagents");
   const filesByPath = /* @__PURE__ */ new Map();
   const workflowByPath = /* @__PURE__ */ new Map();
   for (const file of await listSubagentFiles(subDir, signal)) {
-    const path = resolve2(file);
+    const path = resolve4(file);
     filesByPath.set(path, file);
     const runId = workflowRunIdForSubagent(subDir, file);
     if (runId) {
       workflowByPath.set(path, {
         runId,
-        transcriptDir: dirname2(file)
+        transcriptDir: dirname4(file)
       });
     }
   }
   for (const transcriptDir of await workflowTranscriptDirectories(ref, bindings)) {
     signal?.throwIfAborted();
-    const runId = basename3(transcriptDir);
+    const runId = basename5(transcriptDir);
     for (const file of await listSubagentFiles(transcriptDir, signal)) {
-      const path = resolve2(file);
+      const path = resolve4(file);
       filesByPath.set(path, file);
       const previous = workflowByPath.get(path);
-      if (previous && (previous.runId !== runId || resolve2(previous.transcriptDir) !== resolve2(transcriptDir))) {
+      if (previous && (previous.runId !== runId || resolve4(previous.transcriptDir) !== resolve4(transcriptDir))) {
         throw new ClaudeTaskScopeError(
           `Claude Workflow subagent ${file} belongs to multiple transcript directories`
         );
@@ -1458,7 +2307,7 @@ function indexWorkflowProjection(projection, index) {
   indexWorkflowResults(index, results);
 }
 function fingerprintClaudeEvent(event) {
-  return createHash4("sha256").update(JSON.stringify(event)).digest("hex");
+  return createHash6("sha256").update(JSON.stringify(event)).digest("hex");
 }
 function startsClaudeTask(projection) {
   if (projection.kind !== "user" || projection.prompt === null) return false;
@@ -1745,7 +2594,7 @@ var ClaudeAdapter = class {
   harness = "claude-code";
   aliases = ["claude", "claudish", "openclaw", "nanoclaw"];
   root() {
-    return join3(homedir3(), ".claude", "projects");
+    return join6(homedir3(), ".claude", "projects");
   }
   async sourcePaths(ref, options = {}) {
     const bindings = await readClaudeWorkflowBindings(ref, options);
@@ -1755,7 +2604,7 @@ var ClaudeAdapter = class {
       options.signal?.throwIfAborted();
       const path = file.replace(/\.jsonl$/, ".meta.json");
       try {
-        const source = await stat2(path);
+        const source = await stat3(path);
         if (source.isFile()) metadataFiles.push(path);
       } catch (error) {
         if (!isMissingPathError(error)) throw error;
@@ -1775,7 +2624,7 @@ var ClaudeAdapter = class {
     }
     const refs = [];
     for (const dir of projectDirs) {
-      const dirPath = join3(root, dir);
+      const dirPath = join6(root, dir);
       let files;
       try {
         files = await readdir4(dirPath);
@@ -1785,10 +2634,10 @@ var ClaudeAdapter = class {
       }
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join3(dirPath, f);
+        const path = join6(dirPath, f);
         let st;
         try {
-          st = await stat2(path);
+          st = await stat3(path);
         } catch (error) {
           if (isMissingPathError(error)) continue;
           throw error;
@@ -1797,7 +2646,7 @@ var ClaudeAdapter = class {
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
         const cwd = `/${dir.replace(/^-/, "").replace(/-/g, "/")}`;
         if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
-        refs.push({ harness: this.harness, sessionId: basename4(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename6(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -1899,7 +2748,7 @@ var ClaudeAdapter = class {
   }
   /** Parse nested `subagents/.../agent-*.jsonl`, parenting each under its Agent call. */
   async foldSubagents(ref, traceId, main, workflowBindings, out, options) {
-    const subDir = join3(ref.path.replace(/\.jsonl$/, ""), "subagents");
+    const subDir = join6(ref.path.replace(/\.jsonl$/, ""), "subagents");
     const sources = await collectClaudeSubagentSources(
       ref,
       workflowBindings,
@@ -1909,7 +2758,7 @@ var ClaudeAdapter = class {
     const agents = [];
     for (const file of sources.files) {
       options.signal?.throwIfAborted();
-      const sourceKey = relative3(subDir, file).replace(/\.jsonl$/, "").split(/[\\/]/).map((segment) => encodeURIComponent(segment)).join(":");
+      const sourceKey = relative4(subDir, file).replace(/\.jsonl$/, "").split(/[\\/]/).map((segment) => encodeURIComponent(segment)).join(":");
       const metaPath = file.replace(/\.jsonl$/, ".meta.json");
       let meta = {};
       try {
@@ -1923,7 +2772,7 @@ var ClaudeAdapter = class {
       const agent = {
         file,
         sourceKey,
-        agentId: basename4(file, ".jsonl").replace(/^agent-/, ""),
+        agentId: basename6(file, ".jsonl").replace(/^agent-/, ""),
         meta,
         ...meta.toolUseId ? { parentToolUseId: meta.toolUseId } : {}
       };
@@ -1936,7 +2785,7 @@ var ClaudeAdapter = class {
         );
         const parsed = await parseClaudeSubagent(ref, traceId, agent, options);
         const binding = selectWorkflowBinding(
-          basename4(file),
+          basename6(file),
           runBindings,
           firstSubagentTimestamp(agent, parsed),
           meta.toolUseId
@@ -2304,9 +3153,9 @@ async function resolveCodexParentTask(ref, childSessionId, options = {}) {
 }
 
 // src/adapters/codex.ts
-import { readdir as readdir5, stat as stat3 } from "fs/promises";
+import { readdir as readdir5, stat as stat4 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { basename as basename5, join as join4 } from "path";
+import { basename as basename7, join as join7 } from "path";
 var SERVICE3 = "codex";
 var SESSION_HEAD_LINES = 40;
 function tokenUsageSignature(usage) {
@@ -2527,7 +3376,7 @@ async function* walkRollouts(root) {
     throw error;
   }
   for (const y of years) {
-    const yp = join4(root, y);
+    const yp = join7(root, y);
     let months;
     try {
       months = await readdir5(yp);
@@ -2536,7 +3385,7 @@ async function* walkRollouts(root) {
       throw error;
     }
     for (const m of months) {
-      const mp = join4(yp, m);
+      const mp = join7(yp, m);
       let days;
       try {
         days = await readdir5(mp);
@@ -2545,7 +3394,7 @@ async function* walkRollouts(root) {
         throw error;
       }
       for (const d of days) {
-        const dp = join4(mp, d);
+        const dp = join7(mp, d);
         let files;
         try {
           files = await readdir5(dp);
@@ -2554,7 +3403,7 @@ async function* walkRollouts(root) {
           throw error;
         }
         for (const f of files) {
-          if (f.startsWith("rollout-") && f.endsWith(".jsonl")) yield join4(dp, f);
+          if (f.startsWith("rollout-") && f.endsWith(".jsonl")) yield join7(dp, f);
         }
       }
     }
@@ -2564,19 +3413,19 @@ var CodexAdapter = class {
   harness = "codex";
   aliases = ["codex-acp"];
   root() {
-    return process.env.CODEX_HOME ? join4(process.env.CODEX_HOME, "sessions") : join4(homedir4(), ".codex", "sessions");
+    return process.env.CODEX_HOME ? join7(process.env.CODEX_HOME, "sessions") : join7(homedir4(), ".codex", "sessions");
   }
   async refFromPath(path, opts) {
     let st;
     try {
-      st = await stat3(path);
+      st = await stat4(path);
     } catch (error) {
       if (isMissingPathError(error)) return void 0;
       throw error;
     }
     if (opts.sinceMs && st.mtimeMs < opts.sinceMs) return void 0;
     let cwd = null;
-    let id = basename5(path).replace(/^rollout-[\dT-]+-/, "").replace(/\.jsonl$/, "");
+    let id = basename7(path).replace(/^rollout-[\dT-]+-/, "").replace(/\.jsonl$/, "");
     const ref = { harness: this.harness, sessionId: id, path, cwd, mtimeMs: st.mtimeMs };
     const head = await takeJsonl(path, SESSION_HEAD_LINES, sessionJsonlOptions(ref));
     for (const parsed of head) {
@@ -2604,7 +3453,7 @@ var CodexAdapter = class {
   async locateBySessionId(sessionId, opts = {}) {
     const refs = [];
     for await (const path of walkRollouts(this.root())) {
-      if (!basename5(path).includes(sessionId)) continue;
+      if (!basename7(path).includes(sessionId)) continue;
       const ref = await this.refFromPath(path, opts);
       if (ref?.sessionId === sessionId) refs.push(ref);
     }
@@ -3002,7 +3851,7 @@ var CodexExecStreamError = class extends Error {
 function objectValue(value) {
   return value != null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function stringValue(value) {
+function stringValue2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function isoTime(value) {
@@ -3043,7 +3892,7 @@ function requireObject2(value, sourcePath, label) {
   return object;
 }
 function requireString(value, sourcePath, label) {
-  const string = stringValue(value);
+  const string = stringValue2(value);
   if (!string) throw new CodexExecStreamError(sourcePath, `${label} must be a non-empty string`);
   return string;
 }
@@ -3078,7 +3927,7 @@ function fileChanges(item, sourcePath) {
 function toolInput(itemType2, item, sourcePath) {
   if (itemType2 === "command_execution") {
     const command = requireString(item.command, sourcePath, "command_execution.command");
-    const cwd = stringValue(item.cwd);
+    const cwd = stringValue2(item.cwd);
     return { cmd: command, ...cwd ? { cwd } : {} };
   }
   return { changes: fileChanges(item, sourcePath) };
@@ -3100,7 +3949,7 @@ function completedStatus(itemType2, item, sourcePath) {
   };
 }
 function itemType(item) {
-  return stringValue(item.type);
+  return stringValue2(item.type);
 }
 function toolItemType(item) {
   const type = itemType(item);
@@ -3153,7 +4002,7 @@ var CodexExecAdapter = class {
       const id = requireString(item.id, ref.path, `${type}.id`);
       const name = toolName(type);
       const input = toolInput(type, item, ref.path);
-      const cwd = stringValue(item.cwd);
+      const cwd = stringValue2(item.cwd);
       if (!ref.cwd && cwd) ref.cwd = cwd;
       const toolSpan = span({
         traceId: threadId,
@@ -3240,7 +4089,7 @@ var CodexExecAdapter = class {
     };
     for await (const raw of readJsonl(ref.path, sessionJsonlOptions(ref, options))) {
       const event = objectValue(raw);
-      const type = event ? stringValue(event.type) : void 0;
+      const type = event ? stringValue2(event.type) : void 0;
       if (!event || !type || !SUPPORTED_EVENT_TYPES.has(type)) {
         ignoredEventCount += 1;
         continue;
@@ -3297,7 +4146,7 @@ var CodexExecAdapter = class {
         if (turn.pendingTools.has(id) || turn.completedItemIds.has(id)) {
           fail(`item ${id} started more than once`);
         }
-        const status = stringValue(item.status);
+        const status = stringValue2(item.status);
         if (status !== void 0 && status !== "in_progress") {
           fail(`${toolType}.status on item.started must be "in_progress" when present`);
         }
@@ -3419,15 +4268,15 @@ var CodexExecAdapter = class {
 };
 
 // src/adapters/copilot.ts
-import { readdir as readdir6, stat as stat4 } from "fs/promises";
+import { readdir as readdir6, stat as stat5 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
+import { join as join8 } from "path";
 var SERVICE5 = "github-copilot";
 var CopilotAdapter = class {
   harness = "github-copilot";
   aliases = ["copilot"];
   root() {
-    return join5(process.env.COPILOT_HOME ?? join5(homedir5(), ".copilot"), "session-state");
+    return join8(process.env.COPILOT_HOME ?? join8(homedir5(), ".copilot"), "session-state");
   }
   async locate(opts = {}) {
     let dirs;
@@ -3439,10 +4288,10 @@ var CopilotAdapter = class {
     }
     const refs = [];
     for (const id of dirs) {
-      const path = join5(this.root(), id, "events.jsonl");
+      const path = join8(this.root(), id, "events.jsonl");
       let st;
       try {
-        st = await stat4(path);
+        st = await stat5(path);
       } catch (error) {
         if (isMissingPathError(error)) continue;
         throw error;
@@ -3543,9 +4392,9 @@ var CopilotAdapter = class {
 };
 
 // src/adapters/factory.ts
-import { readdir as readdir7, stat as stat5 } from "fs/promises";
+import { readdir as readdir7, stat as stat6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename6, join as join6 } from "path";
+import { basename as basename8, join as join9 } from "path";
 var SERVICE6 = "factory";
 function textOf4(content) {
   return capText(
@@ -3556,7 +4405,7 @@ var FactoryAdapter = class {
   harness = "factory";
   aliases = ["factory-droids", "droid"];
   root() {
-    return join6(homedir6(), ".factory", "sessions");
+    return join9(homedir6(), ".factory", "sessions");
   }
   async locate(opts = {}) {
     const root = this.root();
@@ -3569,7 +4418,7 @@ var FactoryAdapter = class {
     }
     const refs = [];
     for (const dir of dirs) {
-      const dp = join6(root, dir);
+      const dp = join9(root, dir);
       let files;
       try {
         files = await readdir7(dp);
@@ -3581,16 +4430,16 @@ var FactoryAdapter = class {
       if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join6(dp, f);
+        const path = join9(dp, f);
         let st;
         try {
-          st = await stat5(path);
+          st = await stat6(path);
         } catch (error) {
           if (isMissingPathError(error)) continue;
           throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-        refs.push({ harness: this.harness, sessionId: basename6(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename8(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -3715,9 +4564,9 @@ var FactoryAdapter = class {
 };
 
 // src/adapters/forge.ts
-import { readdir as readdir8, stat as stat6 } from "fs/promises";
+import { readdir as readdir8, stat as stat7 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { basename as basename7, join as join7 } from "path";
+import { basename as basename9, join as join10 } from "path";
 var SERVICE7 = "forge";
 function tokens(t) {
   if (!t) return null;
@@ -3731,7 +4580,7 @@ var ForgeAdapter = class {
   aliases = ["forgecode"];
   /** Directories scanned for `*-dump.json` exports. */
   dumpDirs() {
-    return [process.cwd(), join7(homedir7(), ".forge")];
+    return [process.cwd(), join10(homedir7(), ".forge")];
   }
   async locate(opts = {}) {
     const refs = [];
@@ -3746,16 +4595,16 @@ var ForgeAdapter = class {
       }
       for (const f of files) {
         if (!f.endsWith("-dump.json")) continue;
-        const path = join7(dir, f);
+        const path = join10(dir, f);
         let st;
         try {
-          st = await stat6(path);
+          st = await stat7(path);
         } catch (error) {
           if (isMissingPathError(error)) continue;
           throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-        refs.push({ harness: this.harness, sessionId: basename7(f, ".json"), path, cwd: dir, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename9(f, ".json"), path, cwd: dir, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -3845,9 +4694,9 @@ var ForgeAdapter = class {
 };
 
 // src/adapters/gemini.ts
-import { readdir as readdir9, stat as stat7 } from "fs/promises";
+import { readdir as readdir9, stat as stat8 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { join as join8 } from "path";
+import { join as join11 } from "path";
 function iso(ts, fallback) {
   if (typeof ts === "number") return new Date(ts).toISOString();
   if (typeof ts === "string" && ts.length > 0) return ts;
@@ -3872,7 +4721,7 @@ var GeminiFamilyAdapter = class {
     this.homeDirName = cfg.homeDirName;
   }
   chatsRoot() {
-    return join8(homedir8(), this.homeDirName, "tmp");
+    return join11(homedir8(), this.homeDirName, "tmp");
   }
   /** `<home>/projects.json` maps `{ <absolute-cwd>: <projectName> }`. The session
    *  dir name (`tmp/<projectHash>/`) is that projectName for registered projects,
@@ -3882,7 +4731,7 @@ var GeminiFamilyAdapter = class {
     const nameToPath = /* @__PURE__ */ new Map();
     try {
       const projects = (await readJsonFile(
-        join8(homedir8(), this.homeDirName, "projects.json")
+        join11(homedir8(), this.homeDirName, "projects.json")
       )).projects ?? {};
       for (const [path, name] of Object.entries(projects)) nameToPath.set(name, path);
     } catch (error) {
@@ -3903,7 +4752,7 @@ var GeminiFamilyAdapter = class {
     const refs = [];
     for (const pd of projectDirs) {
       const cwd = projectCwds.get(pd) ?? null;
-      const chatsDir = join8(root, pd, "chats");
+      const chatsDir = join11(root, pd, "chats");
       let files;
       try {
         files = await readdir9(chatsDir);
@@ -3913,10 +4762,10 @@ var GeminiFamilyAdapter = class {
       }
       for (const f of files) {
         if (!f.startsWith("session-") || !f.endsWith(".json")) continue;
-        const path = join8(chatsDir, f);
+        const path = join11(chatsDir, f);
         let st;
         try {
-          st = await stat7(path);
+          st = await stat8(path);
         } catch (error) {
           if (isMissingPathError(error)) continue;
           throw error;
@@ -4020,9 +4869,9 @@ var GeminiAdapter = class extends GeminiFamilyAdapter {
 };
 
 // src/adapters/opencode.ts
-import { readdir as readdir10, stat as stat8 } from "fs/promises";
+import { readdir as readdir10, stat as stat9 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { join as join9 } from "path";
+import { join as join12 } from "path";
 var SERVICE8 = "opencode";
 function isoOf(ms) {
   return new Date(ms ?? 0).toISOString();
@@ -4035,11 +4884,11 @@ function textOf7(parts) {
 var OpencodeAdapter = class {
   harness = "opencode";
   storage() {
-    const base = process.env.XDG_DATA_HOME ?? join9(homedir9(), ".local", "share");
-    return join9(base, "opencode", "storage");
+    const base = process.env.XDG_DATA_HOME ?? join12(homedir9(), ".local", "share");
+    return join12(base, "opencode", "storage");
   }
   async locate(opts = {}) {
-    const msgRoot = join9(this.storage(), "message");
+    const msgRoot = join12(this.storage(), "message");
     let sessionDirs;
     try {
       sessionDirs = await readdir10(msgRoot);
@@ -4049,10 +4898,10 @@ var OpencodeAdapter = class {
     }
     const refs = [];
     for (const sid of sessionDirs) {
-      const dir = join9(msgRoot, sid);
+      const dir = join12(msgRoot, sid);
       let st;
       try {
-        st = await stat8(dir);
+        st = await stat9(dir);
       } catch (error) {
         if (isMissingPathError(error)) continue;
         throw error;
@@ -4067,11 +4916,11 @@ var OpencodeAdapter = class {
   async parse(ref) {
     const traceId = ref.sessionId;
     const rootId = `root:${traceId}`;
-    const partRoot = join9(this.storage(), "part");
+    const partRoot = join12(this.storage(), "part");
     const msgFiles = await listJsonFiles(ref.path);
     const messages = [];
     for (const f of msgFiles) {
-      messages.push(await readJsonFile(join9(ref.path, f)));
+      messages.push(await readJsonFile(join12(ref.path, f)));
     }
     messages.sort((a, b) => (a.time?.created ?? 0) - (b.time?.created ?? 0));
     const spans = [
@@ -4091,7 +4940,7 @@ var OpencodeAdapter = class {
     for (const msg of messages) {
       const mid = msg.id ?? `m${step}`;
       const llmId = `llm:${mid}`;
-      const pdir = join9(partRoot, mid);
+      const pdir = join12(partRoot, mid);
       const parts = [];
       let partFiles = [];
       try {
@@ -4100,7 +4949,7 @@ var OpencodeAdapter = class {
         if (!isMissingJsonSource(error)) throw error;
       }
       for (const pf of partFiles) {
-        parts.push(await readJsonFile(join9(pdir, pf)));
+        parts.push(await readJsonFile(join12(pdir, pf)));
       }
       const turnText = textOf7(parts);
       const isUser = msg.role === "user";
@@ -4176,9 +5025,9 @@ var OpencodeAdapter = class {
 };
 
 // src/adapters/pi.ts
-import { readdir as readdir11, stat as stat9 } from "fs/promises";
+import { readdir as readdir11, stat as stat10 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { basename as basename8, join as join10 } from "path";
+import { basename as basename10, join as join13 } from "path";
 var SERVICE9 = "pi";
 function terminalStatus(message) {
   const stopReason = message?.stopReason ?? "missing";
@@ -4224,7 +5073,7 @@ function completeToolSpan(toolSpan, result) {
 var PiAdapter = class {
   harness = "pi";
   root() {
-    return join10(homedir10(), ".pi", "agent", "sessions");
+    return join13(homedir10(), ".pi", "agent", "sessions");
   }
   async locate(opts = {}) {
     const root = this.root();
@@ -4237,7 +5086,7 @@ var PiAdapter = class {
     }
     const refs = [];
     for (const dir of dirs) {
-      const dp = join10(root, dir);
+      const dp = join13(root, dir);
       let files;
       try {
         files = await readdir11(dp);
@@ -4249,16 +5098,16 @@ var PiAdapter = class {
       if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join10(dp, f);
+        const path = join13(dp, f);
         let st;
         try {
-          st = await stat9(path);
+          st = await stat10(path);
         } catch (error) {
           if (isMissingPathError(error)) continue;
           throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-        const id = basename8(f, ".jsonl").replace(/^[\dTZ.-]+_/, "");
+        const id = basename10(f, ".jsonl").replace(/^[\dTZ.-]+_/, "");
         refs.push({ harness: this.harness, sessionId: id, path, cwd, mtimeMs: st.mtimeMs });
       }
     }
@@ -4297,14 +5146,14 @@ var PiAdapter = class {
       const llmId = `llm:${mid}`;
       if (msg.role === "toolResult") {
         const callId = msg.toolCallId ?? `${mid}:result`;
-        const errorMessage = textOf8(msg.content).slice(0, 500) || "tool result reported error";
+        const errorMessage2 = textOf8(msg.content).slice(0, 500) || "tool result reported error";
         const result = {
           callId,
           toolName: msg.toolName ?? "tool",
           timestamp: ts,
           isError: msg.isError === true,
           output: toolResultOutput(msg.content),
-          errorMessage,
+          errorMessage: errorMessage2,
           step
         };
         const toolSpan = toolByCallId.get(callId);
@@ -4444,9 +5293,9 @@ var PiAdapter = class {
 };
 
 // src/adapters/qwen.ts
-import { readdir as readdir12, stat as stat10 } from "fs/promises";
+import { readdir as readdir12, stat as stat11 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { basename as basename9, join as join11 } from "path";
+import { basename as basename11, join as join14 } from "path";
 var SERVICE10 = "qwen";
 function textOf9(parts) {
   if (!parts) return "";
@@ -4456,7 +5305,7 @@ var QwenAdapter = class {
   harness = "qwen";
   aliases = ["qwen-code"];
   root() {
-    return join11(homedir11(), ".qwen", "projects");
+    return join14(homedir11(), ".qwen", "projects");
   }
   async locate(opts = {}) {
     const root = this.root();
@@ -4469,7 +5318,7 @@ var QwenAdapter = class {
     }
     const refs = [];
     for (const pd of projectDirs) {
-      const chatsDir = join11(root, pd, "chats");
+      const chatsDir = join14(root, pd, "chats");
       let files;
       try {
         files = await readdir12(chatsDir);
@@ -4480,16 +5329,16 @@ var QwenAdapter = class {
       if (opts.cwd) continue;
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join11(chatsDir, f);
+        const path = join14(chatsDir, f);
         let st;
         try {
-          st = await stat10(path);
+          st = await stat11(path);
         } catch (error) {
           if (isMissingPathError(error)) continue;
           throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-        refs.push({ harness: this.harness, sessionId: basename9(f, ".jsonl"), path, cwd: null, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename11(f, ".jsonl"), path, cwd: null, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -4646,8 +5495,8 @@ function selectAdapters(opts) {
 }
 
 // src/repo.ts
-import { stat as stat11 } from "fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join12, normalize, parse as parsePath } from "path";
+import { stat as stat12 } from "fs/promises";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join15, normalize, parse as parsePath } from "path";
 function normalizeRemote(url) {
   const raw = url.trim();
   if (!raw) return null;
@@ -4671,7 +5520,7 @@ function normalizeRemote(url) {
   return null;
 }
 async function readGit(cwd) {
-  await stat11(`${cwd}/.git`);
+  await stat12(`${cwd}/.git`);
   const { execFile } = await import("child_process");
   const { promisify } = await import("util");
   const run = promisify(execFile);
@@ -4728,7 +5577,7 @@ function parseWorktreePorcelain(output) {
 async function equivalentGitCwds(cwd) {
   if (!cwd) return [];
   const selected = normalize(cwd);
-  if (!isAbsolute3(selected)) return [selected];
+  if (!isAbsolute4(selected)) return [selected];
   const top = await gitOutput(selected, ["rev-parse", "--show-toplevel"]);
   if (!top) return [selected];
   const worktrees = await gitOutput(top, ["worktree", "list", "--porcelain"]);
@@ -4744,7 +5593,7 @@ function cwdMatchesSelection(cwd, selections) {
 }
 async function pathStat(path) {
   try {
-    return await stat11(path);
+    return await stat12(path);
   } catch {
     return null;
   }
@@ -4754,13 +5603,13 @@ async function directoryExists(path) {
   return Boolean(s?.isDirectory());
 }
 async function nearestExistingDir(path) {
-  if (!path || !isAbsolute3(path)) return null;
+  if (!path || !isAbsolute4(path)) return null;
   let cur = normalize(path);
   for (; ; ) {
     const s = await pathStat(cur);
     if (s?.isDirectory()) return cur;
-    if (s?.isFile()) return dirname3(cur);
-    const parent = dirname3(cur);
+    if (s?.isFile()) return dirname5(cur);
+    const parent = dirname5(cur);
     if (parent === cur) return null;
     cur = parent;
   }
@@ -4768,15 +5617,15 @@ async function nearestExistingDir(path) {
 async function findGitRoot(path) {
   let cur = await nearestExistingDir(path);
   while (cur) {
-    if (await pathStat(join12(cur, ".git"))) return cur;
-    const parent = dirname3(cur);
+    if (await pathStat(join15(cur, ".git"))) return cur;
+    const parent = dirname5(cur);
     if (parent === cur) return null;
     cur = parent;
   }
   return null;
 }
 async function repairDashedPath(cwd) {
-  if (!isAbsolute3(cwd) || await directoryExists(cwd)) return null;
+  if (!isAbsolute4(cwd) || await directoryExists(cwd)) return null;
   const normalized = normalize(cwd);
   const parsed = parsePath(normalized);
   const parts = normalized.slice(parsed.root.length).split("/").filter(Boolean);
@@ -4786,7 +5635,7 @@ async function repairDashedPath(cwd) {
   while (index < parts.length) {
     const nextPart = parts[index];
     if (!nextPart) break;
-    const exact = join12(current, nextPart);
+    const exact = join15(current, nextPart);
     if (!await directoryExists(exact)) break;
     current = exact;
     index += 1;
@@ -4796,7 +5645,7 @@ async function repairDashedPath(cwd) {
     let consumed = 0;
     for (let n = parts.length - index; n >= 1; n -= 1) {
       const segment = parts.slice(index, index + n).join("-");
-      const candidate = join12(current, segment);
+      const candidate = join15(current, segment);
       if (await directoryExists(candidate)) {
         match = candidate;
         consumed = n;
@@ -4822,7 +5671,7 @@ var SOURCE_WEIGHT = {
 function cleanPathCandidate(raw) {
   let value = raw.trim().replace(/\\n/g, "").replace(/[),\].}]+$/g, "").replace(/:\d+(?::\d+)?$/g, "");
   value = normalize(value);
-  return isAbsolute3(value) ? value : null;
+  return isAbsolute4(value) ? value : null;
 }
 function looksLikeWorkdirKey(key) {
   return key === "cwd" || key === "workdir" || key === "workingDirectory" || key === "working_directory";
@@ -4880,7 +5729,7 @@ function extractAbsolutePaths(spans) {
 async function resolveRepoAttrs(cwd) {
   if (!cwd) return {};
   const attrs = { [ATTR.CWD]: cwd };
-  const basename12 = (() => {
+  const basename14 = (() => {
     const trimmed = cwd.replace(/\/+$/g, "");
     const idx = trimmed.lastIndexOf("/");
     const name = idx === -1 ? trimmed : trimmed.slice(idx + 1);
@@ -4902,7 +5751,7 @@ async function resolveRepoAttrs(cwd) {
     if (commit) attrs[ATTR.GIT_COMMIT] = commit;
   } catch {
   }
-  attrs[ATTR.SUBJECT_KEY] = basename12;
+  attrs[ATTR.SUBJECT_KEY] = basename14;
   return attrs;
 }
 async function repoCandidateForPath(path) {
@@ -5007,7 +5856,7 @@ async function stampSpanWorkdirRepoAttrs(spans) {
 async function awaitWithAbort(operation, signal) {
   if (!signal) return operation;
   signal.throwIfAborted();
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve7, reject) => {
     const stop = () => {
       signal.removeEventListener("abort", stop);
       reject(signal.reason);
@@ -5016,7 +5865,7 @@ async function awaitWithAbort(operation, signal) {
     operation.then(
       (value) => {
         signal.removeEventListener("abort", stop);
-        resolve5(value);
+        resolve7(value);
       },
       (error) => {
         signal.removeEventListener("abort", stop);
@@ -5189,9 +6038,9 @@ function describeSessionRelationship(ref, spans) {
 }
 
 // src/evidence.ts
-import { mkdtemp, writeFile } from "fs/promises";
+import { mkdtemp as mkdtemp2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join13 } from "path";
+import { join as join16 } from "path";
 import {
   OPENINFERENCE_SPAN_KIND as OPENINFERENCE_SPAN_KIND2,
   TOOL_NAME as TOOL_NAME2
@@ -5317,14 +6166,14 @@ function serializePolicyEvidence(records) {
 `;
 }
 async function writePolicyEvidenceFile(records, outPath) {
-  const path = outPath ?? join13(await mkdtemp(join13(tmpdir(), "traces-evidence-")), "policy-evidence.jsonl");
-  await writeFile(path, serializePolicyEvidence(records), "utf8");
+  const path = outPath ?? join16(await mkdtemp2(join16(tmpdir(), "traces-evidence-")), "policy-evidence.jsonl");
+  await writeFile2(path, serializePolicyEvidence(records), "utf8");
   return path;
 }
 
 // src/external.ts
 import { spawn } from "child_process";
-import { readdir as readdir13, readFile as readFile2 } from "fs/promises";
+import { readdir as readdir13, readFile as readFile5 } from "fs/promises";
 
 // src/external-analysis-validation.ts
 var FINDING_KEYS = /* @__PURE__ */ new Set([
@@ -5600,13 +6449,13 @@ function terminateWindowsProcessTree(child) {
     forceKill(child);
     return Promise.resolve();
   }
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     let finished = false;
     const finish = () => {
       if (finished) return;
       finished = true;
       forceKill(child);
-      resolve5();
+      resolve7();
     };
     let killer;
     try {
@@ -5633,7 +6482,7 @@ function signalProcess(pid, signal) {
   }
 }
 function readProcessTableWithPs() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve7, reject) => {
     let child;
     try {
       child = spawn("ps", ["-A", "-o", "pid=", "-o", "ppid="], {
@@ -5687,7 +6536,7 @@ function readProcessTableWithPs() {
           reject(new Error("ps: returned no process records"));
           return;
         }
-        resolve5(rows);
+        resolve7(rows);
       });
     });
   });
@@ -5697,10 +6546,10 @@ async function readLinuxProcProcessTable() {
   const rows = await Promise.all(
     entries.filter((entry) => entry.isDirectory() && /^\d+$/.test(entry.name)).map(async (entry) => {
       try {
-        const stat13 = await readFile2(`/proc/${entry.name}/stat`, "utf8");
-        const commandEnd = stat13.lastIndexOf(")");
+        const stat14 = await readFile5(`/proc/${entry.name}/stat`, "utf8");
+        const commandEnd = stat14.lastIndexOf(")");
         if (commandEnd < 0) return void 0;
-        const fields = stat13.slice(commandEnd + 1).trim().split(/\s+/);
+        const fields = stat14.slice(commandEnd + 1).trim().split(/\s+/);
         const pid = Number(entry.name);
         const parentPid = Number(fields[1]);
         if (!Number.isSafeInteger(pid) || pid < 1 || !Number.isSafeInteger(parentPid) || parentPid < 0) {
@@ -5822,7 +6671,7 @@ function runCommand(command, args = [], opts = {}) {
     throw new RangeError("maxBuffer must be a positive safe integer");
   }
   if (opts.signal?.aborted) return Promise.reject(abortError(opts.signal));
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve7, reject) => {
     let child;
     try {
       child = spawn(command, [...args], { detached: process.platform !== "win32" });
@@ -5854,7 +6703,7 @@ function runCommand(command, args = [], opts = {}) {
       } else if (spawnError) {
         reject(spawnError);
       } else {
-        resolve5({ stdout: out, stderr: err, code: closeCode });
+        resolve7({ stdout: out, stderr: err, code: closeCode });
       }
     };
     function requestTermination(error) {
@@ -6083,22 +6932,22 @@ function commandRedactor(spec) {
 }
 
 // src/hodoscope.ts
-import { createHash as createHash5 } from "crypto";
-import { mkdir, mkdtemp as mkdtemp2, readFile as readFile3, readdir as readdir14, writeFile as writeFile2 } from "fs/promises";
+import { createHash as createHash7 } from "crypto";
+import { mkdir as mkdir3, mkdtemp as mkdtemp3, readFile as readFile6, readdir as readdir14, writeFile as writeFile3 } from "fs/promises";
 import { endianness, tmpdir as tmpdir2 } from "os";
-import { join as join14, resolve as resolve3 } from "path";
+import { join as join17, resolve as resolve5 } from "path";
 var HODOSCOPE_VERSION = "0.2.4";
 async function writeHodoscopeInput(otlpPath, options = {}) {
-  const explicitDirectory = options.directory ? resolve3(options.directory) : void 0;
-  const directory = explicitDirectory ?? await mkdtemp2(join14(tmpdir2(), "traces-hodoscope-input-"));
+  const explicitDirectory = options.directory ? resolve5(options.directory) : void 0;
+  const directory = explicitDirectory ?? await mkdtemp3(join17(tmpdir2(), "traces-hodoscope-input-"));
   if (explicitDirectory) {
-    await mkdir(directory, { recursive: true });
+    await mkdir3(directory, { recursive: true });
     if ((await readdir14(directory)).length > 0) {
       throw new Error(`Hodoscope explicit directory must be empty: ${directory}`);
     }
   }
-  const samples = join14(directory, "samples");
-  await mkdir(samples);
+  const samples = join17(directory, "samples");
+  await mkdir3(samples);
   const rows = [];
   for await (const value of readJsonl(otlpPath)) rows.push(parseOpenInferenceRow(value));
   if (rows.length === 0) throw new Error("Hodoscope input contains no spans");
@@ -6122,8 +6971,8 @@ async function writeHodoscopeInput(otlpPath, options = {}) {
       throw new Error(`Hodoscope trace '${traceId}' contains no assistant actions`);
     }
     actionCount += actions;
-    const file = `${createHash5("sha256").update(traceId).digest("hex").slice(0, 24)}.json`;
-    await writeFile2(join14(samples, file), `${JSON.stringify(trajectory, null, 2)}
+    const file = `${createHash7("sha256").update(traceId).digest("hex").slice(0, 24)}.json`;
+    await writeFile3(join17(samples, file), `${JSON.stringify(trajectory, null, 2)}
 `, "utf8");
   }
   return {
@@ -6145,12 +6994,12 @@ function hodoscopeAnalyzer(options = {}) {
   return {
     name: "hodoscope",
     async analyze(otlpPath, runOptions2 = {}) {
-      const outputRoot = options.outputDir ? resolve3(options.outputDir) : tmpdir2();
-      await mkdir(outputRoot, { recursive: true });
-      const directory = await mkdtemp2(join14(outputRoot, "traces-hodoscope-"));
-      const input = join14(directory, "input");
-      const analysisFile = join14(directory, "analysis.hodoscope.json");
-      const samplesFile = join14(directory, "samples.json");
+      const outputRoot = options.outputDir ? resolve5(options.outputDir) : tmpdir2();
+      await mkdir3(outputRoot, { recursive: true });
+      const directory = await mkdtemp3(join17(outputRoot, "traces-hodoscope-"));
+      const input = join17(directory, "input");
+      const analysisFile = join17(directory, "analysis.hodoscope.json");
+      const samplesFile = join17(directory, "samples.json");
       try {
         const prepared = await writeHodoscopeInput(otlpPath, {
           directory: input,
@@ -6341,20 +7190,20 @@ function sourceMapEntry(traceId, spanId, turnId) {
 }
 async function readHodoscopeAnalysis(path, expected) {
   const value = await readJson(path);
-  if (!isObject(value) || value.version !== 1 || !Array.isArray(value.summaries)) {
+  if (!isObject3(value) || value.version !== 1 || !Array.isArray(value.summaries)) {
     throw new Error("Hodoscope analysis has an unsupported shape");
   }
-  const createdAt = requiredString(value.created_at, "analysis.created_at");
+  const createdAt = requiredString2(value.created_at, "analysis.created_at");
   if (!Number.isFinite(Date.parse(createdAt))) {
     throw new Error("Hodoscope analysis.created_at must be a valid date-time");
   }
-  const source = requiredString(value.source, "analysis.source");
-  if (resolve3(source) !== resolve3(expected.source)) {
+  const source = requiredString2(value.source, "analysis.source");
+  if (resolve5(source) !== resolve5(expected.source)) {
     throw new Error(
       `Hodoscope analysis.source '${source}' does not match requested input '${expected.source}'`
     );
   }
-  const embeddingModel = requiredString(value.embedding_model, "analysis.embedding_model");
+  const embeddingModel = requiredString2(value.embedding_model, "analysis.embedding_model");
   if (embeddingModel !== expected.embeddingModel) {
     throw new Error(
       `Hodoscope analysis.embedding_model '${embeddingModel}' does not match requested model '${expected.embeddingModel}'`
@@ -6411,15 +7260,15 @@ async function readHodoscopeAnalysis(path, expected) {
 }
 function parseHodoscopeSummary(value, index, embeddingDimensions) {
   const path = `analysis.summaries[${index}]`;
-  if (!isObject(value)) throw new Error(`Hodoscope ${path} must be an object`);
-  const trajectoryId2 = requiredString(value.trajectory_id, `${path}.trajectory_id`);
+  if (!isObject3(value)) throw new Error(`Hodoscope ${path} must be an object`);
+  const trajectoryId2 = requiredString2(value.trajectory_id, `${path}.trajectory_id`);
   const turnId = nonNegativeSafeInteger(value.turn_id, `${path}.turn_id`);
-  const summary = requiredString(value.summary, `${path}.summary`);
+  const summary = requiredString2(value.summary, `${path}.summary`);
   if (summary.trimStart().toLowerCase().startsWith("[error:")) {
     throw new Error(`Hodoscope failed to summarize ${formatAction(trajectoryId2, turnId)}`);
   }
-  const actionText = requiredString(value.action_text, `${path}.action_text`);
-  const embedding = requiredString(value.embedding, `${path}.embedding`);
+  const actionText = requiredString2(value.action_text, `${path}.action_text`);
+  const embedding = requiredString2(value.embedding, `${path}.embedding`);
   validateEmbedding(embedding, embeddingDimensions, `${path}.embedding`);
   const taskContext = value.task_context;
   if (typeof taskContext !== "string") {
@@ -6436,16 +7285,16 @@ function parseHodoscopeSummary(value, index, embeddingDimensions) {
   };
 }
 function parseHodoscopeSamples(value, expected) {
-  if (!isObject(value) || !isObject(value.groups)) {
+  if (!isObject3(value) || !isObject3(value.groups)) {
     throw new Error("Hodoscope samples have an unsupported shape");
   }
-  const groupBy = requiredString(value.group_by, "samples.group_by");
+  const groupBy = requiredString2(value.group_by, "samples.group_by");
   if (groupBy !== expected.groupBy) {
     throw new Error(
       `Hodoscope samples.group_by '${groupBy}' does not match requested '${expected.groupBy}'`
     );
   }
-  const method = requiredString(value.method, "samples.method");
+  const method = requiredString2(value.method, "samples.method");
   if (method !== expected.method) {
     throw new Error(
       `Hodoscope samples.method '${method}' does not match requested '${expected.method}'`
@@ -6465,7 +7314,7 @@ function parseHodoscopeSamples(value, expected) {
   );
   const expectedGroupTotals = /* @__PURE__ */ new Map();
   for (const [index, summary] of expected.summaries.entries()) {
-    const group = requiredString(
+    const group = requiredString2(
       summary.metadata[groupBy],
       `analysis.summaries[${index}].metadata.${groupBy}`
     );
@@ -6477,7 +7326,7 @@ function parseHodoscopeSamples(value, expected) {
   let reportedSamples = 0;
   for (const [group, groupValue] of Object.entries(value.groups)) {
     if (!group.trim()) throw new Error("Hodoscope sample group names must be non-empty");
-    if (!isObject(groupValue) || !Array.isArray(groupValue.samples)) {
+    if (!isObject3(groupValue) || !Array.isArray(groupValue.samples)) {
       throw new Error(`Hodoscope sample group '${group}' has an unsupported shape`);
     }
     const total = nonNegativeSafeInteger(groupValue.total, `samples.groups.${group}.total`);
@@ -6498,12 +7347,12 @@ function parseHodoscopeSamples(value, expected) {
     }
     const parsedSamples = groupValue.samples.map((row, index) => {
       const path = `samples.groups.${group}.samples[${index}]`;
-      if (!isObject(row)) throw new Error(`Hodoscope ${path} must be an object`);
+      if (!isObject3(row)) throw new Error(`Hodoscope ${path} must be an object`);
       const rank = nonNegativeSafeInteger(row.rank, `${path}.rank`);
       if (rank !== index) {
         throw new Error(`Hodoscope ${path}.rank must be ${index}, received ${rank}`);
       }
-      const trajectoryId2 = requiredString(row.trajectory_id, `${path}.trajectory_id`);
+      const trajectoryId2 = requiredString2(row.trajectory_id, `${path}.trajectory_id`);
       const turnId = nonNegativeSafeInteger(row.turn_id, `${path}.turn_id`);
       const key = actionKey(trajectoryId2, turnId);
       if (!expected.sourceByAction.has(key)) {
@@ -6522,8 +7371,8 @@ function parseHodoscopeSamples(value, expected) {
           `Hodoscope ${path} has no matching analysis row for ${formatAction(trajectoryId2, turnId)}`
         );
       }
-      const summary = requiredString(row.summary, `${path}.summary`);
-      const actionText = requiredString(row.action_text, `${path}.action_text`);
+      const summary = requiredString2(row.summary, `${path}.summary`);
+      const actionText = requiredString2(row.action_text, `${path}.action_text`);
       const metadata = jsonRecord(row.metadata, `${path}.metadata`);
       if (summary !== sourceSummary.summary || actionText !== sourceSummary.action_text) {
         throw new Error(
@@ -6577,7 +7426,7 @@ function parseHodoscopeSamples(value, expected) {
 function candidatesFromSamples(samples, sourceByAction) {
   const candidates = [];
   for (const [group, value] of Object.entries(samples.groups)) {
-    if (!isObject(value) || !Array.isArray(value.samples) || !Number.isInteger(value.total)) {
+    if (!isObject3(value) || !Array.isArray(value.samples) || !Number.isInteger(value.total)) {
       throw new Error(`Hodoscope sample group '${group}' has an unsupported shape`);
     }
     for (const row of value.samples) {
@@ -6663,7 +7512,7 @@ function validateEmbedding(encoded, dimensions, path) {
     }
   }
 }
-function requiredString(value, path) {
+function requiredString2(value, path) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new Error(`Hodoscope ${path} must be a non-empty string`);
   }
@@ -6676,7 +7525,7 @@ function nonNegativeSafeInteger(value, path) {
   return value;
 }
 function jsonRecord(value, path) {
-  if (!isObject(value)) throw new Error(`Hodoscope ${path} must be a JSON object`);
+  if (!isObject3(value)) throw new Error(`Hodoscope ${path} must be a JSON object`);
   assertJsonValue(value, path);
   return value;
 }
@@ -6691,7 +7540,7 @@ function assertJsonValue(value, path, depth = 0) {
     }
     return;
   }
-  if (isObject(value)) {
+  if (isObject3(value)) {
     for (const [key, child] of Object.entries(value)) {
       assertJsonValue(child, `${path}.${key}`, depth + 1);
     }
@@ -6705,8 +7554,8 @@ function jsonEquals(left, right) {
     if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
     return left.every((value, index) => jsonEquals(value, right[index]));
   }
-  if (isObject(left) || isObject(right)) {
-    if (!isObject(left) || !isObject(right)) return false;
+  if (isObject3(left) || isObject3(right)) {
+    if (!isObject3(left) || !isObject3(right)) return false;
     const leftKeys = Object.keys(left).sort();
     const rightKeys = Object.keys(right).sort();
     return leftKeys.length === rightKeys.length && leftKeys.every(
@@ -6716,10 +7565,10 @@ function jsonEquals(left, right) {
   return false;
 }
 async function readJson(path) {
-  return JSON.parse(await readFile3(path, "utf8"));
+  return JSON.parse(await readFile6(path, "utf8"));
 }
 function parseOpenInferenceRow(value) {
-  if (!isObject(value) || typeof value.trace_id !== "string" || !value.trace_id || typeof value.span_id !== "string" || !value.span_id || typeof value.name !== "string" || typeof value.start_time !== "string" || !isObject(value.status) || !isObject(value.attributes) || value.parent_span_id !== void 0 && value.parent_span_id !== null && typeof value.parent_span_id !== "string") {
+  if (!isObject3(value) || typeof value.trace_id !== "string" || !value.trace_id || typeof value.span_id !== "string" || !value.span_id || typeof value.name !== "string" || typeof value.start_time !== "string" || !isObject3(value.status) || !isObject3(value.attributes) || value.parent_span_id !== void 0 && value.parent_span_id !== null && typeof value.parent_span_id !== "string") {
     throw new TypeError("Hodoscope input must contain complete OpenInference spans");
   }
   return value;
@@ -6752,7 +7601,7 @@ function toJson(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
   if (Array.isArray(value)) return value.map(toJson);
-  if (isObject(value)) {
+  if (isObject3(value)) {
     return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJson(child)]));
   }
   return String(value ?? "");
@@ -6760,7 +7609,7 @@ function toJson(value) {
 function stringifyCompact(value) {
   return typeof value === "string" ? value : JSON.stringify(value);
 }
-function isObject(value) {
+function isObject3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function assertPositiveInteger(name, value) {
@@ -6769,159 +7618,6 @@ function assertPositiveInteger(name, value) {
   }
 }
 
-// src/chat-trajectory.ts
-import { createHash as createHash6 } from "crypto";
-function isChatTrajectoryMessage(value) {
-  return isObject2(value) && typeof value.role === "string" && typeof value.content === "string";
-}
-function isChatTrajectory(value) {
-  return isObject2(value) && Array.isArray(value.messages) && value.messages.length > 0 && value.messages.every(isChatTrajectoryMessage);
-}
-function chatTrajectoryToSpans(input, options = {}) {
-  const trajectory = Array.isArray(input) ? { messages: input } : input;
-  if (trajectory.messages.length === 0) throw new Error("chat trajectory contains no messages");
-  if (!trajectory.messages.every(isChatTrajectoryMessage)) {
-    throw new TypeError("chat trajectory messages require string role and content fields");
-  }
-  const traceId = options.traceId ?? trajectoryId(trajectory);
-  const service = options.service ?? trajectory.trajectory_format ?? "chat-trajectory";
-  const stepMode = options.stepMode ?? "assistant";
-  const times = messageTimes(trajectory.messages);
-  const actionCount = trajectory.messages.filter((message) => messageKind(message.role) === "LLM").length;
-  const root = span({
-    traceId,
-    spanId: "root",
-    name: "trajectory",
-    kind: "AGENT",
-    startTime: times[0],
-    endTime: times.at(-1),
-    service,
-    costUsd: finiteNumber(trajectory.info?.model_stats, "instance_cost"),
-    extra: compactAttributes({
-      "traces.source_format": "chat-trajectory",
-      "trajectory.format": trajectory.trajectory_format,
-      "trajectory.message_count": trajectory.messages.length,
-      "trajectory.action_count": actionCount,
-      "trajectory.source_path": options.sourcePath,
-      "trajectory.api_calls": finiteNumber(trajectory.info?.model_stats, "api_calls"),
-      "trajectory.timestamps_synthetic": trajectory.messages.some(
-        (message) => message.timestamp === void 0
-      )
-    })
-  });
-  const spans = [root];
-  let assistantStep = 0;
-  for (const [index, message] of trajectory.messages.entries()) {
-    const kind = messageKind(message.role);
-    if (kind === "LLM") assistantStep += 1;
-    const step = stepMode === "message" ? index + 1 : kind === "LLM" ? assistantStep : void 0;
-    const spanId = step === void 0 ? `message-${index + 1}` : `step-${step}`;
-    const response = isObject2(message.extra?.response) ? message.extra.response : void 0;
-    const usage = isObject2(response?.usage) ? response.usage : void 0;
-    const completionDetails = isObject2(usage?.completion_tokens_details) ? usage.completion_tokens_details : void 0;
-    const promptDetails = isObject2(usage?.prompt_tokens_details) ? usage.prompt_tokens_details : void 0;
-    spans.push(
-      span({
-        traceId,
-        spanId,
-        parentSpanId: "root",
-        name: messageName(kind, message),
-        kind,
-        startTime: times[index],
-        service,
-        agent: messageAgent(message.role),
-        model: stringValue2(response?.model),
-        inputTokens: finiteNumber(usage, "prompt_tokens"),
-        outputTokens: finiteNumber(usage, "completion_tokens"),
-        reasoningTokens: finiteNumber(completionDetails, "reasoning_tokens"),
-        cachedInputTokens: finiteNumber(promptDetails, "cached_tokens"),
-        step,
-        content: capText(message.content),
-        extra: compactAttributes({
-          "traces.source_format": "chat-trajectory",
-          "trajectory.message_index": index + 1,
-          "trajectory.action_index": kind === "LLM" ? assistantStep : void 0,
-          "trajectory.role": message.role
-        })
-      })
-    );
-  }
-  return validateOtlpSpans(spans, "chat trajectory output");
-}
-function trajectoryId(trajectory) {
-  const value = trajectory.trajectory_id ?? trajectory.traj_id ?? trajectory.instance_id;
-  if (typeof value === "string" && value.trim()) return value;
-  if (typeof value === "number" && Number.isSafeInteger(value)) return String(value);
-  return `trajectory-${createHash6("sha256").update(JSON.stringify(trajectory.messages)).digest("hex").slice(0, 24)}`;
-}
-function messageKind(role) {
-  const normalized = role.trim().toLowerCase();
-  if (normalized === "assistant" || normalized === "agent") return "LLM";
-  if (normalized === "tool" || normalized === "function" || normalized === "observation") {
-    return "TOOL";
-  }
-  return "CHAIN";
-}
-function messageName(kind, message) {
-  if (kind === "LLM") return "message.assistant";
-  if (kind === "TOOL") return `tool.${message.name?.trim() || "result"}`;
-  const role = message.role.trim().toLowerCase();
-  if (role === "system") return "system.prompt";
-  if (role === "user" || role === "human") return "user.prompt";
-  return "message.other";
-}
-function messageAgent(role) {
-  const normalized = role.trim().toLowerCase();
-  return ["system", "user", "human", "tool", "function", "observation"].includes(normalized) ? void 0 : role.trim();
-}
-function messageTimes(messages) {
-  const supplied = messages.filter((message) => message.timestamp !== void 0).length;
-  if (supplied === 0) return messages.map((_, index) => new Date(index).toISOString());
-  if (supplied !== messages.length) {
-    throw new TypeError("chat trajectory timestamps must be present on every message or none");
-  }
-  const times = messages.map((message, index) => messageTime(message.timestamp, index));
-  for (let index = 1; index < times.length; index += 1) {
-    if (Date.parse(times[index]) < Date.parse(times[index - 1])) {
-      throw new RangeError(
-        `chat trajectory message ${index + 1} timestamp precedes message ${index}`
-      );
-    }
-  }
-  return times;
-}
-function messageTime(value, index) {
-  const parsed = parseTime(value);
-  if (!parsed) {
-    throw new TypeError(`chat trajectory message ${index + 1} has an invalid timestamp`);
-  }
-  return parsed;
-}
-function parseTime(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    const millis2 = value < 1e10 ? value * 1e3 : value;
-    const date = new Date(millis2);
-    return Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
-  }
-  if (typeof value !== "string" || !value.trim()) return void 0;
-  const millis = Date.parse(value);
-  return Number.isFinite(millis) ? new Date(millis).toISOString() : void 0;
-}
-function finiteNumber(value, key) {
-  if (!isObject2(value)) return void 0;
-  const number = value[key];
-  return typeof number === "number" && Number.isFinite(number) ? number : void 0;
-}
-function stringValue2(value) {
-  return typeof value === "string" && value.trim() ? value : void 0;
-}
-function compactAttributes(values) {
-  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
-}
-function isObject2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
 // src/redact.ts
 import { DEFAULT_REDACTION_RULES, redactValue } from "@tangle-network/agent-eval/traces";
 var CODING_REDACTION_RULES = [
@@ -7002,10 +7698,10 @@ async function applyRedactor(spans, redactor) {
 }
 
 // src/file-export.ts
-import { createHash as createHash7 } from "crypto";
-import { mkdtemp as mkdtemp3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { createHash as createHash8 } from "crypto";
+import { mkdtemp as mkdtemp4, readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join15 } from "path";
+import { join as join18 } from "path";
 import {
   firstNumberAttr,
   LLM_CACHED_TOKEN_ATTR_KEYS,
@@ -7021,18 +7717,18 @@ import {
   LLM_REASONING_TOKEN_ATTR_KEYS,
   LLM_REASONING_TOKENS
 } from "@tangle-network/agent-eval/trace-attributes";
-function isObject3(value) {
+function isObject4(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function stringValue3(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function objectValue2(value) {
-  return isObject3(value) ? value : void 0;
+  return isObject4(value) ? value : void 0;
 }
 function stableJson(value) {
   return JSON.stringify(value, (_key, v) => {
-    if (!isObject3(v)) return v;
+    if (!isObject4(v)) return v;
     return Object.keys(v).sort().reduce((acc, key) => {
       acc[key] = v[key];
       return acc;
@@ -7040,7 +7736,7 @@ function stableJson(value) {
   });
 }
 function hashId(value, chars = 16) {
-  return createHash7("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
+  return createHash8("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
 }
 function isoTime2(value) {
   if (typeof value === "string") {
@@ -7064,7 +7760,7 @@ function firstTime(obj, keys) {
 }
 function firstTimeDeep(value, keys, depth = 5) {
   if (depth < 0) return void 0;
-  if (isObject3(value)) {
+  if (isObject4(value)) {
     const direct = firstTime(value, keys);
     if (direct) return direct;
     for (const child of Object.values(value)) {
@@ -7091,7 +7787,7 @@ function parseJsonRows(text2) {
     try {
       const parsed = JSON.parse(trimmed);
       if (Array.isArray(parsed)) return { rows: parsed };
-      if (isObject3(parsed)) {
+      if (isObject4(parsed)) {
         const events = parsed.events;
         if (Array.isArray(events)) return { rows: events, wrapper: parsed };
         return { rows: [parsed] };
@@ -7107,21 +7803,21 @@ function parseJsonRows(text2) {
   };
 }
 function isPolicyEvidenceRow(row) {
-  return isObject3(row) && row.kind === "traces.policy_evidence.session";
+  return isObject4(row) && row.kind === "traces.policy_evidence.session";
 }
 function isOpenInferenceRow(row) {
-  if (!isObject3(row)) return false;
-  return typeof row.trace_id === "string" && typeof row.span_id === "string" && (row.parent_span_id === null || typeof row.parent_span_id === "string") && typeof row.name === "string" && typeof row.start_time === "string" && typeof row.end_time === "string" && isObject3(row.status) && isObject3(row.attributes) && isObject3(row.resource) && isObject3(row.scope);
+  if (!isObject4(row)) return false;
+  return typeof row.trace_id === "string" && typeof row.span_id === "string" && (row.parent_span_id === null || typeof row.parent_span_id === "string") && typeof row.name === "string" && typeof row.start_time === "string" && typeof row.end_time === "string" && isObject4(row.status) && isObject4(row.attributes) && isObject4(row.resource) && isObject4(row.scope);
 }
 function isIntelligenceSpanRow(row) {
-  if (!isObject3(row)) return false;
-  return typeof row.trace_id === "string" && typeof row.name === "string" && isObject3(row.attributes) && (row.start_unix_nano != null || row.start_time != null || row.received_at != null);
+  if (!isObject4(row)) return false;
+  return typeof row.trace_id === "string" && typeof row.name === "string" && isObject4(row.attributes) && (row.start_unix_nano != null || row.start_time != null || row.received_at != null);
 }
 function eventType(row) {
   return stringValue3(row.type) ?? stringValue3(row.event) ?? stringValue3(row.name) ?? stringValue3(row.kind);
 }
 function looksLikeSandboxEvent(row) {
-  if (!isObject3(row)) return false;
+  if (!isObject4(row)) return false;
   const type = eventType(row)?.toLowerCase();
   return type === "start" || type === "raw" || type === "result" || type === "done" || type === "error";
 }
@@ -7153,7 +7849,7 @@ function requireIntelligenceSpanRows(rows) {
   return rows;
 }
 function requireObjectRows(rows) {
-  if (!rows.every(isObject3)) throw new Error("sandbox-events input must contain only JSON object events");
+  if (!rows.every(isObject4)) throw new Error("sandbox-events input must contain only JSON object events");
   return rows;
 }
 function chatTrajectoryRowsToSpans(rows, sourcePath) {
@@ -7236,7 +7932,7 @@ function policyEvidenceToSpans(records) {
 }
 function findStringKey(value, keys, depth = 4) {
   if (depth < 0) return void 0;
-  if (isObject3(value)) {
+  if (isObject4(value)) {
     for (const key of keys) {
       const found = stringValue3(value[key]);
       if (found) return found;
@@ -7289,9 +7985,9 @@ function eventEndTimestamp(row, fallback) {
 }
 function eventStatus(row, type) {
   const lowered = type.toLowerCase();
-  const errorMessage = stringValue3(row.error) ?? findStringKey(row, ["error", "errorMessage", "error_message"], 3);
-  if (lowered.includes("error") || errorMessage) {
-    const message = errorMessage ?? stringValue3(row.message);
+  const errorMessage2 = stringValue3(row.error) ?? findStringKey(row, ["error", "errorMessage", "error_message"], 3);
+  if (lowered.includes("error") || errorMessage2) {
+    const message = errorMessage2 ?? stringValue3(row.message);
     return { status: "ERROR", ...message ? { message: capText(message) } : {} };
   }
   return { status: "OK" };
@@ -7524,7 +8220,7 @@ function intelligenceSpansToSpans(rows) {
 }
 function openInferenceToSpans(rows) {
   return rows.map((row) => {
-    const attrs = isObject3(row.attributes) ? { ...row.attributes } : {};
+    const attrs = isObject4(row.attributes) ? { ...row.attributes } : {};
     const resource = objectValue2(row.resource);
     const resourceAttrs = objectValue2(resource?.attributes);
     if (resourceAttrs) copyDefined(attrs, resourceAttrs);
@@ -7637,20 +8333,20 @@ async function exportTraceEvidenceFile(inputPath, opts = {}) {
       redactionsByRule
     };
   }
-  const text2 = await readFile4(inputPath, "utf8");
+  const text2 = await readFile7(inputPath, "utf8");
   return exportTraceEvidenceText(text2, { ...opts, sourcePath: inputPath });
 }
 async function writeTraceEvidenceExportFile(inputPath, outPath, opts = {}) {
   const result = await exportTraceEvidenceFile(inputPath, opts);
-  const path = outPath ?? join15(await mkdtemp3(join15(tmpdir3(), "traces-export-")), "spans.openinference.jsonl");
-  await writeFile3(path, serializeSpans(result.spans), "utf8");
+  const path = outPath ?? join18(await mkdtemp4(join18(tmpdir3(), "traces-export-")), "spans.openinference.jsonl");
+  await writeFile4(path, serializeSpans(result.spans), "utf8");
   return { ...result, path };
 }
 
 // src/inspect.ts
-import { mkdtemp as mkdtemp4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { basename as basename10, join as join16 } from "path";
+import { basename as basename12, join as join19 } from "path";
 var severityRank = {
   high: 0,
   medium: 1,
@@ -7833,7 +8529,7 @@ function addContextFindings(index, findings) {
       refs: invalidJsonlFiles.slice(0, 5).map((file) => file.path)
     });
   }
-  const skillRunFiles = files.filter((file) => basename10(file.path) === "skill-runs.jsonl" && (file.jsonl?.rows ?? 0) > 0).map((file) => {
+  const skillRunFiles = files.filter((file) => basename12(file.path) === "skill-runs.jsonl" && (file.jsonl?.rows ?? 0) > 0).map((file) => {
     const rows = file.jsonl?.rows ?? 0;
     const keys = file.jsonl?.keys ?? {};
     const linkKeyCounts = {
@@ -7934,19 +8630,19 @@ function assertSessionIndex(value) {
   }
 }
 async function readSessionIndexFile(path) {
-  const parsed = JSON.parse(await readFile5(path, "utf8"));
+  const parsed = JSON.parse(await readFile8(path, "utf8"));
   assertSessionIndex(parsed);
   return parsed;
 }
 async function writeInspectionReportFile(report, outPath) {
-  const path = outPath ?? join16(await mkdtemp4(join16(tmpdir4(), "traces-inspect-")), "inspection-report.md");
-  await writeFile4(path, renderInspectionReport(report), "utf8");
+  const path = outPath ?? join19(await mkdtemp5(join19(tmpdir4(), "traces-inspect-")), "inspection-report.md");
+  await writeFile5(path, renderInspectionReport(report), "utf8");
   return path;
 }
 
 // src/adoption.ts
-import { readFile as readFile6 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join20 } from "path";
 function toolName2(s) {
   const n = s.attributes["tool.name"];
   if (typeof n === "string") return n;
@@ -8066,10 +8762,10 @@ async function readLoopRuns(cwds, sessionIds) {
     seenCwds.add(cwd);
     const firstSourceByRun = /* @__PURE__ */ new Map();
     for (const artifactDir of [".agent", ".evolve"]) {
-      const path = join17(cwd, artifactDir, "skill-runs.jsonl");
+      const path = join20(cwd, artifactDir, "skill-runs.jsonl");
       let raw;
       try {
-        raw = await readFile6(path, "utf8");
+        raw = await readFile9(path, "utf8");
       } catch {
         continue;
       }
@@ -8881,9 +9577,9 @@ function renderAdoption(ar) {
 }
 
 // src/improvement.ts
-import { access, mkdir as mkdir2, mkdtemp as mkdtemp5, writeFile as writeFile5 } from "fs/promises";
+import { access, mkdir as mkdir4, mkdtemp as mkdtemp6, writeFile as writeFile6 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import { dirname as dirname4, join as join18, resolve as resolve4 } from "path";
+import { dirname as dirname6, join as join21, resolve as resolve6 } from "path";
 import { pathToFileURL } from "url";
 import {
   AnalystRegistry,
@@ -9227,7 +9923,7 @@ function registryFromConfig(config) {
 async function existingConfigPath(path) {
   const candidates = path ? [path] : ["traces.config.mjs", "traces.config.js", "traces.config.cjs"];
   for (const candidate of candidates) {
-    const resolved = resolve4(candidate);
+    const resolved = resolve6(candidate);
     try {
       await access(resolved);
       return resolved;
@@ -9353,29 +10049,29 @@ async function runTraceStoreInvestigation(opts) {
   };
 }
 async function writeTraceImprovementArtifacts(result, outDir) {
-  const directory = outDir ? resolve4(outDir) : await mkdtemp5(join18(tmpdir5(), "traces-improvement-"));
-  await mkdir2(directory, { recursive: true });
+  const directory = outDir ? resolve6(outDir) : await mkdtemp6(join21(tmpdir5(), "traces-improvement-"));
+  await mkdir4(directory, { recursive: true });
   const paths = {
     directory,
-    result: join18(directory, "result.json"),
-    evidence: join18(directory, "evidence.jsonl"),
-    report: join18(directory, "report.md"),
+    result: join21(directory, "result.json"),
+    evidence: join21(directory, "evidence.jsonl"),
+    report: join21(directory, "report.md"),
     traces: result.otlpPath
   };
   const { report, ...machineResult } = result;
   await Promise.all([
-    writeFile5(paths.result, json(machineResult), "utf8"),
-    writeFile5(paths.evidence, jsonl(buildEvidenceRows(result.findings)), "utf8"),
-    writeFile5(paths.report, report, "utf8")
+    writeFile6(paths.result, json(machineResult), "utf8"),
+    writeFile6(paths.evidence, jsonl(buildEvidenceRows(result.findings)), "utf8"),
+    writeFile6(paths.report, report, "utf8")
   ]);
   return paths;
 }
 async function runTraceImprovement(opts) {
-  const directory = opts.outDir ? resolve4(opts.outDir) : await mkdtemp5(join18(tmpdir5(), "traces-improvement-"));
-  await mkdir2(directory, { recursive: true });
+  const directory = opts.outDir ? resolve6(opts.outDir) : await mkdtemp6(join21(tmpdir5(), "traces-improvement-"));
+  await mkdir4(directory, { recursive: true });
   const investigation = await runTraceInvestigation({
     ...opts,
-    otlpOutPath: opts.otlpOutPath ?? join18(directory, "traces.otlp.jsonl")
+    otlpOutPath: opts.otlpOutPath ?? join21(directory, "traces.otlp.jsonl")
   });
   const result = {
     ...investigation,
@@ -9387,32 +10083,32 @@ async function runTraceImprovement(opts) {
   };
 }
 async function saveReport(path, report) {
-  await mkdir2(dirname4(resolve4(path)), { recursive: true });
-  await writeFile5(path, report, "utf8");
+  await mkdir4(dirname6(resolve6(path)), { recursive: true });
+  await writeFile6(path, report, "utf8");
 }
 
 // src/live.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var VERIFY_RE = /\b(test|tests|vitest|jest|pytest|go test|cargo test|tsc|typecheck|lint|biome|eslint|build|check:invariants|preflight)\b/i;
 var CHANGE_RE = /\b(apply_patch|edit|write|create|delete|rename|replace|update|git apply|sed -i|perl -pi|tee\s|cat\s+>)/i;
 var CLAIM_DONE_RE = /\b(done|fixed|complete|completed|implemented|merged|verified|all green|tests pass|ready|works now)\b/i;
-var sleep = (ms, signal) => new Promise((resolve5) => {
+var sleep = (ms, signal) => new Promise((resolve7) => {
   if (signal?.aborted) {
-    resolve5();
+    resolve7();
     return;
   }
   const onAbort = () => {
     clearTimeout(t);
-    resolve5();
+    resolve7();
   };
   const t = setTimeout(() => {
     signal?.removeEventListener("abort", onAbort);
-    resolve5();
+    resolve7();
   }, ms);
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 function hash(parts) {
-  return createHash8("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+  return createHash9("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
 }
 function asString(value) {
   if (typeof value === "string" && value.trim()) return value;
@@ -10149,11 +10845,11 @@ async function collectSessionWorkflow(adapter, seeds, options = {}) {
 }
 
 // src/session-selection.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { createReadStream as createReadStream2 } from "fs";
 async function fileSha256(path, signal) {
   signal?.throwIfAborted();
-  const hash2 = createHash9("sha256");
+  const hash2 = createHash10("sha256");
   try {
     for await (const chunk of createReadStream2(path, { signal })) {
       signal?.throwIfAborted();
@@ -10181,8 +10877,8 @@ async function sourceSnapshot(adapter, ref, signal) {
     signal?.throwIfAborted();
     files.push({ path, sha256: await fileSha256(path, signal) });
   }
-  const sha256 = files.length === 1 ? files[0].sha256 : createHash9("sha256").update(JSON.stringify(files)).digest("hex");
-  return { sha256, files };
+  const sha2562 = files.length === 1 ? files[0].sha256 : createHash10("sha256").update(JSON.stringify(files)).digest("hex");
+  return { sha256: sha2562, files };
 }
 function summarizeWorkflows(workflows) {
   if (workflows.length === 0) return void 0;
@@ -10276,9 +10972,9 @@ async function collectSessionSelection(groups, options = {}) {
 }
 
 // src/session-index.ts
-import { mkdtemp as mkdtemp6, readdir as readdir15, readFile as readFile7, stat as stat12, writeFile as writeFile6 } from "fs/promises";
+import { mkdtemp as mkdtemp7, readdir as readdir15, readFile as readFile10, stat as stat13, writeFile as writeFile7 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { dirname as dirname5, join as join19 } from "path";
+import { dirname as dirname7, join as join22 } from "path";
 function indexRow(record2) {
   return {
     session: record2.session,
@@ -10333,7 +11029,7 @@ function buildSessionIndex(records, opts = {}) {
 }
 async function pathStat2(path) {
   try {
-    return await stat12(path);
+    return await stat13(path);
   } catch {
     return null;
   }
@@ -10349,13 +11045,13 @@ async function findContextRoot(cwd) {
   let current = cwd;
   const s = await pathStat2(current);
   if (!s) return null;
-  if (!s.isDirectory()) current = dirname5(current);
+  if (!s.isDirectory()) current = dirname7(current);
   for (; ; ) {
-    if (await pathStat2(join19(current, ".git")) || await dirExists(join19(current, ".evolve")) || await fileExists(join19(current, "AGENTS.md")) || await fileExists(join19(current, "CLAUDE.md"))) {
+    if (await pathStat2(join22(current, ".git")) || await dirExists(join22(current, ".evolve")) || await fileExists(join22(current, "AGENTS.md")) || await fileExists(join22(current, "CLAUDE.md"))) {
       return current;
     }
-    const parent = dirname5(current);
-    if (parent === current) return s.isDirectory() ? cwd : dirname5(cwd);
+    const parent = dirname7(current);
+    if (parent === current) return s.isDirectory() ? cwd : dirname7(cwd);
     current = parent;
   }
 }
@@ -10394,7 +11090,7 @@ async function summarizeFile(path, kind) {
   const base = { kind, path, bytes: Number(s.size), mtimeMs: Number(s.mtimeMs) };
   if (!path.endsWith(".md") && !path.endsWith(".jsonl")) return base;
   try {
-    const text2 = await readFile7(path, "utf8");
+    const text2 = await readFile10(path, "utf8");
     const lines = countLines(text2);
     const jsonl2 = path.endsWith(".jsonl") ? summarizeJsonl(text2) : void 0;
     return {
@@ -10419,7 +11115,7 @@ async function walkMarkdown(root, kind, maxFiles = 100) {
     }
     for (const entry of entries) {
       if (out.length >= maxFiles) return;
-      const path = join19(dir, entry.name);
+      const path = join22(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(path);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -10434,20 +11130,20 @@ async function walkMarkdown(root, kind, maxFiles = 100) {
 async function collectContextRoot(root) {
   const files = [];
   for (const name of ["AGENTS.md", "CLAUDE.md", "GEMINI.md"]) {
-    const summary = await summarizeFile(join19(root, name), "instruction-doc");
+    const summary = await summarizeFile(join22(root, name), "instruction-doc");
     if (summary) files.push(summary);
   }
-  const evolve = join19(root, ".evolve");
+  const evolve = join22(root, ".evolve");
   for (const name of ["skill-runs.jsonl", "governor.jsonl", "experiments.jsonl"]) {
-    const summary = await summarizeFile(join19(evolve, name), "evolve-jsonl");
+    const summary = await summarizeFile(join22(evolve, name), "evolve-jsonl");
     if (summary) files.push(summary);
   }
   for (const name of ["scorecard.json"]) {
-    const summary = await summarizeFile(join19(evolve, name), "evolve-json");
+    const summary = await summarizeFile(join22(evolve, name), "evolve-json");
     if (summary) files.push(summary);
   }
-  files.push(...await walkMarkdown(join19(evolve, "reflections"), "reflection"));
-  files.push(...await walkMarkdown(join19(evolve, "handoffs"), "handoff"));
+  files.push(...await walkMarkdown(join22(evolve, "reflections"), "reflection"));
+  files.push(...await walkMarkdown(join22(evolve, "handoffs"), "handoff"));
   return { root, files: files.sort((a, b) => a.path.localeCompare(b.path)) };
 }
 async function collectContextIndex(records) {
@@ -10493,19 +11189,19 @@ function serializeSessionIndex(index) {
 `;
 }
 async function writeSessionIndexFile(index, outPath) {
-  const path = outPath ?? join19(await mkdtemp6(join19(tmpdir6(), "traces-index-")), "session-index.json");
-  await writeFile6(path, serializeSessionIndex(index), "utf8");
+  const path = outPath ?? join22(await mkdtemp7(join22(tmpdir6(), "traces-index-")), "session-index.json");
+  await writeFile7(path, serializeSessionIndex(index), "utf8");
   return path;
 }
 
 // src/upload-state.ts
-import { mkdir as mkdir3, readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile11, writeFile as writeFile8 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname6, join as join20 } from "path";
+import { dirname as dirname8, join as join23 } from "path";
 import { contentHash } from "@tangle-network/agent-eval";
 function stateFile() {
-  const base = process.env.XDG_STATE_HOME ?? join20(homedir12(), ".local", "state");
-  return join20(base, "tangle-traces", "uploaded.json");
+  const base = process.env.XDG_STATE_HOME ?? join23(homedir12(), ".local", "state");
+  return join23(base, "tangle-traces", "uploaded.json");
 }
 function uploadKey(harness, sessionId) {
   return `${harness}:${sessionId}`;
@@ -10518,15 +11214,15 @@ function outboundHash(events, identity) {
 }
 async function loadState() {
   try {
-    return JSON.parse(await readFile8(stateFile(), "utf8"));
+    return JSON.parse(await readFile11(stateFile(), "utf8"));
   } catch {
     return {};
   }
 }
 async function saveState(state) {
   const f = stateFile();
-  await mkdir3(dirname6(f), { recursive: true });
-  await writeFile7(f, `${JSON.stringify(state, null, 2)}
+  await mkdir5(dirname8(f), { recursive: true });
+  await writeFile8(f, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 function alreadyUploaded(state, harness, sessionId, hash2) {
@@ -10534,10 +11230,10 @@ function alreadyUploaded(state, harness, sessionId, hash2) {
 }
 
 // src/upload.ts
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { createRequire } from "module";
-import { hostname } from "os";
-import { basename as basename11, join as join21 } from "path";
+import { hostname as hostname2 } from "os";
+import { basename as basename13, join as join24 } from "path";
 import { hostedClientFromEnv } from "@tangle-network/agent-eval/hosted";
 import { REDACTION_VERSION } from "@tangle-network/agent-eval/traces";
 var require2 = createRequire(import.meta.url);
@@ -10561,7 +11257,7 @@ async function planUpload(opts = {}) {
 async function gitBranch(cwd) {
   if (!cwd) return void 0;
   try {
-    const head = await readFile9(join21(cwd, ".git", "HEAD"), "utf8");
+    const head = await readFile12(join24(cwd, ".git", "HEAD"), "utf8");
     const m = head.match(/^ref:\s*refs\/heads\/(.+)$/m);
     return m?.[1]?.trim();
   } catch {
@@ -10571,8 +11267,8 @@ async function gitBranch(cwd) {
 async function sessionMeta(item) {
   const meta = {
     [ATTR.HARNESS]: item.ref.harness,
-    [ATTR.SESSION_FILE]: basename11(item.ref.path),
-    [ATTR.HOST]: hostname(),
+    [ATTR.SESSION_FILE]: basename13(item.ref.path),
+    [ATTR.HOST]: hostname2(),
     [ATTR.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
     [ATTR.REDACTION_VERSION]: REDACTION_VERSION,
     [ATTR.REDACTION_COUNT]: item.redaction.redactionCount
@@ -10745,6 +11441,10 @@ export {
   sessionIdFromAttributes,
   indexSessionIdsByTrace,
   stampSessionIdentity,
+  isChatTrajectoryMessage,
+  isChatTrajectory,
+  chatTrajectoryToSpans,
+  importCodeTraceBench,
   summarizeOtlpExecution,
   summarizeSpanExecution,
   toRuntimeStore,
@@ -10804,9 +11504,6 @@ export {
   commandRedactor,
   writeHodoscopeInput,
   hodoscopeAnalyzer,
-  isChatTrajectoryMessage,
-  isChatTrajectory,
-  chatTrajectoryToSpans,
   CODING_REDACTION_RULES,
   TRACES_REDACTION_RULES,
   redactSpans,