@tangle-network/traces 0.23.0 → 1.0.0

package/dist/chunk-DLGAKCQJ.js

@@ -0,0 +1,782 @@
+import {
+  SessionWorkflowError,
+  buildSessionFactsReport,
+  describeSessionRelationship,
+  priceReport
+} from "./chunk-UVE5ANVV.js";
+import {
+  isMissingPathError,
+  locateSessions,
+  parseSession
+} from "./chunk-3T62R7ON.js";
+import {
+  tracesVersion,
+  writeOtlpFile
+} from "./chunk-NZ5Y7UEL.js";
+import {
+  SOURCE_ATTRIBUTE_PREFIX,
+  sourceFileId
+} from "./chunk-DU534HAX.js";
+
+// src/session-selection.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+
+// src/session-workflow.ts
+function refPathKey(ref) {
+  return `${ref.harness}\0${ref.path}`;
+}
+function referencesFor(relationship) {
+  return [
+    ...relationship.parentSessionId ? [{
+      sessionId: relationship.parentSessionId,
+      referencedBySessionId: relationship.sessionId,
+      relation: "parent"
+    }] : [],
+    ...relationship.childSessionIds.map((sessionId) => ({
+      sessionId,
+      referencedBySessionId: relationship.sessionId,
+      relation: "child",
+      taskScope: relationship.spawnedChildSessionIds.includes(sessionId) ? "all" : relationship.resumedChildSessionIds.includes(sessionId) ? "latest" : "all"
+    }))
+  ];
+}
+function issueKey(issue) {
+  return JSON.stringify(issue);
+}
+function referenceKey(reference) {
+  return JSON.stringify(reference);
+}
+function findParentCycles(sessions) {
+  const parentBySession = new Map(
+    sessions.filter((session) => session.relationship.parentSessionId).map((session) => [session.relationship.sessionId, session.relationship.parentSessionId])
+  );
+  const cycles = /* @__PURE__ */ new Map();
+  for (const start of parentBySession.keys()) {
+    const path = [];
+    const indexById = /* @__PURE__ */ new Map();
+    let current = start;
+    while (current && parentBySession.has(current)) {
+      const seenAt = indexById.get(current);
+      if (seenAt !== void 0) {
+        const cycle = path.slice(seenAt);
+        const canonicalStart = cycle.reduce(
+          (best, id, index) => id.localeCompare(cycle[best]) < 0 ? index : best,
+          0
+        );
+        const canonical = [...cycle.slice(canonicalStart), ...cycle.slice(0, canonicalStart)];
+        cycles.set(canonical.join("\0"), canonical);
+        break;
+      }
+      indexById.set(current, path.length);
+      path.push(current);
+      current = parentBySession.get(current);
+    }
+  }
+  return [...cycles.values()].map((sessionIds) => ({ kind: "cycle", sessionIds }));
+}
+function relationshipIssues(sessions) {
+  const byId = new Map(sessions.map((session) => [session.relationship.sessionId, session]));
+  const referencedParents = /* @__PURE__ */ new Map();
+  for (const parent of sessions) {
+    for (const childId of parent.relationship.childSessionIds) {
+      if (!byId.has(childId)) continue;
+      const parents = referencedParents.get(childId) ?? /* @__PURE__ */ new Set();
+      parents.add(parent.relationship.sessionId);
+      referencedParents.set(childId, parents);
+    }
+  }
+  const issues = [];
+  for (const session of sessions) {
+    const referenced = [...referencedParents.get(session.relationship.sessionId) ?? []].sort();
+    const declared = session.relationship.parentSessionId;
+    const mismatched = referenced.filter((parent) => parent !== declared);
+    const missingReverseLink = Boolean(declared && byId.has(declared) && !referenced.includes(declared));
+    if (referenced.length > 1 || mismatched.length > 0 || missingReverseLink) {
+      issues.push({
+        kind: "parent-conflict",
+        sessionId: session.relationship.sessionId,
+        ...declared ? { declaredParentSessionId: declared } : {},
+        referencedParentSessionIds: referenced
+      });
+    }
+  }
+  return [...issues, ...findParentCycles(sessions)];
+}
+function orderSessions(sessions) {
+  const byId = new Map(sessions.map((session) => [session.relationship.sessionId, session]));
+  const children = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const parentId = session.relationship.parentSessionId;
+    if (parentId && byId.has(parentId)) {
+      const childIds = children.get(parentId) ?? /* @__PURE__ */ new Set();
+      childIds.add(session.relationship.sessionId);
+      children.set(parentId, childIds);
+    }
+    for (const childId of session.relationship.childSessionIds) {
+      if (!byId.has(childId)) continue;
+      const childIds = children.get(session.relationship.sessionId) ?? /* @__PURE__ */ new Set();
+      childIds.add(childId);
+      children.set(session.relationship.sessionId, childIds);
+    }
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const session = byId.get(id);
+    if (!session) return;
+    ordered.push(session);
+    for (const childId of [...children.get(id) ?? []].sort()) visit(childId);
+  };
+  const roots = sessions.filter((session) => !session.relationship.parentSessionId || !byId.has(session.relationship.parentSessionId)).map((session) => session.relationship.sessionId).sort();
+  for (const id of roots) visit(id);
+  for (const id of [...byId.keys()].sort()) visit(id);
+  return ordered;
+}
+function startedAt(session) {
+  let first = Number.POSITIVE_INFINITY;
+  for (const span of session.spans) {
+    const at = Date.parse(span.start_time);
+    if (Number.isFinite(at) && at < first) first = at;
+  }
+  return first;
+}
+function orderFromSeeds(sessions, seedIds) {
+  const byId = new Map(sessions.map((session) => [session.relationship.sessionId, session]));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    const session = byId.get(id);
+    if (!session || seen.has(id)) return;
+    seen.add(id);
+    ordered.push(session);
+    const children = session.relationship.childSessionIds.map((childId) => byId.get(childId)).filter((child) => child !== void 0).sort((a, b) => startedAt(a) - startedAt(b) || a.relationship.sessionId.localeCompare(b.relationship.sessionId));
+    for (const child of children) visit(child.relationship.sessionId);
+  };
+  for (const id of seedIds) visit(id);
+  for (const session of sessions) visit(session.relationship.sessionId);
+  return ordered;
+}
+async function collectSessionWorkflow(adapter, seeds, options = {}) {
+  const followParents = options.parents !== false;
+  if (seeds.length === 0) {
+    throw new SessionWorkflowError(
+      "SESSION_WORKFLOW_EMPTY_SELECTION",
+      "session workflow needs at least one seed session"
+    );
+  }
+  const maxSessions = options.maxSessions ?? 100;
+  if (!Number.isInteger(maxSessions) || maxSessions < 1) {
+    throw new SessionWorkflowError(
+      "SESSION_WORKFLOW_INVALID_LIMIT",
+      "maxSessions must be a positive integer"
+    );
+  }
+  options.signal?.throwIfAborted();
+  const refsById = /* @__PURE__ */ new Map();
+  const addRef = (ref) => {
+    const refs = refsById.get(ref.sessionId) ?? [];
+    if (!refs.some((candidate) => refPathKey(candidate) === refPathKey(ref))) refs.push(ref);
+    refsById.set(ref.sessionId, refs);
+  };
+  for (const ref of seeds) addRef(ref);
+  let fallbackLocated;
+  const resolvedIds = /* @__PURE__ */ new Set();
+  const refsForId = async (sessionId) => {
+    if (resolvedIds.has(sessionId)) return refsById.get(sessionId) ?? [];
+    if (adapter.locateBySessionId) {
+      for (const ref of await adapter.locateBySessionId(sessionId, options.home !== void 0 ? { home: options.home } : {})) addRef(ref);
+    } else {
+      fallbackLocated ??= await locateSessions(adapter, { home: options.home });
+      for (const ref of fallbackLocated) addRef(ref);
+    }
+    resolvedIds.add(sessionId);
+    options.signal?.throwIfAborted();
+    return refsById.get(sessionId) ?? [];
+  };
+  const queue = [];
+  const queuedByPath = /* @__PURE__ */ new Map();
+  const enqueue = (ref, taskScope, taskTurnId, explicit = false) => {
+    const key = refPathKey(ref);
+    const existing = queuedByPath.get(key);
+    if (existing) {
+      const conflictingExplicitTurns = existing.taskScope === "turn" && taskScope === "turn" && existing.taskTurnId !== taskTurnId && existing.explicitExactTurn && explicit;
+      if (conflictingExplicitTurns) {
+        throw new SessionWorkflowError(
+          "SESSION_WORKFLOW_TASK_CONFLICT",
+          `session ${ref.sessionId} was explicitly selected at two different exact turns`
+        );
+      }
+      if (existing.taskScope === taskScope && existing.taskTurnId === taskTurnId) {
+        if (taskScope === "turn" && explicit) existing.explicitExactTurn = true;
+        return;
+      }
+      existing.taskScope = "all";
+      delete existing.taskTurnId;
+      existing.explicitExactTurn = false;
+      return;
+    }
+    const queued = {
+      ref,
+      taskScope,
+      ...taskTurnId ? { taskTurnId } : {},
+      explicitExactTurn: explicit && taskScope === "turn"
+    };
+    queuedByPath.set(key, queued);
+    queue.push(queued);
+  };
+  const seedTaskScope = options.taskScope ?? "all";
+  for (const seed of seeds) enqueue(seed, seedTaskScope, options.taskTurnId, true);
+  const sessions = [];
+  const parsedById = /* @__PURE__ */ new Map();
+  const references = [];
+  const issues = [];
+  const unresolvedReferences = /* @__PURE__ */ new Set();
+  const seedPaths = new Set(seeds.map(refPathKey));
+  const seedSessionIds = [];
+  const unreadIds = /* @__PURE__ */ new Set();
+  for (let index = 0; index < queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    if (sessions.length >= maxSessions) {
+      throw new SessionWorkflowError(
+        "SESSION_WORKFLOW_LIMIT_EXCEEDED",
+        `the selected session tree holds more than ${maxSessions} sessions, the cap on spawned children read with a session; name one child session to read it alone`
+      );
+    }
+    const selected = queue[index];
+    const { ref, taskScope, taskTurnId } = selected;
+    let spans;
+    try {
+      spans = await parseSession(adapter, ref, {
+        corruptionMode: options.corruptionMode,
+        taskScope,
+        taskTurnId,
+        signal: options.signal
+      });
+    } catch (error) {
+      if (!options.onUnreadable || options.signal?.aborted) throw error;
+      options.onUnreadable({ ref, error, seed: seedPaths.has(refPathKey(ref)) });
+      unreadIds.add(ref.sessionId);
+      continue;
+    }
+    options.signal?.throwIfAborted();
+    const relationship = describeSessionRelationship(ref, spans);
+    const discoveredPaths = followParents ? (await refsForId(relationship.sessionId)).map((candidate) => candidate.path).filter((path, pathIndex, paths) => paths.indexOf(path) === pathIndex) : [];
+    if (discoveredPaths.length > 1) {
+      throw new SessionWorkflowError(
+        "SESSION_WORKFLOW_DUPLICATE_ID",
+        `session ID "${relationship.sessionId}" resolves to ${discoveredPaths.join(", ")}`
+      );
+    }
+    const previous = parsedById.get(relationship.sessionId);
+    if (previous && refPathKey(previous.ref) !== refPathKey(ref)) {
+      throw new SessionWorkflowError(
+        "SESSION_WORKFLOW_DUPLICATE_ID",
+        `session ID "${relationship.sessionId}" resolves to both ${previous.ref.path} and ${ref.path}`
+      );
+    }
+    if (previous) continue;
+    const joinedChildIds = [];
+    if (relationship.unjoinedSpawnPaths.length > 0) {
+      const resolutions = adapter.locateSpawnedChildren ? await adapter.locateSpawnedChildren(relationship.sessionId, relationship.unjoinedSpawnPaths, {
+        corruptionMode: options.corruptionMode,
+        signal: options.signal,
+        ...options.home !== void 0 ? { home: options.home } : {}
+      }) : [];
+      options.signal?.throwIfAborted();
+      if (!adapter.locateSpawnedChildren) {
+        for (const agentPath of relationship.unjoinedSpawnPaths) {
+          issues.push({
+            kind: "unjoined-child",
+            parentSessionId: relationship.sessionId,
+            agentPath,
+            reason: "unsupported"
+          });
+        }
+      }
+      for (const resolution of resolutions) {
+        if (resolution.ref) {
+          addRef(resolution.ref);
+          joinedChildIds.push(resolution.ref.sessionId);
+          continue;
+        }
+        issues.push({
+          kind: "unjoined-child",
+          parentSessionId: relationship.sessionId,
+          agentPath: resolution.agentPath,
+          reason: resolution.reason ?? "not-found",
+          ...resolution.candidates ? { candidates: resolution.candidates } : {}
+        });
+      }
+    }
+    const joined = joinedChildIds.length === 0 ? relationship : {
+      ...relationship,
+      childSessionIds: [.../* @__PURE__ */ new Set([...relationship.childSessionIds, ...joinedChildIds])].sort(),
+      spawnedChildSessionIds: [.../* @__PURE__ */ new Set([...relationship.spawnedChildSessionIds, ...joinedChildIds])].sort()
+    };
+    const session = {
+      adapter,
+      ref,
+      spans,
+      relationship: joined,
+      taskScope,
+      ...taskTurnId ? { taskTurnId } : {}
+    };
+    sessions.push(session);
+    parsedById.set(joined.sessionId, session);
+    if (seedPaths.has(refPathKey(ref))) seedSessionIds.push(joined.sessionId);
+    const discovered = referencesFor(joined).filter((reference) => followParents || reference.relation === "child");
+    references.push(...discovered);
+    for (const reference of discovered) {
+      if (parsedById.has(reference.sessionId)) continue;
+      const candidates = await refsForId(reference.sessionId);
+      if (candidates.length !== 1) continue;
+      if (reference.relation !== "parent" || taskScope !== "latest") {
+        enqueue(candidates[0], reference.taskScope ?? "all");
+        continue;
+      }
+      const resolution = adapter.resolveParentTask ? await adapter.resolveParentTask(candidates[0], joined.sessionId, {
+        corruptionMode: options.corruptionMode,
+        signal: options.signal
+      }) : { kind: "unavailable", reason: "unsupported" };
+      options.signal?.throwIfAborted();
+      if (resolution.kind === "resolved") {
+        enqueue(candidates[0], "turn", resolution.turnId);
+        continue;
+      }
+      unresolvedReferences.add(referenceKey(reference));
+      issues.push({
+        kind: "unresolved-parent-task",
+        parentSessionId: reference.sessionId,
+        childSessionId: joined.sessionId,
+        reason: resolution.reason,
+        ..."turnIds" in resolution && resolution.turnIds ? { turnIds: resolution.turnIds } : {}
+      });
+    }
+  }
+  for (const reference of references) {
+    if (parsedById.has(reference.sessionId) || unreadIds.has(reference.sessionId)) continue;
+    if (unresolvedReferences.has(referenceKey(reference))) continue;
+    const {
+      taskScope: _taskScope,
+      ...publicReference
+    } = reference;
+    const paths = (refsById.get(reference.sessionId) ?? []).map((ref) => ref.path).sort();
+    issues.push(paths.length > 1 ? { kind: "ambiguous-session", ...publicReference, paths } : { kind: "missing-session", ...publicReference });
+  }
+  issues.push(...relationshipIssues(sessions));
+  const uniqueIssues = [...new Map(issues.map((issue) => [issueKey(issue), issue])).values()];
+  const ordered = followParents ? orderSessions(sessions) : orderFromSeeds(sessions, seedSessionIds);
+  return {
+    sessions: ordered,
+    seedSessionIds: [...new Set(seedSessionIds)],
+    complete: uniqueIssues.length === 0,
+    issues: uniqueIssues
+  };
+}
+
+// src/session-selection.ts
+async function fileSha256(path, signal) {
+  signal?.throwIfAborted();
+  const hash = createHash("sha256");
+  try {
+    for await (const chunk of createReadStream(path, { signal })) {
+      signal?.throwIfAborted();
+      hash.update(chunk);
+    }
+  } catch (error) {
+    if (signal?.aborted) signal.throwIfAborted();
+    throw error;
+  }
+  signal?.throwIfAborted();
+  return hash.digest("hex");
+}
+async function sourceSnapshot(adapter, ref, signal) {
+  signal?.throwIfAborted();
+  const paths = [
+    ...adapter.sourcePaths ? await adapter.sourcePaths(ref, { signal }) : [ref.path]
+  ].sort();
+  signal?.throwIfAborted();
+  if (paths.length === 0) throw new Error(`adapter returned no source files for ${ref.path}`);
+  if (new Set(paths).size !== paths.length) {
+    throw new Error(`adapter returned duplicate source files for ${ref.path}`);
+  }
+  const files = [];
+  for (const path of paths) {
+    signal?.throwIfAborted();
+    files.push({ path, sha256: await fileSha256(path, signal) });
+  }
+  const sha256 = files.length === 1 ? files[0].sha256 : createHash("sha256").update(JSON.stringify(files)).digest("hex");
+  return { sha256, files };
+}
+function summarizeWorkflows(workflows) {
+  if (workflows.length === 0) return void 0;
+  const issues = /* @__PURE__ */ new Map();
+  for (const workflow of workflows) {
+    for (const issue of workflow.issues) issues.set(JSON.stringify(issue), issue);
+  }
+  return {
+    seedSessionIds: [...new Set(workflows.flatMap((workflow) => workflow.seedSessionIds))],
+    complete: workflows.every((workflow) => workflow.complete),
+    issues: [...issues.values()]
+  };
+}
+async function boundSessionRow(adapter, ref, taskScope, taskTurnId, expectedRelationship, signal) {
+  const before = await sourceSnapshot(adapter, ref, signal);
+  const spans = await parseSession(adapter, ref, { taskScope, taskTurnId, signal, captureSources: true });
+  signal?.throwIfAborted();
+  const after = await sourceSnapshot(adapter, ref, signal);
+  if (JSON.stringify(before) !== JSON.stringify(after)) {
+    throw new Error(`session source changed while parsing; refusing unbound evidence: ${ref.path}`);
+  }
+  const digests = new Map(after.files.map((file) => [sourceFileId(file.path), file.sha256]));
+  for (const span of spans) {
+    for (const [key, value] of Object.entries(span.attributes)) {
+      if (!key.startsWith(SOURCE_ATTRIBUTE_PREFIX) || typeof value !== "string") continue;
+      const refs = JSON.parse(value);
+      span.attributes[key] = JSON.stringify(refs.map((record) => {
+        const sourceSha256 = digests.get(record.sourceId);
+        if (!sourceSha256) throw new Error("adapter source reference is outside its declared source files");
+        return { ...record, sourceSha256 };
+      }));
+    }
+  }
+  if (expectedRelationship && JSON.stringify(describeSessionRelationship(ref, spans)) !== JSON.stringify(expectedRelationship)) {
+    throw new Error(`session relationships changed during workflow selection: ${ref.path}`);
+  }
+  return {
+    adapter,
+    ref,
+    spans,
+    taskScope,
+    ...taskTurnId ? { taskTurnId } : {},
+    sourceSha256: after.sha256,
+    sourceFiles: after.files
+  };
+}
+async function collectSessionSelection(groups, options = {}) {
+  const rows = [];
+  const workflows = [];
+  const taskScope = options.taskScope ?? "all";
+  const read = /* @__PURE__ */ new Set();
+  const add = async (row) => {
+    const key = `${row.adapter.harness}\0${row.ref.path}`;
+    if (read.has(key)) return;
+    read.add(key);
+    if (options.onRow) await options.onRow(row);
+    else rows.push(row);
+  };
+  for (const { adapter, refs } of groups) {
+    options.signal?.throwIfAborted();
+    if (refs.length === 0) continue;
+    if (!options.workflow) {
+      for (const ref of refs) {
+        let row;
+        try {
+          row = options.bindSources ? await boundSessionRow(
+            adapter,
+            ref,
+            taskScope,
+            options.taskTurnId,
+            void 0,
+            options.signal
+          ) : {
+            adapter,
+            ref,
+            spans: await parseSession(adapter, ref, {
+              taskScope,
+              taskTurnId: options.taskTurnId,
+              signal: options.signal
+            }),
+            taskScope,
+            ...options.taskTurnId ? { taskTurnId: options.taskTurnId } : {}
+          };
+        } catch (error) {
+          if (!options.onUnreadable || options.signal?.aborted) throw error;
+          options.onUnreadable({ ref, error, seed: true });
+          continue;
+        }
+        await add(row);
+      }
+      continue;
+    }
+    const workflow2 = await collectSessionWorkflow(adapter, refs, {
+      maxSessions: options.maxWorkflowSessions,
+      home: options.home,
+      taskScope,
+      taskTurnId: options.taskTurnId,
+      signal: options.signal,
+      ...options.parents === false ? { parents: false } : {},
+      ...options.onUnreadable ? { onUnreadable: options.onUnreadable } : {}
+    });
+    workflows.push(workflow2);
+    for (const session of workflow2.sessions) {
+      await add(options.bindSources ? await boundSessionRow(
+        adapter,
+        session.ref,
+        session.taskScope,
+        session.taskTurnId,
+        session.relationship,
+        options.signal
+      ) : {
+        adapter,
+        ref: session.ref,
+        spans: session.spans,
+        taskScope: session.taskScope,
+        ...session.taskTurnId ? { taskTurnId: session.taskTurnId } : {}
+      });
+    }
+  }
+  const workflow = summarizeWorkflows(workflows);
+  return { rows, ...workflow ? { workflow } : {} };
+}
+
+// src/bundle.ts
+import { cp, copyFile, lstat, mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname, join, relative, resolve, sep } from "path";
+var SESSION_WINDOW_PAD_MS = 15 * 60 * 1e3;
+function bundlePath(...parts) {
+  return parts.join("/");
+}
+async function statOrNull(path) {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if (isMissingPathError(error)) return null;
+    if (error.code === "ENOTDIR") return null;
+    throw error;
+  }
+}
+async function runGitLog(cwd, sinceIso, untilIso) {
+  const { execFile } = await import("child_process");
+  const { promisify } = await import("util");
+  const run = promisify(execFile);
+  try {
+    const { stdout } = await run(
+      "git",
+      ["-C", cwd, "log", `--since=${sinceIso}`, `--until=${untilIso}`, "--date=iso-strict", "--pretty=format:%H %ad %an %s"],
+      { timeout: 5e3 }
+    );
+    return { succeeded: true, stdout };
+  } catch (error) {
+    return { succeeded: false, error: error instanceof Error ? error.message.split("\n", 1)[0] : String(error) };
+  }
+}
+async function listBundleFiles(root) {
+  const out = [];
+  const pending = [resolve(root)];
+  while (pending.length > 0) {
+    const dir = pending.pop();
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) pending.push(path);
+      else if (entry.isFile()) out.push(relative(resolve(root), path).split(sep).join("/"));
+    }
+  }
+  return out.sort();
+}
+async function assembleSessionBundle(opts) {
+  const { adapter, ref } = opts;
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await stat(ref.path);
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      throw new Error(`session transcript not found at ${ref.path} \u2014 a bundle cannot be assembled without its transcript`);
+    }
+    throw error;
+  }
+  const selection = await collectSessionSelection([{ adapter, refs: [ref] }], {
+    bindSources: true,
+    signal: opts.signal
+  });
+  const row = selection.rows[0];
+  const spans = row.spans;
+  const transcriptSha256 = row.sourceFiles.find((file) => resolve(file.path) === resolve(ref.path))?.sha256 ?? row.sourceSha256;
+  const outDir = resolve(opts.outDir);
+  await mkdir(outDir, { recursive: true });
+  if ((await readdir(outDir)).length > 0) {
+    throw new Error(
+      `bundle output directory ${outDir} is not empty \u2014 pass a new directory so one bundle holds exactly one session`
+    );
+  }
+  const absent = [];
+  await mkdir(join(outDir, "session"), { recursive: true });
+  const subagentsSource = join(ref.path.replace(/\.jsonl$/, ""), "subagents");
+  if ((await statOrNull(subagentsSource))?.isDirectory()) {
+    await cp(subagentsSource, join(outDir, "session", "subagents"), { recursive: true });
+  } else {
+    absent.push({ path: bundlePath("session", "subagents"), reason: `no subagents directory at ${subagentsSource}` });
+  }
+  const retainedSourceIds = /* @__PURE__ */ new Map();
+  for (const file of row.sourceFiles) {
+    opts.signal?.throwIfAborted();
+    const sourceId = sourceFileId(file.path);
+    const subagentRelative = relative(subagentsSource, file.path);
+    const path = resolve(file.path) === resolve(ref.path) ? bundlePath("session", "transcript.jsonl") : !subagentRelative.startsWith("..") && !subagentRelative.startsWith(sep) ? bundlePath("session", "subagents", subagentRelative) : bundlePath("session", "sources", `${sourceId}.jsonl`);
+    const target = join(outDir, path);
+    await mkdir(dirname(target), { recursive: true });
+    await copyFile(file.path, target);
+    if (await fileSha256(target, opts.signal) !== file.sha256) {
+      throw new Error(`session source changed while retaining bundle evidence: ${file.path}`);
+    }
+    retainedSourceIds.set(path, sourceId);
+  }
+  await writeOtlpFile(spans, join(outDir, "spans.otlp.jsonl"));
+  const facts = await priceReport(buildSessionFactsReport(spans, { harness: ref.harness, generatedAt }));
+  await writeFile(join(outDir, "facts.json"), `${JSON.stringify(facts, null, 2)}
+`, "utf8");
+  const own = facts.sessions.find((session) => session.sessionId === ref.sessionId) ?? facts.sessions[0];
+  const firstRecordAt = own?.firstRecordAt.value ?? null;
+  const lastRecordAt = own?.lastRecordAt.value ?? null;
+  const cwd = own?.cwd.value ?? ref.cwd ?? null;
+  const gitLogPath = "git-log.txt";
+  if (!cwd) {
+    absent.push({ path: gitLogPath, reason: "session has no recorded cwd to read git history from" });
+  } else if (firstRecordAt === null || lastRecordAt === null) {
+    absent.push({ path: gitLogPath, reason: "session window unavailable (no record carries a time)" });
+  } else {
+    const log = await runGitLog(
+      cwd,
+      new Date(Date.parse(firstRecordAt) - SESSION_WINDOW_PAD_MS).toISOString(),
+      new Date(Date.parse(lastRecordAt) + SESSION_WINDOW_PAD_MS).toISOString()
+    );
+    if (log.succeeded) {
+      await writeFile(join(outDir, gitLogPath), log.stdout ? `${log.stdout}
+` : "", "utf8");
+    } else {
+      absent.push({ path: gitLogPath, reason: `git log failed in ${cwd}: ${log.error}` });
+    }
+  }
+  const files = [];
+  for (const path of await listBundleFiles(outDir)) {
+    const filePath = join(outDir, path);
+    const sourceId = retainedSourceIds.get(path);
+    files.push({
+      ...sourceId !== void 0 ? { sourceId } : {},
+      path,
+      bytes: (await stat(filePath)).size,
+      sha256: await fileSha256(filePath)
+    });
+  }
+  const manifest = {
+    schemaVersion: 3,
+    kind: "traces.session_bundle",
+    createdAt: generatedAt,
+    provenance: {
+      // The id the session recorded; a file named on the command line is its own ref.
+      sessionId: own?.sessionId ?? ref.sessionId,
+      harness: ref.harness,
+      cwd,
+      transcriptPath: resolve(ref.path),
+      transcriptSha256,
+      tracesVersion: tracesVersion(),
+      sessionWindow: { firstRecordAt, lastRecordAt, padMs: SESSION_WINDOW_PAD_MS }
+    },
+    files,
+    absent
+  };
+  const manifestPath = join(outDir, "manifest.json");
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return { directory: outDir, manifestPath, manifest };
+}
+async function readBundleFileList(bundleDir) {
+  const path = join(bundleDir, "manifest.json");
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      throw new Error(`no manifest.json at ${path} \u2014 ${bundleDir} is not a traces session bundle`);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const manifest = parsed;
+  if (manifest?.kind !== "traces.session_bundle") {
+    throw new Error(`${path} has kind ${JSON.stringify(manifest?.kind)}, expected "traces.session_bundle"`);
+  }
+  if (manifest.schemaVersion !== 3 && manifest.schemaVersion !== 2) {
+    throw new Error(`${path} is bundle schemaVersion ${JSON.stringify(manifest.schemaVersion)}; this traces reads 2 and 3`);
+  }
+  if (!Array.isArray(manifest.files)) throw new Error(`${path} lists no files`);
+  return manifest.files;
+}
+function unsafeBundlePath(path) {
+  if (path.length === 0) return "empty path";
+  if (path.includes("\\")) return "contains a backslash";
+  if (path.startsWith("/") || /^[A-Za-z]:/.test(path)) return "is absolute";
+  if (path.split("/").some((part) => part === ".." || part === "." || part === "")) {
+    return 'has an empty, "." or ".." segment';
+  }
+  return null;
+}
+async function nonRegularEntries(root) {
+  const out = [];
+  const pending = [resolve(root)];
+  while (pending.length > 0) {
+    const dir = pending.pop();
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) pending.push(path);
+      else if (!entry.isFile()) out.push(relative(resolve(root), path).split(sep).join("/"));
+    }
+  }
+  return out.sort();
+}
+async function verifySessionBundle(bundleDir) {
+  const directory = resolve(bundleDir);
+  const listedFiles = await readBundleFileList(directory);
+  const issues = [];
+  const listed = /* @__PURE__ */ new Set();
+  let matched = 0;
+  for (const file of listedFiles) {
+    const unsafe = unsafeBundlePath(file.path);
+    if (unsafe) {
+      issues.push({ kind: "unsafe-path", path: file.path, detail: `manifest path ${unsafe}` });
+      continue;
+    }
+    listed.add(file.path);
+    const info = await lstat(join(directory, file.path)).catch((error) => {
+      if (isMissingPathError(error)) return null;
+      throw error;
+    });
+    if (!info) {
+      issues.push({ kind: "missing", path: file.path, detail: "listed in the manifest, not on disk" });
+      continue;
+    }
+    if (!info.isFile()) continue;
+    const sha256 = await fileSha256(join(directory, file.path));
+    if (info.size !== file.bytes || sha256 !== file.sha256) {
+      issues.push({
+        kind: "mismatch",
+        path: file.path,
+        detail: `recorded ${file.bytes} bytes sha256 ${file.sha256}, found ${info.size} bytes sha256 ${sha256}`
+      });
+      continue;
+    }
+    matched += 1;
+  }
+  for (const path of await listBundleFiles(directory)) {
+    if (path === "manifest.json" || listed.has(path)) continue;
+    issues.push({ kind: "unexpected", path, detail: "on disk, not listed in the manifest" });
+  }
+  for (const path of await nonRegularEntries(directory)) {
+    issues.push({ kind: "not-a-file", path, detail: "a symbolic link or special file; a bundle holds regular files only" });
+  }
+  return { ok: issues.length === 0, directory, listed: listedFiles.length, matched, issues };
+}
+
+export {
+  collectSessionSelection,
+  assembleSessionBundle,
+  verifySessionBundle
+};