@mmerterden/multi-agent-pipeline 20.24.0 → 20.25.0

package/pipeline/scripts/transcript-index.mjs

@@ -7,7 +7,10 @@
  * session actually did on the way: which tool calls it repeated, where it sat
  * waiting, where the context was compacted, which subagent failed, what was
  * denied. This reads a Claude Code session file (`<session>.jsonl`, plus the
- * subagent files beside it) and extracts those facts deterministically, so the
+ * subagent files beside it), a Copilot CLI session log
+ * (`session-state/<session>/events.jsonl`) or a Codex rollout
+ * (`sessions/YYYY/MM/DD/rollout-*.jsonl`), detecting the format per file
+ * (_transcript-hosts.mjs), and extracts those facts deterministically, so the
  * same transcript always gives the same index and every finding carries the
  * `file:line` it came from. Interpreting them is left to the model that writes
  * the post-mortem (/multi-agent:postmortem); nothing here guesses.
@@ -46,7 +49,10 @@
  *   options: --json  --no-subagents  --max-mb N  --max-events N
  *            --loop-threshold N  --stall-minutes N  --excerpt N
  *
- * TRANSCRIPTS_ROOT overrides ~/.claude/projects, LOGS_ROOT the run log root.
+ * TRANSCRIPTS_ROOT overrides ~/.claude/projects, COPILOT_TRANSCRIPTS_ROOT
+ * ~/.copilot/session-state (else $COPILOT_HOME/session-state),
+ * CODEX_TRANSCRIPTS_ROOT ~/.codex/sessions (else $CODEX_HOME/sessions), and
+ * LOGS_ROOT the run log root.
  *
  * Exit codes: 0 indexed | 2 usage | 3 nothing to read | 4 redaction guard
  *
@@ -58,6 +64,7 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { readJsonl } from "./_jsonl.mjs";
+import { createAdapter, detectFormat, sessionCwd } from "./_transcript-hosts.mjs";
 import { redactCredentials, scrubCounted } from "./_redact.mjs";
 import { listRuns, logsRoot, taskIdVariants } from "./_run-paths.mjs";
 import { redact } from "../lib/redact.mjs";
@@ -75,7 +82,8 @@ export const DEFAULTS = {
   subagents: true,
 };
 
-const SUBAGENT_TOOLS = new Set(["Agent", "Task"]);
+const SUBAGENT_TOOLS = new Set(["Agent", "Task", "task", "spawn_agent"]);
+const SKILL_TOOL = /^skill$/i;
 const DENIAL =
   /doesn't want to proceed|User rejected tool use|^Permission to use \S+ (?:has been|was) denied|permission denied by the user/i;
 const HOOK_BLOCK = /\bhook (?:error|blocked)|PreToolUse:|PostToolUse:/;
@@ -84,6 +92,33 @@ const INTERRUPT = /^\[Request interrupted by user/;
 export const defaultProjectsRoot = () =>
   process.env.TRANSCRIPTS_ROOT || join(homedir(), ".claude", "projects");
 
+export const defaultCopilotRoot = () =>
+  process.env.COPILOT_TRANSCRIPTS_ROOT ||
+  join(process.env.COPILOT_HOME || join(homedir(), ".copilot"), "session-state");
+
+export const defaultCodexRoot = () =>
+  process.env.CODEX_TRANSCRIPTS_ROOT ||
+  join(process.env.CODEX_HOME || join(homedir(), ".codex"), "sessions");
+
+export { detectFormat };
+
+const COPILOT_LOG = "events.jsonl";
+
+const CODEX_NAME = /^rollout-[\dT:-]+-([0-9a-f]{8})[0-9a-f-]*\.jsonl$/i;
+
+/**
+ * The name a file is cited by. Every Copilot CLI log is `events.jsonl`, so it
+ * is prefixed with the first eight characters of its session directory; a
+ * Codex rollout name carries its start time and full session id, so it is cut
+ * to `rollout-<first eight of the id>.jsonl`. Claude Code names stay as they are.
+ */
+export function displayName(path) {
+  const name = basename(path);
+  if (name === COPILOT_LOG) return `${basename(dirname(path)).slice(0, 8)}/${name}`;
+  const codex = name.match(CODEX_NAME);
+  return codex ? `rollout-${codex[1]}.jsonl` : name;
+}
+
 /** A session id as Claude Code writes it (a UUID), or any token safe as a file name. */
 const SAFE_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
 
@@ -202,6 +237,7 @@ function inputGist(name, input) {
   if (!input || typeof input !== "object") return "";
   for (const k of [
     "command",
+    "cmd",
     "file_path",
     "path",
     "pattern",
@@ -209,6 +245,7 @@ function inputGist(name, input) {
     "query",
     "skill",
     "description",
+    "input",
   ]) {
     if (typeof input[k] === "string" && input[k]) return input[k];
   }
@@ -274,10 +311,18 @@ export async function indexTranscripts(paths, options = {}) {
   let idleGaps = 0;
 
   for (const path of expandFiles(paths, o.subagents)) {
-    const name = basename(path);
+    const name = displayName(path);
     const at = (line) => `${name}:${line}`;
     const stats = {};
-    const fileRow = { name, path: R.clean(path), sidechain: false, malformedAt: [] };
+    const fileRow = {
+      name,
+      path: R.clean(path),
+      format: null,
+      sidechain: false,
+      usagePartial: false,
+      malformedAt: [],
+    };
+    let adapt = null;
     const pending = new Map();
     const groups = new Map();
     let lastKey = null;
@@ -306,246 +351,287 @@ export async function indexTranscripts(paths, options = {}) {
         if (row.reason !== "truncated") fileRow.malformedAt.push(at(row.line));
         continue;
       }
-      const rec = row.record;
+      if (!adapt) {
+        fileRow.format = detectFormat(row.record);
+        adapt = createAdapter(fileRow.format);
+      }
       const line = row.line;
-      const ts = tsOf(rec);
-      if (rec.isSidechain) fileRow.sidechain = true;
-
-      if (ts !== null && prev && prev.ts !== null) {
-        const gap = ts - prev.ts;
-        if (gap >= stallMs) {
-          const startsTurn = rec.type === "user" && isPrompt(rec);
-          if (startsTurn && pending.size === 0) idleGaps++;
-          else {
-            const running = [...pending.values()].at(-1);
-            stalls.push({
-              from: at(prev.line),
-              to: at(line),
-              gapMs: gap,
-              pendingTool: running ? running.name : null,
-            });
+      for (const rec of adapt(row.record)) {
+        const ts = tsOf(rec);
+        if (rec.isSidechain && fileRow.format === "claude") fileRow.sidechain = true;
+
+        if (ts !== null && prev && prev.ts !== null) {
+          const gap = ts - prev.ts;
+          if (gap >= stallMs) {
+            const startsTurn = rec.type === "user" && isPrompt(rec);
+            if (startsTurn && pending.size === 0) idleGaps++;
+            else {
+              const running = [...pending.values()].at(-1);
+              stalls.push({
+                from: at(prev.line),
+                to: at(line),
+                gapMs: gap,
+                pendingTool: running ? running.name : null,
+              });
+            }
           }
         }
-      }
-      if (ts !== null) prev = { ts, line };
-      if (turn && ts !== null) turn.lastTs = ts;
-
-      if (rec.type === "system") {
-        if (rec.subtype === "compact_boundary") {
-          const m = rec.compactMetadata || {};
-          compactions.push({
-            at: at(line),
-            kind: "boundary",
-            trigger: R.clean(m.trigger || "unknown"),
-            preTokens: numberOr(m.preTokens, null),
-            postTokens: numberOr(m.postTokens, null),
-          });
-          push({ at: at(line), role: "system", kind: "compaction" });
-        } else if (rec.subtype === "turn_duration") {
-          if (turn) turn.durationMs = numberOr(rec.durationMs, null);
-        } else if (Array.isArray(rec.hookErrors) && rec.hookErrors.length) {
-          errors.push({ at: at(line), kind: "hook", tool: null, text: ex(textOf(rec.hookErrors)) });
-          if (turn) turn.errors++;
-        } else if (rec.level === "error") {
-          errors.push({ at: at(line), kind: "system", tool: null, text: ex(rec.content) });
-          if (turn) turn.errors++;
+        if (ts !== null) prev = { ts, line };
+        if (turn && ts !== null) turn.lastTs = ts;
+
+        if (rec.type === "x-usage") {
+          const add = rec.usage || {};
+          for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+            const n = numberOr(add[key]);
+            usage[key] += n;
+            if (turn && rec.inTurn) turn.usage[key] += n;
+          }
+          if (rec.countsMessage) usage.messages++;
+          if (turn && rec.inTurn) {
+            const ctx = numberOr(add.input) + numberOr(add.cacheRead) + numberOr(add.cacheWrite);
+            if (ctx > turn.usage.peakContext) turn.usage.peakContext = ctx;
+          }
+          continue;
         }
-        continue;
-      }
 
-      if (rec.type === "user") {
-        const content = rec.message?.content;
-        if (rec.isCompactSummary) {
-          compactions.push({ at: at(line), kind: "summary" });
+        if (rec.type === "system") {
+          if (rec.subtype === "compact_boundary") {
+            const m = rec.compactMetadata || {};
+            compactions.push({
+              at: at(line),
+              kind: "boundary",
+              trigger: R.clean(m.trigger || "unknown"),
+              preTokens: numberOr(m.preTokens, null),
+              postTokens: numberOr(m.postTokens, null),
+            });
+            push({ at: at(line), role: "system", kind: "compaction" });
+          } else if (rec.subtype === "turn_duration") {
+            if (turn) turn.durationMs = numberOr(rec.durationMs, null);
+          } else if (Array.isArray(rec.hookErrors) && rec.hookErrors.length) {
+            errors.push({
+              at: at(line),
+              kind: "hook",
+              tool: null,
+              text: ex(textOf(rec.hookErrors)),
+            });
+            if (turn) turn.errors++;
+          } else if (rec.level === "error") {
+            errors.push({ at: at(line), kind: "system", tool: null, text: ex(rec.content) });
+            if (turn) turn.errors++;
+          }
           continue;
         }
-        if (Array.isArray(content) && content.some((b) => b?.type === "tool_result")) {
-          let first = true;
-          for (const b of content) {
-            if (b?.type !== "tool_result") continue;
-            const call = pending.get(b.tool_use_id);
-            pending.delete(b.tool_use_id);
-            const result = first && rec.toolUseResult !== undefined ? rec.toolUseResult : undefined;
-            first = false;
-            const body = textOf(b.content) || (typeof result === "string" ? result : "");
-            const denied = DENIAL.test(body) || (typeof result === "string" && DENIAL.test(result));
-            const isError = b.is_error === true || denied;
-            if (call) {
-              call.resultAt = at(line);
-              call.isError = isError;
-              const reported =
-                result && typeof result === "object"
-                  ? (result.durationMs ?? result.totalDurationMs)
-                  : undefined;
-              if (Number.isFinite(reported)) {
-                call.durationMs = reported;
-                call.durationSource = "reported";
-              } else if (call.ts !== null && ts !== null) {
-                call.durationMs = ts - call.ts;
-                call.durationSource = "timestamps";
-              }
-              if (call.group) call.group.errors += isError ? 1 : 0;
-              const sub = subagentByToolId.get(b.tool_use_id);
-              if (sub) {
-                sub.resultAt = at(line);
-                if (result && typeof result === "object") {
-                  sub.status = R.clean(result.status || (isError ? "error" : "completed"));
-                  if (result.agentId) subagentByAgentId.set(String(result.agentId), sub);
-                  if (Number.isFinite(result.totalDurationMs))
-                    sub.durationMs = result.totalDurationMs;
-                  if (Number.isFinite(result.totalTokens)) sub.tokens = result.totalTokens;
-                  if (Number.isFinite(result.totalToolUseCount))
-                    sub.toolUses = result.totalToolUseCount;
-                } else {
-                  sub.status = isError ? "error" : "completed";
+
+        if (rec.type === "user") {
+          const content = rec.message?.content;
+          if (rec.isCompactSummary) {
+            compactions.push({ at: at(line), kind: "summary" });
+            continue;
+          }
+          if (Array.isArray(content) && content.some((b) => b?.type === "tool_result")) {
+            let first = true;
+            for (const b of content) {
+              if (b?.type !== "tool_result") continue;
+              const call = pending.get(b.tool_use_id);
+              pending.delete(b.tool_use_id);
+              const result =
+                first && rec.toolUseResult !== undefined ? rec.toolUseResult : undefined;
+              first = false;
+              const body = textOf(b.content) || (typeof result === "string" ? result : "");
+              const denied =
+                b.denied === true ||
+                DENIAL.test(body) ||
+                (typeof result === "string" && DENIAL.test(result));
+              const isError = b.is_error === true || denied;
+              if (call) {
+                call.resultAt = at(line);
+                call.isError = isError;
+                const reported =
+                  result && typeof result === "object"
+                    ? (result.durationMs ?? result.totalDurationMs)
+                    : undefined;
+                if (Number.isFinite(reported)) {
+                  call.durationMs = reported;
+                  call.durationSource = "reported";
+                } else if (call.ts !== null && ts !== null) {
+                  call.durationMs = ts - call.ts;
+                  call.durationSource = "timestamps";
+                }
+                if (call.group) call.group.errors += isError ? 1 : 0;
+                const sub = subagentByToolId.get(b.tool_use_id);
+                if (sub) {
+                  sub.resultAt = at(line);
+                  if (result && typeof result === "object") {
+                    sub.status = R.clean(result.status || (isError ? "error" : "completed"));
+                    if (result.agentId) subagentByAgentId.set(String(result.agentId), sub);
+                    if (Number.isFinite(result.totalDurationMs))
+                      sub.durationMs = result.totalDurationMs;
+                    if (Number.isFinite(result.totalTokens)) sub.tokens = result.totalTokens;
+                    if (Number.isFinite(result.totalToolUseCount))
+                      sub.toolUses = result.totalToolUseCount;
+                  } else {
+                    sub.status = isError ? "error" : "completed";
+                  }
+                  if (
+                    !sub.durationMs &&
+                    call.durationMs !== undefined &&
+                    sub.status !== "async_launched"
+                  )
+                    sub.durationMs = call.durationMs;
+                  sub.result = ex(body);
                 }
-                if (
-                  !sub.durationMs &&
-                  call.durationMs !== undefined &&
-                  sub.status !== "async_launched"
-                )
-                  sub.durationMs = call.durationMs;
-                sub.result = ex(body);
+              }
+              if (isError) {
+                const kind = denied ? "denial" : HOOK_BLOCK.test(body) ? "hook" : "error";
+                errors.push({ at: at(line), kind, tool: call ? call.name : null, text: ex(body) });
+                if (turn) turn.errors++;
+                push({ at: at(line), role: "user", kind, name: call ? call.name : null });
               }
             }
-            if (isError) {
-              const kind = denied ? "denial" : HOOK_BLOCK.test(body) ? "hook" : "error";
-              errors.push({ at: at(line), kind, tool: call ? call.name : null, text: ex(body) });
-              if (turn) turn.errors++;
-              push({ at: at(line), role: "user", kind, name: call ? call.name : null });
-            }
+            continue;
           }
-          continue;
-        }
 
-        const text = textOf(content);
-        if (rec.isSidechain) continue;
-        const notice = text.match(/<task-notification>([\s\S]*?)<\/task-notification>/);
-        if (notice) {
-          const id = (notice[1].match(/<task-id>([^<]+)<\/task-id>/) || [])[1];
-          const status = (notice[1].match(/<status>([^<]+)<\/status>/) || [])[1];
-          const sub = id ? subagentByAgentId.get(id.trim()) : null;
-          if (sub) {
-            sub.notifiedAt = at(line);
-            if (status) sub.status = R.clean(status.trim());
+          const text = textOf(content);
+          if (rec.isSidechain) continue;
+          const notice = text.match(/<task-notification>([\s\S]*?)<\/task-notification>/);
+          if (notice) {
+            const id = (notice[1].match(/<task-id>([^<]+)<\/task-id>/) || [])[1];
+            const status = (notice[1].match(/<status>([^<]+)<\/status>/) || [])[1];
+            const sub = id ? subagentByAgentId.get(id.trim()) : null;
+            if (sub) {
+              sub.notifiedAt = at(line);
+              if (status) sub.status = R.clean(status.trim());
+              const st = rec.subagentStats;
+              if (st) {
+                if (Number.isFinite(st.tokens)) sub.tokens = st.tokens;
+                if (Number.isFinite(st.durationMs)) sub.durationMs = st.durationMs;
+                if (Number.isFinite(st.toolUses)) sub.toolUses = st.toolUses;
+              }
+            }
+            push({ at: at(line), role: "user", kind: "notification", text: ex(status || "") });
+            continue;
           }
-          push({ at: at(line), role: "user", kind: "notification", text: ex(status || "") });
-          continue;
-        }
-        if (INTERRUPT.test(text)) {
-          errors.push({ at: at(line), kind: "interrupt", tool: null, text: ex(text) });
-          if (turn) turn.errors++;
-          push({ at: at(line), role: "user", kind: "interrupt" });
-          continue;
-        }
-        if (rec.isMeta) continue;
-        const command = text.match(/<command-name>\s*([^<\s]+)\s*<\/command-name>/);
-        if (command) {
-          const cmd = R.clean(command[1]);
-          invocations.push({ at: at(line), kind: "command", name: cmd });
-          openTurn(line, ts, cmd);
-          push({ at: at(line), role: "user", kind: "command", name: cmd });
+          if (INTERRUPT.test(text)) {
+            errors.push({ at: at(line), kind: "interrupt", tool: null, text: ex(text) });
+            if (turn) turn.errors++;
+            push({ at: at(line), role: "user", kind: "interrupt" });
+            continue;
+          }
+          if (rec.isMeta) continue;
+          const command = text.match(/<command-name>\s*([^<\s]+)\s*<\/command-name>/);
+          if (command) {
+            const cmd = R.clean(command[1]);
+            invocations.push({ at: at(line), kind: "command", name: cmd });
+            openTurn(line, ts, cmd);
+            push({ at: at(line), role: "user", kind: "command", name: cmd });
+            continue;
+          }
+          if (!text.trim()) continue;
+          const prompt = ex(text);
+          openTurn(line, ts, prompt);
+          push({ at: at(line), role: "user", kind: "prompt", text: prompt });
           continue;
         }
-        if (!text.trim()) continue;
-        const prompt = ex(text);
-        openTurn(line, ts, prompt);
-        push({ at: at(line), role: "user", kind: "prompt", text: prompt });
-        continue;
-      }
 
-      if (rec.type === "assistant") {
-        const msg = rec.message || {};
-        if (!turn && !rec.isSidechain) openTurn(line, ts, null);
-        if (turn) turn.assistantMessages++;
-        const u = msg.usage;
-        if (u && !(msg.id && seenMessages.has(msg.id))) {
-          if (msg.id) seenMessages.add(msg.id);
-          const add = {
-            input: numberOr(u.input_tokens),
-            output: numberOr(u.output_tokens),
-            cacheRead: numberOr(u.cache_read_input_tokens),
-            cacheWrite: numberOr(u.cache_creation_input_tokens),
-          };
-          for (const k of Object.keys(add)) usage[k] += add[k];
-          usage.messages++;
-          if (turn) {
-            for (const k of Object.keys(add)) turn.usage[k] += add[k];
-            const ctx = add.input + add.cacheRead + add.cacheWrite;
-            if (ctx > turn.usage.peakContext) turn.usage.peakContext = ctx;
-          }
-        }
-        if (rec.isApiErrorMessage) {
-          errors.push({
-            at: at(line),
-            kind: "api-error",
-            tool: null,
-            text: ex(textOf(msg.content)),
-          });
-          if (turn) turn.errors++;
-        }
-        for (const b of Array.isArray(msg.content) ? msg.content : []) {
-          if (b?.type === "text" && b.text?.trim()) {
-            push({ at: at(line), role: "assistant", kind: "text", text: ex(b.text) });
-            continue;
+        if (rec.type === "assistant") {
+          const msg = rec.message || {};
+          if (!turn && !rec.isSidechain) openTurn(line, ts, null);
+          if (turn) turn.assistantMessages++;
+          const u = msg.usage;
+          if (u && !(msg.id && seenMessages.has(msg.id))) {
+            if (msg.id) seenMessages.add(msg.id);
+            const add = {
+              input: numberOr(u.input_tokens),
+              output: numberOr(u.output_tokens),
+              cacheRead: numberOr(u.cache_read_input_tokens),
+              cacheWrite: numberOr(u.cache_creation_input_tokens),
+            };
+            for (const k of Object.keys(add)) usage[k] += add[k];
+            usage.messages++;
+            if (turn) {
+              for (const k of Object.keys(add)) turn.usage[k] += add[k];
+              const ctx = add.input + add.cacheRead + add.cacheWrite;
+              if (ctx > turn.usage.peakContext) turn.usage.peakContext = ctx;
+            }
           }
-          if (b?.type !== "tool_use") continue;
-          const toolName = R.clean(b.name || "unknown");
-          const input = b.input || {};
-          const key = `${b.name}\u0000${stable(input)}`;
-          let group = groups.get(key);
-          if (!group) {
-            group = { name: toolName, hash: digest(key), at: [], errors: 0, consecutive: 0 };
-            group.input = ex(inputGist(b.name, input));
-            groups.set(key, group);
+          if (rec.isApiErrorMessage) {
+            errors.push({
+              at: at(line),
+              kind: "api-error",
+              tool: null,
+              text: ex(textOf(msg.content)),
+            });
+            if (turn) turn.errors++;
           }
-          group.at.push(at(line));
-          streak = key === lastKey ? streak + 1 : 1;
-          lastKey = key;
-          if (streak > group.consecutive) group.consecutive = streak;
-          const call = {
-            at: at(line),
-            name: toolName,
-            input: group.input,
-            ts,
-            durationMs: undefined,
-            durationSource: null,
-            resultAt: null,
-            isError: false,
-            group,
-          };
-          toolCalls.push(call);
-          if (b.id) pending.set(b.id, call);
-          if (turn) turn.toolCalls++;
-          push({ at: at(line), role: "assistant", kind: "tool", name: toolName, text: call.input });
-
-          if (SUBAGENT_TOOLS.has(b.name)) {
-            const sub = {
+          for (const b of Array.isArray(msg.content) ? msg.content : []) {
+            if (b?.type === "text" && b.text?.trim()) {
+              push({ at: at(line), role: "assistant", kind: "text", text: ex(b.text) });
+              continue;
+            }
+            if (b?.type !== "tool_use") continue;
+            const toolName = R.clean(b.name || "unknown");
+            const input = b.input || {};
+            const key = `${b.name}\u0000${stable(input)}`;
+            let group = groups.get(key);
+            if (!group) {
+              group = { name: toolName, hash: digest(key), at: [], errors: 0, consecutive: 0 };
+              group.input = ex(inputGist(b.name, input));
+              groups.set(key, group);
+            }
+            group.at.push(at(line));
+            streak = key === lastKey ? streak + 1 : 1;
+            lastKey = key;
+            if (streak > group.consecutive) group.consecutive = streak;
+            const call = {
               at: at(line),
-              agentType: R.clean(input.subagent_type || "general-purpose"),
-              description: ex(input.description || ""),
-              background: input.run_in_background === true,
-              model: input.model ? R.clean(input.model) : null,
-              status: null,
+              name: toolName,
+              input: group.input,
+              ts,
+              durationMs: undefined,
+              durationSource: null,
               resultAt: null,
-              notifiedAt: null,
-              durationMs: null,
-              tokens: null,
-              toolUses: null,
-              result: null,
+              isError: false,
+              group,
             };
-            subagents.push(sub);
-            if (b.id) subagentByToolId.set(b.id, sub);
-          }
-          if (b.name === "Skill" && (input.skill || input.command)) {
-            invocations.push({
+            toolCalls.push(call);
+            if (b.id) pending.set(b.id, call);
+            if (turn) turn.toolCalls++;
+            push({
               at: at(line),
-              kind: "skill",
-              name: R.clean(input.skill || input.command),
+              role: "assistant",
+              kind: "tool",
+              name: toolName,
+              text: call.input,
             });
-          }
-          if (b.name === "SlashCommand" && input.command) {
-            invocations.push({ at: at(line), kind: "command", name: R.clean(input.command) });
+
+            if (SUBAGENT_TOOLS.has(b.name)) {
+              const sub = {
+                at: at(line),
+                agentType: R.clean(input.subagent_type || input.agent_type || "general-purpose"),
+                description: ex(input.description || input.message || ""),
+                background: input.run_in_background === true || input.mode === "background",
+                model: input.model ? R.clean(input.model) : null,
+                status: null,
+                resultAt: null,
+                notifiedAt: null,
+                durationMs: null,
+                tokens: null,
+                toolUses: null,
+                result: null,
+              };
+              subagents.push(sub);
+              if (b.id) subagentByToolId.set(b.id, sub);
+            }
+            if (SKILL_TOOL.test(b.name || "") && (input.skill || input.command)) {
+              invocations.push({
+                at: at(line),
+                kind: "skill",
+                name: R.clean(input.skill || input.command),
+              });
+            }
+            if (b.name === "SlashCommand" && input.command) {
+              invocations.push({ at: at(line), kind: "command", name: R.clean(input.command) });
+            }
           }
         }
       }
@@ -564,6 +650,7 @@ export async function indexTranscripts(paths, options = {}) {
         });
       }
     }
+    fileRow.usagePartial = Boolean(adapt?.usagePartial?.());
     fileRow.lines = stats.lines;
     fileRow.malformed = stats.malformed;
     fileRow.oversized = stats.oversized;
@@ -603,7 +690,7 @@ export async function indexTranscripts(paths, options = {}) {
       errors: errors.length,
       malformedLines: files.reduce((a, f) => a + f.malformed, 0),
     },
-    usage,
+    usage: { ...usage, partial: files.some((f) => f.usagePartial) },
     turns,
     loops,
     stalls,
@@ -685,22 +772,99 @@ async function windowMatches(dirs, start, end) {
   return files;
 }
 
+/** Every Copilot CLI session log under `root` (`<session>/events.jsonl`). */
+function copilotLogs(root) {
+  let dirs;
+  try {
+    dirs = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return dirs
+    .filter((e) => e.isDirectory())
+    .map((e) => join(root, e.name, COPILOT_LOG))
+    .filter((p) => existsSync(p))
+    .sort();
+}
+
+const CODEX_ROLLOUT = /^rollout-.*\.jsonl$/;
+
+/** Every Codex rollout under `root` (`YYYY/MM/DD/rollout-*.jsonl`), at most four levels down. */
+function codexRollouts(root, depth = 0) {
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    const p = join(root, e.name);
+    if (e.isDirectory() && depth < 3) out.push(...codexRollouts(p, depth + 1));
+    else if (e.isFile() && CODEX_ROLLOUT.test(e.name)) out.push(p);
+  }
+  return out.sort();
+}
+
+/** The first timestamp and the starting cwd of a Copilot CLI or Codex session. */
+async function sessionHead(path) {
+  let first = null;
+  let cwd = null;
+  let seen = 0;
+  for await (const row of readJsonl(path, { maxBytes: 1024 * 1024 })) {
+    if (!row.record) continue;
+    if (first === null) first = tsOf(row.record);
+    cwd = cwd ?? sessionCwd(row.record);
+    if ((first !== null && cwd !== null) || ++seen >= 8) break;
+  }
+  return { first, cwd };
+}
+
+const samePath = (p) => String(p).replace(/\/+$/, "");
+
+async function hostWindowMatches(paths, cwds, start, end) {
+  const files = [];
+  for (const p of paths) {
+    let mtime;
+    try {
+      mtime = statSync(p).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (mtime < start) continue;
+    const head = await sessionHead(p);
+    if (head.first === null || head.first > end) continue;
+    if (head.cwd === null || !cwds.has(samePath(head.cwd))) continue;
+    files.push(p);
+  }
+  return files;
+}
+
 /**
- * The session files a run ran in.
+ * The session files a run ran in, across Claude Code, Copilot CLI and Codex.
  *
  * A run launched with a session id (continuous mode, a client that set
  * MULTI_AGENT_SESSION_ID) has it recorded in agent-state.json, and the file is
- * `<sessionId>.jsonl` in whichever project directory holds it. An attended run
- * records none, so the fallback is the sessions whose working directory was
- * the worktree or the main checkout and whose time span overlaps the run's:
- * started before the run finished, last written after it started. That match
- * is a heuristic and is reported as `time-window`.
+ * `<sessionId>.jsonl` in whichever Claude Code project directory holds it,
+ * `<sessionId>/events.jsonl` under Copilot CLI's session-state, or the Codex
+ * rollout whose name ends in `-<sessionId>.jsonl`. An attended run records
+ * none, so the fallback is the sessions whose working directory was the
+ * worktree or the main checkout and whose time span overlaps the run's:
+ * started before the run finished, last written after it started. Claude Code
+ * keys its directories by the working directory; Copilot CLI and Codex record
+ * it in the session's opening record. That match is a heuristic and is
+ * reported as `time-window`.
  *
  * @returns {Promise<{taskId:string|null, runDir:string|null, matchedBy:"session"|"time-window"|null, files:string[], reason?:string}>}
  */
 export async function findRunTranscripts(
   id,
-  { logsRoot: root = logsRoot(), projectsRoot = defaultProjectsRoot() } = {},
+  {
+    logsRoot: root = logsRoot(),
+    projectsRoot = defaultProjectsRoot(),
+    copilotRoot = defaultCopilotRoot(),
+    codexRoot = defaultCodexRoot(),
+  } = {},
 ) {
   const hit = locateRun(id, root);
   if (!hit)
@@ -715,17 +879,24 @@ export async function findRunTranscripts(
   const base = { taskId: doc.taskId || hit.run.taskId, runDir: hit.run.dir };
   const none = (reason) => ({ ...base, matchedBy: null, files: [], reason });
 
-  let projectDirs;
+  let projectDirs = [];
   try {
     projectDirs = readdirSync(projectsRoot).map((d) => join(projectsRoot, d));
   } catch {
-    return none("no transcript directory");
+    // No Claude Code transcripts on this machine; the other hosts may have some.
   }
+  const copilot = copilotLogs(copilotRoot);
+  const codex = codexRollouts(codexRoot);
+  if (!projectDirs.length && !copilot.length && !codex.length)
+    return none("no transcript directory");
 
   if (typeof doc.sessionId === "string" && SAFE_SESSION_ID.test(doc.sessionId)) {
-    const files = projectDirs
-      .map((d) => join(d, `${doc.sessionId}.jsonl`))
-      .filter((p) => existsSync(p));
+    const sid = doc.sessionId;
+    const files = [
+      ...projectDirs.map((d) => join(d, `${sid}.jsonl`)).filter((p) => existsSync(p)),
+      ...copilot.filter((p) => basename(dirname(p)) === sid),
+      ...codex.filter((p) => basename(p).endsWith(`-${sid}.jsonl`)),
+    ];
     if (files.length) return { ...base, matchedBy: "session", files };
   }
 
@@ -741,12 +912,16 @@ export async function findRunTranscripts(
   const cwds = [doc.worktreePath, doc.projectRoot];
   for (const p of Array.isArray(doc.projects) ? doc.projects : [])
     cwds.push(p?.worktreePath, p?.projectRoot);
-  const slugs = new Set(cwds.filter((c) => typeof c === "string" && c).map(projectSlug));
+  const known = cwds.filter((c) => typeof c === "string" && c);
+  const slugs = new Set(known.map(projectSlug));
   const dirs = projectDirs.filter((d) => slugs.has(basename(d)));
-  if (!Number.isFinite(start) || !dirs.length)
+  if (!Number.isFinite(start) || (!dirs.length && !copilot.length && !codex.length))
     return none("no session id recorded and no transcript directory for the run's checkout");
 
-  const files = await windowMatches(dirs, start, end);
+  const files = [
+    ...(await windowMatches(dirs, start, end)),
+    ...(await hostWindowMatches([...copilot, ...codex], new Set(known.map(samePath)), start, end)),
+  ];
   return files.length
     ? { ...base, matchedBy: "time-window", files }
     : none("no session overlaps the run's time window");
@@ -781,7 +956,10 @@ export function renderIndex(idx) {
       `${c.malformedLines} malformed line(s) skipped, redacted ${idx.redaction.total} item(s)${by ? ` (${by})` : ""}`,
   );
   L.push(
-    `usage: in ${k(idx.usage.input)} / out ${k(idx.usage.output)} / cache read ${k(idx.usage.cacheRead)} / cache write ${k(idx.usage.cacheWrite)} over ${idx.usage.messages} message(s)`,
+    `usage: in ${k(idx.usage.input)} / out ${k(idx.usage.output)} / cache read ${k(idx.usage.cacheRead)} / cache write ${k(idx.usage.cacheWrite)} over ${idx.usage.messages} message(s)` +
+      (idx.usage.partial
+        ? " - partial: a Copilot CLI session wrote no session.shutdown record, so only its output tokens are counted"
+        : ""),
   );
   L.push("", "files");
   for (const f of idx.files) {
@@ -791,8 +969,11 @@ export function renderIndex(idx) {
       f.oversized ? `oversized ${f.oversized}` : null,
       f.truncated ? "truncated at the byte cap" : null,
       f.unreadable ? "unreadable" : null,
+      f.usagePartial ? "usage partial (no session.shutdown)" : null,
     ].filter(Boolean);
-    L.push(`  ${f.name}  ${f.lines} lines${flags.length ? `  ${flags.join("  ")}` : ""}`);
+    L.push(
+      `  ${f.name}  ${f.format ?? "empty"}  ${f.lines} lines${flags.length ? `  ${flags.join("  ")}` : ""}`,
+    );
   }
   L.push("", `turns (${idx.turns.length})`);
   idx.turns.forEach((t, i) => {
@@ -821,7 +1002,7 @@ export function renderIndex(idx) {
   for (const m of idx.compactions)
     L.push(
       m.kind === "boundary"
-        ? `  ${m.at}  ${m.trigger}  ${k(m.preTokens ?? 0)} -> ${k(m.postTokens ?? 0)} tokens`
+        ? `  ${m.at}  ${m.trigger}  ${m.preTokens === null ? "?" : k(m.preTokens)} -> ${m.postTokens === null ? "?" : k(m.postTokens)} tokens`
         : `  ${m.at}  summary turn`,
     );
   L.push("", `subagents (${idx.subagents.length})`);
@@ -913,7 +1094,7 @@ async function main() {
         taskId: run.taskId ? R.clean(run.taskId) : null,
         runDir: run.runDir ? tilde(run.runDir) : null,
         matchedBy: run.matchedBy,
-        files: run.files.map((f) => basename(f)),
+        files: run.files.map((f) => displayName(f)),
         reason: run.reason ?? null,
       };
       process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);