@tangle-network/traces 0.23.1 → 1.0.1

package/dist/chunk-WF7PTDCZ.js

@@ -0,0 +1,3921 @@
+import {
+  INTERRUPT_TEXT,
+  PIECE_START,
+  authorOfTypedTurn,
+  isFleetTurn,
+  isHarnessCommand,
+  pieceBoundary,
+  readSessionSpans,
+  readsStoreRoots
+} from "./chunk-7USMM4MA.js";
+import {
+  ACTOR_ATTR,
+  ATTR,
+  INHERITED_SOURCE_ATTR,
+  INHERITED_SPAN_ATTR,
+  SESSION_CWD_ATTR,
+  SESSION_TOTAL_CACHED_INPUT_ATTR,
+  SESSION_TOTAL_CACHE_WRITE_ATTR,
+  SESSION_TOTAL_INPUT_ATTR,
+  SESSION_TOTAL_OUTPUT_ATTR,
+  SESSION_TOTAL_REASONING_ATTR,
+  SUBAGENT_SPAWN_ATTR,
+  SUBAGENT_SPAWN_TASK_ATTR,
+  SUBAGENT_TASK_ATTR,
+  capText,
+  indexSessionIdsByTrace,
+  isSubagentSpan,
+  isSynthesizedSpan,
+  sessionIdFromAttributes,
+  stampSessionIdentity
+} from "./chunk-UQSAGXPH.js";
+import {
+  validateOtlpSpans
+} from "./chunk-CQ6UYZG6.js";
+import {
+  canonicalJson,
+  isInnerToolCall
+} from "./chunk-DU534HAX.js";
+
+// src/session-relationship.ts
+var SessionWorkflowError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SessionWorkflowError";
+    this.code = code;
+  }
+};
+function stringAttribute(span, key) {
+  const value = span?.attributes[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberAttribute(span, key) {
+  const value = span?.attributes[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseSessionIds(value, key) {
+  if (value === void 0) return [];
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      throw new SessionWorkflowError(
+        "SESSION_WORKFLOW_INVALID_RELATION",
+        `${key} must be a JSON array of non-empty session IDs`
+      );
+    }
+  }
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string" || item.length === 0)) {
+    throw new SessionWorkflowError(
+      "SESSION_WORKFLOW_INVALID_RELATION",
+      `${key} must be a JSON array of non-empty session IDs`
+    );
+  }
+  return parsed;
+}
+function sessionRoot(ref, spans) {
+  const roots = spans.filter((span) => span.parent_span_id === null);
+  return roots.find((span) => sessionIdFromAttributes(span.attributes) === ref.sessionId) ?? roots.find((span) => span.trace_id === ref.sessionId) ?? roots[0] ?? spans[0];
+}
+function describeSessionRelationship(ref, spans) {
+  const root = sessionRoot(ref, spans);
+  const sessionId = sessionIdFromAttributes(root?.attributes ?? {}) ?? root?.trace_id ?? ref.sessionId;
+  const parentSessionId = stringAttribute(root, "traces.parent_session_id");
+  const childSessionIds = /* @__PURE__ */ new Set();
+  const spawnedChildSessionIds = /* @__PURE__ */ new Set();
+  const resumedChildSessionIds = /* @__PURE__ */ new Set();
+  const unjoinedSpawnPaths = /* @__PURE__ */ new Set();
+  for (const span of spans) {
+    const direct = parseSessionIds(span.attributes["traces.child_session_ids"], "traces.child_session_ids");
+    for (const id of direct) childSessionIds.add(id);
+    const operation = span.attributes["traces.codex.agent_operation"];
+    const agentSessionIds = parseSessionIds(
+      span.attributes["traces.codex.agent_session_ids"],
+      "traces.codex.agent_session_ids"
+    );
+    const operationName = String(operation);
+    if (["spawn_agent", "send_input", "send_message", "followup_task"].includes(operationName)) {
+      for (const id of agentSessionIds) childSessionIds.add(id);
+    }
+    if (operationName === "spawn_agent") {
+      for (const id of [...direct, ...agentSessionIds]) spawnedChildSessionIds.add(id);
+    }
+    if (["send_input", "send_message", "followup_task"].includes(operationName)) {
+      for (const id of [...direct, ...agentSessionIds]) resumedChildSessionIds.add(id);
+    }
+    const lifecycleChild = stringAttribute(span, "traces.codex.subagent_thread_id");
+    if (lifecycleChild) childSessionIds.add(lifecycleChild);
+    const spawnPath = stringAttribute(span, "traces.codex.spawn_agent_path");
+    if (operationName === "spawn_agent" && spawnPath && agentSessionIds.length === 0 && direct.length === 0) {
+      unjoinedSpawnPaths.add(spawnPath);
+    }
+  }
+  for (const ids of [childSessionIds, spawnedChildSessionIds, resumedChildSessionIds]) {
+    ids.delete(sessionId);
+    if (parentSessionId) ids.delete(parentSessionId);
+  }
+  const role = stringAttribute(root, "traces.session.role");
+  const depth = numberAttribute(root, "traces.codex.agent_depth");
+  const agentNickname = stringAttribute(root, "traces.codex.agent_nickname");
+  const agentRole = stringAttribute(root, "traces.codex.agent_role");
+  const agentPath = stringAttribute(root, "traces.codex.agent_path");
+  const rawTaskScope = stringAttribute(root, "traces.codex.task_scope");
+  const taskScope = rawTaskScope === "all" || rawTaskScope === "latest" || rawTaskScope === "turn" || rawTaskScope === "fork-current" ? rawTaskScope : void 0;
+  const turnId = stringAttribute(root, "traces.codex.turn_id");
+  return {
+    sessionId,
+    role: role === "operator" || role === "child" ? role : "unknown",
+    ...parentSessionId ? { parentSessionId } : {},
+    childSessionIds: [...childSessionIds].sort(),
+    spawnedChildSessionIds: [...spawnedChildSessionIds].sort(),
+    resumedChildSessionIds: [...resumedChildSessionIds].filter((sessionId2) => !spawnedChildSessionIds.has(sessionId2)).sort(),
+    unjoinedSpawnPaths: [...unjoinedSpawnPaths].sort(),
+    ...depth !== void 0 ? { depth } : {},
+    ...agentNickname ? { agentNickname } : {},
+    ...agentRole ? { agentRole } : {},
+    ...agentPath ? { agentPath } : {},
+    ...taskScope ? { taskScope } : {},
+    ...turnId ? { turnId } : {},
+    ...taskScope && taskScope !== "all" && root ? { taskStartedAt: root.start_time } : {}
+  };
+}
+
+// src/shell-commands.ts
+var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh", "ash", "busybox"]);
+var COMMAND_PREFIXES = /* @__PURE__ */ new Set([
+  "env",
+  "command",
+  "builtin",
+  "exec",
+  "nohup",
+  "time",
+  "sudo",
+  "doas",
+  "nice",
+  "stdbuf",
+  "setsid",
+  "then",
+  "do",
+  "else",
+  "elif",
+  "if",
+  "while",
+  "until",
+  "!",
+  "{",
+  "("
+]);
+var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+var MAX_SHELL_DEPTH = 4;
+var MAX_WORDS = 2e4;
+function basename(word) {
+  const cut = word.lastIndexOf("/");
+  return cut === -1 ? word : word.slice(cut + 1);
+}
+var ShellScanner = class {
+  text;
+  length;
+  depth;
+  commands = [];
+  word = [];
+  wordStarted = false;
+  current = [];
+  words = 0;
+  heredocs = [];
+  constructor(text, depth) {
+    this.text = text;
+    this.length = text.length;
+    this.depth = depth;
+  }
+  run() {
+    let index = 0;
+    while (index < this.length && this.words < MAX_WORDS) {
+      index = this.step(index);
+    }
+    this.endCommand();
+    return this.commands;
+  }
+  step(index) {
+    const text = this.text;
+    const char = text[index];
+    if (char === "\\") {
+      if (index + 1 >= this.length) return index + 1;
+      if (text[index + 1] !== "\n") this.push(text[index + 1]);
+      return index + 2;
+    }
+    if (char === "'") return this.readSingleQuote(index);
+    if (char === '"') return this.readDoubleQuote(index);
+    if (char === "`") return this.readBackTick(index);
+    if (char === "$" && text[index + 1] === "(" && text[index + 2] === "(") {
+      const close = text.indexOf("))", index + 3);
+      const end = close === -1 ? this.length : close + 2;
+      this.pushText(text.slice(index, end));
+      return end;
+    }
+    if (char === "$" && text[index + 1] === "(") return this.readSubstitution(index + 2);
+    if (char === "$" && text[index + 1] === "{") {
+      const end = this.findBalanced(index + 2, "{", "}") + 1;
+      this.pushText(text.slice(index, end));
+      return end;
+    }
+    if (char === "#" && !this.wordStarted) {
+      const newline = text.indexOf("\n", index);
+      return newline === -1 ? this.length : newline;
+    }
+    if (char === "<" && text[index + 1] === "<" && text[index + 2] !== "<") return this.readHeredocHeader(index);
+    if (char === ">" || char === "<") return this.readRedirect(index);
+    if (char === "\n") {
+      this.endCommand();
+      return this.heredocs.length > 0 ? this.skipHeredocBodies(index + 1) : index + 1;
+    }
+    if (char === ";" || char === "&" || char === "|" || char === "(" || char === ")") {
+      this.endCommand();
+      return index + 1;
+    }
+    if (char === " " || char === "	" || char === "\r") {
+      this.endWord();
+      return index + 1;
+    }
+    if (char >= "0" && char <= "9" && !this.wordStarted && (text[index + 1] === ">" || text[index + 1] === "<")) {
+      return this.readRedirect(index + 1);
+    }
+    this.push(char);
+    return index + 1;
+  }
+  push(char) {
+    this.word.push(char);
+    this.wordStarted = true;
+  }
+  pushText(text) {
+    if (text.length > 0) this.word.push(text);
+    this.wordStarted = true;
+  }
+  endWord() {
+    if (!this.wordStarted) return;
+    this.current.push(this.word.join(""));
+    this.words += 1;
+    this.word = [];
+    this.wordStarted = false;
+  }
+  endCommand() {
+    this.endWord();
+    if (this.current.length > 0) this.commands.push(this.normalize(this.current));
+    this.current = [];
+  }
+  /** Drop the leading assignments and prefix words so `w[0]` is the command name. */
+  normalize(words) {
+    let start = 0;
+    while (start < words.length) {
+      const word = words[start];
+      if (ASSIGNMENT.test(word) || COMMAND_PREFIXES.has(basename(word))) start += 1;
+      else break;
+    }
+    return start === 0 || start >= words.length ? words : words.slice(start);
+  }
+  readSingleQuote(index) {
+    const end = this.text.indexOf("'", index + 1);
+    const stop = end === -1 ? this.length : end;
+    this.pushText(this.text.slice(index + 1, stop));
+    this.wordStarted = true;
+    return stop + 1;
+  }
+  readDoubleQuote(index) {
+    let cursor = index + 1;
+    this.wordStarted = true;
+    while (cursor < this.length) {
+      const char = this.text[cursor];
+      if (char === '"') return cursor + 1;
+      if (char === "\\") {
+        if (cursor + 1 < this.length && this.text[cursor + 1] !== "\n") this.push(this.text[cursor + 1]);
+        cursor += 2;
+        continue;
+      }
+      if (char === "`") {
+        cursor = this.readBackTick(cursor);
+        continue;
+      }
+      if (char === "$" && this.text[cursor + 1] === "(") {
+        cursor = this.readSubstitution(cursor + 2);
+        continue;
+      }
+      this.push(char);
+      cursor += 1;
+    }
+    return this.length;
+  }
+  /** Scan the commands inside `$( … )` and continue after the closing paren. */
+  readSubstitution(index) {
+    const end = this.findBalanced(index, "(", ")");
+    this.descend(this.text.slice(index, end));
+    this.wordStarted = true;
+    return end + 1;
+  }
+  readBackTick(index) {
+    const end = this.text.indexOf("`", index + 1);
+    const stop = end === -1 ? this.length : end;
+    this.descend(this.text.slice(index + 1, stop));
+    this.wordStarted = true;
+    return stop + 1;
+  }
+  descend(script) {
+    if (this.depth >= MAX_SHELL_DEPTH || script.length === 0) return;
+    for (const command of shellCommands(script, this.depth + 1)) this.commands.push(command);
+  }
+  findBalanced(index, open2, close) {
+    let depth = 1;
+    let cursor = index;
+    while (cursor < this.length) {
+      const char = this.text[cursor];
+      if (char === "\\") cursor += 2;
+      else if (char === open2) {
+        depth += 1;
+        cursor += 1;
+      } else if (char === close) {
+        depth -= 1;
+        if (depth === 0) return cursor;
+        cursor += 1;
+      } else cursor += 1;
+    }
+    return this.length;
+  }
+  /** `<<EOF`, `<<-'EOF'`: record the delimiter; the body is skipped at the newline. */
+  readHeredocHeader(index) {
+    this.endWord();
+    let cursor = index + 2;
+    let stripTabs = false;
+    if (this.text[cursor] === "-") {
+      stripTabs = true;
+      cursor += 1;
+    }
+    while (cursor < this.length && (this.text[cursor] === " " || this.text[cursor] === "	")) cursor += 1;
+    const delimiter = [];
+    while (cursor < this.length) {
+      const char = this.text[cursor];
+      if (char === "'" || char === '"') {
+        const end = this.text.indexOf(char, cursor + 1);
+        const stop = end === -1 ? this.length : end;
+        delimiter.push(this.text.slice(cursor + 1, stop));
+        cursor = stop + 1;
+        continue;
+      }
+      if (char === "\\" && cursor + 1 < this.length) {
+        delimiter.push(this.text[cursor + 1]);
+        cursor += 2;
+        continue;
+      }
+      if (" 	\n;&|<>()".includes(char)) break;
+      delimiter.push(char);
+      cursor += 1;
+    }
+    if (delimiter.length > 0) this.heredocs.push({ delimiter: delimiter.join(""), stripTabs });
+    return cursor;
+  }
+  skipHeredocBodies(index) {
+    let cursor = index;
+    for (const { delimiter, stripTabs } of this.heredocs) {
+      while (cursor < this.length) {
+        const newline = this.text.indexOf("\n", cursor);
+        const rawLine = newline === -1 ? this.text.slice(cursor) : this.text.slice(cursor, newline);
+        const line = (stripTabs ? rawLine.replace(/^\t+/, "") : rawLine).replace(/\r$/, "");
+        cursor = newline === -1 ? this.length : newline + 1;
+        if (line === delimiter) break;
+      }
+    }
+    this.heredocs = [];
+    return cursor;
+  }
+  /** Consume a redirection operator and its target so the target is not read as an argument. */
+  readRedirect(index) {
+    this.endWord();
+    let cursor = index;
+    while (cursor < this.length && "<>&".includes(this.text[cursor])) cursor += 1;
+    while (cursor < this.length && (this.text[cursor] === " " || this.text[cursor] === "	")) cursor += 1;
+    while (cursor < this.length && !" 	\n;&|()<>".includes(this.text[cursor])) {
+      const char = this.text[cursor];
+      if (char === "'" || char === '"') {
+        const close = this.text.indexOf(char, cursor + 1);
+        cursor = (close === -1 ? this.length : close) + 1;
+        continue;
+      }
+      cursor += char === "\\" ? 2 : 1;
+    }
+    return cursor;
+  }
+};
+function shellCommands(script, depth = 0) {
+  if (depth > MAX_SHELL_DEPTH || script.length === 0) return [];
+  const commands = new ShellScanner(script, depth).run();
+  const out = [];
+  for (const words of commands) {
+    out.push(words);
+    const name = basename(words[0] ?? "");
+    if (!SHELLS.has(name) || depth >= MAX_SHELL_DEPTH) continue;
+    for (let index = 1; index < words.length; index += 1) {
+      const word = words[index];
+      if (!word.startsWith("-") || word.startsWith("--") || !word.slice(1).includes("c")) continue;
+      const nested = words[index + 1];
+      if (nested !== void 0) out.push(...shellCommands(nested, depth + 1));
+      break;
+    }
+  }
+  return out;
+}
+var CODE_MODE_COMMAND = /\bexec_command\(\s*\{\s*(?:["']?cmd["']?\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`|[A-Za-z_$][\w$]*)|(cmd)\s*[,}])/gu;
+var FOR_OF = /\bfor\s*\(\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s+of\s+(\[[^\]]*\]|[A-Za-z_$][\w$]*)\s*\)\s*\{/gu;
+var ARRAY_ELEMENT = /\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\$]|\\.|\$(?!\{))*`|-?\d+(?:\.\d+)?)\s*(?:,|$)/uy;
+var MAX_LOOP_COMMANDS = 64;
+var STRING_ESCAPES = { n: "\n", t: "	", r: "\r", b: "\b", f: "\f", v: "\v", 0: "\0", "\n": "" };
+function stringLiteralText(literal) {
+  return literal.slice(1, -1).replace(/\\(u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[\s\S])/gu, (_, escape) => escape.length > 1 ? String.fromCodePoint(Number.parseInt(escape.replace(/[ux{}]/gu, ""), 16)) : STRING_ESCAPES[escape] ?? escape);
+}
+function literalArray(source) {
+  const inner = source.slice(1, -1);
+  const values = [];
+  ARRAY_ELEMENT.lastIndex = 0;
+  while (inner.slice(ARRAY_ELEMENT.lastIndex).trim() !== "") {
+    const match = ARRAY_ELEMENT.exec(inner);
+    if (!match) return void 0;
+    values.push(/^-?\d/u.test(match[1]) ? match[1] : stringLiteralText(match[1]));
+  }
+  return values;
+}
+function quoteEnd(text, start) {
+  for (let index = start + 1; index < text.length; index += 1) {
+    if (text[index] === "\\") index += 1;
+    else if (text[index] === text[start]) return index;
+  }
+  return -1;
+}
+function blockEnd(text, open2) {
+  let depth = 0;
+  for (let index = open2; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '"' || char === "'" || char === "`") index = quoteEnd(text, index);
+    else if (char === "/" && text[index + 1] === "/") index = text.indexOf("\n", index);
+    else if (char === "/" && text[index + 1] === "*") index = text.includes("*/", index + 2) ? text.indexOf("*/", index + 2) + 1 : -1;
+    else if (char === "{") depth += 1;
+    else if (char === "}" && --depth === 0) return index;
+    if (index < 0) return -1;
+  }
+  return -1;
+}
+function forOfLoops(script) {
+  const loops = [];
+  for (const match of script.matchAll(FOR_OF)) {
+    const open2 = match.index + match[0].length - 1;
+    const end = blockEnd(script, open2);
+    if (end === -1) continue;
+    let source = match[2];
+    if (!source.startsWith("[")) {
+      const name = source.replace(/\$/gu, "\\$");
+      source = new RegExp(`\\b(?:const|let|var)\\s+${name}\\s*=\\s*(\\[[^\\]]*\\])`, "u").exec(script)?.[1] ?? "";
+    }
+    loops.push({ variable: match[1], values: source.startsWith("[") ? literalArray(source) : void 0, start: match.index, end });
+  }
+  return loops;
+}
+function codeModeCommands(script) {
+  const loops = forOfLoops(script);
+  const commands = [];
+  for (const match of script.matchAll(CODE_MODE_COMMAND)) {
+    const written = match[1] ?? match[2];
+    const literal = /^["'`]/u.test(written);
+    const around = loops.filter((loop) => loop.start < match.index && match.index < loop.end);
+    let bindings = [{}];
+    for (const loop of around) {
+      if (loop.values === void 0 || bindings.length * loop.values.length > MAX_LOOP_COMMANDS) {
+        bindings = void 0;
+        break;
+      }
+      bindings = bindings.flatMap((bound) => loop.values.map((value) => ({ ...bound, [loop.variable]: value })));
+    }
+    if (bindings === void 0) {
+      if (literal) commands.push(stringLiteralText(written));
+      continue;
+    }
+    for (const bound of bindings) {
+      if (!literal) {
+        if (bound[written] !== void 0) commands.push(bound[written]);
+        continue;
+      }
+      const text = stringLiteralText(written);
+      commands.push(written.startsWith("`") ? text.replace(/\$\{\s*([A-Za-z_$][\w$]*)\s*\}/gu, (part, name) => bound[name] ?? part) : text);
+    }
+  }
+  return commands.filter((command) => command.length > 0);
+}
+function isCodeModeScript(input) {
+  const trimmed = input.trimStart();
+  return !trimmed.startsWith("{") && !trimmed.startsWith("*** Begin Patch") && trimmed.includes("exec_command(");
+}
+function commandTextFromInput(input) {
+  const trimmed = input.trim();
+  if (isCodeModeScript(trimmed)) {
+    const commands = codeModeCommands(trimmed);
+    return commands.length > 0 ? commands.join("\n") : void 0;
+  }
+  if (!trimmed.startsWith("{")) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const record = parsed;
+  const value = record.command ?? record.cmd;
+  if (typeof value === "string") return value.length > 0 ? value : void 0;
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  const words = value.filter((entry) => typeof entry === "string");
+  if (words.length !== value.length) return void 0;
+  const head = basename(words[0] ?? "");
+  if (SHELLS.has(head)) {
+    const flag = words.findIndex((word, position) => position > 0 && /^-[a-z]*c$/.test(word));
+    if (flag !== -1 && words[flag + 1] !== void 0) return words[flag + 1];
+  }
+  return words.join(" ");
+}
+function isShellWrapper(words) {
+  if (!SHELLS.has(basename(words[0] ?? ""))) return false;
+  for (let index = 1; index < words.length; index += 1) {
+    const word = words[index];
+    if (!word.startsWith("-") || word.startsWith("--") || !word.slice(1).includes("c")) continue;
+    return words[index + 1] !== void 0;
+  }
+  return false;
+}
+function commandLines(script) {
+  return simpleCommands(script).map((words) => words.join(" "));
+}
+function simpleCommands(script) {
+  return shellCommands(script).filter((words) => words.length > 0 && !isShellWrapper(words));
+}
+
+// src/turn-index.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { appendFile, link, mkdir as mkdir2, open, readFile as readFile2, rename as rename2, stat as stat2, unlink, utimes, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { setTimeout as sleep } from "timers/promises";
+
+// src/session-facts.ts
+import { createHash } from "crypto";
+
+// src/session-facts-withheld.ts
+function withholdContent(facts) {
+  const withheld = () => ({
+    value: null,
+    spanIds: [],
+    unavailable: "Content was not requested."
+  });
+  return {
+    ...facts,
+    cwd: withheld(),
+    repo: withheld(),
+    humanTurns: withheld(),
+    finalMessages: withheld(),
+    changedFiles: withheld(),
+    commands: withheld(),
+    pullRequests: withheld(),
+    subagents: {
+      ...facts.subagents,
+      value: facts.subagents.value?.map((entry) => ({
+        ...entry,
+        taskName: null,
+        taskNameUnavailable: "Assignment text was not requested.",
+        agentType: null
+      })) ?? null
+    },
+    firstFailure: facts.firstFailure.status === "found" ? { ...facts.firstFailure, message: null, classification: facts.firstFailure.classification ? { ...facts.firstFailure.classification, reason: "Content was not requested." } : null } : facts.firstFailure,
+    measurements: {
+      ...facts.measurements,
+      waste: {
+        ...facts.measurements.waste,
+        failingStreaks: {
+          ...facts.measurements.waste.failingStreaks,
+          value: facts.measurements.waste.failingStreaks.value?.map((streak) => ({ ...streak, command: null })) ?? null
+        }
+      },
+      limitStop: facts.measurements.limitStop ? { ...facts.measurements.limitStop, text: null } : null
+    }
+  };
+}
+
+// src/session-measurements.ts
+import { basename as basename2 } from "path";
+
+// src/execution.ts
+import {
+  summarizeExecution
+} from "@tangle-network/agent-eval/contract";
+import { otlpRowsToRunRecords } from "@tangle-network/agent-eval/traces";
+import {
+  firstNumberAttr,
+  LLM_CACHE_WRITE_TOKEN_ATTR_KEYS,
+  LLM_CACHED_TOKEN_ATTR_KEYS,
+  LLM_INPUT_TOKEN_ATTR_KEYS,
+  LLM_MODEL_ATTR_KEYS,
+  LLM_OUTPUT_TOKEN_ATTR_KEYS,
+  LLM_REASONING_TOKEN_ATTR_KEYS,
+  OPENINFERENCE_SPAN_KIND
+} from "@tangle-network/agent-eval/trace-attributes";
+var COST_LABEL = "list price (Router rates)";
+var routerPricer;
+function routerPrices() {
+  routerPricer ??= import("@tangle-network/agent-runtime").then((runtime) => runtime.priceTokens);
+  return routerPricer;
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function modelOf(span) {
+  for (const key of LLM_MODEL_ATTR_KEYS) {
+    const value = span.attributes[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return null;
+}
+var UNRECORDED_MODEL = "(model not recorded)";
+function modelCallContextTokens(span) {
+  return callUsage(span)?.input ?? null;
+}
+function callUsage(span) {
+  if (span.attributes[OPENINFERENCE_SPAN_KIND] !== "LLM") return null;
+  const fresh = count(firstNumberAttr(span.attributes, LLM_INPUT_TOKEN_ATTR_KEYS));
+  const output = count(firstNumberAttr(span.attributes, LLM_OUTPUT_TOKEN_ATTR_KEYS));
+  const cacheRead = count(firstNumberAttr(span.attributes, LLM_CACHED_TOKEN_ATTR_KEYS)) ?? 0;
+  const cacheWrite = count(firstNumberAttr(span.attributes, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS)) ?? 0;
+  if ((fresh ?? 0) + (output ?? 0) + cacheRead + cacheWrite === 0) return null;
+  const model = modelOf(span);
+  return {
+    model: model ?? UNRECORDED_MODEL,
+    modelRecorded: model !== null,
+    input: (fresh ?? 0) + cacheRead + cacheWrite,
+    output: output ?? 0,
+    cacheRead,
+    cacheWrite,
+    reasoning: count(firstNumberAttr(span.attributes, LLM_REASONING_TOKEN_ATTR_KEYS)),
+    spanId: span.span_id
+  };
+}
+function byModel(calls) {
+  const models = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const entry = models.get(call.model) ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    entry.input += call.input;
+    entry.output += call.output;
+    entry.cacheRead += call.cacheRead;
+    entry.cacheWrite += call.cacheWrite;
+    models.set(call.model, entry);
+  }
+  return [...models].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([model, entry]) => ({ model, ...entry }));
+}
+function sum(values) {
+  const present = values.filter((value) => value !== null);
+  return present.length === 0 ? null : present.reduce((total, value) => total + value, 0);
+}
+function sessionTokens(own) {
+  const calls = own.map(callUsage).filter((call) => call !== null);
+  const root = own.find((span) => span.parent_span_id === null && count(span.attributes[SESSION_TOTAL_INPUT_ATTR]) !== null && count(span.attributes[SESSION_TOTAL_OUTPUT_ATTR]) !== null);
+  if (root) {
+    const input = count(root.attributes[SESSION_TOTAL_INPUT_ATTR]);
+    const output = count(root.attributes[SESSION_TOTAL_OUTPUT_ATTR]);
+    const cacheRead = count(root.attributes[SESSION_TOTAL_CACHED_INPUT_ATTR]) ?? 0;
+    const cacheWrite = count(root.attributes[SESSION_TOTAL_CACHE_WRITE_ATTR]) ?? 0;
+    const perCall = byModel(calls);
+    const recorded = [...new Set(calls.filter((call) => call.modelRecorded).map((call) => call.model))];
+    const callInput = calls.reduce((total, call) => total + call.input, 0);
+    const callOutput = calls.reduce((total, call) => total + call.output, 0);
+    const models = recorded.length === 1 ? [{ model: recorded[0], input, output, cacheRead, cacheWrite }] : recorded.length > 1 && callInput === input && callOutput === output ? perCall : [];
+    return {
+      input,
+      output,
+      cacheRead,
+      cacheWrite,
+      reasoning: count(root.attributes[SESSION_TOTAL_REASONING_ATTR]),
+      modelCalls: calls.length,
+      byModel: models,
+      spanIds: [root.span_id],
+      unavailable: null
+    };
+  }
+  if (calls.length === 0) {
+    return {
+      input: null,
+      output: null,
+      cacheRead: null,
+      cacheWrite: null,
+      reasoning: null,
+      modelCalls: 0,
+      byModel: [],
+      spanIds: [],
+      unavailable: "no model call of this session's own records reports token usage, and no root span carries the harness's cumulative counter"
+    };
+  }
+  return {
+    input: calls.reduce((total, call) => total + call.input, 0),
+    output: calls.reduce((total, call) => total + call.output, 0),
+    cacheRead: calls.reduce((total, call) => total + call.cacheRead, 0),
+    cacheWrite: calls.reduce((total, call) => total + call.cacheWrite, 0),
+    reasoning: sum(calls.map((call) => call.reasoning)),
+    modelCalls: calls.length,
+    byModel: byModel(calls),
+    spanIds: calls.map((call) => call.spanId),
+    unavailable: null
+  };
+}
+function needsPrice(tokens) {
+  return tokens.input !== null && tokens.input + (tokens.output ?? 0) > 0 && tokens.byModel.length > 0;
+}
+function roundUsd(usd) {
+  return Math.round(usd * 1e6) / 1e6;
+}
+function sessionCost(tokens, price) {
+  const unknown = (reason) => ({ usd: null, label: COST_LABEL, unavailable: reason });
+  if (tokens.input === null) return unknown(`no token counts: ${tokens.unavailable}`);
+  if (tokens.input + (tokens.output ?? 0) === 0) return { usd: 0, label: COST_LABEL, unavailable: null };
+  if (tokens.byModel.length === 0) {
+    return unknown("no model call of the session records its model, or several models share a cumulative counter the calls do not add up to");
+  }
+  if (price === void 0) return unknown("not priced yet: `await priceReport(report)` loads the price table and fills it");
+  const unpriced = tokens.byModel.filter((entry) => entry.model === UNRECORDED_MODEL || price({ model: entry.model, inputTokens: entry.input, outputTokens: entry.output, cacheReadTokens: entry.cacheRead, cacheWriteTokens: entry.cacheWrite }) === void 0);
+  if (unpriced.length > 0) {
+    return unknown(`the Router lists no price for ${unpriced.map((entry) => entry.model).join(", ")}`);
+  }
+  const usd = tokens.byModel.reduce((total, entry) => total + price({
+    model: entry.model,
+    inputTokens: entry.input,
+    outputTokens: entry.output,
+    cacheReadTokens: entry.cacheRead,
+    cacheWriteTokens: entry.cacheWrite
+  }), 0);
+  return { usd: roundUsd(usd), label: COST_LABEL, unavailable: null };
+}
+
+// src/skill-usage.ts
+import { mkdir, readdir, readFile, rename, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { STORES } from "@tangle-network/harness-sessions/catalog";
+var NEWLINE = 10;
+var SLASH_LOOKAHEAD_LINES = 8;
+var MAX_PENDING = 16;
+var READ_CONCURRENCY = 8;
+var CLAUDE_NEEDLES = [
+  '"commandName":"',
+  "Launching skill: ",
+  " (forked execution",
+  "<command-name>",
+  "Base directory for this skill: "
+].map((n) => Buffer.from(n));
+var SKILL_RESULT_TEXT = /^(?:Launching skill: (\S+)|Skill "([^"]+)" (?:launched|completed) \(forked execution)/;
+var CODEX_NEEDLE = Buffer.from("SKILL.md");
+var KIMI_NEEDLES = ['"type": "ToolCall"', '"type":"ToolCall"', '"type": "ToolCallPart"', '"type":"ToolCallPart"', '"type": "ToolResult"', '"type":"ToolResult"'].map((n) => Buffer.from(n));
+var BASE_DIRECTORY = "Base directory for this skill: ";
+var SLASH_COMMAND = /<command-name>\/?([^<\s]+)<\/command-name>/;
+var SKILL_READ_VERB = /(?:^|[\s;&|(`'"])(?:cat|sed|head|tail|less|more|awk|nl|bat)\s/;
+var SKILL_DOCUMENT = /(?:^|[\s'"=:(`])((?:[^\s'"`;|&()]*\/)?([A-Za-z0-9][A-Za-z0-9._-]*))\/SKILL\.md\b/g;
+var SESSION_UUID = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
+function skillLaunchedBy(resultText) {
+  const match = SKILL_RESULT_TEXT.exec(resultText);
+  return match ? match[1] ?? match[2] : null;
+}
+function slashCommandOf(text) {
+  return SLASH_COMMAND.exec(text)?.[1] ?? null;
+}
+function skillDocumentReads(text, output, options = {}) {
+  if (!text.includes("SKILL.md")) return [];
+  if (options.path ? !text.endsWith("/SKILL.md") : !SKILL_READ_VERB.test(text)) return [];
+  const reads = /* @__PURE__ */ new Map();
+  for (const match of text.matchAll(SKILL_DOCUMENT)) {
+    const directory = match[1];
+    if (!output.includes(`${directory}/SKILL.md: No such file`) && !reads.has(directory)) reads.set(directory, match[2]);
+    if (options.path) break;
+  }
+  return [...reads].map(([directory, skill]) => ({ skill, directory }));
+}
+function rootOfDirectory(directory) {
+  const slash = directory.lastIndexOf("/");
+  return slash > 0 ? directory.slice(0, slash) : null;
+}
+var TYPED_SLASH = /^\/([A-Za-z0-9][\w:.-]*)(?:\s|$)/u;
+function skillUseOfSpans(spans, harness, sweepThreshold = DEFAULT_SWEEP_THRESHOLD) {
+  const counts = {};
+  const add = (skill, kind) => {
+    const row = counts[skill] ?? (counts[skill] = { model: 0, slash: 0, read: 0 });
+    row[kind] += 1;
+  };
+  let slash = null;
+  for (const span of spans) {
+    const content = typeof span.attributes.content === "string" ? span.attributes.content.trim() : "";
+    if (slash && (slash.seen += 1) > SLASH_LOOKAHEAD_LINES) slash = null;
+    if (span.name === "user.prompt") {
+      const actor = span.attributes[ACTOR_ATTR];
+      const named = slashCommandOf(content) ?? (actor === "human" ? TYPED_SLASH.exec(content)?.[1] ?? null : null);
+      if (named) {
+        slash = { skill: skillName(named), seen: 0 };
+        continue;
+      }
+      if (slash && content.length > 0 && actor !== "human" && !content.startsWith("<local-command-") && !content.startsWith("<command-")) {
+        add(slash.skill, "slash");
+        slash = null;
+      }
+      continue;
+    }
+    const kind = span.attributes["openinference.span.kind"];
+    if (kind === "LLM" || kind === "TOOL" || span.name === "message.assistant") slash = null;
+    if (kind !== "TOOL" || span.status.code === "UNSET") continue;
+    const tool = typeof span.attributes["tool.name"] === "string" ? span.attributes["tool.name"] : span.name.replace(/^tool\./u, "");
+    const input = typeof span.attributes["input.value"] === "string" ? span.attributes["input.value"] : "";
+    const output = typeof span.attributes["output.value"] === "string" ? span.attributes["output.value"] : "";
+    if (tool === "Skill") {
+      if (span.status.code !== "OK") continue;
+      const named = skillLaunchedBy(output) ?? skillArgument(input);
+      if (named) add(skillName(named), "model");
+      continue;
+    }
+    if (harness === "claude-code") continue;
+    const command = commandTextFromInput(input);
+    const path = tool === "ReadFile" && span.status.code === "OK" ? pathArgument(input) : null;
+    const reads = command !== void 0 ? skillDocumentReads(command, output) : path ? skillDocumentReads(path, output, { path: true }) : [];
+    if (reads.length >= sweepThreshold) continue;
+    for (const read of reads) add(read.skill, "read");
+  }
+  return counts;
+}
+function jsonObject(text) {
+  try {
+    const value = JSON.parse(text);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function skillArgument(input) {
+  const args = jsonObject(input);
+  const value = args?.skill ?? args?.command;
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function pathArgument(input) {
+  const value = jsonObject(input)?.path;
+  return typeof value === "string" ? value : null;
+}
+function defaultSkillUsageSources() {
+  const codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
+  return {
+    claudeProjects: join(homedir(), STORES["claude-code.projects-jsonl"].root),
+    codexSessions: [join(codexHome, ...STORES["codex.rollout-jsonl"].root.split("/").slice(1)), join(codexHome, "archived_sessions")],
+    kimiSessions: join(homedir(), STORES["kimi.session-dir"].root)
+  };
+}
+function defaultSkillUsageStorePath() {
+  const state = process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
+  return join(state, "traces", "skill-usage.json");
+}
+function eventKey(e) {
+  return `${e.harness}\0${e.id}`;
+}
+var SkillUsageStore = class _SkillUsageStore {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  events = /* @__PURE__ */ new Map();
+  files = {};
+  static async load(path) {
+    const store = new _SkillUsageStore(path);
+    let raw;
+    try {
+      raw = await readFile(path, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return store;
+      throw error;
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || !Array.isArray(parsed.events) || typeof parsed.files !== "object") {
+      throw new Error(`skill usage store ${path} has an unknown format; move it aside to rebuild from transcripts`);
+    }
+    store.files = parsed.files ?? {};
+    for (const [harness, kind, skill, root, ts, session, id] of parsed.events) {
+      store.add({ harness, kind, skill, root, ts, session, id });
+    }
+    return store;
+  }
+  get size() {
+    return this.events.size;
+  }
+  list() {
+    return [...this.events.values()];
+  }
+  add(event) {
+    const key = eventKey(event);
+    if (this.events.has(key)) return false;
+    this.events.set(key, event);
+    return true;
+  }
+  setRoot(harness, id, root) {
+    const event = this.events.get(eventKey({ harness, id }));
+    if (event && event.root === null) event.root = root;
+  }
+  async save() {
+    const body = {
+      version: 1,
+      files: this.files,
+      events: this.list().map((e) => [e.harness, e.kind, e.skill, e.root, e.ts, e.session, e.id])
+    };
+    await mkdir(dirname(this.path), { recursive: true });
+    const temporary = `${this.path}.${process.pid}.tmp`;
+    await writeFile(temporary, JSON.stringify(body));
+    await rename(temporary, this.path);
+  }
+  /** Read bytes appended since the previous refresh. Cost is proportional to new bytes. */
+  async refresh(sources = defaultSkillUsageSources()) {
+    const claude = await this.refreshHarness("claude-code", await jsonlFiles([sources.claudeProjects]));
+    const codex = await this.refreshHarness("codex", await jsonlFiles(sources.codexSessions));
+    const kimi = await this.refreshHarness("kimi-code", await jsonlFiles(sources.kimiSessions ? [sources.kimiSessions] : [], "wire.jsonl"));
+    return [claude, codex, kimi];
+  }
+  async refreshHarness(harness, paths) {
+    const summary = { harness, files: paths.length, filesRead: 0, bytesRead: 0, eventsAdded: 0 };
+    let next = 0;
+    const worker = async () => {
+      while (next < paths.length) {
+        const path = paths[next++];
+        const read = await this.refreshFile(harness, path);
+        if (read === null) continue;
+        summary.filesRead += 1;
+        summary.bytesRead += read.bytes;
+        summary.eventsAdded += read.events;
+      }
+    };
+    await Promise.all(Array.from({ length: READ_CONCURRENCY }, worker));
+    return summary;
+  }
+  async refreshFile(harness, path) {
+    let info;
+    try {
+      info = await stat(path);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+    const previous = this.files[path];
+    const from = resumeOffset(previous, info);
+    if (from === null) return null;
+    const cursor = previous && from === previous.offset ? { ...previous } : { ino: info.ino, size: 0, offset: 0 };
+    const session = sessionFromPath(path);
+    let events = 0;
+    const { bytes: bytes2, end } = await readCompleteLines(path, from, info.size, (complete) => {
+      events += harness === "claude-code" ? this.scanClaude(complete, cursor, session) : harness === "codex" ? this.scanCodex(complete, session) : this.scanKimi(complete, cursor, kimiSessionFromPath(path));
+    });
+    cursor.offset = end;
+    cursor.ino = info.ino;
+    cursor.size = info.size;
+    if (cursor.pending?.length === 0) delete cursor.pending;
+    this.files[path] = cursor;
+    return { bytes: bytes2, events };
+  }
+  scanClaude(buffer, cursor, fileSession) {
+    let added = 0;
+    const pending = cursor.pending ?? [];
+    cursor.pending = [];
+    const lines = new LineIndex(buffer);
+    for (const command of pending) {
+      const outcome = this.resolveSlash(buffer, lines, 0, command);
+      if (outcome === "confirmed") added += 1;
+      else if (outcome === "pending") cursor.pending.push(command);
+    }
+    for (const start of hitLineStarts(buffer, CLAUDE_NEEDLES)) {
+      const end = lines.endOf(start);
+      const record = parseLine(buffer, start, end);
+      if (!record || record.type !== "user") continue;
+      const session = typeof record.sessionId === "string" ? record.sessionId : fileSession;
+      const ts = typeof record.timestamp === "string" ? record.timestamp : null;
+      const loaded = loadedSkill(record);
+      if (loaded) {
+        if (this.add({ harness: "claude-code", kind: "model", skill: skillName(loaded.skill), root: null, ts, session, id: loaded.id })) added += 1;
+        continue;
+      }
+      const text = messageText(record);
+      if (record.isMeta === true && text.startsWith(BASE_DIRECTORY)) {
+        if (typeof record.sourceToolUseID === "string") {
+          this.setRoot("claude-code", record.sourceToolUseID, rootOf(text));
+        }
+        continue;
+      }
+      const content = record.message?.content;
+      if (typeof content !== "string" || !content.startsWith("<command-")) continue;
+      const name = slashCommandOf(content);
+      if (!name || typeof record.uuid !== "string") continue;
+      const command = { uuid: record.uuid, skill: skillName(name), ts, session, seen: 0 };
+      const outcome = this.resolveSlash(buffer, lines, end + 1, command);
+      if (outcome === "confirmed") added += 1;
+      else if (outcome === "pending" && cursor.pending.length < MAX_PENDING) cursor.pending.push(command);
+    }
+    return added;
+  }
+  /** Confirm a slash command by its expansion: the first later record whose parent it is. */
+  resolveSlash(buffer, lines, from, command) {
+    const at = buffer.indexOf(`"parentUuid":"${command.uuid}"`, from);
+    let start = from;
+    while (command.seen < SLASH_LOOKAHEAD_LINES) {
+      if (start >= buffer.length) return "pending";
+      const end = lines.endOf(start);
+      command.seen += 1;
+      if (at !== -1 && at >= start && at < end) {
+        const record = parseLine(buffer, start, end);
+        const text = record ? messageText(record) : "";
+        if (!record || record.type !== "user" || record.isMeta !== true || text.length === 0) return "rejected";
+        const added = this.add({
+          harness: "claude-code",
+          kind: "slash",
+          skill: command.skill,
+          root: text.startsWith(BASE_DIRECTORY) ? rootOf(text) : null,
+          ts: command.ts,
+          session: command.session,
+          id: command.uuid
+        });
+        return added ? "confirmed" : "rejected";
+      }
+      start = end + 1;
+    }
+    return "rejected";
+  }
+  scanCodex(buffer, fileSession) {
+    let added = 0;
+    const lines = new LineIndex(buffer);
+    for (const start of hitLineStarts(buffer, [CODEX_NEEDLE])) {
+      const record = parseLine(buffer, start, lines.endOf(start));
+      const payload = record?.payload;
+      const item = payload?.item;
+      if (payload?.type !== "item_completed" || item?.type !== "CommandExecution" || typeof item.id !== "string") continue;
+      const command = Array.isArray(item.command) ? item.command.join(" ") : String(item.command ?? "");
+      const output = typeof item.aggregated_output === "string" ? item.aggregated_output : String(item.stdout ?? "");
+      const ts = typeof record?.timestamp === "string" ? record.timestamp : null;
+      for (const { skill, directory } of skillDocumentReads(command, output)) {
+        const event = {
+          harness: "codex",
+          kind: "read",
+          skill,
+          root: rootOfDirectory(directory),
+          ts,
+          session: fileSession,
+          id: `${item.id}#${directory}`
+        };
+        if (this.add(event)) added += 1;
+      }
+    }
+    return added;
+  }
+  scanKimi(buffer, cursor, session) {
+    let added = 0;
+    const calls = cursor.kimiCalls ?? {};
+    const lines = new LineIndex(buffer);
+    for (const start of hitLineStarts(buffer, KIMI_NEEDLES)) {
+      const record = parseLine(buffer, start, lines.endOf(start));
+      const message = record?.message;
+      const payload = message?.payload;
+      if (!payload) continue;
+      if (message?.type === "ToolCall") {
+        const fn = payload.function;
+        const id = payload.id;
+        cursor.kimiLastCall = typeof id === "string" ? id : void 0;
+        if (typeof id === "string" && (fn?.name === "ReadFile" || fn?.name === "Shell")) {
+          calls[id] = { name: fn.name, args: typeof fn.arguments === "string" ? fn.arguments : "", ts: kimiTimestamp(record?.timestamp) };
+        }
+      } else if (message?.type === "ToolCallPart") {
+        const call = cursor.kimiLastCall ? calls[cursor.kimiLastCall] : void 0;
+        if (call && typeof payload.arguments_part === "string") call.args += payload.arguments_part;
+      } else if (message?.type === "ToolResult" && typeof payload.tool_call_id === "string") {
+        const id = payload.tool_call_id;
+        const call = calls[id];
+        delete calls[id];
+        if (!call) continue;
+        const result = payload.return_value;
+        if (result?.is_error !== false) continue;
+        let args;
+        try {
+          args = JSON.parse(call.args);
+        } catch {
+          continue;
+        }
+        const output = typeof result.output === "string" ? result.output : "";
+        const reads = call.name === "ReadFile" && typeof args.path === "string" ? skillDocumentReads(args.path, output, { path: true }) : call.name === "Shell" && typeof args.command === "string" ? skillDocumentReads(args.command, output) : [];
+        for (const { skill, directory } of reads) {
+          if (this.add({
+            harness: "kimi-code",
+            kind: "read",
+            skill,
+            root: rootOfDirectory(directory),
+            ts: call.ts,
+            session,
+            id: `${session}:${id}#${directory}`
+          })) added += 1;
+        }
+      }
+    }
+    cursor.kimiCalls = calls;
+    return added;
+  }
+};
+var LineIndex = class {
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  buffer;
+  endOf(start) {
+    const end = this.buffer.indexOf(NEWLINE, start);
+    return end === -1 ? this.buffer.length : end;
+  }
+};
+function hitLineStarts(buffer, needles) {
+  const starts = /* @__PURE__ */ new Set();
+  for (const needle of needles) {
+    let at = buffer.indexOf(needle);
+    while (at !== -1) {
+      const start = buffer.lastIndexOf(NEWLINE, at) + 1;
+      starts.add(start);
+      const end = buffer.indexOf(NEWLINE, at);
+      if (end === -1) break;
+      at = buffer.indexOf(needle, end + 1);
+    }
+  }
+  return [...starts].sort((a, b) => a - b);
+}
+function parseLine(buffer, start, end) {
+  try {
+    const value = JSON.parse(buffer.toString("utf8", start, end));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function messageText(record) {
+  const content = record.message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const first = content[0];
+  return first?.type === "text" && typeof first.text === "string" ? first.text : "";
+}
+function loadedSkill(record) {
+  const content = record.message?.content;
+  if (!Array.isArray(content)) return null;
+  const result = record.toolUseResult;
+  for (const part of content) {
+    if (part?.type !== "tool_result" || typeof part.tool_use_id !== "string" || part.is_error === true) continue;
+    if (result?.success === true && typeof result.commandName === "string") return { skill: result.commandName, id: part.tool_use_id };
+    const text = typeof part.content === "string" ? part.content : Array.isArray(part.content) ? String(part.content[0]?.text ?? "") : "";
+    const skill = skillLaunchedBy(text);
+    if (skill) return { skill, id: part.tool_use_id };
+  }
+  return null;
+}
+function skillName(value) {
+  return value.replace(/^\//, "");
+}
+function rootOf(baseDirectoryText) {
+  const directory = baseDirectoryText.slice(BASE_DIRECTORY.length).split("\n", 1)[0].trim();
+  return dirname(directory);
+}
+function sessionFromPath(path) {
+  return SESSION_UUID.exec(path)?.[1] ?? path;
+}
+function kimiSessionFromPath(path) {
+  const match = /\/([0-9a-f-]{36})(?:\/subagents\/([^/]+))?\/wire\.jsonl$/.exec(path);
+  return match ? `${match[1]}${match[2] ? `:${match[2]}` : ""}` : path;
+}
+function kimiTimestamp(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  const date = new Date(value * 1e3);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+async function jsonlFiles(roots, name) {
+  const files = [];
+  for (const root of roots) {
+    let entries;
+    try {
+      entries = await readdir(root, { recursive: true, withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && (name ? entry.name === name : entry.name.endsWith(".jsonl"))) files.push(join(entry.parentPath, entry.name));
+    }
+  }
+  return files.sort();
+}
+function defaultSkillCatalogRoots() {
+  const codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
+  return {
+    claudeHome: join(homedir(), ".claude"),
+    codexSkillDirs: [join(codexHome, "skills"), join(codexHome, "skills", ".system"), join(homedir(), ".agents", "skills")]
+  };
+}
+async function skillFolders(directory, prefix = "") {
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const entry of entries.sort()) {
+    if (entry.startsWith(".")) continue;
+    const path = join(directory, entry);
+    try {
+      await stat(join(path, "SKILL.md"));
+      found.push({ name: `${prefix}${entry}`, path });
+    } catch {
+    }
+  }
+  return found;
+}
+async function readJsonObject(path) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    return value && typeof value === "object" ? value : null;
+  } catch {
+    return null;
+  }
+}
+async function readInstalledSkills(roots = defaultSkillCatalogRoots()) {
+  const installed = [];
+  for (const skill of await skillFolders(join(roots.claudeHome, "skills"))) {
+    installed.push({ ...skill, harness: "claude-code" });
+  }
+  const settings = await readJsonObject(join(roots.claudeHome, "settings.json"));
+  const enabled = settings?.enabledPlugins ?? {};
+  const plugins = await readJsonObject(join(roots.claudeHome, "plugins", "installed_plugins.json"));
+  const pluginEntries = plugins?.plugins ?? {};
+  for (const [key, value] of Object.entries(pluginEntries)) {
+    if (enabled[key] !== true) continue;
+    const plugin = key.split("@", 1)[0];
+    for (const install of Array.isArray(value) ? value : [value]) {
+      if (typeof install?.installPath !== "string") continue;
+      for (const skill of await skillFolders(join(install.installPath, "skills"), `${plugin}:`)) {
+        installed.push({ ...skill, harness: "claude-code" });
+      }
+    }
+  }
+  for (const directory of roots.codexSkillDirs) {
+    for (const skill of await skillFolders(directory)) installed.push({ ...skill, harness: "codex" });
+  }
+  return installed;
+}
+var DEFAULT_SWEEP_THRESHOLD = 3;
+function commandOf(event) {
+  const hash = event.id.indexOf("#");
+  return hash === -1 ? event.id : event.id.slice(0, hash);
+}
+function buildSkillUsageReport(events, installed, storePath, options = {}) {
+  const sweepThreshold = options.sweepThreshold ?? DEFAULT_SWEEP_THRESHOLD;
+  const readsByCommand = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind === "read") readsByCommand.set(commandOf(event), (readsByCommand.get(commandOf(event)) ?? 0) + 1);
+  }
+  const sweeps = new Set([...readsByCommand].filter(([, reads]) => reads >= sweepThreshold).map(([command]) => command));
+  const since = options.since;
+  const sinceIso = since === void 0 ? null : new Date(since).toISOString();
+  const inWindow = (event) => sinceIso === null || event.ts !== null && event.ts >= sinceIso;
+  const rows = /* @__PURE__ */ new Map();
+  let sweepReadsExcluded = 0;
+  for (const event of events) {
+    if (!inWindow(event)) continue;
+    if (event.kind === "read" && sweeps.has(commandOf(event))) {
+      sweepReadsExcluded += 1;
+      continue;
+    }
+    const row = rows.get(event.skill) ?? {
+      skill: event.skill,
+      model: 0,
+      slash: 0,
+      read: 0,
+      sessions: 0,
+      firstUsed: null,
+      lastUsed: null,
+      installedIn: [],
+      sessionSet: /* @__PURE__ */ new Set()
+    };
+    row[event.kind] += 1;
+    row.sessionSet.add(`${event.harness}\0${event.session}`);
+    if (event.ts !== null) {
+      if (row.firstUsed === null || event.ts < row.firstUsed) row.firstUsed = event.ts;
+      if (row.lastUsed === null || event.ts > row.lastUsed) row.lastUsed = event.ts;
+    }
+    rows.set(event.skill, row);
+  }
+  const installedBySkill = /* @__PURE__ */ new Map();
+  for (const skill of installed) {
+    const harnesses = installedBySkill.get(skill.name) ?? /* @__PURE__ */ new Set();
+    harnesses.add(skill.harness);
+    installedBySkill.set(skill.name, harnesses);
+  }
+  const result = [];
+  for (const { sessionSet, ...row } of rows.values()) {
+    result.push({ ...row, sessions: sessionSet.size, installedIn: [...installedBySkill.get(row.skill) ?? []].sort() });
+  }
+  result.sort((a, b) => b.sessions - a.sessions || b.model + b.slash + b.read - (a.model + a.slash + a.read) || a.skill.localeCompare(b.skill));
+  const unused = [...installedBySkill].filter(([skill]) => !rows.has(skill)).map(([skill, harnesses]) => ({ skill, installedIn: [...harnesses].sort() })).sort((a, b) => a.skill.localeCompare(b.skill));
+  let firstEvent = null;
+  let lastEvent = null;
+  for (const event of events) {
+    if (event.ts === null) continue;
+    if (firstEvent === null || event.ts < firstEvent) firstEvent = event.ts;
+    if (lastEvent === null || event.ts > lastEvent) lastEvent = event.ts;
+  }
+  return {
+    since: sinceIso,
+    storePath,
+    refresh: options.refresh ?? null,
+    storedEvents: events.length,
+    firstEvent,
+    lastEvent,
+    rows: result,
+    unused,
+    sweepThreshold,
+    sweepCommands: sweeps.size,
+    sweepReadsExcluded,
+    notIndexed: ["opencode", "pi", "gemini", "factory", "other harnesses"]
+  };
+}
+function day(ts) {
+  return ts === null ? "-" : ts.slice(0, 10);
+}
+function renderSkillUsage(report) {
+  const window = report.since === null ? "in every stored event" : `since ${report.since.slice(0, 10)}`;
+  const lines = [
+    `${report.rows.length} skill${report.rows.length === 1 ? "" : "s"} used ${window} \xB7 ${report.unused.length} installed with no use (traces skills --unused) \xB7 no model call`
+  ];
+  if (report.rows.length === 0) return lines.join("\n");
+  const width = Math.max(5, ...report.rows.map((r) => r.skill.length));
+  lines.push(`${"skill".padEnd(width)}  model  slash   read  sessions  last        installed`);
+  for (const row of report.rows) {
+    lines.push(
+      `${row.skill.padEnd(width)}  ${String(row.model).padStart(5)}  ${String(row.slash).padStart(5)}  ${String(row.read).padStart(5)}  ${String(row.sessions).padStart(8)}  ${day(row.lastUsed)}  ${row.installedIn.join(",") || "-"}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/session-measurements.ts
+var STALL_MINUTES = 10;
+var STREAK_RUNS = 3;
+var COMMAND_TEXT_CAP = 300;
+var CONTEXT_BAND_TOKENS = 1e5;
+var CONTEXT_BANDS = 10;
+var LATENCY_MAX_MS = 6e5;
+function contextBandLabel(index) {
+  return index >= CONTEXT_BANDS - 1 ? `${CONTEXT_BANDS - 1}00k+` : `${index * 100 === 0 ? 0 : `${index}00`}-${index + 1}00k`;
+}
+function rankPercentile(sorted, q) {
+  return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * q))];
+}
+function operatingSamplesOf(spans, tools) {
+  const calls = spans.filter((span) => !isInherited(span)).map((span) => ({ span, context: modelCallContextTokens(span) })).filter((call) => call.context !== null).map((call) => ({ ...call, start: Date.parse(call.span.start_time), end: Date.parse(call.span.end_time) })).sort((a, b) => a.start - b.start);
+  const results = tools.filter((span) => !isInherited(span) && span.status.code !== "UNSET").map((span) => Date.parse(span.end_time)).filter((at) => Number.isFinite(at)).sort((a, b) => a - b);
+  const latencyMs = Array.from({ length: CONTEXT_BANDS }, () => []);
+  let next = 0;
+  let previousEnd = Number.NEGATIVE_INFINITY;
+  for (const call of calls) {
+    if (!Number.isFinite(call.start)) continue;
+    let result;
+    while (next < results.length && results[next] <= call.start) {
+      if (results[next] > previousEnd) result = results[next];
+      next++;
+    }
+    const elapsed = result === void 0 ? NaN : call.start - result;
+    if (elapsed > 0 && elapsed < LATENCY_MAX_MS) latencyMs[Math.min(CONTEXT_BANDS - 1, Math.floor(call.context / CONTEXT_BAND_TOKENS))].push(elapsed);
+    previousEnd = Number.isFinite(call.end) ? Math.max(call.end, call.start) : call.start;
+  }
+  return { contextTokens: calls.map((call) => call.context), latencyMs };
+}
+function modelCallMeasurement(samples) {
+  const contexts = [...samples.contextTokens].sort((a, b) => a - b);
+  return {
+    calls: contexts.length,
+    contextTokens: contexts.length === 0 ? { mean: null } : {
+      mean: Math.round(contexts.reduce((sum2, value) => sum2 + value, 0) / contexts.length),
+      // One call is a value, not a distribution.
+      ...contexts.length >= 2 ? { p50: rankPercentile(contexts, 0.5) } : {}
+    },
+    latencyByContext: samples.latencyMs.flatMap((values, index) => {
+      if (values.length < 2) return [];
+      const sorted = [...values].sort((a, b) => a - b);
+      return [{ band: contextBandLabel(index), calls: sorted.length, p50Ms: rankPercentile(sorted, 0.5), p90Ms: rankPercentile(sorted, 0.9) }];
+    })
+  };
+}
+var HOOK_ERROR = /hook error: (?:\[([^\]]+)\]|([A-Za-z0-9_.-]+)(?=:| \())?/u;
+function refusingGuard(span) {
+  if (span.status.code !== "ERROR") return void 0;
+  const match = HOOK_ERROR.exec(span.status.message ?? "");
+  if (!match) return void 0;
+  return match[1] ? basename2(match[1]) : match[2] ?? "(unnamed)";
+}
+function guardRefusalsOf(tools) {
+  const byGuard = {};
+  const spanIds = [];
+  for (const span of tools) {
+    const guard = refusingGuard(span);
+    if (guard === void 0) continue;
+    byGuard[guard] = (byGuard[guard] ?? 0) + 1;
+    spanIds.push(span.span_id);
+  }
+  return { refusals: spanIds.length, byGuard, spanIds };
+}
+var LIMIT_TEXT = /^(?:you['’]ve hit your ([\w-]+) limit|claude ai (usage) limit reached|([\w-]+) limit reached\b|you['’]ve reached your ([\w-]+) limit)/iu;
+var LIMIT_NOTICE_MAX_CHARS = 300;
+var REPLY_SPANS = /* @__PURE__ */ new Set(["message.assistant", "llm.turn"]);
+function limitStopOf(spans) {
+  const root = spans.find((span) => span.parent_span_id === null && span.status.code === "ERROR");
+  const notice = root?.status.message?.trim() ?? "";
+  const rootMatch = notice.length <= LIMIT_NOTICE_MAX_CHARS ? LIMIT_TEXT.exec(notice) : null;
+  if (root && rootMatch) {
+    return { kind: (rootMatch[1] ?? rootMatch[2] ?? rootMatch[3] ?? rootMatch[4] ?? "usage").toLowerCase(), text: notice, at: root.end_time, spanId: root.span_id };
+  }
+  let last;
+  for (const span of spans) {
+    if (isInherited(span) || !REPLY_SPANS.has(span.name) || typeof span.attributes.content !== "string") continue;
+    if (!last || Date.parse(span.end_time) >= Date.parse(last.end_time)) last = span;
+  }
+  const text = typeof last?.attributes.content === "string" ? last.attributes.content.trim() : "";
+  const match = last && text.length <= LIMIT_NOTICE_MAX_CHARS ? LIMIT_TEXT.exec(text) : null;
+  if (!last || !match) return null;
+  return { kind: (match[1] ?? match[2] ?? match[3] ?? match[4] ?? "usage").toLowerCase(), text, at: last.end_time, spanId: last.span_id };
+}
+var number = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+function measure(spans, read, reason) {
+  let total = 0;
+  let measured = 0;
+  for (const span of spans) {
+    const value = read(span);
+    if (value !== null) {
+      total += value;
+      measured += 1;
+    }
+  }
+  return {
+    total: measured > 0 || spans.length === 0 ? total : null,
+    measured,
+    eligible: spans.length,
+    unavailable: measured === spans.length ? null : reason
+  };
+}
+function bytes(span, side) {
+  const recorded = number(span.attributes[`traces.${side}.bytes`]);
+  if (recorded !== null) return recorded;
+  const text = span.attributes[`${side}.value`];
+  if (typeof text !== "string" || span.attributes[`traces.${side}.truncated`] === true) return null;
+  return Buffer.byteLength(text);
+}
+function toolMeasurements(tools) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const name = typeof tool.attributes["tool.name"] === "string" ? tool.attributes["tool.name"] : tool.name;
+    const group = groups.get(name);
+    if (group) group.push(tool);
+    else groups.set(name, [tool]);
+  }
+  return [...groups].sort(([a], [b]) => a.localeCompare(b)).map(([name, spans]) => ({
+    name,
+    calls: spans.length,
+    outcomes: {
+      ok: spans.filter((span) => span.status.code === "OK").length,
+      error: spans.filter((span) => span.status.code === "ERROR").length,
+      unset: spans.filter((span) => span.status.code === "UNSET").length
+    },
+    inputBytes: measure(spans, (span) => bytes(span, "input"), "Input byte count missing or truncated without a size receipt."),
+    outputBytes: measure(spans, (span) => bytes(span, "output"), "Output byte count missing or truncated without a size receipt."),
+    callToResultMs: measure(spans, (span) => {
+      if (span.status.code === "UNSET") return null;
+      const elapsed = Date.parse(span.end_time) - Date.parse(span.start_time);
+      return Number.isFinite(elapsed) && elapsed > 0 ? elapsed : null;
+    }, "A completed span with distinct recorded endpoints is required; equal endpoints may be an adapter default."),
+    spanIds: spans.map((span) => span.span_id)
+  }));
+}
+function compactions(spans) {
+  const events = spans.filter((span) => span.name === "session.compacted" && span.attributes[INHERITED_SOURCE_ATTR] !== "pre-task-prefix").sort((a, b) => Date.parse(a.start_time) - Date.parse(b.start_time));
+  if (events.length === 0) return {
+    value: null,
+    spanIds: [],
+    unavailable: "No compaction boundary was captured. This does not establish that no compaction occurred."
+  };
+  return {
+    value: events.map((span, i) => {
+      const previous = i > 0 ? events[i - 1] : void 0;
+      const interval = previous ? Date.parse(span.start_time) - Date.parse(previous.start_time) : NaN;
+      return {
+        spanId: span.span_id,
+        at: span.start_time,
+        sincePreviousMs: Number.isFinite(interval) && interval >= 0 ? interval : null,
+        latencyMs: number(span.attributes["traces.compaction.latency_ms"]),
+        tokensBefore: number(span.attributes["traces.compaction.tokens_before"]),
+        tokensAfter: number(span.attributes["traces.compaction.tokens_after"])
+      };
+    }),
+    spanIds: events.map((span) => span.span_id),
+    unavailable: null,
+    partial: "Observed boundaries only. Latency and context sizes are null unless the source explicitly records them."
+  };
+}
+function contextFootprints(spans) {
+  const out = [];
+  for (const span of spans) {
+    const fields = ["gen_ai.tool.definitions", "gen_ai.system_instructions"];
+    if (span.name === "message.system" || span.name === "message.developer" || span.name === "user.prompt" && span.attributes["tangle.actor"] === "injected") fields.push("content");
+    for (const field of fields) {
+      const value = span.attributes[field];
+      if (value === void 0 || value === null) continue;
+      const text = typeof value === "string" ? value : canonicalJson(value);
+      let entries = Array.isArray(value) ? value.length : null;
+      if (typeof value === "string") {
+        try {
+          const parsed = JSON.parse(value);
+          if (Array.isArray(parsed)) entries = parsed.length;
+        } catch {
+        }
+      }
+      out.push({ spanId: span.span_id, field, bytes: Buffer.byteLength(text), lines: text.split("\n").length, entries, scope: "captured-attribute" });
+    }
+  }
+  return out;
+}
+var MINUTE_MS = 6e4;
+var STALL_MS = STALL_MINUTES * MINUTE_MS;
+var STALL_LIST_CAP = 200;
+var minutes = (ms) => Math.round(ms / 6e3) / 10;
+function timeOf(value) {
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) && ms > 0 ? ms : null;
+}
+var isInherited = (span) => span.attributes[INHERITED_SPAN_ATTR] === true;
+var promptText = (span) => span.name === "user.prompt" && typeof span.attributes.content === "string" ? span.attributes.content.trim() : "";
+function endsWait(span) {
+  if (span.name !== "user.prompt") return false;
+  const actor = span.attributes[ACTOR_ATTR];
+  const content = promptText(span);
+  return actor === "human" || actor === "agent" || INTERRUPT_TEXT.test(content) || isFleetTurn(content);
+}
+var BACKGROUND_RESULT = /^<task-notification>/u;
+var toolNameOf = (span) => typeof span.attributes["tool.name"] === "string" ? span.attributes["tool.name"] : span.name.replace(/^tool\./u, "");
+function isRollback(line) {
+  const words = line.split(" ");
+  if (basename2(words[0] ?? "") !== "git") return false;
+  let at = 1;
+  while (at < words.length && words[at].startsWith("-")) at += words[at] === "-C" || words[at] === "-c" ? 2 : 1;
+  return words[at] === "revert" || words[at] === "reset" && words.slice(at + 1).includes("--hard");
+}
+function timeline(records) {
+  const points = [];
+  for (const span of records) {
+    const start = timeOf(span.start_time);
+    const end = timeOf(span.end_time);
+    if (start !== null) points.push({ at: start, span, end: false });
+    if (end !== null && (start === null || end > start)) points.push({ at: end, span, end: true });
+  }
+  return points.sort((left, right) => left.at - right.at);
+}
+function unionMs(intervals) {
+  let total = 0;
+  let reach = Number.NEGATIVE_INFINITY;
+  for (const [start, end] of [...intervals].sort((a, b) => a[0] - b[0])) {
+    if (end <= reach) continue;
+    total += end - Math.max(start, reach);
+    reach = end;
+  }
+  return total;
+}
+function measureTime(spans, records, tools) {
+  const points = timeline(records.filter((span) => !isInherited(span)));
+  const stalls = [];
+  const stallIntervals = [];
+  let activeMs = 0;
+  for (let i = 1; i < points.length; i++) {
+    const before = points[i - 1].at;
+    const gap = points[i].at - before;
+    activeMs += Math.min(gap, STALL_MS);
+    if (gap < STALL_MS) continue;
+    const ending = [];
+    for (let j = i; j < points.length && points[j].at === points[i].at; j++) ending.push(points[j]);
+    if (ending.some((point) => !point.end && endsWait(point.span))) continue;
+    const result = ending.find((point) => point.end && point.span.attributes["openinference.span.kind"] === "TOOL" || !point.end && BACKGROUND_RESULT.test(promptText(point.span)));
+    stalls.push({
+      at: new Date(before).toISOString(),
+      minutes: minutes(gap),
+      kind: result ? "waiting on a command" : "idle",
+      spanId: (result ?? ending[0]).span.span_id
+    });
+    stallIntervals.push([before, points[i].at]);
+  }
+  const noTime = "no record of this session's own carries a readable time";
+  const stallFact = points.length === 0 ? { value: null, spanIds: [], unavailable: noTime } : {
+    value: stalls.slice(0, STALL_LIST_CAP),
+    spanIds: stalls.map((stall) => stall.spanId),
+    unavailable: null,
+    ...stalls.length > STALL_LIST_CAP ? { partial: `${stalls.length - STALL_LIST_CAP} of ${stalls.length} stalls omitted; the spanIds are complete` } : {}
+  };
+  const own = tools.filter((span) => !isInherited(span));
+  const runs = [];
+  for (const span of own) {
+    const input = span.attributes["input.value"];
+    const script = typeof input === "string" ? commandTextFromInput(input) : void 0;
+    if (script !== void 0) runs.push({ span, script, command: script.replace(/\s+/gu, " ").trim(), statusKnown: !isCodeModeScript(input) });
+  }
+  const statusUnknown = runs.filter((run) => !run.statusKnown).length;
+  const unread = own.length > 0 && !own.some((span) => typeof span.attributes["input.value"] === "string") ? "no tool call recorded its arguments, so which commands ran cannot be read" : null;
+  const byCommand = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const group = byCommand.get(run.command);
+    if (group) group.push(run);
+    else byCommand.set(run.command, [run]);
+  }
+  const repeated = [...byCommand.values()].filter((group) => group.length > 1);
+  const rollbacks = runs.flatMap((run) => commandLines(run.script).filter(isRollback).map(() => run.span.span_id));
+  const streaks = [];
+  const streakIntervals = [];
+  const open2 = /* @__PURE__ */ new Map();
+  const close = (command) => {
+    const failed = open2.get(command);
+    open2.delete(command);
+    if (!failed || failed.length < STREAK_RUNS) return;
+    const start = Math.min(...failed.map((run) => timeOf(run.span.start_time) ?? Number.POSITIVE_INFINITY));
+    const end = Math.max(...failed.map((run) => timeOf(run.span.end_time) ?? timeOf(run.span.start_time) ?? Number.NEGATIVE_INFINITY));
+    const known = Number.isFinite(start) && Number.isFinite(end) && end >= start;
+    streaks.push({
+      command: failed[0].command.length > COMMAND_TEXT_CAP ? `${failed[0].command.slice(0, COMMAND_TEXT_CAP - 1)}\u2026` : failed[0].command,
+      tool: toolNameOf(failed[0].span),
+      runs: failed.length,
+      minutes: known ? minutes(end - start) : 0,
+      at: failed[0].span.start_time,
+      spanIds: failed.map((run) => run.span.span_id)
+    });
+    if (known) streakIntervals.push([start, end]);
+  };
+  const runOf = new Map(runs.map((run) => [run.span, run]));
+  for (const span of spans) {
+    if (endsWait(span)) {
+      for (const command of [...open2.keys()]) close(command);
+      continue;
+    }
+    const run = runOf.get(span);
+    if (!run || !run.statusKnown) continue;
+    if (span.status.code === "OK") close(run.command);
+    else if (span.status.code === "ERROR") {
+      const failed = open2.get(run.command);
+      if (failed) failed.push(run);
+      else open2.set(run.command, [run]);
+    }
+  }
+  for (const command of [...open2.keys()]) close(command);
+  streaks.sort((left, right) => (timeOf(left.at) ?? 0) - (timeOf(right.at) ?? 0));
+  const commandFact = (value, spanIds) => unread === null ? { value, spanIds, unavailable: null } : { value: null, spanIds: [], unavailable: unread };
+  const unavailable = [unread, points.length === 0 ? noTime : null].filter((reason) => reason !== null).join("; ");
+  return {
+    waste: {
+      minutes: unavailable === "" ? minutes(unionMs([...streakIntervals, ...stallIntervals])) : null,
+      unavailable: unavailable === "" ? null : unavailable,
+      failingStreaks: unread === null && statusUnknown > 0 ? {
+        ...commandFact(streaks, streaks.flatMap((streak) => streak.spanIds)),
+        partial: `${statusUnknown} of ${runs.length} command runs were inside Codex code-mode scripts, which record the script's status, not the command's exit code, so no streak among them can be read`
+      } : commandFact(streaks, streaks.flatMap((streak) => streak.spanIds)),
+      stalls: stallFact,
+      rollbacks: commandFact(rollbacks.length, rollbacks),
+      repeatedCommands: commandFact(
+        { commands: repeated.length, extraRuns: repeated.reduce((sum2, group) => sum2 + group.length - 1, 0) },
+        repeated.flatMap((group) => group.slice(1).map((run) => run.span.span_id))
+      )
+    },
+    activeMinutes: points.length === 0 ? { value: null, spanIds: [], unavailable: noTime } : { value: minutes(activeMs), spanIds: [], unavailable: null }
+  };
+}
+function computeSessionMeasurements(input) {
+  const { spans, records, tools, sessionId, harness } = input;
+  return {
+    skills: skillUseOfSpans(spans.filter((span) => !isInherited(span)), harness),
+    ...measureTime(spans, records, tools),
+    relationship: describeSessionRelationship({
+      sessionId: sessionId ?? spans[0]?.trace_id ?? "",
+      harness: harness ?? "",
+      path: "",
+      cwd: null,
+      mtimeMs: 0
+    }, spans),
+    tools: toolMeasurements(tools),
+    compactions: compactions(spans),
+    contextFootprints: contextFootprints(spans),
+    modelCalls: modelCallMeasurement(input.operating ?? operatingSamplesOf(spans, tools)),
+    guardRefusals: guardRefusalsOf(tools),
+    limitStop: limitStopOf(spans)
+  };
+}
+
+// src/session-facts.ts
+import { OPENINFERENCE_SPAN_KIND as OPENINFERENCE_SPAN_KIND3, TOOL_NAME } from "@tangle-network/agent-eval/trace-attributes";
+import { ingestSpans, rankFirstFailure } from "@tangle-network/agent-eval/diagnosis";
+
+// src/session-turns.ts
+import { OPENINFERENCE_SPAN_KIND as OPENINFERENCE_SPAN_KIND2 } from "@tangle-network/agent-eval/trace-attributes";
+function stringAttr(span, key) {
+  const value = span.attributes[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+var FACT_TEXT_CAP = 2e3;
+var ANSWERED_TEXT_CAP = 1500;
+var TURN_EXCLUSION_REASONS = {
+  injected: "harness-injected content rather than typed text: an instruction file, an environment-context block, a system reminder, a task or subagent notification, an interrupt or turn-aborted marker, or a skill or slash-command expansion",
+  agent: "a parent agent sent this prompt to this session; no person typed it",
+  "subagent-spawn": "the brief that spawned this run, written by the agent that spawned it",
+  "tool-result": "a tool result the harness surfaced as a user turn",
+  fleet: "another agent or session sent this turn in: a fleet message, a session-to-session message, an operator handoff, or a lane brief (a first turn over 1,500 characters); no person typed it here",
+  relay: "a person pasted another agent's output: a long, markdown-heavy turn after the session's first",
+  unclassified: "the span carries no actor, so whether a person typed it cannot be read from the spans"
+};
+var INHERITED_TURN_REASON = "context this session carries but did not receive: history copied from the parent when the session forked, or the turns a compaction retained. The person typed it into the parent thread, not into this session";
+var DUPLICATE_TURN_REASON = "a second record of the turn before it: the same text at the same instant, with no model call, tool call or assistant message between them";
+var SUBAGENT_TURN_REASON = "a turn inside a subagent this session spawned, not a turn of this session: the person addressed the session, and the brief and notifications the subagent received are the parent agent talking to it";
+var HARNESS_COMMAND_REASON = "a command the person gave the harness (/model, /clear, \u2026), not a message to the agent";
+var CLAIM_WORD = /\b(?:done|fixed|complete|completed|finished|implemented|merged|shipped|landed|resolved|verified|all green|tests pass(?:ed)?|ready|works now)\b/i;
+var CLAIM_DENIED = /\b(?:not|no|never|yet|still|cannot|can['’]?t|won['’]?t|isn['’]?t|aren['’]?t|wasn['’]?t|didn['’]?t|doesn['’]?t|hasn['’]?t|haven['’]?t|fail(?:s|ed|ing)?|broken|blocked)\b/i;
+function openingSentence(text) {
+  const plain = text.trimStart().replace(/[*_`#>]/g, "").replace(/^\s*(?:[-•→]|\d+[.)])\s+/u, "");
+  const end = /[.!?:;](?=\s|$)|\n/.exec(plain);
+  return (end ? plain.slice(0, end.index + end[0].length) : plain).slice(0, 200).trim();
+}
+function isCompletionClaim(text) {
+  const opening = openingSentence(text);
+  return CLAIM_WORD.test(opening) && !CLAIM_DENIED.test(opening) && !opening.endsWith("?");
+}
+var REJECTED_TOOL_TEXT = /The user doesn't want to proceed with this tool use|tool use was rejected|rejected by (?:the )?user|user (?:rejected|declined|denied) (?:this|the)/iu;
+function isAgentActivity(span) {
+  if (span.name === "user.prompt") return false;
+  const kind = span.attributes[OPENINFERENCE_SPAN_KIND2];
+  return kind === "TOOL" || kind === "LLM" || span.name === "message.assistant" || span.name.startsWith("message.agent.");
+}
+function rawContent(span) {
+  return typeof span.attributes.content === "string" ? span.attributes.content : "";
+}
+function turnText(span) {
+  return capText(rawContent(span), FACT_TEXT_CAP);
+}
+function normalizedTurnText(span) {
+  return turnText(span).replace(/\s+/g, " ").trim();
+}
+var CAPTURE_CUT_MARKER = /… \[\+(\d+) chars\]$/;
+function clipAnswered(raw) {
+  const text = raw.trim();
+  const marker = CAPTURE_CUT_MARKER.exec(text);
+  const body = marker ? text.slice(0, marker.index) : text;
+  if (body.length <= ANSWERED_TEXT_CAP) return text;
+  const lastKept = body.charCodeAt(ANSWERED_TEXT_CAP - 1);
+  const keep = lastKept >= 55296 && lastKept <= 56319 ? ANSWERED_TEXT_CAP - 1 : ANSWERED_TEXT_CAP;
+  const hidden = body.length - keep + (marker ? Number(marker[1]) : 0);
+  return `${body.slice(0, keep)}\u2026 [+${hidden} chars]`;
+}
+function isOwnAgentMessage(span) {
+  return span.name === "message.assistant" && span.attributes[INHERITED_SPAN_ATTR] !== true && rawContent(span).trim().length > 0;
+}
+function isRejectedTool(span) {
+  if (span.attributes[OPENINFERENCE_SPAN_KIND2] !== "TOOL" || span.status.code !== "ERROR" || span.attributes[INHERITED_SPAN_ATTR] === true) return false;
+  const output = span.attributes["output.value"];
+  return REJECTED_TOOL_TEXT.test(`${span.status.message ?? ""}
+${typeof output === "string" ? output.slice(0, 2e3) : ""}`);
+}
+var TURN_FOLD_START = { typed: false, kept: null, activity: false };
+function typedTurnsOf(spans, start = TURN_FOLD_START) {
+  const excluded = /* @__PURE__ */ new Map();
+  const drop = (reason, author, span) => {
+    const key = `${reason}\0${author}`;
+    excluded.set(key, [...excluded.get(key) ?? [], { spanId: span.span_id, at: span.start_time }]);
+  };
+  const turns = [];
+  let kept = start.kept;
+  let activity = start.activity;
+  let lastAgentMessage = null;
+  let lastTurn = null;
+  let awaitingReply = [];
+  let pending = /* @__PURE__ */ new Set();
+  let agentWroteSinceHuman = false;
+  for (const span of spans) {
+    if (isSubagentSpan(span.attributes)) {
+      if (span.name === "user.prompt") drop(SUBAGENT_TURN_REASON, stringAttr(span, ACTOR_ATTR) ?? "unclassified", span);
+      continue;
+    }
+    if (span.name !== "user.prompt") {
+      if (isOwnAgentMessage(span)) {
+        lastAgentMessage = span;
+        agentWroteSinceHuman = true;
+        for (const turn2 of awaitingReply) {
+          turn2.reply = clipAnswered(rawContent(span));
+          turn2.replySpanId = span.span_id;
+        }
+        awaitingReply = [];
+      }
+      if (isRejectedTool(span)) pending.add("rejected-tool");
+      if (isAgentActivity(span)) activity = true;
+      continue;
+    }
+    const actor = stringAttr(span, ACTOR_ATTR) ?? "unclassified";
+    if (span.attributes[INHERITED_SPAN_ATTR] === true) {
+      const source = stringAttr(span, INHERITED_SOURCE_ATTR);
+      drop(source === null ? INHERITED_TURN_REASON : `${INHERITED_TURN_REASON} (${source})`, actor, span);
+      continue;
+    }
+    const text = rawContent(span);
+    if (INTERRUPT_TEXT.test(text.trim())) {
+      pending.add("interrupt");
+      if (lastTurn) lastTurn.interrupted = true;
+    }
+    if (actor !== "human") {
+      drop(TURN_EXCLUSION_REASONS[actor] ?? `the adapter classified this turn as "${actor}", not as a person typing`, actor, span);
+      continue;
+    }
+    const author = authorOfTypedTurn(text, { firstTurn: !start.typed && turns.length === 0 });
+    if (author === "injected") {
+      drop(TURN_EXCLUSION_REASONS.injected, "injected", span);
+      continue;
+    }
+    if (author === "human" && isHarnessCommand(text)) {
+      drop(HARNESS_COMMAND_REASON, "human", span);
+      continue;
+    }
+    const normalized = normalizedTurnText(span);
+    const duplicate = author === "human" && kept !== null && kept.at === span.start_time && kept.text === normalized && normalized.length > 0 && !activity;
+    if (duplicate) {
+      drop(DUPLICATE_TURN_REASON, "human", span);
+      continue;
+    }
+    const answered = lastAgentMessage ? rawContent(lastAgentMessage) : null;
+    if (agentWroteSinceHuman && answered !== null && isCompletionClaim(answered)) pending.add("after-claim");
+    const turn = {
+      actor: "human",
+      author,
+      at: span.start_time,
+      text: turnText(span),
+      spanId: span.span_id,
+      answered: answered === null ? null : clipAnswered(answered),
+      answeredSpanId: lastAgentMessage?.span_id ?? null,
+      reply: null,
+      replySpanId: null,
+      interrupted: false,
+      // A fleet message is another agent talking: a signal is a person's.
+      signals: author === "fleet" ? [] : SIGNAL_ORDER.filter((signal) => pending.has(signal))
+    };
+    turns.push(turn);
+    lastTurn = turn;
+    awaitingReply.push(turn);
+    if (author === "human") {
+      kept = { at: span.start_time, text: normalized };
+      activity = false;
+      pending = /* @__PURE__ */ new Set();
+      agentWroteSinceHuman = false;
+    } else {
+      drop(TURN_EXCLUSION_REASONS[author], author, span);
+    }
+  }
+  return { turns, excluded, state: { typed: start.typed || turns.length > 0, kept, activity } };
+}
+var SIGNAL_ORDER = ["interrupt", "rejected-tool", "after-claim"];
+
+// src/pull-request-facts.ts
+var GH_NAMES = /* @__PURE__ */ new Set(["gh", "gh-drew"]);
+var CREATE_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-H",
+  "--head",
+  "-B",
+  "--base",
+  "-R",
+  "--repo",
+  "-t",
+  "--title",
+  "-b",
+  "--body",
+  "-F",
+  "--body-file",
+  "-a",
+  "--assignee",
+  "-l",
+  "--label",
+  "-m",
+  "--milestone",
+  "-p",
+  "--project",
+  "-r",
+  "--reviewer",
+  "-T",
+  "--template"
+]);
+var MERGE_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-t",
+  "--subject",
+  "-b",
+  "--body",
+  "-F",
+  "--body-file",
+  "--match-head-commit",
+  "-R",
+  "--repo",
+  "-A",
+  "--author-email"
+]);
+var ANSI = /\u001B\[[0-9;?]*[A-Za-z]|\u001B\][^\u0007]*\u0007/g;
+var PR_URL_LINE = /^https?:\/\/[^/\s]+\/[^/\s]+\/[^/\s]+\/pull\/(\d+)\/?$/;
+var PR_NUMBER = /https?:\/\/[^/\s"']+\/[^/\s"']+\/[^/\s"']+\/pull\/(\d+)|(?:^|\s)#(\d+)\b/g;
+var MERGED_NUMBER = /(?:(?:Squashed and merged|Rebased and merged|Merged) pull request|Pull request)\s+(?:[\w.\-]+\/[\w.\-]+)?#(\d+)/;
+var CREATE_REACHED_GH = /createPullRequest|pull request create failed|must first push the current branch|a pull request for branch|already exists|Creating pull request for|No commits between|Head ref must be a branch|GraphQL:|HTTP 4\d\d/i;
+var MERGE_REACHED_GH = /mergePullRequest|pull request|Merged|not mergeable|GraphQL:|failed to run git|base branch policy|approving review is required|HTTP 4\d\d/i;
+var PULL_REQUEST_URL = /https?:\/\/[^/\s"']+\/[^/\s"']+\/[^/\s"']+\/pull\/\d+/;
+var PUSH_TRACKING = /branch '([^']+)' set up to track/;
+var PUSH_NEW_BRANCH = /\[new branch\]\s+\S+\s+->\s+(\S+)/;
+var SCRIPT_RESULT_START = '{"chunk_id"';
+function jsonObjectEnd(text, start) {
+  let depth = 0;
+  let inString = false;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (char === "\\") index += 1;
+      else if (char === '"') inString = false;
+    } else if (char === '"') inString = true;
+    else if (char === "{") depth += 1;
+    else if (char === "}" && --depth === 0) return index + 1;
+  }
+  return -1;
+}
+function scriptResults(output) {
+  const results = [];
+  for (let from = output.indexOf(SCRIPT_RESULT_START); from !== -1; from = output.indexOf(SCRIPT_RESULT_START, from + 1)) {
+    const end = jsonObjectEnd(output, from);
+    if (end === -1) break;
+    let value;
+    try {
+      value = JSON.parse(output.slice(from, end));
+    } catch {
+      continue;
+    }
+    const session = value.session_id;
+    results.push({
+      sessionId: typeof session === "number" || typeof session === "string" ? String(session) : null,
+      exitCode: typeof value.exit_code === "number" ? value.exit_code : null,
+      output: typeof value.output === "string" ? value.output : ""
+    });
+    from = end - 1;
+  }
+  return results;
+}
+function stringAttribute2(span, key) {
+  const value = span.attributes[key];
+  return typeof value === "string" ? value : null;
+}
+function basename3(word) {
+  const cut = word.lastIndexOf("/");
+  return cut === -1 ? word : word.slice(cut + 1);
+}
+function commandRecords(spans) {
+  const scripted = /* @__PURE__ */ new Map();
+  const codeMode = /* @__PURE__ */ new Set();
+  for (const span of spans) {
+    const input = stringAttribute2(span, "input.value");
+    if (input === null) continue;
+    const script = commandTextFromInput(input);
+    if (script === void 0) continue;
+    scripted.set(span, script);
+    if (isCodeModeScript(input)) codeMode.add(span);
+  }
+  const innerParents = /* @__PURE__ */ new Set();
+  const innerScripts = /* @__PURE__ */ new Set();
+  for (const [span, script] of scripted) {
+    if (!isInnerToolCall(span.attributes)) continue;
+    if (span.parent_span_id !== null) innerParents.add(span.parent_span_id);
+    innerScripts.add(script);
+  }
+  const records = [];
+  for (const [span, script] of scripted) {
+    const outer = !isInnerToolCall(span.attributes);
+    if (outer && (innerParents.has(span.span_id) || innerScripts.has(script))) continue;
+    const exit = span.attributes["process.exit_code"];
+    const exitCode = typeof exit === "number" ? exit : null;
+    const output = stringAttribute2(span, "output.value") ?? "";
+    const results = codeMode.has(span) ? scriptResults(output) : [];
+    const header = RUNNING_SESSION.exec(output)?.[1];
+    records.push({
+      spanId: span.span_id,
+      at: span.start_time,
+      script,
+      output,
+      text: [output, ...results.map((result) => result.output)].join("\n"),
+      running: [
+        ...header === void 0 ? [] : [header],
+        ...results.filter((result) => result.sessionId !== null && result.exitCode === null).map((result) => result.sessionId)
+      ],
+      failed: codeMode.has(span) || (exitCode === null ? span.status.code === "ERROR" : exitCode !== 0),
+      inputTruncated: span.attributes["traces.input.truncated"] === true,
+      outputTruncated: span.attributes["traces.output.truncated"] === true
+    });
+  }
+  return records;
+}
+function parseFlags(args, valueFlags) {
+  const flags = /* @__PURE__ */ new Map();
+  const positional = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--") {
+      positional.push(...args.slice(index + 1));
+      break;
+    }
+    if (arg.startsWith("--") && arg.includes("=")) {
+      const cut = arg.indexOf("=");
+      flags.set(arg.slice(0, cut), arg.slice(cut + 1));
+    } else if (valueFlags.has(arg)) {
+      flags.set(arg, args[index + 1] ?? true);
+      index += 1;
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      flags.set(arg, true);
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+function flagValue(flags, ...names) {
+  for (const name of names) {
+    const value = flags.get(name);
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return null;
+}
+function printedPullRequestNumbers(output) {
+  const numbers = [];
+  for (const raw of output.split("\n")) {
+    const line = raw.replace(ANSI, "").split("\r").pop().trim();
+    const match = PR_URL_LINE.exec(line);
+    if (match) numbers.push(match[1]);
+  }
+  return numbers;
+}
+function numbersInLine(line) {
+  const found = [];
+  for (const match of line.matchAll(PR_NUMBER)) found.push(match[1] ?? match[2]);
+  return found;
+}
+function inferHeadBranch(commands, upTo, output) {
+  for (let index = upTo - 1; index >= 0; index -= 1) {
+    const words = commands[index];
+    if (basename3(words[0] ?? "") !== "git" || words.length < 2) continue;
+    const sub = words[1];
+    const rest = words.slice(2);
+    if (sub === "push") {
+      const positional = rest.filter((word) => !word.startsWith("-"));
+      const ref = positional[positional.length - 1];
+      if (positional.length >= 2 && ref !== void 0 && ref !== "HEAD") {
+        const branch = (ref.includes(":") ? ref.slice(ref.indexOf(":") + 1) : ref).replace(/^\+/, "");
+        if (branch.length > 0) return branch;
+      }
+    }
+    if (sub === "checkout" || sub === "switch") {
+      for (let position = 0; position < rest.length - 1; position += 1) {
+        if (["-b", "-B", "-c", "-C", "--create", "--force-create"].includes(rest[position])) return rest[position + 1];
+      }
+    }
+    if (sub === "worktree" && rest[0] === "add") {
+      for (let position = 1; position < rest.length - 1; position += 1) {
+        if (rest[position] === "-b" || rest[position] === "-B") return rest[position + 1];
+      }
+    }
+  }
+  return PUSH_TRACKING.exec(output)?.[1] ?? PUSH_NEW_BRANCH.exec(output)?.[1] ?? null;
+}
+function reachedGh(record, action, sawNumber) {
+  if (!record.failed) return true;
+  if (sawNumber || PULL_REQUEST_URL.test(record.text)) return true;
+  return action === "create" ? CREATE_REACHED_GH.test(record.text) : MERGE_REACHED_GH.test(record.text);
+}
+function createEvent(record, recordIndex, words, commands, commandIndex, printed) {
+  const { flags } = parseFlags(words.slice(3), CREATE_VALUE_FLAGS);
+  if (flags.has("--help") || flags.has("-h")) return null;
+  if (!reachedGh(record, "create", printed !== null)) return null;
+  const printedNumber = printed?.number ?? null;
+  const headFlag = flagValue(flags, "--head", "-H");
+  const headBranch = headFlag ?? inferHeadBranch(commands, commandIndex, record.text);
+  const evidence = printed?.pollSpanId ? `the pull-request URL a later poll of this backgrounded command printed, in span ${printed.pollSpanId}` : printedNumber !== null ? `the pull-request URL this command printed, in span ${record.spanId}` : headFlag !== null ? "the --head branch given to the command" : headBranch !== null ? "the branch this same command pushed or created before calling gh" : "none: the command named no head branch and printed no pull-request URL";
+  return {
+    action: "create",
+    number: printedNumber,
+    headBranch,
+    command: words.join(" "),
+    evidence,
+    spanIds: printed?.pollSpanId ? [record.spanId, printed.pollSpanId] : [record.spanId],
+    at: record.at,
+    failed: record.failed,
+    recordIndex,
+    outputTruncated: record.outputTruncated
+  };
+}
+function mergeEvent(record, recordIndex, words) {
+  const { flags, positional } = parseFlags(words.slice(3), MERGE_VALUE_FLAGS);
+  if (flags.has("--help") || flags.has("-h")) return null;
+  const target = positional[0] ?? null;
+  const numberInCommand = target === null ? null : /^#?(\d+)$/.exec(target)?.[1] ?? numbersInLine(target)[0] ?? null;
+  const numberInOutput = numberInCommand === null ? MERGED_NUMBER.exec(record.text)?.[1] ?? null : null;
+  const number2 = numberInCommand ?? numberInOutput;
+  if (!reachedGh(record, "merge", number2 !== null)) return null;
+  const evidence = numberInCommand !== null ? "the pull request the command names" : numberInOutput !== null ? `the merge line this command printed, in span ${record.spanId}` : target !== null ? "the branch the command names; no output that joins to it stated a number" : "none: the command named neither a pull request nor a branch";
+  return {
+    action: "merge",
+    number: number2,
+    headBranch: number2 === null ? target : null,
+    command: words.join(" "),
+    evidence,
+    spanIds: [record.spanId],
+    at: record.at,
+    failed: record.failed,
+    recordIndex,
+    outputTruncated: record.outputTruncated
+  };
+}
+function eventsFromRecord(record, recordIndex, polled) {
+  if (!/\bpr\b/.test(record.script)) return [];
+  const commands = shellCommands(record.script);
+  const printed = [...printedPullRequestNumbers(record.text).map((number2) => ({ number: number2, pollSpanId: null })), ...polled];
+  const events = [];
+  let createIndex = 0;
+  for (let index = 0; index < commands.length; index += 1) {
+    const words = commands[index];
+    if (words.length < 3 || !GH_NAMES.has(basename3(words[0])) || words[1] !== "pr") continue;
+    const action = words[2];
+    if (action === "create") {
+      const printedNumber = printed[createIndex] ?? null;
+      createIndex += 1;
+      const event2 = createEvent(record, recordIndex, words, commands, index, printedNumber);
+      if (event2) events.push(event2);
+      continue;
+    }
+    if (action !== "merge") continue;
+    const event = mergeEvent(record, recordIndex, words);
+    if (event) events.push(event);
+  }
+  return events;
+}
+function numberFromLaterOutput(records, after, headBranch) {
+  for (let index = after + 1; index < records.length; index += 1) {
+    const record = records[index];
+    const found = /* @__PURE__ */ new Set();
+    for (const raw of `${record.script}
+${record.text}`.split("\n")) {
+      const line = raw.replace(ANSI, "");
+      if (!line.includes(headBranch)) continue;
+      for (const number2 of numbersInLine(line)) found.add(number2);
+    }
+    if (found.size === 1) return { number: [...found][0], spanId: record.spanId };
+  }
+  return null;
+}
+function identify(event) {
+  const identifier = event.number ?? event.headBranch;
+  return {
+    identifier,
+    number: event.number,
+    headBranch: event.headBranch,
+    command: event.command,
+    evidence: event.evidence,
+    spanIds: [...new Set(event.spanIds)],
+    at: event.at,
+    unavailable: identifier === null ? "the command named no pull-request number and no head branch, and no output that joins to it stated one" : null
+  };
+}
+function distinct(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const key = event.number ?? event.headBranch ?? `command:${event.command}`;
+    groups.set(key, [...groups.get(key) ?? [], event]);
+  }
+  return [...groups.values()].map((group) => {
+    const shown = group.find((event) => !event.failed) ?? group[0];
+    return { ...identify(shown), spanIds: [...new Set(group.flatMap((event) => event.spanIds))] };
+  });
+}
+var RUNNING_SESSION = /Process running with session ID (\d+)/;
+function pollsSession(input, session) {
+  if (!input.includes(session)) return false;
+  if (isCodeModeScript(input) || input.includes("write_stdin(")) {
+    return new RegExp(`write_stdin\\(\\s*\\{[^}]*\\bsession_id["']?\\s*:\\s*${session}\\b`, "u").test(input);
+  }
+  try {
+    return String(JSON.parse(input).session_id) === session;
+  } catch {
+    return false;
+  }
+}
+function polledNumbers(spans, record) {
+  const found = [];
+  for (const session of record.running) {
+    for (const span of spans) {
+      if (span.start_time < record.at || span.span_id === record.spanId) continue;
+      const input = stringAttribute2(span, "input.value");
+      if (input === null || !pollsSession(input, session)) continue;
+      const output = stringAttribute2(span, "output.value") ?? "";
+      const text = [output, ...scriptResults(output).map((result) => result.output)].join("\n");
+      const numbers = new Set(printedPullRequestNumbers(text));
+      if (numbers.size !== 1) continue;
+      found.push({ number: [...numbers][0], pollSpanId: span.span_id });
+      break;
+    }
+  }
+  return found;
+}
+function readPullRequests(spans) {
+  const records = commandRecords(spans);
+  if (records.length === 0) {
+    return {
+      facts: null,
+      spanIds: [],
+      commandSpans: 0,
+      partial: null,
+      unavailable: "no span in this trace carries an executed command (an input.value with a command or cmd field), so whether the agent created or merged a pull request cannot be read from these spans"
+    };
+  }
+  const events = [];
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    const creates = /\bpr\b/.test(record.script) && record.running.length > 0;
+    events.push(...eventsFromRecord(record, index, creates ? polledNumbers(spans, record) : []));
+  }
+  const numberByBranch = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.action !== "create" || event.number === null || event.headBranch === null) continue;
+    if (!numberByBranch.has(event.headBranch)) numberByBranch.set(event.headBranch, event.number);
+  }
+  let unjoinedTruncated = 0;
+  for (const event of events) {
+    if (event.number !== null || event.headBranch === null) continue;
+    const sibling = numberByBranch.get(event.headBranch);
+    if (sibling !== void 0) {
+      event.number = sibling;
+      event.evidence = `${event.evidence}, resolved to the number another create for this branch printed`;
+      continue;
+    }
+    const later2 = numberFromLaterOutput(records, event.recordIndex, event.headBranch);
+    if (later2 !== null) {
+      event.number = later2.number;
+      event.spanIds.push(later2.spanId);
+      event.evidence = `${event.evidence}, resolved to the number a later output states for this branch, in span ${later2.spanId}`;
+      continue;
+    }
+    if (event.outputTruncated) unjoinedTruncated += 1;
+  }
+  const created = distinct(events.filter((event) => event.action === "create"));
+  const merged = distinct(events.filter((event) => event.action === "merge"));
+  const truncatedCommands = records.filter((record) => record.inputTruncated && /\bpr\b/.test(record.script)).length;
+  const notes = [];
+  if (truncatedCommands > 0) {
+    notes.push(
+      `${truncatedCommands} command span(s) mentioning a pull request had truncated input; a gh command past the cut is not in this list`
+    );
+  }
+  if (unjoinedTruncated > 0) {
+    notes.push(
+      `${unjoinedTruncated} entr(y|ies) kept a branch identity while the output that could have named its number was truncated`
+    );
+  }
+  return {
+    facts: { created, merged },
+    spanIds: [...new Set([...created, ...merged].flatMap((fact) => fact.spanIds))],
+    commandSpans: records.length,
+    unavailable: null,
+    partial: notes.length > 0 ? notes.join("; ") : null
+  };
+}
+
+// src/session-identity.ts
+import { readFileSync } from "fs";
+import { join as join2 } from "path";
+import { ATTR as ATTR2 } from "@tangle-network/agent-trace-contract";
+var AGENT_IDENTITY_KEYS = [
+  ["profileDigest", ATTR2.profileDigest],
+  ["profileName", ATTR2.profileName],
+  ["model", ATTR2.agentModel],
+  ["harness", ATTR2.harness],
+  ["skillsDigest", ATTR2.skillsDigest],
+  ["directiveVariant", ATTR2.directiveVariant]
+];
+function identityFieldsOf(attributes) {
+  const fields = {};
+  for (const [field, key] of AGENT_IDENTITY_KEYS) {
+    const value = attributes[key];
+    if (typeof value === "string" && value.length > 0) fields[field] = value;
+  }
+  return fields;
+}
+function mergeAgentIdentity(sources) {
+  const merged = {};
+  let source = null;
+  for (const entry of sources) {
+    for (const [field] of AGENT_IDENTITY_KEYS) {
+      const value = entry.fields[field];
+      if (value === void 0 || merged[field] !== void 0) continue;
+      merged[field] = value;
+      source ??= entry.source;
+    }
+  }
+  return source === null ? null : { ...merged, source };
+}
+var PLAIN_ID = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/u;
+var RECORD_DIR = join2(".local", "state", "session-identity", "claude-code");
+var DIRECTIVES_LOG = join2(".claude", "directives-log.jsonl");
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function sessionIdentityLookup(home) {
+  let variants;
+  const variantOf = (sessionId) => {
+    if (variants === void 0) {
+      variants = /* @__PURE__ */ new Map();
+      let text = "";
+      try {
+        text = readFileSync(join2(home, DIRECTIVES_LOG), "utf8");
+      } catch {
+      }
+      for (const line of text.split("\n")) {
+        if (!line.includes('"variant"')) continue;
+        try {
+          const row = JSON.parse(line);
+          if (typeof row.session === "string" && typeof row.variant === "string" && row.variant.length > 0 && !variants.has(row.session)) {
+            variants.set(row.session, row.variant);
+          }
+        } catch {
+        }
+      }
+    }
+    return variants.get(sessionId);
+  };
+  return ({ sessionId, harness }) => {
+    if (harness !== "claude-code") {
+      return { sources: [], reason: `no hook records who acted in ${harness ?? "this harness's"} sessions, so only spans could say` };
+    }
+    const recordPath = join2(home, RECORD_DIR, `${sessionId}.json`);
+    const sources = [];
+    if (PLAIN_ID.test(sessionId)) {
+      const record = readJson(recordPath);
+      const attributes = record !== null && typeof record === "object" ? record.attributes : void 0;
+      if (attributes !== null && typeof attributes === "object") {
+        const fields = identityFieldsOf(attributes);
+        if (Object.keys(fields).length > 0) sources.push({ source: "session-identity", fields });
+      }
+    }
+    const variant = variantOf(sessionId);
+    if (variant !== void 0) sources.push({ source: "directives-log", fields: { directiveVariant: variant } });
+    return {
+      sources,
+      reason: `no session identity record at ${recordPath} and no entry in ${join2(home, DIRECTIVES_LOG)}: the session predates the SessionStart hook that writes the record, or the hook is not installed`
+    };
+  };
+}
+
+// src/session-facts.ts
+var SESSION_FACTS_MEASUREMENT_VERSION = "8";
+var SPAN_SYNTHESIZED_ATTR = "traces.codex.span_synthesized";
+var CORRUPTION_COUNT_ATTR = "traces.session.corruption_count";
+var CORRUPTION_RECEIPT_VERSION_ATTR = "traces.session.corruption.receipt_version";
+var FACT_LIST_CAP = 200;
+var CHANGED_FILE_LIST_CAP = 5e3;
+function attr(span, key) {
+  return span.attributes[key];
+}
+function stringAttr2(span, key) {
+  const value = span.attributes[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function orderOf(span) {
+  const step = span.attributes.step;
+  const start = Date.parse(span.start_time);
+  return [typeof step === "number" ? step : Number.MAX_SAFE_INTEGER, Number.isFinite(start) ? start : 0];
+}
+function byTraceOrder(left, right) {
+  const [leftStep, leftStart] = orderOf(left);
+  const [rightStep, rightStart] = orderOf(right);
+  if (leftStart !== rightStart) return leftStart - rightStart;
+  return leftStep - rightStep;
+}
+function isSynthesizedSpan2(span) {
+  if (isSynthesizedSpan(span.attributes)) return true;
+  if (attr(span, SPAN_SYNTHESIZED_ATTR) === true) return true;
+  return stringAttr2(span, "traces.codex.subagent_thread_id") !== null && stringAttr2(span, "traces.codex.subagent_path") !== null;
+}
+function isToolSpan(span) {
+  return attr(span, OPENINFERENCE_SPAN_KIND3) === "TOOL";
+}
+function toolName(span) {
+  return stringAttr2(span, TOOL_NAME) ?? span.name.replace(/^tool\./, "");
+}
+function inputValue(span) {
+  const value = span.attributes["input.value"];
+  return typeof value === "string" ? value : null;
+}
+function inputTruncated(span) {
+  return span.attributes["traces.input.truncated"] === true;
+}
+var PATCH_HEADER = /\*\*\* (Add|Update|Delete|Move to) File: ([^\n"\\]+)/g;
+var PATCH_OPERATION = {
+  Add: "add",
+  Update: "update",
+  Delete: "delete",
+  "Move to": "move"
+};
+var FILE_CHANGE_SPAN = "file.change";
+var FILE_CHANGE_KIND_ATTR = "traces.codex.file_change_kind";
+var UNRESOLVED_PATH = /(?:^|\/)\$/;
+var FILE_PATH_TOOLS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "Write", "NotebookEdit", "edit", "write"]);
+var FILE_PATH_KEY = /"(?:file_path|filePath|path|notebook_path)"\s*:\s*"((?:[^"\\]|\\.)*)"/g;
+var SUBAGENT_TYPE_KEY = /"subagent_type"\s*:\s*"((?:[^"\\]|\\.)*)"/u;
+function decodeJsonString(raw) {
+  try {
+    const value = JSON.parse(`"${raw}"`);
+    return typeof value === "string" && value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function recordChangedPath(into, path, operation, spanId) {
+  const entry = into.get(path) ?? { operations: [], spanIds: [] };
+  if (!entry.operations.includes(operation)) entry.operations.push(operation);
+  if (!entry.spanIds.includes(spanId)) entry.spanIds.push(spanId);
+  into.set(path, entry);
+}
+function harnessChangedPaths(span) {
+  const input = inputValue(span);
+  if (input === null) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    return [];
+  }
+  if (parsed === null || typeof parsed !== "object") return [];
+  const record = parsed;
+  const path = typeof record.path === "string" ? record.path.trim() : "";
+  if (path.length === 0) return [];
+  const kind = stringAttr2(span, FILE_CHANGE_KIND_ATTR) ?? (typeof record.kind === "string" ? record.kind : "");
+  const movePath = typeof record.move_path === "string" ? record.move_path.trim() : "";
+  return [
+    { path, operation: kind.length > 0 ? kind : "update" },
+    ...movePath.length > 0 ? [{ path: movePath, operation: "move" }] : []
+  ];
+}
+function recordRecoveredPath(into, resolved, path, operation, spanId) {
+  if (UNRESOLVED_PATH.test(path)) return false;
+  const known = resolved.filter((candidate) => candidate === path || candidate.endsWith(`/${path}`));
+  if (known.length > 1) return true;
+  recordChangedPath(into, known[0] ?? path, operation, spanId);
+  return true;
+}
+function changedFilesOf(toolSpans, spans) {
+  const paths = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    if (span.name !== FILE_CHANGE_SPAN || span.status.code === "ERROR") continue;
+    for (const change of harnessChangedPaths(span)) {
+      recordChangedPath(paths, change.path, change.operation, span.span_id);
+    }
+  }
+  const resolved = [...paths.keys()];
+  let truncatedInputs = 0;
+  let unresolvedPaths = 0;
+  for (const span of toolSpans) {
+    const input = inputValue(span);
+    if (input === null) continue;
+    let matched = false;
+    for (const match of input.matchAll(PATCH_HEADER)) {
+      const operation = PATCH_OPERATION[match[1]];
+      const path = match[2]?.trim();
+      if (!operation || !path) continue;
+      matched = true;
+      if (!recordRecoveredPath(paths, resolved, path, operation, span.span_id)) unresolvedPaths += 1;
+    }
+    if (!matched && FILE_PATH_TOOLS.has(toolName(span))) {
+      for (const match of input.matchAll(FILE_PATH_KEY)) {
+        const path = decodeJsonString(match[1] ?? "");
+        if (!path) continue;
+        matched = true;
+        if (!recordRecoveredPath(paths, resolved, path, "update", span.span_id)) unresolvedPaths += 1;
+      }
+    }
+    if (matched && inputTruncated(span)) truncatedInputs += 1;
+  }
+  const files = [...paths].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([path, entry]) => ({ path, operations: entry.operations, spanIds: entry.spanIds }));
+  return { files, truncatedInputs, unresolvedPaths };
+}
+function subagentsOf(ownSpans, spans) {
+  const lifecycleByPath = /* @__PURE__ */ new Map();
+  const lifecycleByParent = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    if (!isSynthesizedSpan2(span)) continue;
+    const path = stringAttr2(span, "traces.codex.subagent_path");
+    if (path !== null) {
+      lifecycleByPath.set(path, [...lifecycleByPath.get(path) ?? [], span.span_id]);
+    }
+    const parent = span.parent_span_id;
+    if (parent !== null && span.attributes[SUBAGENT_TASK_ATTR] !== void 0) {
+      lifecycleByParent.set(parent, [...lifecycleByParent.get(parent) ?? [], span.span_id]);
+    }
+  }
+  const spawns = [];
+  for (const span of ownSpans) {
+    const isSpawn = attr(span, "traces.codex.agent_operation") === "spawn_agent" || stringAttr2(span, "traces.codex.spawn_agent_path") !== null || attr(span, SUBAGENT_SPAWN_ATTR) === true;
+    if (!isSpawn || isSynthesizedSpan2(span)) continue;
+    const taskName = stringAttr2(span, "traces.codex.spawn_agent_path") ?? stringAttr2(span, SUBAGENT_SPAWN_TASK_ATTR);
+    const agentType = SUBAGENT_TYPE_KEY.exec(inputValue(span) ?? "")?.[1];
+    spawns.push({
+      taskName,
+      taskNameUnavailable: taskName === null ? "the spawn span carries no task name; the harness recorded none for this call" : null,
+      agentType: agentType === void 0 ? null : decodeJsonString(agentType),
+      startedAt: span.start_time,
+      status: span.status.code,
+      spanIds: [
+        span.span_id,
+        ...taskName ? lifecycleByPath.get(taskName) ?? [] : [],
+        ...lifecycleByParent.get(span.span_id) ?? []
+      ]
+    });
+  }
+  return spawns;
+}
+function toolCounts(spans) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const row = rows.get(toolName(span)) ?? { calls: 0, failed: 0 };
+    row.calls += 1;
+    if (span.status.code === "ERROR") row.failed += 1;
+    rows.set(toolName(span), row);
+  }
+  return [...rows].map(([name, row]) => ({ name, ...row })).sort((left, right) => right.calls - left.calls || left.name.localeCompare(right.name));
+}
+function finalMessagesOf(spans) {
+  const last = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    let task;
+    if (span.name === "message.assistant") {
+      task = isSubagentSpan(span.attributes) ? stringAttr2(span, SUBAGENT_TASK_ATTR) ?? "unattributed subagent" : null;
+    } else if (span.name.startsWith("message.agent.")) {
+      task = stringAttr2(span, "traces.codex.agent_message_author") ?? "unattributed subagent";
+    }
+    if (task === void 0) continue;
+    const previous = last.get(task);
+    if (!previous || byTraceOrder(previous, span) <= 0) last.set(task, span);
+  }
+  return [...last].sort(([left], [right]) => left === null ? -1 : right === null ? 1 : left.localeCompare(right)).map(([task, span]) => ({
+    task,
+    at: span.end_time,
+    text: capText(typeof span.attributes.content === "string" ? span.attributes.content : "", FACT_TEXT_CAP),
+    spanId: span.span_id
+  }));
+}
+var EXIT_CODE = /^(?:Process exited with code|Exit code:?|Command failed with exit code)[ \t]+(-?\d+)\.?[ \t]*$/imu;
+function printedExitCode(span) {
+  const output = span.attributes["output.value"];
+  if (typeof output !== "string") return null;
+  const end = output.indexOf("\nOutput:\n");
+  const code = EXIT_CODE.exec(end >= 0 ? output.slice(0, end) : output.slice(0, 400))?.[1];
+  return code === void 0 ? null : Number(code);
+}
+var SHELL_STATE_BUILTINS = /* @__PURE__ */ new Set(["cd", "pushd", "popd", "export", "set", "unset", "source", ".", ":", "true", "false", "exit", "shift", "local", "alias"]);
+var DATA_FIRST_PROGRAMS = /* @__PURE__ */ new Set([
+  "awk",
+  "basename",
+  "cat",
+  "chmod",
+  "column",
+  "cp",
+  "curl",
+  "cut",
+  "date",
+  "diff",
+  "dirname",
+  "du",
+  "echo",
+  "egrep",
+  "fgrep",
+  "file",
+  "find",
+  "grep",
+  "head",
+  "jq",
+  "kill",
+  "less",
+  "ln",
+  "ls",
+  "mkdir",
+  "mv",
+  "nl",
+  "open",
+  "printf",
+  "readlink",
+  "realpath",
+  "rg",
+  "rm",
+  "sed",
+  "sleep",
+  "sort",
+  "stat",
+  "tail",
+  "tee",
+  "test",
+  "[",
+  "touch",
+  "tr",
+  "uniq",
+  "wc",
+  "wget",
+  "which",
+  "xargs"
+]);
+var PLAIN_WORD = /^[A-Za-z][\w:-]{0,39}$/u;
+function commandName(words) {
+  const program = words[0].slice(words[0].lastIndexOf("/") + 1);
+  const next = words[1];
+  return next !== void 0 && !DATA_FIRST_PROGRAMS.has(program) && PLAIN_WORD.test(next) ? `${program} ${next}` : program;
+}
+function callCommands(span) {
+  const input = inputValue(span);
+  const script = input === null ? void 0 : commandTextFromInput(input);
+  if (script === void 0) return void 0;
+  const inScript = isCodeModeScript(input);
+  const commands = simpleCommands(script);
+  const programs = commands.flatMap((words, index) => SHELL_STATE_BUILTINS.has(words[0]) ? [] : [index]);
+  const own = !inScript && programs.length === 1 && span.status.code !== "UNSET" ? programs[0] : -1;
+  return { commands, inScript, failed: commands.map((_, index) => index === own ? span.status.code === "ERROR" : null) };
+}
+function commandsOf(tools) {
+  const own = tools.filter((span) => span.attributes[INHERITED_SPAN_ATTR] !== true);
+  if (own.length > 0 && !own.some((span) => inputValue(span) !== null)) {
+    return { value: null, spanIds: [], unavailable: "no tool call recorded its arguments, so which commands ran cannot be read" };
+  }
+  const rows = /* @__PURE__ */ new Map();
+  const spanIds = [];
+  for (const span of own) {
+    const call = callCommands(span);
+    if (call === void 0) continue;
+    let ran = false;
+    call.commands.forEach((words, index) => {
+      if (SHELL_STATE_BUILTINS.has(words[0])) return;
+      ran = true;
+      const name = commandName(words);
+      const row = rows.get(name) ?? { runs: 0, failed: 0, inScripts: 0, nonZeroExits: [], lastSpanId: span.span_id };
+      row.runs += 1;
+      row.lastSpanId = span.span_id;
+      if (call.failed[index] === true) {
+        row.failed += 1;
+        row.nonZeroExits.push({ code: printedExitCode(span), inScript: call.inScript, at: span.start_time, spanId: span.span_id });
+      }
+      if (call.inScript) row.inScripts += 1;
+      rows.set(name, row);
+    });
+    if (ran) spanIds.push(span.span_id);
+  }
+  const counts = [...rows].map(([command, row]) => ({ command, ...row })).sort((left, right) => right.runs - left.runs || left.command.localeCompare(right.command));
+  return listFact(counts, spanIds);
+}
+function capList(items, cap = FACT_LIST_CAP) {
+  if (items.length <= cap) return { kept: items };
+  return {
+    kept: items.slice(0, cap),
+    partial: `${items.length - cap} of ${items.length} entries omitted; the count above the list is complete`
+  };
+}
+function listFact(items, spanIds, cap = FACT_LIST_CAP) {
+  const { kept, partial } = capList(items, cap);
+  return { value: kept, spanIds: [...new Set(spanIds)], unavailable: null, ...partial ? { partial } : {} };
+}
+function changedFilesFact(files, truncatedInputs, unresolvedPaths) {
+  const fact = listFact(files, files.flatMap((entry) => entry.spanIds), CHANGED_FILE_LIST_CAP);
+  const gaps = [
+    ...fact.partial ? [fact.partial] : [],
+    ...truncatedInputs > 0 ? [
+      `${truncatedInputs} contributing tool span(s) had truncated input; paths named after the cut are not in this list`
+    ] : [],
+    ...unresolvedPaths > 0 ? [
+      `${unresolvedPaths} recovered path(s) still held an unexpanded variable and were dropped; each names a file only if the harness also recorded that change`
+    ] : []
+  ];
+  return { ...fact, ...gaps.length > 0 ? { partial: gaps.join("; ") } : {} };
+}
+function excludedTurnFacts(excluded, keep) {
+  return [...excluded].map(([key, entries]) => {
+    const [reason, author] = key.split("\0");
+    return { reason, author, spanIds: entries.filter((entry) => keep(entry.at)).map((entry) => entry.spanId) };
+  }).filter((entry) => entry.spanIds.length > 0).sort((left, right) => left.reason.localeCompare(right.reason) || left.author.localeCompare(right.author)).map(({ reason, author, spanIds }) => ({ reason, author, turns: spanIds.length, spanIds }));
+}
+function windowBounds(window) {
+  if (!window || window.since === void 0 && window.until === void 0) return null;
+  const bound = (value, name, open2) => {
+    if (value === void 0) return open2;
+    const ms = Date.parse(value);
+    if (!Number.isFinite(ms)) throw new RangeError(`window ${name} is not a readable time: ${value}`);
+    return ms;
+  };
+  const sinceMs = bound(window.since, "since", Number.NEGATIVE_INFINITY);
+  const untilMs = bound(window.until, "until", Number.POSITIVE_INFINITY);
+  if (!(sinceMs < untilMs)) throw new RangeError(`window since (${window.since}) must be before until (${window.until})`);
+  return {
+    since: window.since === void 0 ? null : new Date(sinceMs).toISOString(),
+    until: window.until === void 0 ? null : new Date(untilMs).toISOString(),
+    sinceMs,
+    untilMs
+  };
+}
+function insideWindow(bounds, time) {
+  if (bounds === null) return true;
+  const ms = Date.parse(time);
+  return Number.isFinite(ms) && ms >= bounds.sinceMs && ms < bounds.untilMs;
+}
+function isRecordSpan(span) {
+  return span.parent_span_id !== null && span.attributes[CORRUPTION_RECEIPT_VERSION_ATTR] === void 0;
+}
+function computeSessionFacts(spans, options = {}) {
+  const bounds = windowBounds(options.window);
+  return groupByTrace(spans).sort((left, right) => compareIds(left.traceId, right.traceId)).map((group) => readSession(group.traceId, group.sessionId, group.spans, options, bounds).facts);
+}
+function compareIds(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function groupByTrace(spans) {
+  const { sessionByTrace } = indexSessionIdsByTrace(spans);
+  const byTrace = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const group = byTrace.get(span.trace_id);
+    if (group) group.push(span);
+    else byTrace.set(span.trace_id, [span]);
+  }
+  return [...byTrace].map(([traceId, traceSpans]) => ({
+    traceId,
+    sessionId: sessionByTrace.get(traceId) ?? null,
+    spans: traceSpans
+  }));
+}
+function readSession(traceId, sessionId, unordered, options, bounds) {
+  const spans = [...unordered].sort(byTraceOrder);
+  const harness = spans.map((span) => stringAttr2(span, "service.name")).find((name) => name !== null) ?? null;
+  const ownSpans = spans.filter((span) => !isSubagentSpan(span.attributes));
+  const toolSpans = spans.filter(isToolSpan);
+  const synthesized = toolSpans.filter(isSynthesizedSpan2);
+  const invoked = ownSpans.filter((span) => isToolSpan(span) && !isSynthesizedSpan2(span));
+  const subagentTools = toolSpans.filter(
+    (span) => isSubagentSpan(span.attributes) && !isSynthesizedSpan2(span)
+  );
+  const byName = {};
+  for (const span of invoked) byName[toolName(span)] = (byName[toolName(span)] ?? 0) + 1;
+  const subagents = subagentsOf(ownSpans, spans);
+  const pullRequests = readPullRequests(ownSpans);
+  const inWindow = (at) => insideWindow(bounds, at);
+  const promptSpans = spans.filter((span) => span.name === "user.prompt" && inWindow(span.start_time));
+  const turnFacts = typedTurnsOf(spans);
+  const typedTurns = turnFacts.turns.filter((turn) => inWindow(turn.at));
+  const humanTurns = typedTurns.filter((turn) => turn.author === "human");
+  const excludedTurns = excludedTurnFacts(turnFacts.excluded, inWindow);
+  const actorCounts = /* @__PURE__ */ new Map();
+  for (const span of promptSpans) {
+    const actor = stringAttr2(span, ACTOR_ATTR) ?? "unclassified";
+    actorCounts.set(actor, [...actorCounts.get(actor) ?? [], span.span_id]);
+  }
+  const finalMessages = finalMessagesOf(spans);
+  const { files, truncatedInputs, unresolvedPaths } = changedFilesOf(invoked, ownSpans);
+  const starts = ownSpans.filter((span) => Number.isFinite(Date.parse(span.start_time)));
+  const ends = ownSpans.filter((span) => Number.isFinite(Date.parse(span.end_time)));
+  const firstSpan = starts.reduce(
+    (best, span) => best === null || Date.parse(span.start_time) < Date.parse(best.start_time) ? span : best,
+    null
+  );
+  const lastSpan = ends.reduce(
+    (best, span) => best === null || Date.parse(span.end_time) > Date.parse(best.end_time) ? span : best,
+    null
+  );
+  const tokens = sessionTokens(ownSpans);
+  const operating = operatingSamplesOf(ownSpans, invoked);
+  const receipts = spans.filter((span) => span.attributes[CORRUPTION_RECEIPT_VERSION_ATTR] !== void 0);
+  const recordSpans = spans.filter(isRecordSpan).length;
+  const corruptionSpan = spans.find((span) => typeof span.attributes[CORRUPTION_COUNT_ATTR] === "number");
+  const cwdSpan = spans.find((span) => stringAttr2(span, SESSION_CWD_ATTR) !== null);
+  const repoSpan = spans.find((span) => stringAttr2(span, ATTR.GIT_REPOSITORY) !== null);
+  const firstFailure = ownSpans.length === 0 ? { status: "unknown", traceId, unsetCount: 0, reason: "no span of this session's own records" } : rankFirstFailure(ingestSpans(ownSpans, { contentIncluded: true }).spans);
+  const failedSpan = firstFailure.status === "found" ? ownSpans.find((span) => span.span_id === firstFailure.spanId) : void 0;
+  const agent = agentFact(spans, sessionId, harness, options.agentIdentity);
+  const facts = {
+    schemaVersion: 1,
+    kind: "traces.session_facts",
+    traceId,
+    sessionId,
+    harness,
+    parentSessionId: spans.filter((span) => span.parent_span_id === null).map((span) => stringAttr2(span, "traces.parent_session_id")).find((id) => id !== null) ?? null,
+    cwd: cwdSpan ? { value: stringAttr2(cwdSpan, SESSION_CWD_ATTR), spanIds: [cwdSpan.span_id], unavailable: null } : {
+      value: null,
+      spanIds: [],
+      unavailable: `no span carries ${SESSION_CWD_ATTR}: the session source records no working directory, or the adapter that read it does not read one`
+    },
+    spanCount: spans.length,
+    recordSpans,
+    unreadRecords: corruptionSpan ? {
+      value: corruptionSpan.attributes[CORRUPTION_COUNT_ATTR],
+      spanIds: [corruptionSpan.span_id, ...receipts.map((span) => span.span_id)],
+      unavailable: null
+    } : {
+      value: null,
+      spanIds: [],
+      unavailable: `no span carries ${CORRUPTION_COUNT_ATTR}; this trace was not read through the session integrity path, so whether any record was skipped is unknown`
+    },
+    repo: repoSpan ? {
+      value: {
+        repository: stringAttr2(repoSpan, ATTR.GIT_REPOSITORY),
+        branch: stringAttr2(repoSpan, ATTR.GIT_BRANCH_NAME),
+        commit: stringAttr2(repoSpan, ATTR.GIT_COMMIT)
+      },
+      spanIds: [repoSpan.span_id],
+      unavailable: null
+    } : {
+      value: null,
+      spanIds: [],
+      unavailable: `no span carries ${ATTR.GIT_REPOSITORY}: the recorded cwd is not a checkout with a remote, or no longer exists`
+    },
+    measurements: computeSessionMeasurements({ spans: ownSpans, records: ownSpans.filter(isRecordSpan), tools: invoked, sessionId, harness, operating }),
+    toolCalls: {
+      value: invoked.length,
+      spanIds: invoked.map((span) => span.span_id),
+      unavailable: null
+    },
+    synthesizedToolSpans: {
+      value: synthesized.length,
+      spanIds: synthesized.map((span) => span.span_id),
+      unavailable: null
+    },
+    subagentTools: {
+      value: toolCounts(subagentTools),
+      spanIds: subagentTools.map((span) => span.span_id),
+      unavailable: null
+    },
+    toolCallsByName: {
+      value: byName,
+      spanIds: invoked.map((span) => span.span_id),
+      unavailable: null
+    },
+    subagents: listFact(subagents, subagents.flatMap((entry) => entry.spanIds)),
+    pullRequests: pullRequests.facts ? {
+      value: pullRequests.facts,
+      spanIds: pullRequests.spanIds,
+      unavailable: null,
+      ...pullRequests.partial ? { partial: pullRequests.partial } : {}
+    } : { value: null, spanIds: [], unavailable: pullRequests.unavailable ?? "unread" },
+    humanTurns: listFact(humanTurns, humanTurns.map((turn) => turn.spanId)),
+    excludedTurns: listFact(excludedTurns, excludedTurns.flatMap((entry) => entry.spanIds)),
+    turnsByActor: listFact(
+      [...actorCounts].sort(([left], [right]) => left.localeCompare(right)).map(([actor, spanIds]) => ({ actor, turns: spanIds.length, spanIds })),
+      promptSpans.map((span) => span.span_id)
+    ),
+    finalMessages: listFact(finalMessages, finalMessages.map((entry) => entry.spanId)),
+    changedFiles: changedFilesFact(files, truncatedInputs, unresolvedPaths),
+    commands: commandsOf(invoked),
+    firstRecordAt: firstSpan ? { value: firstSpan.start_time, spanIds: [firstSpan.span_id], unavailable: null } : { value: null, spanIds: [], unavailable: "no span of this session's own records carries a parseable start time" },
+    lastRecordAt: lastSpan ? { value: lastSpan.end_time, spanIds: [lastSpan.span_id], unavailable: null } : { value: null, spanIds: [], unavailable: "no span of this session's own records carries a parseable end time" },
+    // rankFirstFailure throws on an empty list (distinct from "every span is
+    // UNSET", which it reports as status 'unknown'); a trace whose spans are
+    // all traces.span.subagent — every record folded into subagents' own
+    // reports — legitimately has no records of its own to rank.
+    firstFailure: failedSpan ? { ...firstFailure, at: failedSpan.end_time } : firstFailure,
+    tokens,
+    // Priced by `priceReport`, which loads the price table only when a session needs it.
+    cost: sessionCost(tokens, void 0),
+    tokenTotal: tokens.input === null ? { value: null, spanIds: [], unavailable: tokens.unavailable } : { value: tokens.input + (tokens.output ?? 0), spanIds: tokens.spanIds, unavailable: null },
+    agent
+  };
+  if (options.includeContent !== false) return { facts, spans, turns: typedTurns, operating };
+  return { facts: withholdContent(facts), spans, turns: [], operating };
+}
+function agentFact(spans, sessionId, harness, lookup) {
+  const root = spans.find((span) => span.parent_span_id === null);
+  const fromSpans = root ? identityFieldsOf(root.attributes) : {};
+  const outside = sessionId !== null && lookup ? lookup({ sessionId, harness }) : void 0;
+  const value = mergeAgentIdentity([{ source: "spans", fields: fromSpans }, ...outside?.sources ?? []]);
+  if (value !== null) {
+    return { value, spanIds: root && Object.keys(fromSpans).length > 0 ? [root.span_id] : [], unavailable: null };
+  }
+  return {
+    value: null,
+    spanIds: [],
+    unavailable: `no root span carries ${AGENT_IDENTITY_KEYS.map(([, key]) => key).join(", ")}; ` + (outside?.reason ?? "no source outside the spans was read")
+  };
+}
+async function priceReport(report) {
+  if (!report.sessions.some((session) => needsPrice(session.tokens))) return report;
+  const price = await routerPrices();
+  return { ...report, sessions: report.sessions.map((session) => ({ ...session, cost: sessionCost(session.tokens, price) })) };
+}
+function buildSessionFactsReport(spans, options = {}) {
+  const builder = createSessionFactsReportBuilder(options);
+  builder.add(spans);
+  return builder.build();
+}
+var WINDOW_SESSION_RULE = "a session is selected when at least one of its records starts or ends inside [since, until)";
+var WINDOW_TURN_RULE = "humanTurns, excludedTurns and turnsByActor keep only user.prompt turns that started inside [since, until); every other fact, and each turn's answered text, covers the whole session";
+var SWEEP_SESSION_RULE = "the sessions the selection named or found; one that could not be read is named here and skipped";
+var SWEEP_TURN_RULE = "every turn of each selected session";
+function createSessionFactsReportBuilder(options = {}) {
+  const bounds = windowBounds(options.window);
+  const sessions = [];
+  const digests = [];
+  const outsideWindow = [];
+  const unreadSessions = [];
+  let spanCount = 0;
+  let evidenceThrough = null;
+  const select = (group) => {
+    const digest = createHash("sha256");
+    for (const span of [...group.spans].sort((a, b) => a.span_id.localeCompare(b.span_id))) {
+      digest.update(canonicalJson(span)).update("\n");
+      for (const time of [span.start_time, span.end_time]) {
+        if (Number.isFinite(Date.parse(time)) && (evidenceThrough === null || Date.parse(time) > Date.parse(evidenceThrough))) evidenceThrough = time;
+      }
+    }
+    digests.push({ traceId: group.traceId, digest: digest.digest("hex") });
+    spanCount += group.spans.length;
+    const reading = readSession(group.traceId, group.sessionId, group.spans, options, bounds);
+    sessions.push(reading.facts);
+    options.onSession?.(reading);
+  };
+  return {
+    add(spans) {
+      for (const group of groupByTrace(spans)) {
+        if (bounds === null && options.nameUnread !== true) {
+          select(group);
+          continue;
+        }
+        const records = group.spans.filter(isRecordSpan);
+        if (records.length === 0) {
+          const unread = group.spans.find((span) => typeof span.attributes[CORRUPTION_COUNT_ATTR] === "number");
+          unreadSessions.push({
+            sessionId: group.sessionId,
+            traceId: group.traceId,
+            source: null,
+            reason: `no record could be read (${unread ? `${unread.attributes[CORRUPTION_COUNT_ATTR]} unread record(s)` : "no record spans"})` + (bounds === null ? "" : ", so whether the session holds a record inside the window is unknown")
+          });
+          continue;
+        }
+        if (bounds === null || records.some((span) => insideWindow(bounds, span.start_time) || insideWindow(bounds, span.end_time))) select(group);
+        else outsideWindow.push(group.sessionId ?? group.traceId);
+      }
+    },
+    addUnread(session) {
+      unreadSessions.push(session);
+    },
+    build() {
+      const digest = createHash("sha256");
+      for (const entry of [...digests].sort((a, b) => a.traceId.localeCompare(b.traceId) || a.digest.localeCompare(b.digest))) {
+        digest.update(`${entry.traceId}
+${entry.digest}
+`);
+      }
+      return {
+        schemaVersion: 1,
+        kind: "traces.session_facts_report",
+        measurementVersion: SESSION_FACTS_MEASUREMENT_VERSION,
+        sourceDigest: "sha256:" + digest.digest("hex"),
+        evidenceThrough,
+        contentIncluded: options.includeContent !== false,
+        generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        harness: options.harness ?? null,
+        spanCount,
+        selection: bounds === null && unreadSessions.length === 0 ? null : {
+          since: bounds?.since ?? null,
+          until: bounds?.until ?? null,
+          sessionRule: bounds === null ? SWEEP_SESSION_RULE : WINDOW_SESSION_RULE,
+          turnRule: bounds === null ? SWEEP_TURN_RULE : WINDOW_TURN_RULE,
+          outsideWindow: [...outsideWindow].sort(compareIds),
+          unreadSessions: [...unreadSessions]
+        },
+        // In the order they were selected: a named session first, each spawned
+        // child after it in the order it started.
+        sessions: [...sessions]
+      };
+    }
+  };
+}
+var SHEET_TEXT_CAP = 100;
+function sheetText(text, cap = SHEET_TEXT_CAP) {
+  const line = text.trim().split("\n", 1)[0].replace(/\s+/gu, " ");
+  return line.length > cap || text.trim().includes("\n") ? `${line.slice(0, cap - 1)}\u2026` : line;
+}
+function utcMinute(iso) {
+  const ms = Date.parse(iso);
+  return Number.isFinite(ms) ? new Date(ms).toISOString().slice(5, 16).replace("T", " ") : iso;
+}
+function minutesText(minutes2) {
+  if (minutes2 > 0 && minutes2 < 1) return `${Math.round(minutes2 * 60)} s`;
+  return minutes2 < 60 ? `${Math.round(minutes2)} min` : `${(minutes2 / 60).toFixed(1)} h`;
+}
+function plural(count2, noun) {
+  return `${count2} ${noun}${count2 === 1 ? "" : "s"}`;
+}
+function topCounts(counts, keep = 3, note = () => "") {
+  const rows = Object.entries(counts).sort(([leftName, left], [rightName, right]) => right - left || leftName.localeCompare(rightName));
+  return rows.slice(0, keep).map(([name, count2]) => `${name} ${count2}${note(name)}`).join(", ") + (rows.length > keep ? ", \u2026" : "");
+}
+function failedNote(failed, inScripts) {
+  const parts = [...failed > 0 ? [`${failed} failed`] : [], ...inScripts > 0 ? [`${inScripts} in scripts`] : []];
+  return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
+var SHEET_COMMANDS = 5;
+function commandLine(facts) {
+  const commands = facts.commands.value;
+  if (commands === null) return `commands unknown: ${facts.commands.unavailable}`;
+  if (commands.length === 0) return null;
+  const runs = commands.reduce((sum2, row) => sum2 + row.runs, 0);
+  const shown = commands.slice(0, SHEET_COMMANDS).map((row) => `${row.command} ${row.runs}${failedNote(row.failed, row.inScripts)}`);
+  return `commands ${runs}: ${shown.join(", ")}${commands.length > SHEET_COMMANDS ? ", \u2026" : ""}`;
+}
+function renderSessionFacts(report) {
+  const lines = [];
+  const selection = report.selection;
+  if (selection !== null || report.sessions.length !== 1) {
+    const window = selection && (selection.since !== null || selection.until !== null) ? ` \xB7 window ${selection.since ?? "open"} \u2192 ${selection.until ?? "open"}, ${selection.outsideWindow.length} read with no record inside it` : "";
+    const unread = selection?.unreadSessions ?? [];
+    lines.push(`${plural(report.sessions.length, "session")}${window}${unread.length > 0 ? ` \xB7 ${unread.length} unreadable` : ""} \xB7 $0, no model call`);
+    for (const entry of unread.slice(0, 3)) {
+      lines.push(`unreadable ${entry.sessionId ?? entry.traceId ?? entry.source ?? "unknown"}: ${sheetText(entry.reason)}`);
+    }
+    if (unread.length > 3) lines.push(`\u2026 ${unread.length - 3} more unreadable: --format json | jq .selection.unreadSessions`);
+  }
+  for (const facts of report.sessions) {
+    if (lines.length > 0) lines.push("");
+    lines.push(...sessionSheet(facts));
+  }
+  return `${lines.join("\n")}
+`;
+}
+function sessionSheet(facts) {
+  const lines = [sheetHeader(facts)];
+  if (facts.agent.value) lines.push(`who ${renderAgent(facts.agent.value)}`);
+  lines.push(turnLine(facts));
+  const subagents = facts.subagents.value ?? [];
+  const names = subagents.flatMap((entry) => entry.taskName === null ? [] : [
+    `${sheetText(entry.taskName, 40)}${entry.agentType ? ` [${sheetText(entry.agentType, 40)}]` : ""}`
+  ]);
+  const failedCalls = new Map(facts.measurements.tools.map((row) => [row.name, row.outcomes.error]));
+  lines.push(
+    `tools ${facts.toolCalls.value}${facts.toolCalls.value ? ` (${topCounts(facts.toolCallsByName.value ?? {}, 3, (name) => failedNote(failedCalls.get(name) ?? 0, 0))})` : ""} \xB7 subagents ${subagents.length}${names.length > 0 ? ` (${names.slice(0, 3).join(", ")}${names.length > 3 ? ", \u2026" : ""})` : ""}`
+  );
+  const subagentTools = facts.subagentTools.value ?? [];
+  if (subagentTools.length > 0) {
+    const calls = Object.fromEntries(subagentTools.map((row) => [row.name, row.calls]));
+    const failed = new Map(subagentTools.map((row) => [row.name, row.failed]));
+    lines.push(`subagent tools ${facts.subagentTools.spanIds.length} (${topCounts(calls, 3, (name) => failedNote(failed.get(name) ?? 0, 0))}), not in the tools count`);
+  }
+  const commands = commandLine(facts);
+  if (commands !== null) lines.push(commands);
+  const skills = Object.fromEntries(Object.entries(facts.measurements.skills).map(([name, use]) => [name, use.model + use.slash + use.read]));
+  if (Object.keys(skills).length > 0) lines.push(`skills ${topCounts(skills, 5)}`);
+  lines.push(`tokens ${renderTokens(facts.tokens, facts.cost)}`);
+  lines.push(wasteLine(facts));
+  lines.push(pullRequestLine(facts));
+  lines.push(`first failure ${renderFirstFailure(facts.firstFailure)}`);
+  const final = facts.finalMessages.value?.find((message) => message.task === null);
+  if (final && final.text.trim().length > 0) lines.push(`final "${sheetText(final.text)}"`);
+  if ((facts.unreadRecords.value ?? 0) > 0) {
+    lines.push(`unread records ${facts.unreadRecords.value}: the facts above are computed from the rest`);
+  }
+  return lines;
+}
+function sheetHeader(facts) {
+  const parts = [`${(facts.sessionId ?? facts.traceId).slice(0, 8)} ${facts.harness ?? "unknown harness"}`];
+  const repo = facts.repo.value;
+  const place = repo ? `${repo.repository.split("/").at(-1)}${repo.branch ? ` (${repo.branch})` : ""}` : facts.cwd.value?.split("/").filter(Boolean).at(-1);
+  if (place) parts.push(place);
+  const first = facts.firstRecordAt.value;
+  const last = facts.lastRecordAt.value;
+  if (first !== null && last !== null) {
+    const [from, to] = [utcMinute(first), utcMinute(last)];
+    parts.push(`${from}\u2192${from.slice(0, 5) === to.slice(0, 5) ? to.slice(6) : to} UTC`);
+  }
+  const active = facts.measurements.activeMinutes.value;
+  if (active !== null) parts.push(`active ${minutesText(active)}`);
+  if (facts.parentSessionId) parts.push(`child of ${facts.parentSessionId.slice(0, 8)}`);
+  return parts.join(" \xB7 ");
+}
+function turnLine(facts) {
+  const turns = facts.humanTurns.value;
+  if (turns === null) return `human turns unknown: ${facts.humanTurns.unavailable}`;
+  const excluded = {};
+  for (const entry of facts.excludedTurns.value ?? []) excluded[entry.author] = (excluded[entry.author] ?? 0) + entry.turns;
+  const signalled = (signal) => turns.filter((turn) => turn.signals.includes(signal)).length;
+  return [
+    `human turns ${turns.length}${Object.keys(excluded).length > 0 ? ` (excluded: ${topCounts(excluded, 6)})` : ""}`,
+    `interrupts ${turns.filter((turn) => turn.interrupted).length}`,
+    ...signalled("rejected-tool") > 0 ? [`after a rejected tool ${signalled("rejected-tool")}`] : [],
+    ...signalled("after-claim") > 0 ? [`after a completion claim ${signalled("after-claim")}`] : []
+  ].join(" \xB7 ");
+}
+function wasteLine(facts) {
+  const waste = facts.measurements.waste;
+  if (waste.minutes === null) return `waste unknown: ${waste.unavailable}`;
+  const parts = [];
+  const streaks = waste.failingStreaks.value ?? [];
+  const worst = [...streaks].sort((left, right) => right.minutes - left.minutes || right.runs - left.runs)[0];
+  if (worst) {
+    const command = worst.command === null ? `a ${worst.tool} command` : `\`${sheetText(worst.command, 60)}\``;
+    parts.push(`${command} failed ${worst.runs}\xD7 in a row (${minutesText(worst.minutes)})${streaks.length > 1 ? ` + ${plural(streaks.length - 1, "more streak")}` : ""}`);
+  }
+  const stalls = waste.stalls.value ?? [];
+  if (stalls.length > 0) {
+    parts.push(`${plural(stalls.length, "stall")} \u2265 ${STALL_MINUTES} min (${minutesText(stalls.reduce((sum2, stall) => sum2 + stall.minutes, 0))})`);
+  }
+  if ((waste.rollbacks.value ?? 0) > 0) parts.push(`reverts ${waste.rollbacks.value}`);
+  return `waste ${minutesText(waste.minutes)}${parts.length > 0 ? `: ${parts.join(" \xB7 ")}` : ""}`;
+}
+function pullRequestLine(facts) {
+  const files = facts.changedFiles.value === null ? "" : ` \xB7 changed ${plural(facts.changedFiles.value.length, "file")}`;
+  const prs = facts.pullRequests.value;
+  if (prs === null) return `PRs unknown: ${facts.pullRequests.unavailable}${files}`;
+  const named = (entries) => {
+    const ids = entries.flatMap((entry) => entry.identifier === null ? [] : [/^\d+$/u.test(entry.identifier) ? `#${entry.identifier}` : entry.identifier]);
+    const unnumbered = entries.length - ids.length;
+    if (entries.length === 0) return "none";
+    return [...ids, ...unnumbered > 0 ? [`${ids.length > 0 ? "+ " : ""}${unnumbered} unnumbered`] : []].join(" ");
+  };
+  return `PRs opened ${named(prs.created)} \xB7 merged ${named(prs.merged)}${files}`;
+}
+var MATCH_TEXT_CAP = 300;
+function matchExcerpt(text, pattern) {
+  const flat = text.replace(/\s+/gu, " ").trim();
+  if (flat.length <= MATCH_TEXT_CAP) return flat;
+  const at = pattern.exec(flat)?.index ?? 0;
+  let start = Math.max(0, Math.min(at - 100, flat.length - MATCH_TEXT_CAP));
+  let end = start + MATCH_TEXT_CAP;
+  if (start > 0) start += 1;
+  if (end < flat.length) end -= 1;
+  return `${start > 0 ? "\u2026" : ""}${flat.slice(start, end)}${end < flat.length ? "\u2026" : ""}`;
+}
+function sessionRows(spans, turns) {
+  const rows = [];
+  const byId = new Map(spans.map((span) => [span.span_id, span]));
+  for (const turn of turns) {
+    const span = byId.get(turn.spanId);
+    if (turn.author === "human" && span) rows.push({ kind: "human", at: span.start_time, spanId: span.span_id, text: rawContent(span) });
+  }
+  for (const span of spans) {
+    if (isSubagentSpan(span.attributes)) continue;
+    if (isOwnAgentMessage(span)) {
+      rows.push({ kind: "agent", at: span.start_time, spanId: span.span_id, text: rawContent(span) });
+      continue;
+    }
+    if (!isToolSpan(span) || isSynthesizedSpan2(span)) continue;
+    const call = callCommands(span);
+    if (call === void 0) continue;
+    call.commands.forEach((words, index) => {
+      rows.push({ kind: "command", at: span.start_time, spanId: span.span_id, text: words.join(" "), failed: call.failed[index] ?? null });
+    });
+  }
+  return rows;
+}
+function matchRows(sessionId, rows, pattern, window) {
+  const bounds = windowBounds(window);
+  const matches = [];
+  for (const row of rows) {
+    if (!insideWindow(bounds, row.at)) continue;
+    pattern.lastIndex = 0;
+    if (!pattern.test(row.text)) continue;
+    pattern.lastIndex = 0;
+    matches.push({
+      sessionId,
+      kind: row.kind,
+      at: row.at,
+      spanId: row.spanId,
+      text: matchExcerpt(row.text, pattern),
+      ...row.kind === "command" ? { failed: row.failed ?? null } : {}
+    });
+  }
+  return matches.sort((left, right) => Date.parse(left.at) - Date.parse(right.at));
+}
+function sessionMatches(reading, pattern, window) {
+  return matchRows(reading.facts.sessionId, sessionRows(reading.spans, reading.turns), pattern, window);
+}
+function readSessionIndex(spans, options = {}) {
+  const groups = groupByTrace(spans);
+  const group = groups.find((entry) => entry.sessionId === options.sessionId) ?? groups[0];
+  const ordered = [...group?.spans ?? []].sort(byTraceOrder);
+  const own = ordered.filter((span) => !isSubagentSpan(span.attributes));
+  const typed = typedTurnsOf(ordered, options.state);
+  const human = typed.turns.filter((turn) => turn.author === "human");
+  let firstAt = null;
+  let lastAt = null;
+  for (const span of own) {
+    if (Number.isFinite(Date.parse(span.start_time)) && (firstAt === null || Date.parse(span.start_time) < Date.parse(firstAt))) firstAt = span.start_time;
+    if (Number.isFinite(Date.parse(span.end_time)) && (lastAt === null || Date.parse(span.end_time) > Date.parse(lastAt))) lastAt = span.end_time;
+  }
+  return {
+    sessionId: group?.sessionId ?? null,
+    parentSessionId: ordered.filter((span) => span.parent_span_id === null).map((span) => stringAttr2(span, "traces.parent_session_id")).find((id) => id !== null) ?? null,
+    cwd: ordered.map((span) => stringAttr2(span, SESSION_CWD_ATTR)).find((cwd) => cwd !== null) ?? null,
+    firstAt,
+    lastAt,
+    records: ordered.filter(isRecordSpan).length,
+    humanTurns: human.map((turn) => turn.spanId),
+    firstPrompt: human[0]?.text ?? null,
+    rows: sessionRows(ordered, typed.turns),
+    state: typed.state
+  };
+}
+function renderTokens(tokens, cost) {
+  if (tokens.input === null) return `unknown: ${tokens.unavailable}`;
+  const parts = [`in ${tokenCount(tokens.input)}`, `out ${tokenCount(tokens.output ?? 0)}`];
+  if ((tokens.cacheRead ?? 0) > 0) parts.push(`cache read ${tokenCount(tokens.cacheRead)}`);
+  if ((tokens.cacheWrite ?? 0) > 0) parts.push(`cache write ${tokenCount(tokens.cacheWrite)}`);
+  parts.push(cost.usd === null ? `cost unknown (${cost.unavailable})` : `$${cost.usd.toFixed(cost.usd < 1 ? 4 : 2)} ${cost.label}`);
+  return parts.join(" \xB7 ");
+}
+function tokenCount(value) {
+  if (value >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1e3) return `${Math.round(value / 1e3)}k`;
+  return String(value);
+}
+function renderAgent(agent) {
+  const digest = agent.profileDigest?.replace(/^(sha256:)?([0-9a-f]{4})[0-9a-f]+([0-9a-f]{4})$/u, (_, prefix, head, tail) => `${prefix ?? ""}${head}\u2026${tail}`);
+  const profile = [agent.profileName, digest].filter(Boolean).join(" ");
+  return `${[profile, agent.model, agent.directiveVariant].filter(Boolean).join(" \xB7 ")} (from ${agent.source})`;
+}
+function renderFirstFailure(failure) {
+  if (failure.status === "unknown") return `unknown: ${sheetText(failure.reason)}`;
+  if (failure.status === "none") return `none: ${sheetText(failure.reason)}`;
+  if (failure.status === "ambiguous") return `ambiguous ${failure.stage}: ${sheetText(failure.reason)} (spans ${failure.candidates.join(", ")})`;
+  const when = failure.at ? `${utcMinute(failure.at).slice(6)} ` : "";
+  const message = failure.message ? `: ${sheetText(failure.message, 80)}` : "";
+  return `${when}${failure.name}${message} (blame ${failure.blame}, span ${failure.spanId})`;
+}
+var PREPARED_CONTEXT_BYTE_CEILING = 3e4;
+function renderSessionFactsContext(report, options = {}) {
+  const ceiling = options.byteCeiling ?? PREPARED_CONTEXT_BYTE_CEILING;
+  const header = "SESSION FACTS (deterministic, computed from the spans, no model call). Each fact names the span ids it came from: cite those spans, never this sheet. A null value carries the reason the spans cannot support it \u2014 do not replace it with a guess.";
+  let sessions = report.sessions.map(compactFacts);
+  const encode = (dropped2) => `${header}
+${JSON.stringify({ sessions, ...dropped2.length ? { omitted_fields: dropped2 } : {} })}`;
+  const dropped = [];
+  const sheds = [
+    ["human_turn_answered", (facts) => {
+      for (const turn of facts.human_turns) delete turn.answered;
+    }],
+    ["human_turn_text", (facts) => {
+      for (const turn of facts.human_turns) delete turn.text;
+    }],
+    ["final_message_text", (facts) => {
+      for (const message of facts.final_messages) delete message.text;
+    }],
+    ["pull_request_commands", (facts) => {
+      for (const entry of [...facts.pull_requests.created ?? [], ...facts.pull_requests.merged ?? []]) {
+        delete entry.command;
+        delete entry.span_ids;
+      }
+    }],
+    ["tool_call_span_ids", (facts) => {
+      facts.tool_calls.span_ids = [];
+    }],
+    ["measurements", (facts) => {
+      delete facts.measurements;
+    }],
+    ["tool_calls_by_name", (facts) => {
+      delete facts.tool_calls_by_name;
+    }],
+    ["excluded_turn_span_ids", (facts) => {
+      facts.excluded_turns = facts.excluded_turns?.map((entry) => {
+        const { span_ids: _dropped, ...rest } = entry;
+        return rest;
+      });
+    }],
+    ["changed_files", (facts) => {
+      facts.changed_files = { count: facts.changed_files.count };
+    }],
+    ["turns_by_actor", (facts) => {
+      delete facts.turns_by_actor;
+    }],
+    ["pull_request_evidence", (facts) => {
+      for (const entry of [...facts.pull_requests.created ?? [], ...facts.pull_requests.merged ?? []]) {
+        delete entry.evidence;
+      }
+    }],
+    ["excluded_turns", (facts) => {
+      delete facts.excluded_turns;
+    }],
+    ["subagents", (facts) => {
+      facts.subagents = { count: facts.subagents.count };
+    }],
+    ["final_messages", (facts) => {
+      facts.final_messages = [];
+    }],
+    ["human_turns", (facts) => {
+      facts.human_turns = [];
+    }]
+  ];
+  for (const [name, shed] of sheds) {
+    if (Buffer.byteLength(encode(dropped)) <= ceiling) break;
+    for (const facts of sessions) shed(facts);
+    dropped.push(name);
+  }
+  let text = encode(dropped);
+  while (Buffer.byteLength(text) > ceiling && sessions.length > 1) {
+    sessions = sessions.slice(0, Math.max(1, Math.floor(sessions.length / 2)));
+    text = encode([...dropped, `sessions_beyond_${sessions.length}`]);
+  }
+  if (Buffer.byteLength(text) <= ceiling) return text;
+  const refusal = `${header}
+${JSON.stringify({ sessions: [], omitted_fields: ["all: the byte ceiling is below one session record"] })}`;
+  return Buffer.byteLength(refusal) <= ceiling ? refusal : "";
+}
+function factJson(fact) {
+  return fact.value === null ? { value: null, unavailable: fact.unavailable } : { value: fact.value, span_ids: fact.spanIds };
+}
+function compactPullRequests(fact) {
+  if (fact.value === null) return { value: null, unavailable: fact.unavailable ?? "unread" };
+  const entry = (pr) => ({
+    id: pr.identifier,
+    number: pr.number,
+    head_branch: pr.headBranch,
+    evidence: pr.evidence,
+    command: pr.command,
+    span_ids: pr.spanIds,
+    ...pr.unavailable ? { unavailable: pr.unavailable } : {}
+  });
+  return {
+    created: fact.value.created.map(entry),
+    merged: fact.value.merged.map(entry),
+    ...fact.partial ? { partial: fact.partial } : {}
+  };
+}
+function compactFacts(facts) {
+  return {
+    session_id: facts.sessionId,
+    trace_id: facts.traceId,
+    cwd: factJson(facts.cwd),
+    agent: factJson(facts.agent),
+    spans: facts.spanCount,
+    tool_calls: {
+      count: facts.toolCalls.value,
+      synthesized_excluded: facts.synthesizedToolSpans.value,
+      subagent_excluded: facts.subagentTools.spanIds.length,
+      span_ids: facts.toolCalls.spanIds
+    },
+    tool_calls_by_name: facts.toolCallsByName.value,
+    subagents: {
+      count: facts.subagents.value?.length ?? 0,
+      entries: facts.subagents.value?.map((entry) => ({
+        task_name: entry.taskName,
+        ...entry.taskNameUnavailable ? { task_name_unavailable: entry.taskNameUnavailable } : {},
+        ...entry.agentType ? { agent_type: entry.agentType } : {},
+        started_at: entry.startedAt,
+        status: entry.status,
+        span_ids: entry.spanIds
+      }))
+    },
+    pull_requests: compactPullRequests(facts.pullRequests),
+    human_turns: (facts.humanTurns.value ?? []).map((turn) => ({
+      at: turn.at,
+      span_id: turn.spanId,
+      text: turn.text,
+      answered: turn.answered
+    })),
+    excluded_turns: facts.excludedTurns.value?.map((entry) => ({
+      reason: entry.reason,
+      turns: entry.turns,
+      span_ids: entry.spanIds
+    })),
+    turns_by_actor: facts.turnsByActor.value?.map((entry) => ({
+      actor: entry.actor,
+      turns: entry.turns,
+      span_ids: entry.spanIds
+    })),
+    final_messages: (facts.finalMessages.value ?? []).map((message) => ({
+      task: message.task,
+      at: message.at,
+      span_id: message.spanId,
+      text: message.text
+    })),
+    changed_files: {
+      count: facts.changedFiles.value?.length ?? 0,
+      paths: facts.changedFiles.value?.map((file) => ({
+        path: file.path,
+        operations: file.operations,
+        span_ids: file.spanIds
+      })),
+      ...facts.changedFiles.partial ? { partial: facts.changedFiles.partial } : {}
+    },
+    first_record_at: factJson(facts.firstRecordAt),
+    last_record_at: factJson(facts.lastRecordAt),
+    token_total: factJson(facts.tokenTotal),
+    first_failure: compactFirstFailure(facts.firstFailure),
+    measurements: facts.measurements
+  };
+}
+function compactFirstFailure(failure) {
+  if (failure.status === "unknown") {
+    return { status: "unknown", reason: failure.reason, unset_count: failure.unsetCount };
+  }
+  if (failure.status === "none") return { status: "none", reason: failure.reason };
+  if (failure.status === "ambiguous") {
+    return { status: "ambiguous", stage: failure.stage, reason: failure.reason, span_ids: failure.candidates };
+  }
+  return {
+    status: "found",
+    stage: failure.stage,
+    span_id: failure.spanId,
+    name: failure.name,
+    kind: failure.kind,
+    blame: failure.blame,
+    message: failure.message
+  };
+}
+function readSessionTurnGroups(spans, window) {
+  const bounds = windowBounds(window);
+  return groupByTrace(spans).flatMap((group) => {
+    const records = group.spans.filter(isRecordSpan);
+    if (records.length > 0 && bounds !== null && !records.some((span) => insideWindow(bounds, span.start_time) || insideWindow(bounds, span.end_time))) return [];
+    const ordered = [...group.spans].sort(byTraceOrder);
+    return [{
+      sessionId: group.sessionId,
+      records: records.length,
+      harness: ordered.map((span) => stringAttr2(span, "service.name")).find((value) => value !== null) ?? null,
+      cwd: ordered.map((span) => stringAttr2(span, SESSION_CWD_ATTR)).find((value) => value !== null) ?? null,
+      turns: typedTurnsOf(ordered).turns.filter((turn) => insideWindow(bounds, turn.at))
+    }];
+  });
+}
+
+// src/turn-index.ts
+function resumeOffset(previous, info) {
+  if (!previous) return 0;
+  if (previous.ino === info.ino && previous.size === info.size) return null;
+  return previous.ino === info.ino && info.size >= previous.size && previous.offset <= info.size ? previous.offset : 0;
+}
+var CHUNK_BYTES = 8 * 1024 * 1024;
+var NEWLINE2 = 10;
+async function readCompleteLines(path, from, to, consume) {
+  const handle = await open(path, "r");
+  let bytes2 = 0;
+  let end = from;
+  let carry = Buffer.alloc(0);
+  try {
+    const chunk = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, Math.max(0, to - from)));
+    let position = from;
+    while (position < to) {
+      const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, to - position), position);
+      if (bytesRead === 0) break;
+      position += bytesRead;
+      bytes2 += bytesRead;
+      const buffer = carry.length > 0 ? Buffer.concat([carry, chunk.subarray(0, bytesRead)]) : chunk.subarray(0, bytesRead);
+      const complete = buffer.lastIndexOf(NEWLINE2) + 1;
+      if (complete > 0) {
+        await consume(Buffer.from(buffer.subarray(0, complete)));
+        end += complete;
+      }
+      carry = Buffer.from(buffer.subarray(complete));
+    }
+  } finally {
+    await handle.close();
+  }
+  return { bytes: bytes2, end, rest: carry };
+}
+var INDEX_VERSION = 4;
+var EMPTY_SESSION = {
+  sessionId: null,
+  parentSessionId: null,
+  cwd: null,
+  firstAt: null,
+  lastAt: null,
+  records: 0,
+  humanTurns: [],
+  firstPrompt: null
+};
+var PIECE_WORKERS = 4;
+var LOCK_HEARTBEAT_MS = 2e4;
+var LOCK_STALE_MS = 12e4;
+function defaultTurnIndexDir() {
+  const state = process.env.XDG_STATE_HOME ?? join3(homedir2(), ".local", "state");
+  return join3(state, "traces", "turn-index");
+}
+function later(left, right) {
+  if (left === null) return right;
+  if (right === null) return left;
+  return Date.parse(right) > Date.parse(left) ? right : left;
+}
+function earlier(left, right) {
+  if (left === null) return right;
+  if (right === null) return left;
+  return Date.parse(right) < Date.parse(left) ? right : left;
+}
+var FIRST_PROMPT_CHARS = 200;
+function extend(session, read) {
+  const prompt = session.firstPrompt ?? read.firstPrompt;
+  return {
+    sessionId: session.sessionId ?? read.sessionId,
+    parentSessionId: session.parentSessionId ?? read.parentSessionId,
+    cwd: session.cwd ?? read.cwd,
+    firstAt: earlier(session.firstAt, read.firstAt),
+    lastAt: later(session.lastAt, read.lastAt),
+    records: session.records + read.records,
+    humanTurns: [.../* @__PURE__ */ new Set([...session.humanTurns, ...read.humanTurns])],
+    firstPrompt: prompt === null ? null : prompt.replace(/\s+/gu, " ").trim().slice(0, FIRST_PROMPT_CHARS)
+  };
+}
+function storedRows(rows) {
+  const seen = /* @__PURE__ */ new Map();
+  return rows.map((row) => {
+    const key = `${row.kind}\0${row.spanId}`;
+    const n = seen.get(key) ?? 0;
+    seen.set(key, n + 1);
+    return row.kind === "command" ? [row.kind, row.at, row.spanId, n, row.text, row.failed ?? null] : [row.kind, row.at, row.spanId, n, row.text];
+  });
+}
+function serialize(rows) {
+  return rows.map((row) => `${JSON.stringify(row)}
+`).join("");
+}
+function parseLines(buffer) {
+  const records = [];
+  const bytes2 = [];
+  let start = 0;
+  while (start < buffer.length) {
+    let end = buffer.indexOf(NEWLINE2, start);
+    if (end === -1) end = buffer.length;
+    records.push(parseRecord(buffer.toString("utf8", start, end)));
+    bytes2.push(end + 1 - start);
+    start = end + 1;
+  }
+  return { records, bytes: bytes2 };
+}
+function parseRecord(line) {
+  const text = line.replace(/\r$/u, "");
+  if (text.trim().length === 0) return null;
+  try {
+    const value = JSON.parse(text);
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+var MARK_BYTES = 4096;
+async function markOf(path, offset) {
+  if (offset === 0) return "";
+  const handle = await open(path, "r");
+  try {
+    const hash = createHash2("sha256");
+    for (const start of [0, Math.max(0, offset - MARK_BYTES)]) {
+      const buffer = Buffer.alloc(Math.min(MARK_BYTES, offset - start));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+      hash.update(buffer.subarray(0, bytesRead));
+    }
+    return hash.digest("hex").slice(0, 32);
+  } finally {
+    await handle.close();
+  }
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var TurnIndex = class _TurnIndex {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  files = {};
+  /** Whole reads, one after another. */
+  queue = Promise.resolve();
+  changed = false;
+  /** What this process writes into the lock, so it removes only its own. */
+  token = `${process.pid} ${randomUUID()}`;
+  heartbeat;
+  /** Open the index at `dir`, waiting while another traces process is refreshing it. */
+  static async open(dir = defaultTurnIndexDir()) {
+    const index = new _TurnIndex(dir);
+    await mkdir2(join3(dir, "rows"), { recursive: true });
+    await index.lock();
+    try {
+      const parsed = JSON.parse(await readFile2(join3(dir, "index.json"), "utf8"));
+      if (parsed.version === INDEX_VERSION && typeof parsed.files === "object" && parsed.files !== null) index.files = parsed.files;
+    } catch {
+    }
+    return index;
+  }
+  /** Open the index, run `use` on it, and close it whatever `use` does. */
+  static async with(use, dir) {
+    const index = await _TurnIndex.open(dir);
+    try {
+      return await use(index);
+    } finally {
+      await index.close();
+    }
+  }
+  get lockPath() {
+    return join3(this.dir, "lock");
+  }
+  async lock() {
+    for (; ; ) {
+      try {
+        const handle = await open(this.lockPath, "wx");
+        await handle.writeFile(this.token);
+        await handle.close();
+        this.heartbeat = setInterval(() => {
+          const now = /* @__PURE__ */ new Date();
+          utimes(this.lockPath, now, now).catch(() => {
+          });
+        }, LOCK_HEARTBEAT_MS);
+        this.heartbeat.unref();
+        return;
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+      const stale = await this.staleLock();
+      if (stale === null) await sleep(100);
+      else await this.removeStale(stale);
+    }
+  }
+  /**
+   * The inode of the lock when the process that wrote it left it behind: its
+   * pid is gone, or it went untouched for {@link LOCK_STALE_MS}. Null while a
+   * live process holds it, or once it is gone.
+   */
+  async staleLock() {
+    let handle;
+    try {
+      handle = await open(this.lockPath, "r");
+    } catch {
+      return null;
+    }
+    try {
+      const [info, text] = await Promise.all([handle.stat(), handle.readFile("utf8")]);
+      if (Date.now() - info.mtimeMs > LOCK_STALE_MS) return info.ino;
+      const pid = Number(text.split(" ")[0]);
+      if (!Number.isInteger(pid) || pid <= 0) return null;
+      try {
+        process.kill(pid, 0);
+        return null;
+      } catch (error) {
+        return error.code === "ESRCH" ? info.ino : null;
+      }
+    } finally {
+      await handle.close();
+    }
+  }
+  /**
+   * Remove the stale lock `ino`, and only that one: two processes can find
+   * the same lock stale, and the second must not remove the lock the first
+   * then took. The lock is moved aside first; when what moved is another
+   * process's new lock, it goes back.
+   */
+  async removeStale(ino) {
+    const aside = `${this.lockPath}.${this.token.replace(" ", ".")}`;
+    try {
+      await rename2(this.lockPath, aside);
+    } catch {
+      return;
+    }
+    if ((await stat2(aside)).ino !== ino) await link(aside, this.lockPath).catch(() => {
+    });
+    await unlink(aside);
+  }
+  /** Save what was read and let the next process in. */
+  async close() {
+    clearInterval(this.heartbeat);
+    try {
+      if (!this.changed) return;
+      const temporary = join3(this.dir, `index.json.${process.pid}.tmp`);
+      await writeFile2(temporary, JSON.stringify({ version: INDEX_VERSION, files: this.files }));
+      await rename2(temporary, join3(this.dir, "index.json"));
+    } finally {
+      const held = await readFile2(this.lockPath, "utf8").catch(() => "");
+      if (held === this.token) await unlink(this.lockPath).catch(() => {
+      });
+    }
+  }
+  rowsPath(key) {
+    return join3(this.dir, "rows", `${createHash2("sha256").update(key).digest("hex").slice(0, 24)}.jsonl`);
+  }
+  static keyOf(adapter, ref) {
+    return `${adapter.harness}\0${ref.path}\0${ref.sessionId}`;
+  }
+  /**
+   * Bring each session up to date: read what it appended since the last
+   * refresh, or all of it the first time. A session that cannot be read is
+   * recorded with its reason, never dropped.
+   */
+  async refresh(sessions) {
+    const stats = { path: this.dir, sessions: sessions.length, sessionsRead: 0, bytesRead: 0, wholeReads: 0, rowsAdded: 0 };
+    let next = 0;
+    const worker = async () => {
+      while (next < sessions.length) {
+        const { adapter, ref } = sessions[next++];
+        const read = await this.refreshOne(adapter, ref);
+        if (read === null) continue;
+        this.changed = true;
+        stats.sessionsRead += 1;
+        stats.bytesRead += read.bytes;
+        stats.rowsAdded += read.rows;
+        if (read.whole) stats.wholeReads += 1;
+      }
+    };
+    await Promise.all(Array.from({ length: PIECE_WORKERS }, worker));
+    return stats;
+  }
+  async refreshOne(adapter, ref) {
+    const key = _TurnIndex.keyOf(adapter, ref);
+    let info;
+    try {
+      info = await stat2(ref.path);
+    } catch (error) {
+      const entry = this.blank({ ino: 0, size: 0, mtimeMs: 0 }, "whole");
+      entry.unread = errorText(error);
+      this.files[key] = entry;
+      return { bytes: 0, rows: 0, whole: false };
+    }
+    const previous = this.files[key];
+    const pieces = readsStoreRoots(adapter) && adapter.readsPieces(ref) && previous?.mode !== "whole";
+    if (pieces) {
+      try {
+        return await this.readPieces(key, adapter, ref, info, previous);
+      } catch {
+      }
+    }
+    const version = ref.path.endsWith(".db") ? `m${ref.mtimeMs}` : `${info.ino}:${info.size}:${info.mtimeMs}`;
+    if (previous?.mode === "whole" && previous.version === version) return null;
+    return this.readWhole(key, adapter, ref, info, version);
+  }
+  blank(info, mode) {
+    return {
+      mode,
+      ino: info.ino,
+      size: info.size,
+      mtimeMs: info.mtimeMs,
+      version: "",
+      offset: 0,
+      mark: "",
+      carry: null,
+      turn: TURN_FOLD_START,
+      session: EMPTY_SESSION,
+      tail: null,
+      unread: null
+    };
+  }
+  /** Read a session whole, as `facts <ref>` reads it, replacing every row it had. */
+  async readWhole(key, adapter, ref, info, version) {
+    const entry = this.blank(info, "whole");
+    entry.version = version;
+    const read = this.queue.then(async () => {
+      let rows = [];
+      try {
+        const read2 = readSessionIndex(await readSessionSpans(adapter, ref), { sessionId: ref.sessionId });
+        entry.session = extend(EMPTY_SESSION, read2);
+        entry.turn = read2.state;
+        rows = storedRows(read2.rows);
+        if (read2.records === 0) entry.unread = "no record could be read";
+      } catch (error) {
+        entry.unread = errorText(error);
+      }
+      await writeFile2(this.rowsPath(key), serialize(rows));
+      this.files[key] = entry;
+      return rows.length;
+    });
+    this.queue = read.then(() => {
+    }, () => {
+    });
+    return { bytes: 0, rows: await read, whole: true };
+  }
+  /**
+   * Read what a Claude Code or Codex file appended since `previous`: commit
+   * the rows of every piece up to the last response, and keep that response's
+   * rows as the uncommitted tail, read again next time.
+   */
+  async readPieces(key, adapter, ref, info, previous) {
+    const old = previous?.mode === "pieces" ? previous : void 0;
+    let from = resumeOffset(old, info);
+    if (old && (from === null ? old.mtimeMs !== info.mtimeMs : from > 0) && old.mark !== await markOf(ref.path, old.offset)) from = 0;
+    if (from === null) {
+      if (old && old.mtimeMs !== info.mtimeMs) {
+        this.files[key] = { ...old, mtimeMs: info.mtimeMs };
+        this.changed = true;
+      }
+      return null;
+    }
+    const entry = from === 0 || !old ? this.blank(info, "pieces") : { ...old, tail: null };
+    let carry = entry.carry ?? PIECE_START;
+    let pending = { records: [], bytes: [] };
+    const committed = [];
+    const piece = async (records) => {
+      const read2 = await adapter.readPiece(ref, records, carry);
+      carry = read2.carry;
+      const spans = validateOtlpSpans(read2.spans, `${adapter.harness} piece of ${ref.path}`);
+      if (spans.length > 0) stampSessionIdentity(spans, ref.sessionId);
+      return readSessionIndex(spans, { state: entry.turn });
+    };
+    const read = await readCompleteLines(ref.path, from, info.size, async (buffer) => {
+      const lines = parseLines(buffer);
+      const records = [...pending.records, ...lines.records];
+      const bytes2 = [...pending.bytes, ...lines.bytes];
+      if (carry.lines === 0 && !adapter.readsPieces(ref, records)) throw new Error("read whole");
+      const cut = pieceBoundary(adapter.nativeHarness, records, carry);
+      if (cut > 0) {
+        const result = await piece(records.slice(0, cut));
+        entry.session = extend(entry.session, result);
+        entry.turn = result.state;
+        committed.push(...storedRows(result.rows));
+        entry.offset += bytes2.slice(0, cut).reduce((sum2, value) => sum2 + value, 0);
+        entry.carry = carry;
+      }
+      pending = { records: records.slice(cut), bytes: bytes2.slice(cut) };
+    });
+    const last = read.rest.length > 0 ? parseRecord(read.rest.toString("utf8")) : null;
+    const tailRecords = last ? [...pending.records, last] : pending.records;
+    if (entry.offset === 0 && tailRecords.length > 0 && !adapter.readsPieces(ref, tailRecords)) throw new Error("read whole");
+    if (tailRecords.length > 0) {
+      const saved = carry;
+      const result = await piece(tailRecords);
+      carry = saved;
+      entry.tail = { session: extend(EMPTY_SESSION, result), rows: storedRows(result.rows) };
+    }
+    entry.ino = info.ino;
+    entry.size = info.size;
+    entry.mtimeMs = info.mtimeMs;
+    entry.mark = await markOf(ref.path, entry.offset);
+    if (from === 0) await writeFile2(this.rowsPath(key), serialize(committed));
+    else if (committed.length > 0) await appendFile(this.rowsPath(key), serialize(committed));
+    this.files[key] = entry;
+    return { bytes: read.bytes, rows: committed.length + (entry.tail?.rows.length ?? 0), whole: false };
+  }
+  /** The session as the index holds it: its committed rows' facts and its tail's, or why it could not be read. */
+  session(adapter, ref) {
+    const entry = this.files[_TurnIndex.keyOf(adapter, ref)];
+    if (!entry) return null;
+    const session = entry.tail ? extend(entry.session, entry.tail.session) : entry.session;
+    return { session, unread: entry.unread ?? (session.records === 0 ? "no record could be read" : null) };
+  }
+  /**
+   * A session's rows in the order a whole read lists them: its human turns,
+   * then its agent messages and commands, each in trace order. A row read
+   * twice (a harness that writes a record again) is listed once.
+   */
+  async rows(adapter, ref) {
+    const key = _TurnIndex.keyOf(adapter, ref);
+    const entry = this.files[key];
+    if (!entry) return [];
+    let text = "";
+    try {
+      text = await readFile2(this.rowsPath(key), "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const human = [];
+    const other = [];
+    const take = ([kind, at, spanId, n, body, failed]) => {
+      const key2 = `${kind}\0${spanId}\0${n}`;
+      if (seen.has(key2)) return;
+      seen.add(key2);
+      (kind === "human" ? human : other).push({ kind, at, spanId, text: body, ...kind === "command" ? { failed: failed ?? null } : {} });
+    };
+    let start = 0;
+    while (start < text.length) {
+      let end = text.indexOf("\n", start);
+      if (end === -1) end = text.length;
+      if (end > start) take(JSON.parse(text.slice(start, end)));
+      start = end + 1;
+    }
+    for (const row of entry.tail?.rows ?? []) take(row);
+    return [...human, ...other];
+  }
+};
+
+export {
+  SessionWorkflowError,
+  describeSessionRelationship,
+  commandTextFromInput,
+  commandLines,
+  TurnIndex,
+  defaultSkillUsageStorePath,
+  SkillUsageStore,
+  readInstalledSkills,
+  buildSkillUsageReport,
+  renderSkillUsage,
+  CONTEXT_BANDS,
+  modelCallMeasurement,
+  sessionIdentityLookup,
+  isSynthesizedSpan2 as isSynthesizedSpan,
+  computeSessionFacts,
+  priceReport,
+  buildSessionFactsReport,
+  createSessionFactsReportBuilder,
+  sheetText,
+  utcMinute,
+  minutesText,
+  topCounts,
+  renderSessionFacts,
+  matchRows,
+  sessionMatches,
+  renderFirstFailure,
+  renderSessionFactsContext,
+  readSessionTurnGroups
+};