cogpit-memory 0.2.1 → 0.3.0

package/dist/index.js

@@ -54,8 +54,526 @@ var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 var Database = import_better_sqlite3.default;
 
 // src/lib/search-index.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_fs2 = require("node:fs");
+
+// src/lib/types.ts
+var AGENT_KINDS = ["codex", "copilot", "claude"];
+
+// src/lib/agent-descriptors.ts
+var SESSION_UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var SESSION_UUID_RE = new RegExp(`^${SESSION_UUID}$`, "i");
+function encodeBase64DirName(prefix, cwd) {
+  const bytes = new TextEncoder().encode(cwd);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const encoded = btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${prefix}${encoded}`;
+}
+function decodeBase64DirName(prefix, dirName) {
+  if (!dirName.startsWith(prefix)) return null;
+  try {
+    const encoded = dirName.slice(prefix.length).replace(/-/g, "+").replace(/_/g, "/");
+    const binary = atob(encoded);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function base64DirNameCodec(prefix) {
+  return {
+    lossy: false,
+    owns: (dirName) => typeof dirName === "string" && dirName.startsWith(prefix),
+    encode: (cwd) => encodeBase64DirName(prefix, cwd),
+    decode: (dirName) => decodeBase64DirName(prefix, dirName)
+  };
+}
+function sessionIdFromJsonlName(fileName) {
+  const match = new RegExp(`(${SESSION_UUID})\\.jsonl$`, "i").exec(fileName);
+  return match ? match[1] : null;
+}
+var jsonlPathUrlCodec = {
+  urlId: (fileName) => fileName.replace(/\.jsonl$/, ""),
+  fileNameFromUrlId: (urlId) => urlId.endsWith(".jsonl") ? urlId : `${urlId}.jsonl`
+};
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function flag(name, value) {
+  return value ? [name, value] : [];
+}
+function commandCapture(command, pattern) {
+  return pattern.exec(command)?.[1] ?? null;
+}
+var ARGV_SESSION_ID = "[0-9a-f-]{36}";
+var CODEX_DIR_PREFIX = "codex__";
+var COPILOT_DIR_PREFIX = "copilot__";
+var CLAUDE_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "plan", "acceptEdits", "dontAsk", "auto"]);
+var claude = {
+  kind: "claude",
+  displayName: "Claude Code",
+  binName: "claude",
+  dirName: {
+    lossy: true,
+    // Claude has no prefix: it owns every dirName no other agent claims. The
+    // registry checks the prefixed agents first, so this is only ever reached
+    // as the terminal arm.
+    owns: (dirName) => typeof dirName === "string" && !dirName.startsWith(CODEX_DIR_PREFIX) && !dirName.startsWith(COPILOT_DIR_PREFIX),
+    /**
+     * Claude Code's own convention: every character outside `[A-Za-z0-9]`
+     * becomes `-`, so `/Users/x/proj` and `C:\Users\x\proj` both collapse into a
+     * flat name under `~/.claude/projects`.
+     */
+    encode: (cwd) => (cwd.replace(/[\\/]+$/, "") || cwd).replace(/[^a-zA-Z0-9]/g, "-"),
+    /**
+     * Best-effort inverse. The encoding is lossy — a literal `-` is
+     * indistinguishable from a separator — so a caller that can read the
+     * session's recorded `cwd` should always prefer that.
+     */
+    decode: (dirName) => {
+      const windowsDrive = /^([A-Za-z])--(.*)$/.exec(dirName);
+      if (windowsDrive) return `${windowsDrive[1]}:\\${windowsDrive[2].replace(/-/g, "\\")}`;
+      return "/" + dirName.replace(/^-/, "").replace(/-/g, "/");
+    }
+  },
+  sessionFile: {
+    name: (sessionId) => `${sessionId}.jsonl`,
+    sessionId: sessionIdFromJsonlName,
+    ...jsonlPathUrlCodec
+  },
+  metadataFromHead: true,
+  resume: {
+    command: (sessionId) => `claude --resume ${sessionId}`,
+    args: (sessionId) => ["--resume", sessionId]
+  },
+  launchArgs: {
+    permissions: (permissions) => {
+      if (!permissions?.mode) return ["--permission-mode", "default"];
+      if (permissions.mode === "bypassPermissions") return ["--dangerously-skip-permissions"];
+      return [
+        ...CLAUDE_PERMISSION_MODES.has(permissions.mode) ? ["--permission-mode", permissions.mode] : [],
+        ...(permissions.allowedTools ?? []).flatMap((tool) => ["--allowedTools", tool]),
+        ...(permissions.disallowedTools ?? []).flatMap((tool) => ["--disallowedTools", tool])
+      ];
+    },
+    model: (model) => flag("--model", model),
+    effort: (effort) => flag("--effort", effort),
+    // Claude's faster tier is a setting on the live Agent SDK query, not a flag.
+    fastTier: () => []
+  },
+  serviceTier: null,
+  cli: {
+    packageName: "@anthropic-ai/claude-code",
+    homebrew: { name: "claude-code", cask: false },
+    wingetId: null,
+    versionArgs: ["--version"],
+    selfUpdate: {
+      args: ["update"],
+      matches: (path) => path.endsWith("/.local/bin/claude") || path.endsWith("/.local/bin/claude.exe") || path.includes("/.local/share/claude/")
+    },
+    bundledBySdk: true,
+    homeDirName: ".claude",
+    homeEnvVar: null,
+    installMarker: "projects",
+    homeIsDiscoverable: false,
+    process: {
+      by: "command",
+      sessionIdFromCommand: (command) => commandCapture(command, new RegExp(`--resume(?:=|\\s+)(${ARGV_SESSION_ID})`)) ?? commandCapture(command, new RegExp(`--session-id(?:=|\\s+)(${ARGV_SESSION_ID})`))
+    }
+  },
+  config: {
+    rootDirName: ".claude",
+    instructions: [
+      { in: "scope", path: "CLAUDE.md", scopes: ["global", "project"] },
+      { in: "root", path: "CLAUDE.md", label: ".claude/CLAUDE.md", scopes: ["project"] }
+    ],
+    settings: [
+      { in: "root", path: "settings.json", scopes: ["global"] },
+      { in: "root", path: "settings.local.json", scopes: ["project"] }
+    ],
+    skillsDir: "skills",
+    agentsDir: "agents",
+    commandsDir: "commands",
+    themesDir: "themes",
+    pluginsDir: "plugins",
+    pluginManifestDir: ".claude-plugin"
+  },
+  contextWindow: {
+    // Anything not listed is treated as current-generation, so a model released
+    // after this table was written reports the larger window rather than a
+    // stale small one. Limits are LiteLLM `max_input_tokens`, the same table the
+    // cost code prices against. Deliberately not family-based: sonnet-4-5 is
+    // 200k while sonnet-4-6 is 1M.
+    defaultLimit: 1e6,
+    limits: [
+      { match: "claude-haiku-4-5", limit: 2e5 },
+      { match: "claude-haiku-4-1", limit: 2e5 },
+      { match: "claude-sonnet-4-5", limit: 2e5 },
+      { match: "claude-opus-4-5", limit: 2e5 },
+      { match: "claude-opus-4-1", limit: 2e5 }
+    ],
+    compactBuffer: 33e3,
+    extendedContext: { marker: "[1m]", limit: 1e6 }
+  },
+  capabilities: {
+    worktrees: true,
+    mcp: true,
+    slashCommands: true,
+    workflows: true,
+    agentTeams: true,
+    subagentTranscripts: true,
+    nestedSubagents: false,
+    sharing: true,
+    goals: "transcript",
+    undo: true,
+    redo: true,
+    nativeRewind: false,
+    fileCheckpoints: true,
+    reasoningEffort: true,
+    fastTier: true,
+    imageInput: true,
+    midTurnSteering: false,
+    stopSession: true,
+    ultracode: true,
+    contextWindow: true,
+    externalProcesses: false,
+    accountSwitching: true,
+    modelFallbackNotices: true,
+    autoPermissionMode: "per-model",
+    settingsApply: "live",
+    turnLiveness: "transcript",
+    tokenStreaming: true,
+    nativeFork: false,
+    namedSessions: true
+  }
+};
+var CODEX_SERVICE_TIER = {
+  appServerValue: "priority",
+  cliConfigValue: "fast"
+};
+var codex = {
+  kind: "codex",
+  displayName: "Codex",
+  binName: "codex",
+  dirName: base64DirNameCodec(CODEX_DIR_PREFIX),
+  sessionFile: {
+    /**
+     * Codex nests rollouts by local date:
+     * `YYYY/MM/DD/rollout-YYYY-MM-DDTHH-MM-SS-<sessionId>.jsonl`.
+     */
+    name: (sessionId, at = /* @__PURE__ */ new Date()) => {
+      const year = String(at.getFullYear());
+      const month = String(at.getMonth() + 1).padStart(2, "0");
+      const day = String(at.getDate()).padStart(2, "0");
+      const hour = String(at.getHours()).padStart(2, "0");
+      const minute = String(at.getMinutes()).padStart(2, "0");
+      const second = String(at.getSeconds()).padStart(2, "0");
+      return `${year}/${month}/${day}/rollout-${year}-${month}-${day}T${hour}-${minute}-${second}-${sessionId}.jsonl`;
+    },
+    sessionId: sessionIdFromJsonlName,
+    // The date nesting is unrecoverable from the id, so the URL keeps the path.
+    ...jsonlPathUrlCodec
+  },
+  // A rollout's header carries no turn count and no last user message; both
+  // only settle at the end of the file.
+  metadataFromHead: false,
+  resume: {
+    command: (sessionId, cwd) => cwd ? `codex -C ${shellQuote(cwd)} resume ${sessionId}` : `codex resume ${sessionId}`,
+    args: (sessionId) => ["resume", sessionId]
+  },
+  launchArgs: {
+    permissions: (permissions) => {
+      const mode = permissions?.mode || "default";
+      if (mode === "bypassPermissions") return ["--dangerously-bypass-approvals-and-sandbox"];
+      return [
+        "--sandbox",
+        mode === "plan" ? "read-only" : "workspace-write",
+        "-c",
+        'approval_policy="never"'
+      ];
+    },
+    model: (model) => flag("-m", model),
+    effort: (effort) => effort ? ["-c", `model_reasoning_effort=${JSON.stringify(effort)}`] : [],
+    fastTier: (enabled) => enabled ? [
+      "-c",
+      `service_tier=${JSON.stringify(CODEX_SERVICE_TIER.cliConfigValue)}`,
+      "--enable",
+      "fast_mode"
+    ] : []
+  },
+  serviceTier: CODEX_SERVICE_TIER,
+  cli: {
+    packageName: "@openai/codex",
+    homebrew: { name: "codex", cask: false },
+    wingetId: null,
+    versionArgs: ["--version"],
+    // Codex ships no self-updater; a hand-placed binary has to be replaced by
+    // whatever put it there.
+    selfUpdate: null,
+    bundledBySdk: false,
+    homeDirName: ".codex",
+    homeEnvVar: "CODEX_HOME",
+    installMarker: "",
+    homeIsDiscoverable: true,
+    process: {
+      by: "command",
+      sessionIdFromCommand: (command) => commandCapture(
+        command,
+        new RegExp(`codex(?:\\s+\\S+)*\\s+exec\\s+resume\\s+(${ARGV_SESSION_ID})`)
+      )
+    }
+  },
+  config: {
+    rootDirName: ".codex",
+    instructions: [{ in: "scope", path: "AGENTS.md", scopes: ["global", "project"] }],
+    settings: [{ in: "root", path: "config.toml", scopes: ["global", "project"] }],
+    skillsDir: "skills",
+    agentsDir: "agents",
+    commandsDir: "prompts",
+    themesDir: null,
+    pluginsDir: null,
+    pluginManifestDir: null
+  },
+  contextWindow: {
+    // The GPT-5 family window. A rollout that reports `model_context_window`
+    // overrides this; it is only the fallback for a model Cogpit has not seen.
+    defaultLimit: 272e3,
+    limits: [],
+    // Codex decides its own compaction point and never publishes a reserve.
+    compactBuffer: 0,
+    extendedContext: null
+  },
+  capabilities: {
+    worktrees: false,
+    mcp: false,
+    slashCommands: false,
+    workflows: false,
+    agentTeams: false,
+    subagentTranscripts: true,
+    nestedSubagents: true,
+    sharing: false,
+    goals: "thread-api",
+    undo: true,
+    redo: true,
+    nativeRewind: false,
+    fileCheckpoints: false,
+    reasoningEffort: true,
+    fastTier: true,
+    imageInput: true,
+    midTurnSteering: true,
+    stopSession: false,
+    ultracode: false,
+    contextWindow: false,
+    externalProcesses: false,
+    accountSwitching: false,
+    modelFallbackNotices: false,
+    autoPermissionMode: "never",
+    settingsApply: "next-turn",
+    turnLiveness: "runtime",
+    tokenStreaming: true,
+    nativeFork: false,
+    // Codex derives its own thread name.
+    namedSessions: false
+  }
+};
+var copilot = {
+  kind: "copilot",
+  displayName: "GitHub Copilot CLI",
+  binName: "copilot",
+  dirName: base64DirNameCodec(COPILOT_DIR_PREFIX),
+  sessionFile: {
+    /** Copilot keeps one directory per session: `<uuid>/events.jsonl`. */
+    name: (sessionId) => `${sessionId}/events.jsonl`,
+    sessionId: (fileName) => {
+      const match = new RegExp(`^(${SESSION_UUID})/events\\.jsonl$`, "i").exec(fileName);
+      return match ? match[1] : null;
+    },
+    // `<id>/events.jsonl` rebuilds from the id, so URLs stay short.
+    urlId: (fileName) => {
+      const match = new RegExp(`^(${SESSION_UUID})/events\\.jsonl$`, "i").exec(fileName);
+      return match ? match[1] : fileName.replace(/\.jsonl$/, "");
+    },
+    fileNameFromUrlId: (urlId) => urlId.endsWith(".jsonl") ? urlId : `${urlId}/events.jsonl`
+  },
+  metadataFromHead: true,
+  resume: {
+    command: (sessionId, cwd) => cwd ? `copilot -C ${shellQuote(cwd)} --resume ${sessionId}` : `copilot --resume ${sessionId}`,
+    args: (sessionId) => [`--resume=${sessionId}`]
+  },
+  // Cogpit launches Copilot as a stdio RPC server and configures each turn
+  // afterwards, over `session.create` and `session.setPermissionMode`. These are
+  // the flags its CLI accepts for the same settings when it is driven straight
+  // from a shell instead.
+  launchArgs: {
+    permissions: (permissions) => permissions?.mode === "bypassPermissions" || permissions?.mode === "auto" ? ["--allow-all"] : [],
+    model: (model) => flag("--model", model),
+    effort: (effort) => flag("--reasoning-effort", effort),
+    fastTier: () => []
+  },
+  serviceTier: null,
+  cli: {
+    packageName: "@github/copilot",
+    homebrew: { name: "copilot-cli", cask: true },
+    wingetId: "GitHub.Copilot",
+    versionArgs: ["--version"],
+    selfUpdate: {
+      args: ["update"],
+      // `/usr/local/bin/copilot` is also an npm prefix, so this is only ever
+      // reached after the package-manager checks have declined — which they can
+      // only do because the caller passes the realpath in as well.
+      matches: (path) => path.endsWith("/.local/bin/copilot") || path === "/usr/local/bin/copilot"
+    },
+    bundledBySdk: false,
+    homeDirName: ".copilot",
+    homeEnvVar: "COPILOT_HOME",
+    installMarker: "session-state",
+    homeIsDiscoverable: true,
+    // `copilot` is too common a word to match loosely: editor extensions and
+    // unrelated tools name it in their argv.
+    process: {
+      by: "executable",
+      sessionIdFromCommand: (command) => commandCapture(command, new RegExp(`--resume(?:=|\\s+)(${ARGV_SESSION_ID})`))
+    }
+  },
+  config: {
+    rootDirName: ".copilot",
+    // Copilot reads the same cross-CLI instruction file Codex does, so the two
+    // entries merge into one row carrying both badges.
+    instructions: [{ in: "scope", path: "AGENTS.md", scopes: ["global", "project"] }],
+    settings: [{ in: "root", path: "config.json", scopes: ["global"] }],
+    skillsDir: "skills",
+    agentsDir: null,
+    commandsDir: null,
+    themesDir: null,
+    pluginsDir: null,
+    pluginManifestDir: null
+  },
+  contextWindow: {
+    // Copilot brokers models from several vendors, so this is the smallest
+    // window any of them offers rather than a per-model table Cogpit cannot
+    // keep current.
+    defaultLimit: 2e5,
+    limits: [],
+    compactBuffer: 0,
+    extendedContext: null
+  },
+  capabilities: {
+    worktrees: false,
+    mcp: false,
+    slashCommands: false,
+    workflows: false,
+    agentTeams: false,
+    subagentTranscripts: false,
+    nestedSubagents: false,
+    sharing: false,
+    goals: false,
+    undo: true,
+    // Copilot persists no undo state of its own, so there is nothing to redo
+    // from and no branch history to show.
+    redo: false,
+    nativeRewind: true,
+    fileCheckpoints: false,
+    // Effort is only offered for models whose catalog entry advertises it.
+    reasoningEffort: false,
+    fastTier: false,
+    imageInput: false,
+    midTurnSteering: true,
+    stopSession: true,
+    ultracode: false,
+    contextWindow: false,
+    externalProcesses: true,
+    accountSwitching: false,
+    modelFallbackNotices: false,
+    autoPermissionMode: "always",
+    settingsApply: "next-turn",
+    turnLiveness: "runtime",
+    tokenStreaming: false,
+    nativeFork: true,
+    namedSessions: true
+  }
+};
+var DESCRIPTORS = Object.freeze({
+  claude,
+  codex,
+  copilot
+});
+function descriptorFor(kind) {
+  return DESCRIPTORS[kind];
+}
+function descriptorForDirName(dirName) {
+  for (const kind of AGENT_KINDS) {
+    if (kind === "claude") continue;
+    if (DESCRIPTORS[kind].dirName.owns(dirName)) return DESCRIPTORS[kind];
+  }
+  return claude;
+}
+
+// src/lib/codex-exec.ts
+var JS_SIMPLE_ESCAPES = {
+  "0": "\0",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	",
+  v: "\v"
+};
+function readJsStringLiteral(source, startIndex) {
+  const quote = source[startIndex];
+  if (quote !== '"' && quote !== "'" && quote !== "`") return null;
+  let value = "";
+  let index = startIndex + 1;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === quote) return { endIndex: index + 1, value };
+    if (char !== "\\") {
+      value += char;
+      index++;
+      continue;
+    }
+    index++;
+    if (index >= source.length) return null;
+    const escaped = source[index];
+    if (escaped in JS_SIMPLE_ESCAPES) {
+      value += JS_SIMPLE_ESCAPES[escaped];
+      index++;
+      continue;
+    }
+    if (escaped === "\n") {
+      index++;
+      continue;
+    }
+    if (escaped === "\r") {
+      index += source[index + 1] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (escaped === "x" && /^[0-9a-fA-F]{2}$/.test(source.slice(index + 1, index + 3))) {
+      value += String.fromCharCode(Number.parseInt(source.slice(index + 1, index + 3), 16));
+      index += 3;
+      continue;
+    }
+    if (escaped === "u") {
+      const braced = source.slice(index + 1).match(/^\{([0-9a-fA-F]+)\}/);
+      if (braced) {
+        const codePoint = Number.parseInt(braced[1], 16);
+        if (Number.isFinite(codePoint) && codePoint <= 1114111) {
+          value += String.fromCodePoint(codePoint);
+          index += braced[0].length + 1;
+          continue;
+        }
+      }
+      const hex = source.slice(index + 1, index + 5);
+      if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+        value += String.fromCharCode(Number.parseInt(hex, 16));
+        index += 5;
+        continue;
+      }
+    }
+    value += escaped;
+    index++;
+  }
+  return null;
+}
 
 // src/lib/messageTypeGuards.ts
 function isUserMessage(msg) {
@@ -86,6 +604,59 @@ function isCompactBoundary(msg) {
   return msg.type === "system" && msg.subtype === "compact_boundary";
 }
 
+// src/lib/sessionStats.ts
+function countToolCalls(toolCalls, counts) {
+  let errors = 0;
+  for (const tc of toolCalls) {
+    counts[tc.name] = (counts[tc.name] ?? 0) + 1;
+    if (tc.isError) errors++;
+  }
+  return errors;
+}
+function addUsageToStats(stats, usage) {
+  stats.totalInputTokens += usage.input_tokens;
+  stats.totalOutputTokens += usage.output_tokens;
+  stats.totalCacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+  stats.totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+}
+function createEmptySessionStats(turnCount) {
+  return {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheCreationTokens: 0,
+    totalCacheReadTokens: 0,
+    toolCallCounts: {},
+    errorCount: 0,
+    totalDurationMs: 0,
+    turnCount
+  };
+}
+function computeStats(turns) {
+  const stats = createEmptySessionStats(turns.length);
+  for (const turn of turns) {
+    if (turn.tokenUsage) addUsageToStats(stats, turn.tokenUsage);
+    if (turn.durationMs) stats.totalDurationMs += turn.durationMs;
+    stats.errorCount += countToolCalls(turn.toolCalls, stats.toolCallCounts);
+    for (const sa of turn.subAgentActivity) {
+      stats.errorCount += countToolCalls(sa.toolCalls, stats.toolCallCounts);
+      if (sa.tokenUsage) addUsageToStats(stats, sa.tokenUsage);
+    }
+  }
+  return stats;
+}
+function mergeTokenUsage(existing, incoming) {
+  if (!existing) return { ...incoming };
+  const thinking = (existing.output_tokens_details?.thinking_tokens ?? 0) + (incoming.output_tokens_details?.thinking_tokens ?? 0);
+  return {
+    input_tokens: existing.input_tokens + incoming.input_tokens,
+    output_tokens: existing.output_tokens + incoming.output_tokens,
+    cache_creation_input_tokens: (existing.cache_creation_input_tokens ?? 0) + (incoming.cache_creation_input_tokens ?? 0),
+    cache_read_input_tokens: (existing.cache_read_input_tokens ?? 0) + (incoming.cache_read_input_tokens ?? 0),
+    speed: incoming.speed ?? existing.speed,
+    ...existing.output_tokens_details || incoming.output_tokens_details ? { output_tokens_details: { thinking_tokens: thinking } } : {}
+  };
+}
+
 // src/lib/agentEnvelope.ts
 var ENVELOPE_RE = /<(agent-message|teammate-message)([^>]*)>([\s\S]*?)<\/\1>/g;
 var SENDER_PATTERNS = [
@@ -180,18 +751,6 @@ function mergeAttribution(current, msg) {
   }
   return merged;
 }
-function mergeTokenUsage(existing, incoming) {
-  if (!existing) {
-    return { ...incoming };
-  }
-  return {
-    input_tokens: existing.input_tokens + incoming.input_tokens,
-    output_tokens: existing.output_tokens + incoming.output_tokens,
-    cache_creation_input_tokens: (existing.cache_creation_input_tokens ?? 0) + (incoming.cache_creation_input_tokens ?? 0),
-    cache_read_input_tokens: (existing.cache_read_input_tokens ?? 0) + (incoming.cache_read_input_tokens ?? 0),
-    speed: incoming.speed ?? existing.speed
-  };
-}
 var RESUME_PREAMBLE_RE = /^This session is being continued from a previous conversation[\s\S]*?\n\nSummary:\s*\n/;
 var RESUME_INSTRUCTIONS_RE = /\n+(?:If you need specific details from before compaction|(?:Please c|C)ontinue the conversation from where it left off)[\s\S]*$/;
 function extractCompactionSummary(content) {
@@ -364,8 +923,11 @@ function findTurnStartIndices(messages) {
   }
   return starts;
 }
-function buildTurns(messages) {
+function buildTurnsWithStarts(messages) {
   const turns = [];
+  const turnStartIndices = [];
+  let pendingTurnStart = null;
+  let recordIndex = 0;
   let current = null;
   let pendingCompaction = null;
   function attachPendingCompaction(turn) {
@@ -457,10 +1019,13 @@ function buildTurns(messages) {
     }
     current.contentBlocks = groupPlanModeBlocks(current.contentBlocks);
     turns.push(current);
+    if (pendingTurnStart !== null) turnStartIndices.push(pendingTurnStart);
+    pendingTurnStart = null;
     current = null;
     agentBlockMap.clear();
   }
-  for (const msg of messages) {
+  for (recordIndex = 0; recordIndex < messages.length; recordIndex++) {
+    const msg = messages[recordIndex];
     if (isSummaryMessage(msg)) {
       finalizeTurn2();
       pendingCompaction = { summary: msg.summary };
@@ -473,6 +1038,7 @@ function buildTurns(messages) {
     }
     if (isCompactSummaryMessage(msg)) {
       finalizeTurn2();
+      pendingTurnStart = recordIndex;
       current = createTurn(msg, null);
       current.compactionSummary = extractCompactionSummary(msg.message.content);
       current.compactionMeta = pendingCompaction?.meta;
@@ -595,12 +1161,14 @@ function buildTurns(messages) {
           current.contentBlocks.push(notification);
           continue;
         }
+        pendingTurnStart = recordIndex;
         current = createTurn(msg, null);
         current.contentBlocks.push(notification);
         attachPendingCompaction(current);
         continue;
       }
       finalizeTurn2();
+      pendingTurnStart = recordIndex;
       current = createTurn(msg, msg.message.content);
       attachPendingCompaction(current);
       if (pendingRecap) {
@@ -628,6 +1196,7 @@ function buildTurns(messages) {
       };
       var flushToolCalls = flushToolCalls2, flushThinking = flushThinking2;
       if (!current) {
+        pendingTurnStart = recordIndex;
         current = createTurn(msg, null);
         attachPendingCompaction(current);
       }
@@ -831,115 +1400,290 @@ function buildTurns(messages) {
   }
   flushPendingQueuedPrompts();
   finalizeTurn2();
-  return pairAgentMessageReplies(turns);
+  return { turns: pairAgentMessageReplies(turns), turnStartIndices };
+}
+function buildTurns(messages) {
+  return buildTurnsWithStarts(messages).turns;
 }
 
-// src/lib/sessionStats.ts
-function countToolCalls(toolCalls, counts) {
-  let errors = 0;
-  for (const tc of toolCalls) {
-    counts[tc.name] = (counts[tc.name] ?? 0) + 1;
-    if (tc.isError) errors++;
+// src/lib/claude.ts
+function isClaudeSessionText() {
+  return true;
+}
+function parseRecords(lines) {
+  const messages = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      messages.push(JSON.parse(trimmed));
+    } catch {
+    }
   }
-  return errors;
+  return messages;
 }
-function addUsageToStats(stats, usage) {
-  stats.totalInputTokens += usage.input_tokens;
-  stats.totalOutputTokens += usage.output_tokens;
-  stats.totalCacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
-  stats.totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+function parseLines(jsonlText) {
+  return parseRecords(jsonlText.split("\n"));
 }
-function createEmptySessionStats(turnCount) {
+function extractSessionMetadata(messages) {
+  const meta = { sessionId: "", version: "", gitBranch: "", cwd: "", slug: "", name: "", model: "", branchedFrom: void 0 };
+  for (const msg of messages) {
+    if (msg.sessionId && !meta.sessionId) meta.sessionId = msg.sessionId;
+    if (msg.version && !meta.version) meta.version = msg.version;
+    if (msg.gitBranch && !meta.gitBranch) meta.gitBranch = msg.gitBranch;
+    if (msg.cwd && !meta.cwd) meta.cwd = msg.cwd;
+    if (msg.slug && !meta.slug) meta.slug = msg.slug;
+    if (msg.name && !meta.name) meta.name = msg.name;
+    if (msg.branchedFrom && !meta.branchedFrom) {
+      meta.branchedFrom = msg.branchedFrom;
+    }
+    if (isAssistantMessage(msg) && msg.message.model && !meta.model) {
+      meta.model = msg.message.model;
+    }
+    if (meta.sessionId && meta.version && meta.gitBranch && meta.cwd && meta.model) break;
+  }
+  return meta;
+}
+function extractClaudeMetadataFromLines(lines) {
+  return extractSessionMetadata(parseRecords(lines));
+}
+function parseClaudeSession(jsonlText, options) {
+  const rawMessages = parseLines(jsonlText);
+  const metadata = extractSessionMetadata(rawMessages);
+  const turns = buildTurns(rawMessages);
+  const stats = options?.skipStats ? createEmptySessionStats(turns.length) : computeStats(turns);
   return {
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    totalCacheCreationTokens: 0,
-    totalCacheReadTokens: 0,
-    toolCallCounts: {},
-    errorCount: 0,
-    totalDurationMs: 0,
-    turnCount
+    ...metadata,
+    turns,
+    stats,
+    rawMessages: options?.skipStats ? [] : rawMessages,
+    agentKind: "claude"
   };
 }
-function computeStats(turns) {
-  const stats = createEmptySessionStats(turns.length);
-  for (const turn of turns) {
-    if (turn.tokenUsage) addUsageToStats(stats, turn.tokenUsage);
-    if (turn.durationMs) stats.totalDurationMs += turn.durationMs;
-    stats.errorCount += countToolCalls(turn.toolCalls, stats.toolCallCounts);
-    for (const sa of turn.subAgentActivity) {
-      stats.errorCount += countToolCalls(sa.toolCalls, stats.toolCallCounts);
-      if (sa.tokenUsage) addUsageToStats(stats, sa.tokenUsage);
+function appendClaudeSession(existing, newJsonlText) {
+  const newMessages = parseLines(newJsonlText);
+  if (newMessages.length === 0) return existing;
+  const existingRawMessages = existing.rawMessages;
+  const allRawMessages = [...existingRawMessages, ...newMessages];
+  const turnStarts = findTurnStartIndices(existingRawMessages);
+  const historyTurnCount = Math.max(0, existing.turns.length - turnStarts.length);
+  let rebuildFromTurn = Math.max(0, turnStarts.length - 1);
+  const progressParentIds = /* @__PURE__ */ new Set();
+  for (const msg of newMessages) {
+    if (msg.type === "progress") {
+      const parentId = msg.parentToolUseID;
+      if (parentId) progressParentIds.add(parentId);
     }
   }
-  return stats;
-}
-
-// src/lib/codex-exec.ts
-var JS_SIMPLE_ESCAPES = {
-  "0": "\0",
-  b: "\b",
-  f: "\f",
-  n: "\n",
-  r: "\r",
-  t: "	",
-  v: "\v"
-};
-function readJsStringLiteral(source, startIndex) {
-  const quote = source[startIndex];
-  if (quote !== '"' && quote !== "'" && quote !== "`") return null;
-  let value = "";
-  let index = startIndex + 1;
-  while (index < source.length) {
-    const char = source[index];
-    if (char === quote) return { endIndex: index + 1, value };
-    if (char !== "\\") {
-      value += char;
-      index++;
+  if (progressParentIds.size > 0) {
+    for (let t = rebuildFromTurn - 1; t >= 0; t--) {
+      const turn = existing.turns[historyTurnCount + t];
+      if (turn?.toolCalls.some((tc) => progressParentIds.has(tc.id))) {
+        rebuildFromTurn = t;
+        break;
+      }
+    }
+  }
+  const rebuildFrom = turnStarts[rebuildFromTurn] ?? existingRawMessages.length;
+  const keptTurns = existing.turns.slice(0, historyTurnCount + rebuildFromTurn);
+  const tailTurns = buildTurns(allRawMessages.slice(rebuildFrom));
+  const allTurns = pairAgentMessageReplies([...keptTurns, ...tailTurns]);
+  const stats = computeStats(allTurns);
+  return {
+    sessionId: existing.sessionId,
+    version: existing.version,
+    gitBranch: existing.gitBranch,
+    cwd: existing.cwd,
+    slug: existing.slug,
+    name: existing.name,
+    model: existing.model || (allTurns.length > 0 ? allTurns[allTurns.length - 1].model || "" : ""),
+    turns: allTurns,
+    stats,
+    rawMessages: allRawMessages,
+    branchedFrom: existing.branchedFrom,
+    agentKind: existing.agentKind
+  };
+}
+var TASK_NOTIFICATION_MARKER = "<task-notification>";
+var TASK_ID_RE = /<task-id>([^<]+)<\/task-id>/g;
+var TOOL_USE_ID_RE = /<tool-use-id>([^<]+)<\/tool-use-id>/g;
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function userMessageTexts(msg) {
+  const message = isObject(msg.message) ? msg.message : null;
+  const content = message?.content;
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+  return content.filter((block) => isObject(block) && typeof block.text === "string").map((block) => block.text);
+}
+function collectClaudeBackgroundWork(rawMessages) {
+  const launches = [];
+  const resolved = /* @__PURE__ */ new Set();
+  const queuedIds = /* @__PURE__ */ new Set();
+  const deliveredIds = /* @__PURE__ */ new Set();
+  function noteNotifications(text, sink) {
+    if (!text.includes(TASK_NOTIFICATION_MARKER)) return;
+    for (const match of text.matchAll(TASK_ID_RE)) {
+      resolved.add(match[1]);
+      sink?.add(match[1]);
+    }
+    for (const match of text.matchAll(TOOL_USE_ID_RE)) {
+      resolved.add(match[1]);
+      sink?.add(match[1]);
+    }
+  }
+  for (const msg of rawMessages) {
+    if (msg.type === "user") {
+      const toolUseResult = isObject(msg.toolUseResult) ? msg.toolUseResult : null;
+      if (toolUseResult?.status === "async_launched") {
+        const message = isObject(msg.message) ? msg.message : null;
+        const blocks = Array.isArray(message?.content) ? message.content : [];
+        const toolUseIds = blocks.filter((block) => isObject(block) && block.type === "tool_result").map((block) => block.tool_use_id);
+        const ids = [toolUseResult.agentId, toolUseResult.taskId, ...toolUseIds].filter((id) => typeof id === "string" && id.length > 0);
+        const description = [toolUseResult.description, toolUseResult.workflowName, toolUseResult.summary].find((value) => typeof value === "string" && value.length > 0) ?? "";
+        if (ids.length > 0) launches.push({ ids, description });
+      }
+      for (const text of userMessageTexts(msg)) noteNotifications(text, deliveredIds);
       continue;
     }
-    index++;
-    if (index >= source.length) return null;
-    const escaped = source[index];
-    if (escaped in JS_SIMPLE_ESCAPES) {
-      value += JS_SIMPLE_ESCAPES[escaped];
-      index++;
+    if (msg.type === "assistant") {
+      const message = isObject(msg.message) ? msg.message : null;
+      const blocks = Array.isArray(message?.content) ? message.content : [];
+      for (const block of blocks) {
+        if (!isObject(block) || block.type !== "tool_use" || block.name !== "TaskStop") continue;
+        const input = isObject(block.input) ? block.input : null;
+        const taskId = input?.task_id ?? input?.shell_id;
+        if (typeof taskId === "string") resolved.add(taskId);
+      }
       continue;
     }
-    if (escaped === "\n") {
-      index++;
+    if (msg.type === "attachment") {
+      const attachment = isObject(msg.attachment) ? msg.attachment : null;
+      if (typeof attachment?.prompt === "string") noteNotifications(attachment.prompt, deliveredIds);
       continue;
     }
-    if (escaped === "\r") {
-      index += source[index + 1] === "\n" ? 2 : 1;
+    if (msg.type === "queue-operation" && typeof msg.content === "string") {
+      const op = msg.operation;
+      noteNotifications(msg.content, op === "enqueue" ? queuedIds : deliveredIds);
+    }
+  }
+  return {
+    pendingDescriptions: launches.filter((launch) => !launch.ids.some((id) => resolved.has(id))).map((launch) => launch.description),
+    undeliveredNotifications: [...queuedIds].filter((id) => !deliveredIds.has(id)).length
+  };
+}
+function awaitingAgentsResult(pendingDescriptions, pendingQueue) {
+  return {
+    status: "awaiting_agents",
+    pendingQueue,
+    pendingAgents: pendingDescriptions.length,
+    pendingAgentDescriptions: pendingDescriptions.filter((description) => description.length > 0)
+  };
+}
+function deriveClaudeSessionStatus(rawMessages) {
+  let pendingEnqueues = 0;
+  let backgroundWork = null;
+  let deliveringNotification = false;
+  function result(status, toolName) {
+    const info = { status, pendingQueue: Math.max(0, pendingEnqueues) };
+    if (toolName) info.toolName = toolName;
+    return info;
+  }
+  function getBackgroundWork() {
+    return backgroundWork ??= collectClaudeBackgroundWork(rawMessages);
+  }
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const msg = rawMessages[i];
+    if (msg.type === "queue-operation") continue;
+    if (msg.type === "progress") {
+      const data = msg.data;
+      if (data?.type === "hook_progress") {
+        const decision = data.decision ?? data.hookSpecificOutput?.permissionDecision;
+        if (decision === "defer") return result("deferred");
+      }
+      break;
+    }
+    break;
+  }
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const msg = rawMessages[i];
+    if (msg.type === "queue-operation") {
+      if (typeof msg.content === "string" && msg.content.includes(TASK_NOTIFICATION_MARKER)) continue;
+      const op = msg.operation;
+      if (op === "enqueue") pendingEnqueues++;
+      else if (op === "dequeue" || op === "remove") pendingEnqueues--;
       continue;
     }
-    if (escaped === "x" && /^[0-9a-fA-F]{2}$/.test(source.slice(index + 1, index + 3))) {
-      value += String.fromCharCode(Number.parseInt(source.slice(index + 1, index + 3), 16));
-      index += 3;
+    if (msg.type === "attachment") {
+      const attachment = isObject(msg.attachment) ? msg.attachment : null;
+      if (attachment?.commandMode === "task-notification") deliveringNotification = true;
       continue;
     }
-    if (escaped === "u") {
-      const braced = source.slice(index + 1).match(/^\{([0-9a-fA-F]+)\}/);
-      if (braced) {
-        const codePoint = Number.parseInt(braced[1], 16);
-        if (Number.isFinite(codePoint) && codePoint <= 1114111) {
-          value += String.fromCodePoint(codePoint);
-          index += braced[0].length + 1;
-          continue;
+    if (msg.type === "assistant") {
+      const message = msg.message;
+      const stopReason = message?.stop_reason;
+      if (stopReason === "end_turn") {
+        const work = getBackgroundWork();
+        if (deliveringNotification || work.undeliveredNotifications > 0) return result("processing");
+        if (work.pendingDescriptions.length > 0) {
+          return awaitingAgentsResult(work.pendingDescriptions, Math.max(0, pendingEnqueues));
         }
+        let hasActivity = false;
+        for (let j = i - 1; j >= 0; j--) {
+          const m = rawMessages[j];
+          if (m.type === "user" && !m.isMeta) {
+            hasActivity = true;
+            break;
+          }
+        }
+        return result(hasActivity ? "completed" : "idle");
       }
-      const hex = source.slice(index + 1, index + 5);
-      if (/^[0-9a-fA-F]{4}$/.test(hex)) {
-        value += String.fromCharCode(Number.parseInt(hex, 16));
-        index += 5;
-        continue;
+      if (stopReason === "tool_use") {
+        const content = message?.content;
+        const toolUseBlock = content?.findLast?.((b) => b.type === "tool_use");
+        return result("tool_use", toolUseBlock?.name);
       }
+      return result("thinking");
     }
-    value += escaped;
-    index++;
+    if (msg.type === "user") {
+      const isMeta = msg.isMeta;
+      if (isMeta) continue;
+      return result("processing");
+    }
+    if (msg.type === "system" && msg.subtype === "terminal_reason") {
+      const reason = msg.reason;
+      if (reason) {
+        return { status: "completed", terminalReason: reason, pendingQueue: Math.max(0, pendingEnqueues) };
+      }
+      continue;
+    }
+    if (msg.type === "summary") continue;
+    if (msg.type === "system" && msg.subtype === "compact_boundary") continue;
   }
-  return null;
+  return { status: "idle" };
+}
+function brandClaudeBranch(firstRecord, sessionId, turnIndex) {
+  const originalId = typeof firstRecord.sessionId === "string" ? firstRecord.sessionId : "";
+  return {
+    record: { ...firstRecord, sessionId, branchedFrom: { sessionId: originalId, turnIndex } },
+    originalId
+  };
+}
+function claudeTurnBoundaries(records) {
+  return buildTurnsWithStarts(records).turnStartIndices;
+}
+
+// src/lib/turnContent.ts
+function appendAssistantText(turn, text, timestamp) {
+  if (!text) return;
+  turn.assistantText.push(text);
+  const last = turn.contentBlocks[turn.contentBlocks.length - 1];
+  if (last?.kind === "text") {
+    last.text.push(text);
+    return;
+  }
+  turn.contentBlocks.push({ kind: "text", text: [text], timestamp });
 }
 
 // src/lib/codex-patches.ts
@@ -977,8 +1721,8 @@ function extractApplyPatchInputs(execSource) {
 function resolveCodexPatchPath(filePath, cwd) {
   if (!cwd || filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath)) return filePath;
   const base = cwd.replace(/[\\/]+$/, "");
-  const relative = filePath.replace(/^\.[\\/]/, "");
-  return /^[A-Za-z]:[\\/]/.test(cwd) ? `${base}\\${relative.replace(/\//g, "\\")}` : `${base}/${relative}`;
+  const relative2 = filePath.replace(/^\.[\\/]/, "");
+  return /^[A-Za-z]:[\\/]/.test(cwd) ? `${base}\\${relative2.replace(/\//g, "\\")}` : `${base}/${relative2}`;
 }
 function parseApplyPatch(patchText, callId, timestamp, cwd = "") {
   const toolCalls = [];
@@ -1102,7 +1846,7 @@ function findFailedNestedPatchCallIds(output, wrapperIsError, calls) {
 }
 
 // src/lib/codex-tool-normalization.ts
-function isObject(value) {
+function isObject2(value) {
   return typeof value === "object" && value !== null;
 }
 var COLLABORATION_TOOL_NAMES = /* @__PURE__ */ new Map([
@@ -1119,43 +1863,135 @@ var COLLABORATION_TOOL_NAMES = /* @__PURE__ */ new Map([
   ["interrupt_agent", "interrupt_agent"],
   ["interruptAgent", "interrupt_agent"]
 ]);
+var NATIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "exec",
+  "exec_command",
+  "write_stdin",
+  "apply_patch",
+  "update_plan",
+  "view_image",
+  "request_user_input",
+  "request_user_input_async",
+  "tool_search",
+  "list_mcp_resources",
+  "list_mcp_resource_templates",
+  "read_mcp_resource",
+  "request_plugin_install",
+  "create_goal",
+  "get_goal",
+  "update_goal",
+  "wait"
+]);
 function normalizeFunctionName(rawName) {
+  if (rawName.startsWith("mcp__")) return rawName;
   const leaf = rawName.split(/(?:__|[.:/])+/).filter(Boolean).at(-1) ?? rawName;
-  return COLLABORATION_TOOL_NAMES.get(leaf) ?? rawName;
+  return COLLABORATION_TOOL_NAMES.get(leaf) ?? (NATIVE_TOOL_NAMES.has(leaf) ? leaf : rawName);
+}
+function hasFailedExit(output) {
+  const exitMatch = output?.match(/Process exited with code (\d+)/);
+  return exitMatch ? exitMatch[1] !== "0" : false;
+}
+function isCodexQuestionTool(name) {
+  return name === "request_user_input" || name === "request_user_input_async";
 }
-function inferToolError(output) {
-  if (!output) return false;
-  const exitMatch = output.match(/Process exited with code (\d+)/);
-  if (exitMatch) return exitMatch[1] !== "0";
-  const withoutSuccessSummaries = output.replace(/\b0\s+(?:fail(?:ed|ures?)?|errors?)\b/gi, "").replace(/\bno\s+(?:failures?|errors?)\b/gi, "");
-  return /\b(error|failed|exception)\b/i.test(withoutSuccessSummaries);
+function normalizeQuestions(input) {
+  const source = Array.isArray(input.questions) ? input.questions : [input];
+  const questions = source.filter((question) => isObject2(question)).map((question) => {
+    const text = typeof question.question === "string" ? question.question : typeof question.title === "string" ? question.title : "";
+    const options = Array.isArray(question.options) ? question.options : [];
+    return {
+      question: text,
+      ...typeof question.header === "string" && question.header ? { header: question.header } : {},
+      options: options.map((option) => {
+        if (typeof option === "string") return { label: option };
+        if (!isObject2(option) || typeof option.label !== "string") return null;
+        return {
+          label: option.label,
+          ...typeof option.description === "string" && option.description ? { description: option.description } : {}
+        };
+      }).filter((option) => option !== null)
+    };
+  }).filter((question) => question.question);
+  return questions.length > 0 ? { ...input, questions } : input;
 }
 function normalizePlanToTodos(input) {
   const plan = Array.isArray(input.plan) ? input.plan : [];
-  const todos = plan.filter((item) => isObject(item)).map((item) => ({
+  const todos = plan.filter((item) => isObject2(item)).map((item) => ({
     content: typeof item.step === "string" ? item.step : "",
     status: typeof item.status === "string" ? item.status : "pending",
     activeForm: typeof item.step === "string" ? item.step : ""
   }));
   return { todos };
 }
-function extractCustomToolOutputText(output) {
-  if (typeof output === "string") return output;
-  if (!Array.isArray(output)) return "";
-  return output.filter((block) => isObject(block) && typeof block.text === "string").map((block) => block.text).join("");
+function outputImage(block) {
+  if (block.type !== "image" && block.type !== "input_image" && block.type !== "image_url") return null;
+  const source = isObject2(block.source) ? block.source : block;
+  const mediaType = source.media_type ?? source.mimeType;
+  if (typeof mediaType === "string" && mediaType.startsWith("image/") && typeof source.data === "string" && source.data) {
+    return { type: "image", source: { type: "base64", media_type: mediaType, data: source.data } };
+  }
+  const url = isObject2(block.image_url) ? block.image_url.url : block.image_url;
+  const match = typeof url === "string" ? /^data:(image\/[^;,]+);base64,(.+)$/is.exec(url) : null;
+  return match ? { type: "image", source: { type: "base64", media_type: match[1].toLowerCase(), data: match[2] } } : null;
+}
+function outputContent(output) {
+  if (typeof output === "string") return { parts: [output], text: output, images: [] };
+  if (!Array.isArray(output)) {
+    const text = output == null ? "" : JSON.stringify(output);
+    return { parts: [text], text, images: [] };
+  }
+  const parts = [];
+  const images = [];
+  for (const block of output) {
+    if (!isObject2(block)) continue;
+    if (typeof block.text === "string") parts.push(block.text);
+    const image = outputImage(block);
+    if (image) images.push(image);
+  }
+  return { parts, text: parts.join(""), images };
+}
+var SCRIPT_STATUS = /^Script (?:completed|failed|running)\b/;
+function collectExitCodes(chunk, codes) {
+  if (!isObject2(chunk)) return;
+  if (chunk.status === "rejected") codes.push(1);
+  else if (chunk.status === "fulfilled") collectExitCodes(chunk.value, codes);
+  else if (typeof chunk.exit_code === "number") codes.push(chunk.exit_code);
+}
+function scriptFailed(parts) {
+  const status = parts[0] ?? "";
+  if (!SCRIPT_STATUS.test(status)) return void 0;
+  if (status.startsWith("Script failed")) return true;
+  const codes = [];
+  for (const part of parts.slice(1)) {
+    let chunk;
+    try {
+      chunk = JSON.parse(part);
+    } catch {
+      continue;
+    }
+    for (const entry of Array.isArray(chunk) ? chunk : [chunk]) collectExitCodes(entry, codes);
+  }
+  return codes.length > 0 ? codes.some((code) => code !== 0) : void 0;
 }
 function parseCustomToolOutput(output) {
-  const rawOutput = extractCustomToolOutputText(output);
-  if (!rawOutput) return { text: "", isError: false };
+  const original = outputContent(output);
+  let envelope = isObject2(output) && !Array.isArray(output) ? output : null;
   try {
-    const parsed = JSON.parse(rawOutput);
-    const text = typeof parsed.output === "string" ? parsed.output : rawOutput;
-    const meta = isObject(parsed.metadata) ? parsed.metadata : null;
-    const isError = meta ? meta.exit_code !== 0 && meta.exit_code !== void 0 : inferToolError(text);
-    return { text, isError };
+    const parsed = envelope ?? JSON.parse(original.text);
+    if (isObject2(parsed) && !Array.isArray(parsed)) envelope = parsed;
   } catch {
-    return { text: rawOutput, isError: inferToolError(rawOutput) };
   }
+  const content = envelope && ("output" in envelope || "content" in envelope) ? outputContent(envelope.output ?? envelope.content) : original;
+  const images = content === original ? original.images : [...original.images, ...content.images];
+  const metadata = isObject2(envelope?.metadata) ? envelope.metadata : null;
+  const exitCode = metadata?.exit_code ?? envelope?.exit_code;
+  const explicitError = typeof envelope?.isError === "boolean" ? envelope.isError : typeof envelope?.is_error === "boolean" ? envelope.is_error : void 0;
+  const isError = explicitError === true || (typeof exitCode === "number" ? exitCode !== 0 : explicitError ?? scriptFailed(original.parts) ?? hasFailedExit(content.text));
+  return {
+    text: content.text,
+    isError,
+    ...images.length > 0 ? { images } : {}
+  };
 }
 
 // src/lib/codex.ts
@@ -1177,7 +2013,7 @@ function safeParseLine(line) {
     return null;
   }
 }
-function isObject2(value) {
+function isObject3(value) {
   return typeof value === "object" && value !== null;
 }
 function isCodexRecord(record) {
@@ -1187,7 +2023,7 @@ function isCodexRecord(record) {
 function extractMessageText(payload, blockType) {
   const content = payload?.content;
   if (!Array.isArray(content)) return "";
-  return content.filter((block) => isObject2(block) && block.type === blockType && typeof block.text === "string").map((block) => block.text).join("\n").trim();
+  return content.filter((block) => isObject3(block) && block.type === blockType && typeof block.text === "string").map((block) => block.text).join("\n").trim();
 }
 var CODEX_IMAGE_DATA_URL = /^data:(image\/(?:png|jpeg|gif|webp));base64,(.+)$/is;
 var CODEX_AUDIO_DATA_URL = /^data:(audio\/(?:wav|x-wav|mpeg|mp4|webm|ogg));base64,(.+)$/is;
@@ -1227,11 +2063,11 @@ function extractEventMessageAudio(payload) {
 }
 function extractResponseMessageImages(payload) {
   if (!Array.isArray(payload.content)) return [];
-  return payload.content.filter((block) => isObject2(block) && block.type === "input_image").map((block) => parseImageDataUrl(block.image_url)).filter((image) => image !== null);
+  return payload.content.filter((block) => isObject3(block) && block.type === "input_image").map((block) => parseImageDataUrl(block.image_url)).filter((image) => image !== null);
 }
 function extractResponseMessageAudio(payload) {
   if (!Array.isArray(payload.content)) return [];
-  return payload.content.filter((block) => isObject2(block) && block.type === "input_audio").map((block) => parseAudioDataUrl(block.audio_url)).filter((audio) => audio !== null);
+  return payload.content.filter((block) => isObject3(block) && block.type === "input_audio").map((block) => parseAudioDataUrl(block.audio_url)).filter((audio) => audio !== null);
 }
 function buildCodexUserContent(message, images, audio = [], localImages = [], localAudio = []) {
   const attachmentSuffix = [
@@ -1276,17 +2112,8 @@ function normalizePromptText(text) {
   if (SKIP_PROMPT_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) return "";
   return trimmed;
 }
-function mergeTokenUsage2(existing, incoming) {
-  if (!existing) return { ...incoming };
-  return {
-    input_tokens: existing.input_tokens + incoming.input_tokens,
-    output_tokens: existing.output_tokens + incoming.output_tokens,
-    cache_creation_input_tokens: (existing.cache_creation_input_tokens ?? 0) + (incoming.cache_creation_input_tokens ?? 0),
-    cache_read_input_tokens: (existing.cache_read_input_tokens ?? 0) + (incoming.cache_read_input_tokens ?? 0)
-  };
-}
 function parseTokenUsage(value) {
-  if (!isObject2(value)) return null;
+  if (!isObject3(value)) return null;
   const reportedInputTokens = typeof value.input_tokens === "number" ? value.input_tokens : 0;
   const outputTokens = typeof value.output_tokens === "number" ? value.output_tokens : 0;
   const cacheCreation = typeof value.cache_write_input_tokens === "number" ? value.cache_write_input_tokens : typeof value.cache_creation_input_tokens === "number" ? value.cache_creation_input_tokens : 0;
@@ -1301,16 +2128,6 @@ function parseTokenUsage(value) {
     cache_read_input_tokens: cacheRead
   };
 }
-function appendAssistantText(turn, text, timestamp) {
-  if (!text) return;
-  turn.assistantText.push(text);
-  const last = turn.contentBlocks[turn.contentBlocks.length - 1];
-  if (last && last.kind === "text") {
-    last.text.push(text);
-    return;
-  }
-  turn.contentBlocks.push({ kind: "text", text: [text], timestamp });
-}
 function appendThinking(turn, text, timestamp) {
   if (!text) return;
   const block = { type: "thinking", thinking: text, signature: "" };
@@ -1349,7 +2166,7 @@ function parseToolInput(argumentsText) {
   if (typeof argumentsText !== "string" || !argumentsText.trim()) return {};
   try {
     const parsed = JSON.parse(argumentsText);
-    return isObject2(parsed) ? parsed : { value: parsed };
+    return isObject3(parsed) ? parsed : { value: parsed };
   } catch {
     return { raw: argumentsText };
   }
@@ -1369,15 +2186,16 @@ function isCodeModeChild(callId) {
   return callId.startsWith("exec-");
 }
 function parseMcpEventResult(value) {
-  if (!isObject2(value)) return { text: safeStringify(value), isError: false };
+  if (!isObject3(value)) return { text: safeStringify(value), isError: false };
   if ("Err" in value) return { text: safeStringify(value.Err), isError: true };
-  const ok = isObject2(value.Ok) ? value.Ok : null;
+  const ok = isObject3(value.Ok) ? value.Ok : null;
   if (!ok) return { text: safeStringify(value), isError: false };
-  const parsedContent = parseCustomToolOutput(ok.content);
-  const text = parsedContent.text || (ok.structuredContent !== void 0 ? safeStringify(ok.structuredContent) : safeStringify(ok));
+  const parsedContent = parseCustomToolOutput({ ...ok, content: ok.content });
+  const text = parsedContent.text || (parsedContent.images?.length ? "" : ok.structuredContent !== void 0 ? safeStringify(ok.structuredContent) : safeStringify(ok));
   return {
+    ...parsedContent,
     text,
-    isError: ok.isError === true || parsedContent.isError
+    isError: parsedContent.isError
   };
 }
 function createTurn2(turnId, timestamp, model) {
@@ -1396,10 +2214,10 @@ function createTurn2(turnId, timestamp, model) {
   };
 }
 function extractPromptFromRecord(record) {
-  if (record.type === "event_msg" && isObject2(record.payload) && record.payload.type === "user_message" && typeof record.payload.message === "string") {
+  if (record.type === "event_msg" && isObject3(record.payload) && record.payload.type === "user_message" && typeof record.payload.message === "string") {
     return normalizePromptText(record.payload.message);
   }
-  if (record.type === "response_item" && isObject2(record.payload) && record.payload.type === "message" && record.payload.role === "user") {
+  if (record.type === "response_item" && isObject3(record.payload) && record.payload.type === "message" && record.payload.role === "user") {
     return normalizePromptText(extractMessageText(record.payload, "input_text"));
   }
   return "";
@@ -1432,12 +2250,12 @@ function extractMetadataFromRecords(records) {
   let agentPath = "/root";
   let previousPrompt = "";
   for (const record of records) {
-    if (!isObject2(record.payload)) continue;
+    if (!isObject3(record.payload)) continue;
     if (record.type === "session_meta") {
       sessionId ||= typeof record.payload.id === "string" ? record.payload.id : "";
       version ||= typeof record.payload.cli_version === "string" ? record.payload.cli_version : "";
       cwd ||= typeof record.payload.cwd === "string" ? record.payload.cwd : "";
-      if (!branchedFrom && isObject2(record.payload.branchedFrom)) {
+      if (!branchedFrom && isObject3(record.payload.branchedFrom)) {
         const sourceId = typeof record.payload.branchedFrom.sessionId === "string" ? record.payload.branchedFrom.sessionId : "";
         if (sourceId) {
           branchedFrom = {
@@ -1446,10 +2264,10 @@ function extractMetadataFromRecords(records) {
           };
         }
       }
-      const source = isObject2(record.payload.source) ? record.payload.source : null;
-      if (source && isObject2(source.subagent)) {
+      const source = isObject3(record.payload.source) ? record.payload.source : null;
+      if (source && isObject3(source.subagent)) {
         isSubagent = true;
-        const threadSpawn = isObject2(source.subagent.thread_spawn) ? source.subagent.thread_spawn : null;
+        const threadSpawn = isObject3(source.subagent.thread_spawn) ? source.subagent.thread_spawn : null;
         if (threadSpawn && typeof threadSpawn.agent_path === "string") {
           agentPath = threadSpawn.agent_path;
         }
@@ -1457,7 +2275,7 @@ function extractMetadataFromRecords(records) {
       if (typeof record.payload.forked_from_id === "string" && record.payload.forked_from_id) {
         parentSessionId = record.payload.forked_from_id;
       }
-      const git = isObject2(record.payload.git) ? record.payload.git : null;
+      const git = isObject3(record.payload.git) ? record.payload.git : null;
       gitBranch ||= git && typeof git.branch === "string" ? git.branch : "";
     }
     if (record.type === "turn_context") {
@@ -1502,13 +2320,17 @@ function isCodexSessionText(jsonlText) {
   }
   return false;
 }
+function isCodexRawRecords(records) {
+  return isCodexRecord(records[0] ?? null);
+}
 function extractCodexMetadataFromLines(lines) {
   const records = lines.map(safeParseLine).filter(isCodexRecord);
   return extractMetadataFromRecords(records);
 }
-function parseCodexSession(jsonlText, options) {
-  const records = jsonlText.split("\n").map((line) => line.trim()).filter(Boolean).map(safeParseLine).filter(isCodexRecord);
-  const metadata = extractMetadataFromRecords(records);
+function walkCodexRecords(records, options) {
+  const metadata = extractMetadataFromRecords(
+    records.filter(isCodexRecord)
+  );
   const turns = [];
   const pendingToolCalls = /* @__PURE__ */ new Map();
   const webSearchCalls = /* @__PURE__ */ new Map();
@@ -1518,7 +2340,7 @@ function parseCodexSession(jsonlText, options) {
   const agentIdByPath = /* @__PURE__ */ new Map();
   const agentIdBySpawnCall = /* @__PURE__ */ new Map();
   const agentMessages = /* @__PURE__ */ new Map();
-  function upsertAgentMessage(agentId, targetTurn, eventTimestamp, update = {}) {
+  function upsertAgentMessage(agentId, targetTurn, eventTimestamp2, update = {}) {
     const info = agentRegistry.get(agentId);
     let entry = agentMessages.get(agentId);
     if (!entry) {
@@ -1532,7 +2354,7 @@ function parseCodexSession(jsonlText, options) {
         toolCalls: [],
         thinking: [],
         text: [],
-        timestamp: info?.timestamp ?? eventTimestamp,
+        timestamp: info?.timestamp ?? eventTimestamp2,
         tokenUsage: null,
         model: info?.model ?? null,
         isBackground: false,
@@ -1544,7 +2366,7 @@ function parseCodexSession(jsonlText, options) {
       if (lastBlock?.kind === "sub_agent") {
         lastBlock.messages.push(agentMessage2);
       } else {
-        targetTurn.contentBlocks.push({ kind: "sub_agent", messages: [agentMessage2], timestamp: eventTimestamp });
+        targetTurn.contentBlocks.push({ kind: "sub_agent", messages: [agentMessage2], timestamp: eventTimestamp2 });
       }
       entry = { message: agentMessage2, turn: targetTurn };
       agentMessages.set(agentId, entry);
@@ -1566,9 +2388,9 @@ function parseCodexSession(jsonlText, options) {
       if (!(update.status === "running" && agentMessage.status && terminalStatuses.has(agentMessage.status))) {
         agentMessage.status = update.status;
       }
-      if (terminalStatuses.has(update.status) && agentMessage.timestamp && eventTimestamp) {
+      if (terminalStatuses.has(update.status) && agentMessage.timestamp && eventTimestamp2) {
         const startedAt = new Date(agentMessage.timestamp).getTime();
-        const endedAt = new Date(eventTimestamp).getTime();
+        const endedAt = new Date(eventTimestamp2).getTime();
         if (Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt) {
           agentMessage.durationMs = endedAt - startedAt;
         }
@@ -1582,8 +2404,23 @@ function parseCodexSession(jsonlText, options) {
   let lastTurnTimestamp = "";
   let pendingCompaction = null;
   let sawTurnStart = false;
+  const turnStartIndices = [];
+  let recordIndex = 0;
+  let pendingContextIndex = null;
+  let pendingTurnStart = null;
+  function commitTurn(turn) {
+    const before = turns.length;
+    const result = finalizeTurn(turns, turn, lastTurnTimestamp);
+    if (turns.length > before && pendingTurnStart !== null) {
+      turnStartIndices.push(pendingTurnStart);
+    }
+    pendingTurnStart = null;
+    return result;
+  }
   function createActiveTurn(turnId, timestamp, model) {
     const turn = createTurn2(turnId, timestamp, model);
+    pendingTurnStart = pendingContextIndex ?? recordIndex;
+    pendingContextIndex = null;
     if (!sawTurnStart) turn.isFragment = true;
     if (pendingCompaction) {
       turn.compactionSummary = pendingCompaction;
@@ -1610,18 +2447,22 @@ function parseCodexSession(jsonlText, options) {
     webSearchCalls.set(id, toolCall);
     appendToolCall(targetTurn, toolCall, timestamp);
   }
-  for (const record of records) {
-    const payload = isObject2(record.payload) ? record.payload : void 0;
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    if (!isCodexRecord(record)) continue;
+    recordIndex = index;
+    const payload = isObject3(record.payload) ? record.payload : void 0;
     const timestamp = record.timestamp ?? "";
     if (record.type === "compacted") {
-      current = finalizeTurn(turns, current, lastTurnTimestamp);
+      current = commitTurn(current);
       pendingCompaction = "Conversation compacted";
       lastTurnTimestamp = timestamp;
       continue;
     }
     if (record.type === "world_state") continue;
     if (record.type === "turn_context") {
-      current = finalizeTurn(turns, current, lastTurnTimestamp);
+      current = commitTurn(current);
+      pendingContextIndex = index;
       currentTurnId = typeof payload?.turn_id === "string" ? payload.turn_id : null;
       currentModel = typeof payload?.model === "string" ? payload.model : currentModel;
       lastTurnTimestamp = timestamp;
@@ -1630,7 +2471,7 @@ function parseCodexSession(jsonlText, options) {
     }
     if (record.type === "event_msg" && payload?.type === "user_message" && typeof payload.message === "string") {
       if (current && (current.assistantText.length > 0 || current.toolCalls.length > 0 || current.thinking.length > 0)) {
-        current = finalizeTurn(turns, current, lastTurnTimestamp);
+        current = commitTurn(current);
       }
       sawTurnStart = true;
       current ??= createActiveTurn(currentTurnId, timestamp, currentModel);
@@ -1658,30 +2499,31 @@ function parseCodexSession(jsonlText, options) {
     if (!current.timestamp) current.timestamp = timestamp;
     if (timestamp) lastTurnTimestamp = timestamp;
     if (record.type === "event_msg" && payload?.type === "token_count") {
-      const info = isObject2(payload.info) ? payload.info : null;
+      const info = isObject3(payload.info) ? payload.info : null;
       const lastUsage = info ? parseTokenUsage(info.last_token_usage) : null;
       if (lastUsage) {
-        current.tokenUsage = mergeTokenUsage2(current.tokenUsage, lastUsage);
+        current.tokenUsage = mergeTokenUsage(current.tokenUsage, lastUsage);
       }
       continue;
     }
     if (record.type === "event_msg" && payload?.type === "web_search_end" && typeof payload.call_id === "string") {
       const input = {};
       if (typeof payload.query === "string" && payload.query) input.query = payload.query;
-      if (isObject2(payload.action)) input.action = payload.action;
+      if (isObject3(payload.action)) input.action = payload.action;
       upsertWebSearchCall(current, payload.call_id, input, "completed", timestamp);
       continue;
     }
-    if (record.type === "event_msg" && payload?.type === "mcp_tool_call_end" && typeof payload.call_id === "string" && isObject2(payload.invocation)) {
+    if (record.type === "event_msg" && payload?.type === "mcp_tool_call_end" && typeof payload.call_id === "string" && isObject3(payload.invocation)) {
       const invocation = payload.invocation;
       const server = typeof invocation.server === "string" ? invocation.server : "mcp";
       const tool = typeof invocation.tool === "string" ? invocation.tool : "tool";
-      const input = isObject2(invocation.arguments) ? invocation.arguments : {};
+      const input = isObject3(invocation.arguments) ? invocation.arguments : {};
       const result = parseMcpEventResult(payload.result);
       const existing = pendingToolCalls.get(payload.call_id);
       if (existing) {
         existing.result = result.text;
         existing.isError = result.isError;
+        if (result.images) existing.resultImages = result.images;
         pendingToolCalls.delete(payload.call_id);
       } else if (!isCodeModeChild(payload.call_id)) {
         appendToolCall(current, {
@@ -1690,6 +2532,7 @@ function parseCodexSession(jsonlText, options) {
           input,
           result: result.text,
           isError: result.isError,
+          ...result.images ? { resultImages: result.images } : {},
           timestamp
         }, timestamp);
       }
@@ -1697,9 +2540,9 @@ function parseCodexSession(jsonlText, options) {
     }
     if (record.type === "event_msg" && payload?.type === "sub_agent_activity" && typeof payload.agent_thread_id === "string" && typeof payload.agent_path === "string") {
       const agentId = payload.agent_thread_id;
-      const eventId = typeof payload.event_id === "string" ? payload.event_id : "";
+      const eventId2 = typeof payload.event_id === "string" ? payload.event_id : "";
       const kind = typeof payload.kind === "string" ? payload.kind : "started";
-      const spawnInfo = eventId ? spawnAgentCalls.get(eventId) : void 0;
+      const spawnInfo = eventId2 ? spawnAgentCalls.get(eventId2) : void 0;
       const existingId = agentIdByPath.get(payload.agent_path);
       const existing = agentRegistry.get(agentId) ?? (existingId ? agentRegistry.get(existingId) : void 0);
       if (kind !== "started" && !existing && !spawnInfo) continue;
@@ -1720,11 +2563,11 @@ function parseCodexSession(jsonlText, options) {
         model: existing?.model ?? spawnInfo?.model ?? null,
         agentType: existing?.agentType ?? spawnInfo?.agentType ?? null,
         timestamp: existing?.timestamp ?? (timestamp || spawnInfo?.timestamp || ""),
-        parentToolCallId: existing?.parentToolCallId ?? eventId
+        parentToolCallId: existing?.parentToolCallId ?? eventId2
       };
       agentRegistry.set(agentId, info);
       agentIdByPath.set(payload.agent_path, agentId);
-      if (eventId && (kind === "started" || spawnInfo)) agentIdBySpawnCall.set(eventId, agentId);
+      if (eventId2 && (kind === "started" || spawnInfo)) agentIdBySpawnCall.set(eventId2, agentId);
       const status = kind === "interrupted" ? "interrupted" : "running";
       upsertAgentMessage(agentId, current, timestamp, { status });
       continue;
@@ -1752,7 +2595,7 @@ function parseCodexSession(jsonlText, options) {
     }
     if (payload.type === "web_search_call" && typeof payload.id === "string") {
       const input = {};
-      if (isObject2(payload.action)) input.action = payload.action;
+      if (isObject3(payload.action)) input.action = payload.action;
       const status = typeof payload.status === "string" ? payload.status : "completed";
       upsertWebSearchCall(current, payload.id, input, status, timestamp);
       continue;
@@ -1763,7 +2606,7 @@ function parseCodexSession(jsonlText, options) {
         const toolCall = {
           id: callId,
           name: "ToolSearch",
-          input: isObject2(payload.arguments) ? payload.arguments : {},
+          input: isObject3(payload.arguments) ? payload.arguments : {},
           result: null,
           isError: false,
           timestamp
@@ -1777,7 +2620,7 @@ function parseCodexSession(jsonlText, options) {
       const toolCall = pendingToolCalls.get(payload.call_id);
       if (toolCall) {
         const tools = Array.isArray(payload.tools) ? payload.tools : [];
-        const names = tools.filter(isObject2).map((tool) => findString(tool.name) ?? "").filter(Boolean);
+        const names = tools.filter(isObject3).map((tool) => findString(tool.name) ?? "").filter(Boolean);
         const count = names.length > 0 ? names.length : tools.length;
         const found = `Found ${count} tool${count === 1 ? "" : "s"}`;
         toolCall.result = names.length > 0 ? `${found}: ${names.join(", ")}` : found;
@@ -1830,6 +2673,9 @@ function parseCodexSession(jsonlText, options) {
       } else if (functionName === "update_plan") {
         name = "TodoWrite";
         input = normalizePlanToTodos(parsedInput);
+      } else if (isCodexQuestionTool(functionName)) {
+        name = "AskUserQuestion";
+        input = normalizeQuestions(parsedInput);
       }
       if (functionName === "spawn_agent") {
         spawnAgentCalls.set(payload.call_id, {
@@ -1847,7 +2693,8 @@ function parseCodexSession(jsonlText, options) {
         input,
         result: null,
         isError: false,
-        timestamp
+        timestamp,
+        ...functionName === "request_user_input_async" ? { asyncQuestion: true } : {}
       };
       pendingToolCalls.set(toolCall.id, toolCall);
       appendToolCall(current, toolCall, timestamp);
@@ -1856,9 +2703,11 @@ function parseCodexSession(jsonlText, options) {
     if (payload.type === "function_call_output" && typeof payload.call_id === "string") {
       const toolCall = pendingToolCalls.get(payload.call_id);
       if (!toolCall) continue;
-      const output = typeof payload.output === "string" ? payload.output : null;
+      const parsedOutput = parseCustomToolOutput(payload.output);
+      const output = parsedOutput.text;
       toolCall.result = output;
-      toolCall.isError = inferToolError(output);
+      toolCall.isError = parsedOutput.isError;
+      if (parsedOutput.images) toolCall.resultImages = parsedOutput.images;
       pendingToolCalls.delete(payload.call_id);
       if (toolCall.name === "spawn_agent" && output) {
         try {
@@ -1890,9 +2739,9 @@ function parseCodexSession(jsonlText, options) {
       if (toolCall.name === "wait_agent" && output && current) {
         try {
           const result = JSON.parse(output);
-          const statusMap = isObject2(result.status) ? result.status : {};
+          const statusMap = isObject3(result.status) ? result.status : {};
           for (const [agentId, status] of Object.entries(statusMap)) {
-            const statusValue = isObject2(status) ? status : {};
+            const statusValue = isObject3(status) ? status : {};
             const completedText = typeof statusValue.completed === "string" ? statusValue.completed : "";
             const failedText = typeof statusValue.failed === "string" ? statusValue.failed : typeof statusValue.error === "string" ? statusValue.error : "";
             const interruptedText = typeof statusValue.interrupted === "string" ? statusValue.interrupted : "";
@@ -1920,7 +2769,7 @@ function parseCodexSession(jsonlText, options) {
       continue;
     }
     if (payload.type === "custom_tool_call" && typeof payload.call_id === "string") {
-      const name = typeof payload.name === "string" ? payload.name : "tool";
+      const name = normalizeFunctionName(typeof payload.name === "string" ? payload.name : "tool");
       const rawInput = typeof payload.input === "string" ? payload.input : "";
       const callId = payload.call_id;
       const perFileCalls = rawInput ? parseCodexToolPatches(name, rawInput, callId, timestamp, metadata.cwd) : [];
@@ -1950,7 +2799,7 @@ function parseCodexSession(jsonlText, options) {
     }
     if (payload.type === "custom_tool_call_output" && typeof payload.call_id === "string") {
       const callId = payload.call_id;
-      const { text, isError } = parseCustomToolOutput(payload.output);
+      const { text, isError, images } = parseCustomToolOutput(payload.output);
       const patchCalls = patchCallIds.get(callId);
       if (patchCalls) {
         const failedIds = patchCalls.direct && isError ? new Set(patchCalls.calls.map((call) => call.id)) : findFailedNestedPatchCallIds(text, isError, patchCalls.calls);
@@ -1968,13 +2817,15 @@ function parseCodexSession(jsonlText, options) {
       if (toolCall) {
         toolCall.result = text;
         toolCall.isError = isError;
+        if (images) toolCall.resultImages = images;
         pendingToolCalls.delete(callId);
       }
       continue;
     }
   }
-  finalizeTurn(turns, current, lastTurnTimestamp);
+  commitTurn(current);
   return {
+    turnStartIndices,
     sessionId: metadata.sessionId,
     version: metadata.version,
     gitBranch: metadata.gitBranch,
@@ -1989,115 +2840,1120 @@ function parseCodexSession(jsonlText, options) {
     agentKind: "codex"
   };
 }
+function parseCodexSession(jsonlText, options) {
+  const records = jsonlText.split("\n").map((line) => line.trim()).filter(Boolean).map(safeParseLine).filter(isCodexRecord);
+  const { turnStartIndices: _starts, ...session } = walkCodexRecords(
+    records,
+    options
+  );
+  return session;
+}
+function appendCodexSession(existing, newJsonlText) {
+  const prefix = existing.rawMessages.map((record) => JSON.stringify(record)).join("\n");
+  return parseCodexSession(prefix ? `${prefix}
+${newJsonlText}` : newJsonlText);
+}
+var TERMINAL_INTER_AGENT_TYPES = /* @__PURE__ */ new Set(["FINAL_ANSWER", "ERROR", "FAILED", "INTERRUPTED"]);
+function codexPayloadText(payload) {
+  const content = payload.content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => isObject3(block) && block.type === "input_text" && typeof block.text === "string").map((block) => block.text).join("\n");
+}
+function parseJsonObject(value) {
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return isObject3(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function collectCodexPendingAgents(rawMessages) {
+  const alive = /* @__PURE__ */ new Map();
+  const done = /* @__PURE__ */ new Set();
+  const agentIdByPath = /* @__PURE__ */ new Map();
+  const spawnCalls = /* @__PURE__ */ new Map();
+  const waitCalls = /* @__PURE__ */ new Set();
+  const interruptCalls = /* @__PURE__ */ new Map();
+  function markAlive(agentId, description) {
+    if (!done.has(agentId)) alive.set(agentId, alive.get(agentId) || description);
+  }
+  for (const msg of rawMessages) {
+    const payload = isObject3(msg.payload) ? msg.payload : null;
+    if (!payload) continue;
+    if (msg.type === "event_msg" && payload.type === "sub_agent_activity" && typeof payload.agent_thread_id === "string" && typeof payload.agent_path === "string") {
+      const agentId = payload.agent_thread_id;
+      const kind = typeof payload.kind === "string" ? payload.kind : "started";
+      const eventId2 = typeof payload.event_id === "string" ? payload.event_id : "";
+      const existingId = agentIdByPath.get(payload.agent_path);
+      const known = alive.has(agentId) || done.has(agentId) || existingId !== void 0 || spawnCalls.has(eventId2);
+      if (kind !== "started" && !known) continue;
+      if (existingId && existingId !== agentId) {
+        if (alive.has(existingId)) {
+          markAlive(agentId, alive.get(existingId) ?? "");
+          alive.delete(existingId);
+        }
+        if (done.has(existingId)) done.add(agentId);
+      }
+      agentIdByPath.set(payload.agent_path, agentId);
+      if (kind === "interrupted") {
+        done.add(agentId);
+        alive.delete(agentId);
+      } else {
+        markAlive(agentId, spawnCalls.get(eventId2) ?? "");
+      }
+      continue;
+    }
+    if (msg.type !== "response_item") continue;
+    if (payload.type === "function_call" && typeof payload.call_id === "string") {
+      const name = normalizeFunctionName(typeof payload.name === "string" ? payload.name : "");
+      if (name === "spawn_agent") {
+        const input = parseJsonObject(payload.arguments);
+        spawnCalls.set(payload.call_id, typeof input?.task_name === "string" ? input.task_name : "");
+      } else if (name === "wait_agent") {
+        waitCalls.add(payload.call_id);
+      } else if (name === "interrupt_agent") {
+        const input = parseJsonObject(payload.arguments);
+        const targets = [input?.agent_id, ...Array.isArray(input?.agent_ids) ? input.agent_ids : []].filter((id) => typeof id === "string");
+        interruptCalls.set(payload.call_id, targets);
+      }
+      continue;
+    }
+    if (payload.type === "function_call_output" && typeof payload.call_id === "string") {
+      const callId = payload.call_id;
+      if (spawnCalls.has(callId)) {
+        const output = parseJsonObject(payload.output);
+        const agentId = typeof output?.agent_id === "string" ? output.agent_id : "";
+        if (agentId) {
+          markAlive(agentId, spawnCalls.get(callId) ?? "");
+          const agentPath = typeof output?.task_name === "string" ? output.task_name : "";
+          if (agentPath && !agentIdByPath.has(agentPath)) agentIdByPath.set(agentPath, agentId);
+        }
+      } else if (waitCalls.has(callId)) {
+        const output = parseJsonObject(payload.output);
+        const statusMap = isObject3(output?.status) ? output.status : {};
+        for (const [agentId, status] of Object.entries(statusMap)) {
+          const statusValue = isObject3(status) ? status : {};
+          const lifecycle = typeof statusValue.status === "string" ? statusValue.status : "";
+          const isTerminal = typeof statusValue.completed === "string" || typeof statusValue.failed === "string" || typeof statusValue.error === "string" || typeof statusValue.interrupted === "string" || lifecycle === "completed" || lifecycle === "failed" || lifecycle === "interrupted";
+          if (isTerminal) {
+            done.add(agentId);
+            alive.delete(agentId);
+          }
+        }
+      } else if (interruptCalls.has(callId)) {
+        for (const agentId of interruptCalls.get(callId) ?? []) {
+          done.add(agentId);
+          alive.delete(agentId);
+        }
+      }
+      continue;
+    }
+    if (payload.type === "agent_message" && typeof payload.author === "string") {
+      const text = codexPayloadText(payload);
+      const messageType = text.match(/^Message Type:\s*([^\r\n]+)/)?.[1]?.trim().toUpperCase() ?? "";
+      if (!TERMINAL_INTER_AGENT_TYPES.has(messageType)) continue;
+      const agentId = agentIdByPath.get(payload.author) ?? payload.author;
+      done.add(agentId);
+      alive.delete(agentId);
+    }
+  }
+  return [...alive.entries()].filter(([agentId]) => !done.has(agentId)).map(([, description]) => description);
+}
+function deriveCodexSessionStatus(rawMessages) {
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const msg = rawMessages[i];
+    if (msg.type === "event_msg") {
+      const payload = msg.payload;
+      switch (payload?.type) {
+        case "task_complete": {
+          const pending = collectCodexPendingAgents(rawMessages);
+          if (pending.length > 0) {
+            return {
+              status: "awaiting_agents",
+              pendingQueue: 0,
+              pendingAgents: pending.length,
+              pendingAgentDescriptions: pending.filter((description) => description.length > 0)
+            };
+          }
+          return { status: "completed" };
+        }
+        case "task_started":
+          return { status: "processing" };
+        case "agent_message":
+          return { status: "thinking" };
+        case "token_count":
+          continue;
+      }
+    }
+    if (msg.type === "response_item") {
+      const payload = msg.payload;
+      if (!payload) continue;
+      if (payload.type === "function_call") {
+        return { status: "tool_use", toolName: payload.name ? normalizeFunctionName(payload.name) : payload.name };
+      }
+      if (payload.type === "message") {
+        if (payload.role === "assistant") return { status: "thinking" };
+        if (payload.role === "user") return { status: "processing" };
+      }
+    }
+  }
+  return { status: "idle" };
+}
+function brandCodexBranch(firstRecord, sessionId, turnIndex) {
+  const payload = isObject3(firstRecord.payload) ? { ...firstRecord.payload } : {};
+  const originalId = typeof payload.id === "string" ? payload.id : "";
+  payload.id = sessionId;
+  payload.branchedFrom = { sessionId: originalId, turnIndex };
+  return { record: { ...firstRecord, payload }, originalId };
+}
+function codexTurnBoundaries(records) {
+  return walkCodexRecords(records, { skipStats: true }).turnStartIndices;
+}
 
-// src/lib/parser.ts
-function extractTextFromContent2(content) {
-  if (typeof content === "string") return content;
-  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+// src/lib/copilot.ts
+var COPILOT_EVENT_PREFIX = /^(?:assistant|auto_mode|auto_mode_switch|background_tasks|canvas|command|custom|elicitation|exit_plan_mode|extensions|external_tool|factory|hook|managed_settings|mcp|model|pending_messages|permission|sampling|session|skill|subagent|system|tool|ui|user_input)\./;
+function isObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parseLines(jsonlText) {
-  const messages = [];
+function isRootEvent(event) {
+  return typeof event.agentId !== "string" || event.agentId.length === 0;
+}
+function isCopilotEvent(value) {
+  if (!isObject4(value) || typeof value.type !== "string" || !isObject4(value.data)) return false;
+  return value.type === "abort" || value.type === "binary_asset" || value.type === "user.message" || COPILOT_EVENT_PREFIX.test(value.type);
+}
+function safeParseLine2(line) {
+  try {
+    const value = JSON.parse(line);
+    return isCopilotEvent(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function parseEvents(jsonlText) {
+  return jsonlText.split("\n").map((line) => line.trim()).filter(Boolean).map(safeParseLine2).filter((event) => event !== null);
+}
+function readString(...values) {
+  return values.find((value) => typeof value === "string") ?? "";
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function eventTimestamp(event) {
+  return typeof event.timestamp === "string" ? event.timestamp : "";
+}
+function eventId(event, prefix) {
+  if (typeof event.id === "string" && event.id) return event.id;
+  return globalThis.crypto?.randomUUID?.() ?? `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function turnEventId(event) {
+  const durableEventId = eventId(event, "copilot-turn");
+  const sourceTurnId = readString(event.data.turnId);
+  return sourceTurnId ? `${sourceTurnId}@${durableEventId}` : durableEventId;
+}
+function applyContext(context, current) {
+  if (!isObject4(context)) return;
+  const cwd = readString(context.cwd);
+  const branch = readString(context.branch);
+  if (cwd) current.cwd = cwd;
+  if (branch) current.gitBranch = branch;
+}
+function extractMetadata(events) {
+  const metadata = {
+    sessionId: "",
+    version: "",
+    gitBranch: "",
+    cwd: "",
+    model: "",
+    slug: "",
+    name: "",
+    firstUserMessage: "",
+    lastUserMessage: "",
+    timestamp: "",
+    lastTimestamp: "",
+    turnCount: 0,
+    isSubagent: false,
+    parentSessionId: null
+  };
+  for (const event of events) {
+    if (!isRootEvent(event)) continue;
+    const { data } = event;
+    const timestamp = eventTimestamp(event);
+    if (timestamp) metadata.lastTimestamp = timestamp;
+    if (event.type === "session.start") {
+      metadata.sessionId ||= readString(data.sessionId);
+      metadata.version ||= readString(data.copilotVersion) || (typeof data.version === "number" ? String(data.version) : readString(data.version));
+      applyContext(data.context, metadata);
+      metadata.model = readString(data.selectedModel) || metadata.model;
+      continue;
+    }
+    if (event.type === "session.resume") {
+      applyContext(data.context, metadata);
+      metadata.model = readString(data.selectedModel) || metadata.model;
+      continue;
+    }
+    if (event.type === "session.context_changed") {
+      applyContext(data, metadata);
+      continue;
+    }
+    if (event.type === "session.auto_mode_resolved") {
+      metadata.model = readString(data.chosenModel) || metadata.model;
+      continue;
+    }
+    if (event.type === "session.model_change") {
+      metadata.model = readString(data.newModel) || metadata.model;
+      continue;
+    }
+    if (event.type === "session.title_changed") {
+      metadata.name = readString(data.title) || metadata.name;
+      continue;
+    }
+    if (event.type === "session.shutdown") {
+      metadata.model = readString(data.currentModel) || metadata.model;
+      continue;
+    }
+    if (event.type === "assistant.turn_start" || event.type === "assistant.turn_end" || event.type === "assistant.message" || event.type === "assistant.usage" || event.type === "tool.execution_start" || event.type === "tool.execution_complete") {
+      metadata.model = readString(data.model) || metadata.model;
+    }
+    if (event.type !== "user.message") continue;
+    metadata.turnCount++;
+    metadata.timestamp ||= timestamp;
+    const content = readString(data.content).trim();
+    if (!content) continue;
+    metadata.firstUserMessage ||= content;
+    metadata.lastUserMessage = content;
+  }
+  metadata.lastTimestamp ||= metadata.timestamp;
+  return metadata;
+}
+function isCopilotSessionText(jsonlText) {
   for (const line of jsonlText.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
-      messages.push(JSON.parse(trimmed));
+      const value = JSON.parse(trimmed);
+      if (isCopilotEvent(value)) return true;
     } catch {
     }
   }
-  return messages;
+  return false;
 }
-function isCodexRawMessages(rawMessages) {
-  const firstType = rawMessages[0]?.type;
-  return firstType === "session_meta" || firstType === "turn_context" || firstType === "event_msg" || firstType === "response_item" || firstType === "compacted" || firstType === "world_state" || firstType === "inter_agent_communication_metadata";
+function isCopilotRawRecords(records) {
+  return isCopilotEventType(records[0]?.type);
 }
-function serializeRawMessages(rawMessages) {
-  return rawMessages.map((msg) => JSON.stringify(msg)).join("\n");
+function extractCopilotMetadataFromLines(lines) {
+  const events = lines.map((line) => safeParseLine2(line.trim())).filter(
+    (event) => event !== null
+  );
+  return extractMetadata(events);
 }
-function extractSessionMetadata(messages) {
-  const meta = { sessionId: "", version: "", gitBranch: "", cwd: "", slug: "", name: "", model: "", branchedFrom: void 0 };
-  for (const msg of messages) {
-    if (msg.sessionId && !meta.sessionId) meta.sessionId = msg.sessionId;
-    if (msg.version && !meta.version) meta.version = msg.version;
-    if (msg.gitBranch && !meta.gitBranch) meta.gitBranch = msg.gitBranch;
-    if (msg.cwd && !meta.cwd) meta.cwd = msg.cwd;
-    if (msg.slug && !meta.slug) meta.slug = msg.slug;
-    if (msg.name && !meta.name) meta.name = msg.name;
-    if (msg.branchedFrom && !meta.branchedFrom) {
-      meta.branchedFrom = msg.branchedFrom;
-    }
-    if (isAssistantMessage(msg) && msg.message.model && !meta.model) {
-      meta.model = msg.message.model;
-    }
-    if (meta.sessionId && meta.version && meta.gitBranch && meta.cwd && meta.model) break;
+function safeStringify2(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
-  return meta;
 }
-function parseSession(jsonlText, options) {
-  if (isCodexSessionText(jsonlText)) {
-    return parseCodexSession(jsonlText, options);
+function textFromValue(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value.flatMap((part) => {
+    const text = typeof part === "string" ? part : isObject4(part) ? readString(part.text, part.content) : "";
+    return text ? [text] : [];
+  }).join("\n");
+}
+function collectBinaryAssets(events) {
+  const assets = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "session.binary_asset" && event.type !== "binary_asset") continue;
+    const assetId = readString(event.data.assetId);
+    const data = readString(event.data.data);
+    const mimeType = readString(event.data.mimeType);
+    if (assetId && data && mimeType) assets.set(assetId, { data, mimeType });
   }
-  const rawMessages = parseLines(jsonlText);
-  const metadata = extractSessionMetadata(rawMessages);
-  const turns = buildTurns(rawMessages);
-  const stats = options?.skipStats ? createEmptySessionStats(turns.length) : computeStats(turns);
+  return assets;
+}
+function resolveImage(value, assets) {
+  if (!isObject4(value)) return null;
+  const asset = assets.get(readString(value.assetId));
+  const mimeType = readString(value.mimeType, asset?.mimeType).toLowerCase();
+  const data = readString(value.data, asset?.data);
+  if (!mimeType.startsWith("image/") || !data) return null;
   return {
-    ...metadata,
-    turns,
-    stats,
-    rawMessages: options?.skipStats ? [] : rawMessages,
-    agentKind: "claude"
+    type: "image",
+    source: { type: "base64", media_type: mimeType, data }
   };
 }
-function parseSessionAppend(existing, newJsonlText) {
-  if (isCodexRawMessages(existing.rawMessages) || isCodexSessionText(newJsonlText)) {
-    const prefix = serializeRawMessages(existing.rawMessages);
-    return parseCodexSession(prefix ? `${prefix}
-${newJsonlText}` : newJsonlText);
-  }
-  const newMessages = parseLines(newJsonlText);
-  if (newMessages.length === 0) return existing;
-  const existingRawMessages = existing.rawMessages;
-  const allRawMessages = [...existingRawMessages, ...newMessages];
-  const turnStarts = findTurnStartIndices(existingRawMessages);
-  const historyTurnCount = Math.max(0, existing.turns.length - turnStarts.length);
-  let rebuildFromTurn = Math.max(0, turnStarts.length - 1);
-  const progressParentIds = /* @__PURE__ */ new Set();
-  for (const msg of newMessages) {
-    if (msg.type === "progress") {
-      const parentId = msg.parentToolUseID;
-      if (parentId) progressParentIds.add(parentId);
-    }
+function extractImages(values, assets) {
+  if (!Array.isArray(values)) return [];
+  const images = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const image = resolveImage(value, assets);
+    if (!image) continue;
+    const key = `${image.source.media_type}:${image.source.data}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    images.push(image);
   }
-  if (progressParentIds.size > 0) {
-    for (let t = rebuildFromTurn - 1; t >= 0; t--) {
-      const turn = existing.turns[historyTurnCount + t];
-      if (turn?.toolCalls.some((tc) => progressParentIds.has(tc.id))) {
-        rebuildFromTurn = t;
-        break;
-      }
-    }
+  return images;
+}
+function buildUserContent(data, assets) {
+  const text = readString(data.content);
+  const images = extractImages(data.attachments, assets);
+  if (images.length === 0) return text;
+  return [...images, ...text ? [{ type: "text", text }] : []];
+}
+function extractToolResultImages(data, assets) {
+  if (!isObject4(data.result)) return [];
+  return extractImages([
+    ...Array.isArray(data.result.contents) ? data.result.contents : [],
+    ...Array.isArray(data.result.binaryResultsForLlm) ? data.result.binaryResultsForLlm : []
+  ], assets);
+}
+function parseUsage(data, inputIncludesCache = false) {
+  const cacheCreationInputTokens = readNumber(data.cacheWriteTokens);
+  const cacheReadInputTokens = readNumber(data.cacheReadTokens);
+  const inputTokens = readNumber(data.inputTokens);
+  const usage = {
+    input_tokens: inputIncludesCache ? Math.max(0, inputTokens - cacheCreationInputTokens - cacheReadInputTokens) : inputTokens,
+    output_tokens: readNumber(data.outputTokens),
+    cache_creation_input_tokens: cacheCreationInputTokens,
+    cache_read_input_tokens: cacheReadInputTokens
+  };
+  const thinkingTokens = readNumber(data.reasoningTokens);
+  if (thinkingTokens) usage.output_tokens_details = { thinking_tokens: thinkingTokens };
+  if (usage.input_tokens === 0 && usage.output_tokens === 0 && usage.cache_creation_input_tokens === 0 && usage.cache_read_input_tokens === 0 && thinkingTokens === 0) return null;
+  return usage;
+}
+function parseModelMetrics(data) {
+  if (!isObject4(data.modelMetrics)) return null;
+  let total = null;
+  for (const value of Object.values(data.modelMetrics)) {
+    if (!isObject4(value) || !isObject4(value.usage)) continue;
+    const usage = parseUsage(value.usage, true);
+    if (usage) total = mergeTokenUsage(total, usage);
   }
-  const rebuildFrom = turnStarts[rebuildFromTurn] ?? existingRawMessages.length;
-  const keptTurns = existing.turns.slice(0, historyTurnCount + rebuildFromTurn);
-  const tailTurns = buildTurns(allRawMessages.slice(rebuildFrom));
-  const allTurns = pairAgentMessageReplies([...keptTurns, ...tailTurns]);
-  const stats = computeStats(allTurns);
+  return total;
+}
+function normalizeChoice(value) {
+  if (typeof value === "string") return { label: value };
+  if (!isObject4(value)) return null;
+  const label = readString(value.label, value.title, value.value, value.name);
+  if (!label) return null;
+  const description = readString(value.description);
+  return description ? { label, description } : { label };
+}
+function normalizeChoices(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(normalizeChoice).filter((choice) => choice !== null);
+}
+function normalizeQuestion(value) {
+  if (!isObject4(value)) return null;
+  const question = readString(value.question, value.prompt, value.text, value.message);
+  if (!question) return null;
+  const header = readString(value.header, value.title);
+  const multiSelect = typeof value.multiSelect === "boolean" ? value.multiSelect : typeof value.multi_select === "boolean" ? value.multi_select : void 0;
   return {
-    sessionId: existing.sessionId,
-    version: existing.version,
-    gitBranch: existing.gitBranch,
-    cwd: existing.cwd,
-    slug: existing.slug,
-    name: existing.name,
-    model: existing.model || (allTurns.length > 0 ? allTurns[allTurns.length - 1].model || "" : ""),
-    turns: allTurns,
+    question,
+    ...header ? { header } : {},
+    options: normalizeChoices(value.options ?? value.choices),
+    ...multiSelect === void 0 ? {} : { multiSelect }
+  };
+}
+function normalizeAskUserInput(input) {
+  const source = Array.isArray(input.questions) ? input.questions : [input];
+  const questions = source.map(normalizeQuestion).filter((question) => question !== null);
+  return questions.length > 0 ? { ...input, questions } : input;
+}
+function normalizeToolName(name) {
+  switch (name.toLowerCase().replace(/-/g, "_")) {
+    case "ask_user":
+      return "AskUserQuestion";
+    case "bash":
+    case "powershell":
+    case "shell":
+      return "Bash";
+    case "create":
+      return "Write";
+    case "edit":
+      return "Edit";
+    default:
+      return name;
+  }
+}
+function normalizeToolInput(name, value) {
+  const input = isObject4(value) ? value : value === void 0 ? {} : { value };
+  if (name === "AskUserQuestion") return normalizeAskUserInput(input);
+  if (name === "Edit") {
+    return {
+      ...input,
+      file_path: readString(input.file_path, input.path),
+      old_string: readString(input.old_string, input.old_str),
+      new_string: readString(input.new_string, input.new_str)
+    };
+  }
+  if (name === "Write") {
+    return {
+      ...input,
+      file_path: readString(input.file_path, input.path),
+      content: readString(input.content, input.file_text)
+    };
+  }
+  if (name === "Bash" && typeof input.command !== "string" && typeof input.cmd === "string") {
+    return { ...input, command: input.cmd };
+  }
+  return input;
+}
+function extractToolResult(data) {
+  const error = data.error;
+  if (typeof error === "string") return error;
+  if (isObject4(error)) {
+    const message = readString(error.message, error.code);
+    if (message) return message;
+  }
+  const result = data.result;
+  if (typeof result === "string") return result;
+  if (!isObject4(result)) return result === void 0 ? "" : safeStringify2(result);
+  if (typeof result.detailedContent === "string") return result.detailedContent;
+  if (typeof result.content === "string") return result.content;
+  if (Array.isArray(result.contents)) {
+    const content = result.contents.flatMap((part) => {
+      const text = typeof part === "string" ? part : isObject4(part) ? readString(part.text, part.content, part.output) : "";
+      return text ? [text] : [];
+    }).join("\n");
+    if (content) return content;
+  }
+  if (result.structuredContent !== void 0) return safeStringify2(result.structuredContent);
+  return safeStringify2(result);
+}
+function appendThinking2(turn, text, timestamp, signature) {
+  if (!text || turn.thinking.some((block2) => block2.thinking === text)) return;
+  const block = { type: "thinking", thinking: text, signature };
+  turn.thinking.push(block);
+  const last = turn.contentBlocks[turn.contentBlocks.length - 1];
+  if (last?.kind === "thinking") {
+    last.blocks.push(block);
+    return;
+  }
+  turn.contentBlocks.push({ kind: "thinking", blocks: [block], timestamp });
+}
+function appendToolCall2(turn, call, timestamp) {
+  turn.toolCalls.push(call);
+  const last = turn.contentBlocks[turn.contentBlocks.length - 1];
+  if (last?.kind === "tool_calls") {
+    last.toolCalls.push(call);
+    return;
+  }
+  turn.contentBlocks.push({ kind: "tool_calls", toolCalls: [call], timestamp });
+}
+function newToolCall(id, name, input, timestamp) {
+  return { id, name, input, result: null, isError: false, timestamp };
+}
+function toolCallsFromRequests(value, timestamp, isPending) {
+  if (!Array.isArray(value)) return [];
+  const calls = [];
+  for (const request of value) {
+    if (!isObject4(request)) continue;
+    const id = readString(request.toolCallId);
+    const rawName = readString(request.name);
+    if (!id || !rawName || isPending(id)) continue;
+    const name = normalizeToolName(rawName);
+    calls.push(newToolCall(id, name, normalizeToolInput(name, request.arguments), timestamp));
+  }
+  return calls;
+}
+function updateToolCallStart(call, name, input, timestamp) {
+  call.name = name;
+  call.input = normalizeToolInput(name, input);
+  call.timestamp = timestamp || call.timestamp;
+}
+function updateToolCallResult(call, data, binaryAssets) {
+  call.result = extractToolResult(data);
+  const resultImages = extractToolResultImages(data, binaryAssets);
+  if (resultImages.length > 0) call.resultImages = resultImages;
+  call.isError = data.success === false || data.error !== void 0 && data.error !== null;
+}
+function createTurn3(id, timestamp, userMessage, model, effort, isFragment) {
+  return {
+    id,
+    userMessage,
+    contentBlocks: [],
+    thinking: [],
+    assistantText: [],
+    toolCalls: [],
+    subAgentActivity: [],
+    timestamp,
+    durationMs: null,
+    tokenUsage: null,
+    model,
+    ...effort ? { effort } : {},
+    ...isFragment ? { isFragment: true } : {}
+  };
+}
+function hasTurnContent(turn) {
+  return turn.userMessage !== null || turn.assistantText.length > 0 || turn.thinking.length > 0 || turn.toolCalls.length > 0 || turn.subAgentActivity.length > 0;
+}
+function parseCopilotSession(jsonlText, options) {
+  const events = parseEvents(jsonlText);
+  const metadata = extractMetadata(events);
+  const binaryAssets = collectBinaryAssets(events);
+  const turns = [];
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  const agentMessages = /* @__PURE__ */ new Map();
+  const pendingAgentToolCalls = /* @__PURE__ */ new Map();
+  const endTimestamps = /* @__PURE__ */ new WeakMap();
+  const apiDurationMs = /* @__PURE__ */ new WeakMap();
+  let current = null;
+  let currentModel = null;
+  let currentEffort;
+  let sawAssistantUsage = false;
+  let sawAssistantDuration = false;
+  let shutdownUsage = null;
+  function noteTimestamp(turn, timestamp) {
+    if (timestamp) endTimestamps.set(turn, timestamp);
+  }
+  function ensureTurn(event) {
+    if (!current) {
+      current = createTurn3(
+        turnEventId(event),
+        eventTimestamp(event),
+        null,
+        currentModel,
+        currentEffort,
+        true
+      );
+    }
+    return current;
+  }
+  function finalizeCurrent() {
+    if (!current) return;
+    if (hasTurnContent(current)) turns.push(current);
+    current = null;
+  }
+  function ensureAgent(event) {
+    const agentId = typeof event.agentId === "string" ? event.agentId : "";
+    if (!agentId) return null;
+    const existing = agentMessages.get(agentId);
+    if (existing) return existing.message;
+    const data = event.data;
+    const parentToolUseId = readString(data.toolCallId);
+    const targetTurn = parentToolUseId ? pendingToolCalls.get(parentToolUseId)?.turn ?? current : current;
+    if (!targetTurn) return null;
+    const executionMode = readString(data.executionMode);
+    const message = {
+      agentId,
+      ...parentToolUseId ? { parentToolUseId } : {},
+      agentName: readString(data.agentDisplayName, data.agentName) || null,
+      subagentType: readString(data.agentType, data.agentName) || null,
+      type: "assistant",
+      content: null,
+      toolCalls: [],
+      thinking: [],
+      text: [],
+      timestamp: eventTimestamp(event),
+      tokenUsage: null,
+      model: readString(data.model) || null,
+      isBackground: executionMode === "background",
+      ...readString(data.description) ? { prompt: readString(data.description) } : {},
+      status: "running"
+    };
+    targetTurn.subAgentActivity.push(message);
+    targetTurn.contentBlocks.push({
+      kind: message.isBackground ? "background_agent" : "sub_agent",
+      messages: [message],
+      timestamp: message.timestamp
+    });
+    agentMessages.set(agentId, { message, turn: targetTurn });
+    return message;
+  }
+  function applyAgentEvent(event) {
+    if (isRootEvent(event)) return false;
+    const message = ensureAgent(event);
+    if (!message) return true;
+    const { data } = event;
+    const timestamp = eventTimestamp(event);
+    if (event.type === "subagent.started" || event.type === "subagent.configured") {
+      message.parentToolUseId ||= readString(data.toolCallId) || void 0;
+      message.agentName = readString(data.agentDisplayName, data.agentName) || message.agentName;
+      message.subagentType = readString(data.agentType, data.agentName) || message.subagentType;
+      message.model = readString(data.model) || message.model;
+      message.prompt ||= readString(data.description) || void 0;
+      message.isBackground ||= readString(data.executionMode) === "background";
+      message.status = "running";
+      return true;
+    }
+    if (event.type === "subagent.completed" || event.type === "subagent.failed") {
+      message.agentName = readString(data.agentDisplayName, data.agentName) || message.agentName;
+      message.subagentType = readString(data.agentType, data.agentName) || message.subagentType;
+      message.model = readString(data.model) || message.model;
+      message.durationMs = readNumber(data.durationMs) || message.durationMs;
+      message.toolUseCount = readNumber(data.totalToolCalls) || message.toolUseCount;
+      message.status = event.type === "subagent.completed" ? "completed" : "failed";
+      const failure = readString(data.error, data.message);
+      if (failure && !message.text.includes(failure)) message.text.push(failure);
+      return true;
+    }
+    if (event.type === "user.message") {
+      message.prompt ||= readString(data.content) || void 0;
+      return true;
+    }
+    if (event.type === "assistant.reasoning") {
+      const reasoning = readString(data.content);
+      if (reasoning && !message.thinking.includes(reasoning)) message.thinking.push(reasoning);
+      return true;
+    }
+    if (event.type === "assistant.message") {
+      message.model = readString(data.model) || message.model;
+      const reasoning = readString(data.reasoningText);
+      if (reasoning && !message.thinking.includes(reasoning)) message.thinking.push(reasoning);
+      const text = textFromValue(data.content);
+      if (text && !message.text.includes(text)) message.text.push(text);
+      for (const call of toolCallsFromRequests(
+        data.toolRequests,
+        timestamp,
+        (id) => pendingAgentToolCalls.has(id)
+      )) {
+        message.toolCalls.push(call);
+        pendingAgentToolCalls.set(call.id, { call, message });
+      }
+      return true;
+    }
+    if (event.type === "assistant.usage") {
+      message.model = readString(data.model) || message.model;
+      const usage = parseUsage(data);
+      if (usage) message.tokenUsage = mergeTokenUsage(message.tokenUsage, usage);
+      return true;
+    }
+    if (event.type === "tool.execution_start") {
+      const callId = readString(data.toolCallId) || eventId(event, "copilot-agent-tool");
+      const rawName = readString(data.toolName) || "Tool";
+      const name = normalizeToolName(rawName);
+      const existing = pendingAgentToolCalls.get(callId);
+      if (existing) {
+        updateToolCallStart(existing.call, name, data.arguments, timestamp);
+      } else {
+        const call = newToolCall(
+          callId,
+          name,
+          normalizeToolInput(name, data.arguments),
+          timestamp
+        );
+        message.toolCalls.push(call);
+        pendingAgentToolCalls.set(callId, { call, message });
+      }
+      return true;
+    }
+    if (event.type === "tool.execution_complete") {
+      const callId = readString(data.toolCallId) || eventId(event, "copilot-agent-tool");
+      let pending = pendingAgentToolCalls.get(callId);
+      if (!pending) {
+        const rawName = readString(data.toolName) || "Tool";
+        const name = normalizeToolName(rawName);
+        const call = newToolCall(callId, name, {}, timestamp);
+        message.toolCalls.push(call);
+        pending = { call, message };
+      }
+      updateToolCallResult(pending.call, data, binaryAssets);
+      pendingAgentToolCalls.delete(callId);
+      return true;
+    }
+    return true;
+  }
+  for (const event of events) {
+    if (applyAgentEvent(event)) continue;
+    const { data } = event;
+    const timestamp = eventTimestamp(event);
+    if (event.type === "session.start" || event.type === "session.resume") {
+      currentModel = readString(data.selectedModel) || currentModel;
+      currentEffort = readString(data.reasoningEffort) || currentEffort;
+      continue;
+    }
+    if (event.type === "session.auto_mode_resolved") {
+      currentModel = readString(data.chosenModel) || currentModel;
+      if (current) current.model = currentModel;
+      continue;
+    }
+    if (event.type === "session.model_change") {
+      currentModel = readString(data.newModel) || currentModel;
+      const effort = data.reasoningEffort;
+      if (typeof effort === "string") currentEffort = effort;
+      if (current) {
+        current.model = currentModel;
+        if (currentEffort) current.effort = currentEffort;
+      }
+      continue;
+    }
+    if (event.type === "session.shutdown") {
+      currentModel = readString(data.currentModel) || currentModel;
+      if (current && !current.model) current.model = currentModel;
+      shutdownUsage = parseModelMetrics(data) ?? shutdownUsage;
+      const duration = readNumber(data.totalApiDurationMs);
+      if (current && !sawAssistantDuration && duration) apiDurationMs.set(current, duration);
+      continue;
+    }
+    if (event.type === "user.message") {
+      finalizeCurrent();
+      current = createTurn3(
+        turnEventId(event),
+        timestamp,
+        buildUserContent(data, binaryAssets),
+        currentModel,
+        currentEffort,
+        false
+      );
+      noteTimestamp(current, timestamp);
+      continue;
+    }
+    if (event.type === "assistant.turn_start") {
+      currentModel = readString(data.model) || currentModel;
+      const turn = ensureTurn(event);
+      turn.model = currentModel;
+      if (currentEffort) turn.effort = currentEffort;
+      noteTimestamp(turn, timestamp);
+      continue;
+    }
+    if (event.type === "assistant.reasoning") {
+      const turn = ensureTurn(event);
+      appendThinking2(
+        turn,
+        readString(data.content),
+        timestamp,
+        readString(data.reasoningId) || eventId(event, "copilot-thinking")
+      );
+      noteTimestamp(turn, timestamp);
+      continue;
+    }
+    if (event.type === "assistant.message") {
+      currentModel = readString(data.model) || currentModel;
+      const turn = ensureTurn(event);
+      turn.model = currentModel;
+      if (currentEffort) turn.effort = currentEffort;
+      appendThinking2(
+        turn,
+        readString(data.reasoningText),
+        timestamp,
+        eventId(event, "copilot-thinking")
+      );
+      appendAssistantText(turn, textFromValue(data.content), timestamp);
+      for (const call of toolCallsFromRequests(
+        data.toolRequests,
+        timestamp,
+        (id) => pendingToolCalls.has(id)
+      )) {
+        appendToolCall2(turn, call, timestamp);
+        pendingToolCalls.set(call.id, { call, turn });
+      }
+      noteTimestamp(turn, timestamp);
+      continue;
+    }
+    if (event.type === "assistant.usage") {
+      currentModel = readString(data.model) || currentModel;
+      currentEffort = readString(data.reasoningEffort) || currentEffort;
+      const usage = parseUsage(data);
+      const duration = readNumber(data.duration);
+      if (usage) sawAssistantUsage = true;
+      if (duration) sawAssistantDuration = true;
+      const turn = ensureTurn(event);
+      turn.model = currentModel;
+      if (currentEffort) turn.effort = currentEffort;
+      if (usage) turn.tokenUsage = mergeTokenUsage(turn.tokenUsage, usage);
+      if (duration) apiDurationMs.set(turn, (apiDurationMs.get(turn) ?? 0) + duration);
+      noteTimestamp(turn, timestamp);
+      continue;
+    }
+    if (event.type === "tool.execution_start") {
+      currentModel = readString(data.model) || currentModel;
+      const turn = ensureTurn(event);
+      turn.model = currentModel;
+      const callId = readString(data.toolCallId) || eventId(event, "copilot-tool");
+      const rawName = readString(data.toolName) || "Tool";
+      const name = normalizeToolName(rawName);
+      const existing = pendingToolCalls.get(callId);
+      if (existing) {
+        updateToolCallStart(existing.call, name, data.arguments, timestamp);
+      } else {
+        const call = newToolCall(
+          callId,
+          name,
+          normalizeToolInput(name, data.arguments),
+          timestamp
+        );
+        appendToolCall2(turn, call, timestamp);
+        pendingToolCalls.set(callId, { call, turn });
+      }
+      noteTimestamp(turn, timestamp);
+      continue;
+    }
+    if (event.type === "tool.execution_complete") {
+      currentModel = readString(data.model) || currentModel;
+      const callId = readString(data.toolCallId) || eventId(event, "copilot-tool");
+      let pending = pendingToolCalls.get(callId);
+      if (!pending) {
+        const turn = ensureTurn(event);
+        const rawName = readString(data.toolName) || "Tool";
+        const name = normalizeToolName(rawName);
+        const call = newToolCall(callId, name, {}, timestamp);
+        appendToolCall2(turn, call, timestamp);
+        pending = { call, turn };
+      }
+      updateToolCallResult(pending.call, data, binaryAssets);
+      pendingToolCalls.delete(callId);
+      noteTimestamp(pending.turn, timestamp);
+      continue;
+    }
+    if (event.type === "session.error") {
+      const turn = ensureTurn(event);
+      const errorType = readString(data.errorType) || "unknown";
+      const input = { errorType };
+      if (typeof data.statusCode === "number") input.statusCode = data.statusCode;
+      if (typeof data.errorCode === "string") input.errorCode = data.errorCode;
+      appendToolCall2(turn, {
+        id: eventId(event, "copilot-error"),
+        name: "Error",
+        input,
+        result: readString(data.message) || "Copilot session error",
+        isError: true,
+        timestamp
+      }, timestamp);
+      noteTimestamp(turn, timestamp);
+      continue;
+    }
+    if (event.type === "assistant.turn_end" || event.type === "assistant.idle" || event.type === "session.idle") {
+      if (current) noteTimestamp(current, timestamp);
+    }
+  }
+  finalizeCurrent();
+  if (!sawAssistantUsage && shutdownUsage && turns.length === 1) {
+    turns[0].tokenUsage = mergeTokenUsage(turns[0].tokenUsage, shutdownUsage);
+  }
+  if (metadata.model) {
+    for (const turn of turns) turn.model ||= metadata.model;
+  }
+  for (const turn of turns) {
+    const endTimestamp = endTimestamps.get(turn);
+    const start = Date.parse(turn.timestamp);
+    const end = endTimestamp ? Date.parse(endTimestamp) : Number.NaN;
+    if (Number.isFinite(start) && Number.isFinite(end) && end >= start) {
+      turn.durationMs = end - start;
+    } else {
+      const duration = apiDurationMs.get(turn) ?? 0;
+      if (duration) turn.durationMs = duration;
+    }
+  }
+  const stats = options?.skipStats ? createEmptySessionStats(turns.length) : computeStats(turns);
+  if (!options?.skipStats && !sawAssistantUsage && shutdownUsage && turns.length > 1) {
+    stats.totalInputTokens = shutdownUsage.input_tokens;
+    stats.totalOutputTokens = shutdownUsage.output_tokens;
+    stats.totalCacheCreationTokens = shutdownUsage.cache_creation_input_tokens ?? 0;
+    stats.totalCacheReadTokens = shutdownUsage.cache_read_input_tokens ?? 0;
+  }
+  return {
+    sessionId: metadata.sessionId,
+    version: metadata.version,
+    gitBranch: metadata.gitBranch,
+    cwd: metadata.cwd,
+    slug: metadata.slug,
+    name: metadata.name,
+    model: metadata.model,
+    turns,
     stats,
-    rawMessages: allRawMessages,
-    branchedFrom: existing.branchedFrom,
-    agentKind: existing.agentKind
+    rawMessages: options?.skipStats ? [] : events,
+    agentKind: "copilot"
   };
 }
+function appendCopilotSession(existing, newJsonlText) {
+  const prefix = existing.rawMessages.map((record) => JSON.stringify(record)).join("\n");
+  return parseCopilotSession(prefix ? `${prefix}
+${newJsonlText}` : newJsonlText);
+}
+function isCopilotEventType(type) {
+  return typeof type === "string" && (type === "abort" || type === "binary_asset" || type === "user.message" || type.startsWith("assistant.") || type.startsWith("permission.") || type.startsWith("session.") || type.startsWith("subagent.") || type.startsWith("tool.") || type.startsWith("user_input."));
+}
+function deriveCopilotSessionStatus(rawMessages) {
+  const pendingAgents = /* @__PURE__ */ new Map();
+  for (const event of rawMessages) {
+    const agentId = typeof event.agentId === "string" ? event.agentId : "";
+    if (!agentId && (event.type === "abort" || event.type === "session.shutdown" || event.type === "session.error")) {
+      pendingAgents.clear();
+      continue;
+    }
+    if (!agentId || !event.type.startsWith("subagent.")) continue;
+    const data = isObject4(event.data) ? event.data : {};
+    if (event.type === "subagent.completed" || event.type === "subagent.failed") {
+      pendingAgents.delete(agentId);
+      continue;
+    }
+    if (event.type === "subagent.started" || event.type === "subagent.configured") {
+      const description = [data.agentDisplayName, data.description, data.agentName].find((value) => typeof value === "string") ?? "";
+      pendingAgents.set(agentId, description || pendingAgents.get(agentId) || "");
+    }
+  }
+  if (pendingAgents.size > 0) {
+    const descriptions = [...pendingAgents.values()];
+    return {
+      status: "awaiting_agents",
+      pendingQueue: 0,
+      pendingAgents: descriptions.length,
+      pendingAgentDescriptions: descriptions.filter((description) => description.length > 0)
+    };
+  }
+  let sawUserActivity = false;
+  const completedPermissionRequests = /* @__PURE__ */ new Set();
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const event = rawMessages[i];
+    if (typeof event.agentId === "string" && event.agentId) continue;
+    const data = isObject4(event.data) ? event.data : {};
+    switch (event.type) {
+      case "abort":
+      case "session.shutdown":
+        return { status: "completed" };
+      case "assistant.turn_end": {
+        for (let j = i - 1; j >= 0; j--) {
+          const previous = rawMessages[j];
+          if (typeof previous.agentId === "string" && previous.agentId) continue;
+          if (previous.type === "user.message") break;
+          if (previous.type === "abort") return { status: "completed" };
+          if (previous.type !== "assistant.message") continue;
+          const previousData = isObject4(previous.data) ? previous.data : {};
+          return Array.isArray(previousData.toolRequests) && previousData.toolRequests.length > 0 ? { status: "processing" } : { status: "completed" };
+        }
+        return { status: "processing" };
+      }
+      case "session.error":
+        return {
+          status: "completed",
+          terminalReason: typeof data.message === "string" ? data.message : "Copilot session error"
+        };
+      case "assistant.idle":
+      case "session.idle":
+        return { status: sawUserActivity ? "completed" : "idle" };
+      case "permission.completed": {
+        const requestId = typeof data.requestId === "string" ? data.requestId : "";
+        if (requestId) completedPermissionRequests.add(requestId);
+        continue;
+      }
+      case "permission.requested": {
+        const requestId = typeof data.requestId === "string" ? data.requestId : "";
+        if (requestId && completedPermissionRequests.has(requestId)) continue;
+        return { status: "deferred" };
+      }
+      case "user_input.requested":
+        return { status: "tool_use", toolName: "AskUserQuestion" };
+      case "tool.execution_start":
+        if (completedPermissionRequests.size > 0) return { status: "thinking" };
+        return {
+          status: "tool_use",
+          toolName: typeof data.toolName === "string" ? normalizeFunctionName(data.toolName) : typeof data.name === "string" ? normalizeFunctionName(data.name) : void 0
+        };
+      case "tool.execution_complete":
+        return { status: "thinking" };
+      case "assistant.turn_start":
+        return { status: "processing" };
+      case "assistant.message":
+      case "assistant.message_delta":
+      case "assistant.reasoning":
+      case "assistant.reasoning_delta":
+        return { status: "thinking" };
+      case "user.message":
+        sawUserActivity = true;
+        return { status: "processing" };
+      case "session.start":
+      case "session.resume":
+        return { status: sawUserActivity ? "processing" : "idle" };
+    }
+  }
+  return { status: "idle" };
+}
+function brandCopilotBranch() {
+  throw new Error("Copilot sessions branch through the CLI's fork API, not by copying the transcript");
+}
+function copilotTurnBoundaries(records) {
+  const boundaries = [];
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    if (record.type !== "user.message" || typeof record.agentId === "string") continue;
+    const data = record.data;
+    if (!data || typeof data !== "object" || Array.isArray(data)) continue;
+    if (typeof record.id !== "string" || !record.id) continue;
+    boundaries.push(index);
+  }
+  return boundaries;
+}
+
+// src/lib/agents.ts
+var TERMINAL_AGENT_KIND = AGENT_KINDS[AGENT_KINDS.length - 1];
+var codexFormat = {
+  kind: "codex",
+  descriptor: descriptorFor("codex"),
+  detectsText: isCodexSessionText,
+  detectsRecords: isCodexRawRecords,
+  parse: parseCodexSession,
+  append: appendCodexSession,
+  metadataFromLines: extractCodexMetadataFromLines,
+  status: deriveCodexSessionStatus,
+  brandBranch: brandCodexBranch,
+  turnBoundaries: codexTurnBoundaries
+};
+var copilotFormat = {
+  kind: "copilot",
+  descriptor: descriptorFor("copilot"),
+  detectsText: isCopilotSessionText,
+  detectsRecords: isCopilotRawRecords,
+  parse: parseCopilotSession,
+  append: appendCopilotSession,
+  metadataFromLines: extractCopilotMetadataFromLines,
+  status: deriveCopilotSessionStatus,
+  brandBranch: brandCopilotBranch,
+  turnBoundaries: copilotTurnBoundaries
+};
+var claudeFormat = {
+  kind: "claude",
+  descriptor: descriptorFor("claude"),
+  // The terminal arm answers `true` for both, so order alone decides.
+  detectsText: isClaudeSessionText,
+  detectsRecords: isClaudeSessionText,
+  parse: parseClaudeSession,
+  append: appendClaudeSession,
+  metadataFromLines: extractClaudeMetadataFromLines,
+  status: deriveClaudeSessionStatus,
+  brandBranch: brandClaudeBranch,
+  turnBoundaries: claudeTurnBoundaries
+};
+var FORMATS = Object.freeze({
+  claude: claudeFormat,
+  codex: codexFormat,
+  copilot: copilotFormat
+});
+function firstMatch(matches) {
+  for (const kind of AGENT_KINDS) {
+    if (matches(FORMATS[kind])) return FORMATS[kind];
+  }
+  return FORMATS[TERMINAL_AGENT_KIND];
+}
+function formatForText(jsonlText) {
+  return firstMatch((format) => format.detectsText(jsonlText));
+}
+function formatForRecords(records) {
+  return firstMatch((format) => format.detectsRecords(records));
+}
+
+// src/lib/parser.ts
+function extractTextFromContent2(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function parseSession(jsonlText, options) {
+  return formatForText(jsonlText).parse(jsonlText, options);
+}
+function parseSessionAppend(existing, newJsonlText) {
+  const byRecords = formatForRecords(existing.rawMessages);
+  const format = byRecords.kind === TERMINAL_AGENT_KIND ? formatForText(newJsonlText) : byRecords;
+  return format.append(existing, newJsonlText);
+}
 function getUserMessageText(content) {
   if (content === null) return "";
   if (typeof content === "string") return content;
@@ -2108,20 +3964,272 @@ function getUserMessageImages(content) {
   return content.filter((b) => b.type === "image");
 }
 
+// src/lib/stores.ts
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/lib/dirs.ts
+var import_node_path = require("node:path");
+var import_node_os = require("node:os");
+function agentHomeDir(kind, env = process.env, homeDirectory = (0, import_node_os.homedir)()) {
+  const { homeEnvVar, homeDirName } = descriptorFor(kind).cli;
+  const override = homeEnvVar ? env[homeEnvVar] : void 0;
+  return override || (0, import_node_path.join)(homeDirectory, homeDirName);
+}
+var dirs = {
+  PROJECTS_DIR: (0, import_node_path.join)(agentHomeDir("claude"), "projects"),
+  TEAMS_DIR: (0, import_node_path.join)(agentHomeDir("claude"), "teams"),
+  TASKS_DIR: (0, import_node_path.join)(agentHomeDir("claude"), "tasks"),
+  CODEX_SESSIONS_DIR: (0, import_node_path.join)(agentHomeDir("codex"), "sessions"),
+  COPILOT_SESSIONS_DIR: (0, import_node_path.join)(agentHomeDir("copilot"), "session-state")
+};
+var DEFAULT_DB_PATH = (0, import_node_path.join)(agentHomeDir("claude"), "cogpit-memory", "search-index.db");
+
+// src/lib/stores.ts
+var NON_PROJECT_DIRS = /* @__PURE__ */ new Set(["memory"]);
+var MAX_WALK_DEPTH = 4;
+var SUBAGENTS_DIR = "subagents";
+function mtimeOf(filePath) {
+  try {
+    return (0, import_node_fs.statSync)(filePath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function readDirSafe(dir) {
+  try {
+    return (0, import_node_fs.readdirSync)(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function isWithin(root, target) {
+  const rel = (0, import_node_path2.relative)(root, target);
+  return rel !== "" && !rel.startsWith("..") && !(0, import_node_path2.isAbsolute)(rel);
+}
+function canonicalWithinRoot(root, filePath) {
+  try {
+    const realRoot = (0, import_node_fs.realpathSync)(root);
+    const real = (0, import_node_fs.realpathSync)(filePath);
+    return isWithin(realRoot, real) ? real : null;
+  } catch {
+    return null;
+  }
+}
+function segmentsUnder(root, filePath) {
+  return (0, import_node_path2.relative)(root, filePath).split(import_node_path2.sep).filter(Boolean);
+}
+function claudeIdentify(filePath, root) {
+  const segments = segmentsUnder(root, filePath);
+  const subagentAt = segments.lastIndexOf(SUBAGENTS_DIR);
+  if (subagentAt > 0) {
+    const parentSessionId = segments[subagentAt - 1];
+    return { sessionId: parentSessionId, isSubagent: true, parentSessionId };
+  }
+  const fileName = segments[segments.length - 1] ?? "";
+  return {
+    sessionId: descriptorFor("claude").sessionFile.sessionId(fileName) ?? fileName.replace(/\.jsonl$/, ""),
+    isSubagent: false,
+    parentSessionId: null
+  };
+}
+function subagentDirOf(parentPath) {
+  return (0, import_node_path2.join)(parentPath.replace(/\.jsonl$/, ""), SUBAGENTS_DIR);
+}
+function walkClaudeSubagents(parentPath, parentSessionId, cutoffMs, depth, out) {
+  if (depth >= MAX_WALK_DEPTH) return;
+  const dir = subagentDirOf(parentPath);
+  for (const entry of readDirSafe(dir)) {
+    if (!entry.name.startsWith("agent-") || !entry.name.endsWith(".jsonl")) continue;
+    const filePath = (0, import_node_path2.join)(dir, entry.name);
+    const mtimeMs = mtimeOf(filePath);
+    if (mtimeMs !== null && mtimeMs >= cutoffMs) {
+      out.push({
+        path: filePath,
+        mtimeMs,
+        sessionId: parentSessionId,
+        isSubagent: true,
+        parentSessionId
+      });
+    }
+    walkClaudeSubagents(filePath, parentSessionId, cutoffMs, depth + 1, out);
+  }
+}
+function walkClaude(root, cutoffMs) {
+  const found = [];
+  for (const project of readDirSafe(root)) {
+    if (!project.isDirectory() || NON_PROJECT_DIRS.has(project.name)) continue;
+    const projectDir = (0, import_node_path2.join)(root, project.name);
+    for (const entry of readDirSafe(projectDir)) {
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+      const filePath = (0, import_node_path2.join)(projectDir, entry.name);
+      const mtimeMs = mtimeOf(filePath);
+      const { sessionId } = claudeIdentify(filePath, root);
+      if (mtimeMs !== null && mtimeMs >= cutoffMs) {
+        found.push({ path: filePath, mtimeMs, sessionId, isSubagent: false, parentSessionId: null });
+      }
+      walkClaudeSubagents(filePath, sessionId, cutoffMs, 0, found);
+    }
+  }
+  return found;
+}
+function walkCodex(root, cutoffMs, dir = root, depth = 0) {
+  if (depth > MAX_WALK_DEPTH) return [];
+  const found = [];
+  for (const entry of readDirSafe(dir)) {
+    const filePath = (0, import_node_path2.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      found.push(...walkCodex(root, cutoffMs, filePath, depth + 1));
+      continue;
+    }
+    if (!entry.name.endsWith(".jsonl")) continue;
+    const mtimeMs = mtimeOf(filePath);
+    if (mtimeMs === null || mtimeMs < cutoffMs) continue;
+    found.push({
+      path: filePath,
+      mtimeMs,
+      sessionId: descriptorFor("codex").sessionFile.sessionId(entry.name) ?? "",
+      isSubagent: false,
+      parentSessionId: null
+    });
+  }
+  return found;
+}
+function copilotTranscript(root, sessionId) {
+  return (0, import_node_path2.join)(root, descriptorFor("copilot").sessionFile.name(sessionId));
+}
+function walkCopilot(root, cutoffMs) {
+  const found = [];
+  for (const entry of readDirSafe(root)) {
+    if (!entry.isDirectory()) continue;
+    const filePath = copilotTranscript(root, entry.name);
+    const mtimeMs = mtimeOf(filePath);
+    if (mtimeMs === null || mtimeMs < cutoffMs) continue;
+    found.push({
+      path: filePath,
+      mtimeMs,
+      sessionId: entry.name,
+      isSubagent: false,
+      parentSessionId: null
+    });
+  }
+  return found;
+}
+var WALKERS = {
+  claude: {
+    root: () => dirs.PROJECTS_DIR,
+    list: walkClaude,
+    identify: claudeIdentify,
+    find(root, sessionId) {
+      const fileName = descriptorFor("claude").sessionFile.name(sessionId);
+      for (const project of readDirSafe(root)) {
+        if (!project.isDirectory() || NON_PROJECT_DIRS.has(project.name)) continue;
+        const candidate = (0, import_node_path2.join)(root, project.name, fileName);
+        if (mtimeOf(candidate) !== null) return candidate;
+      }
+      return null;
+    }
+  },
+  codex: {
+    root: () => dirs.CODEX_SESSIONS_DIR,
+    list: (root, cutoffMs) => walkCodex(root, cutoffMs),
+    identify: (filePath) => ({
+      sessionId: descriptorFor("codex").sessionFile.sessionId(filePath) ?? "",
+      isSubagent: false,
+      parentSessionId: null
+    }),
+    // A rollout's date nesting cannot be rebuilt from the id, so the tree is
+    // walked; every rollout carries the id in its file name.
+    find(root, sessionId) {
+      const walk = (dir, depth) => {
+        if (depth > MAX_WALK_DEPTH) return null;
+        for (const entry of readDirSafe(dir)) {
+          const filePath = (0, import_node_path2.join)(dir, entry.name);
+          if (entry.isDirectory()) {
+            const match = walk(filePath, depth + 1);
+            if (match) return match;
+            continue;
+          }
+          if (entry.name.endsWith(`${sessionId}.jsonl`)) return filePath;
+        }
+        return null;
+      };
+      return walk(root, 0);
+    }
+  },
+  copilot: {
+    root: () => dirs.COPILOT_SESSIONS_DIR,
+    list: walkCopilot,
+    identify: (filePath, root) => ({
+      sessionId: segmentsUnder(root, filePath)[0] ?? "",
+      isSubagent: false,
+      parentSessionId: null
+    }),
+    find(root, sessionId) {
+      const candidate = copilotTranscript(root, sessionId);
+      return mtimeOf(candidate) === null ? null : candidate;
+    }
+  }
+};
+function makeStore(kind) {
+  const walker = WALKERS[kind];
+  return {
+    kind,
+    descriptor: descriptorFor(kind),
+    root: walker.root,
+    ownsPath: (filePath) => isWithin((0, import_node_path2.resolve)(walker.root()), (0, import_node_path2.resolve)(filePath)),
+    identify: (filePath, root = walker.root()) => walker.identify(filePath, root),
+    list: (cutoffMs, root = walker.root()) => walker.list(root, cutoffMs),
+    find: (sessionId) => walker.find(walker.root(), sessionId)
+  };
+}
+var STORES = {
+  claude: makeStore("claude"),
+  codex: makeStore("codex"),
+  copilot: makeStore("copilot")
+};
+function storeFor(kind) {
+  return STORES[kind];
+}
+function defaultStore() {
+  return storeFor(descriptorForDirName(null).kind);
+}
+function allStores() {
+  return AGENT_KINDS.map((kind) => STORES[kind]);
+}
+function storeForPath(filePath) {
+  return allStores().find((store) => store.ownsPath(filePath)) ?? null;
+}
+function listAllSessionFiles(cutoffMs) {
+  return allStores().flatMap((store) => store.list(cutoffMs)).sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+function isSinglePathSegment(value) {
+  return value.length > 0 && !value.includes("/") && !value.includes("\\") && !value.includes("\0") && value !== "." && value !== "..";
+}
+async function findSessionFile(sessionId) {
+  if (!isSinglePathSegment(sessionId)) return null;
+  for (const store of allStores()) {
+    const filePath = store.find(sessionId);
+    const canonical = filePath && canonicalWithinRoot(store.root(), filePath);
+    if (canonical) return canonical;
+  }
+  return null;
+}
+
 // src/lib/search-index.ts
 var MAX_CONTENT_LEN = 4096;
 function truncContent(text) {
   return text.length > MAX_CONTENT_LEN ? text.slice(0, MAX_CONTENT_LEN) : text;
 }
+function identifyTranscript(filePath) {
+  const store = storeForPath(filePath) ?? defaultStore();
+  return store.identify(filePath, store.root());
+}
 var SearchIndex = class {
   db;
   dbPath;
-  projectsDir = null;
-  _watcherRunning = false;
   _lastFullBuild = null;
   _lastUpdate = null;
-  watcher = null;
-  debounceTimers = /* @__PURE__ */ new Map();
   constructor(dbPath) {
     this.dbPath = dbPath;
     this.db = new Database(dbPath);
@@ -2157,7 +4265,7 @@ var SearchIndex = class {
     const { count: totalRows } = this.db.prepare("SELECT COUNT(*) as count FROM search_content").get();
     let dbSizeBytes = 0;
     try {
-      dbSizeBytes = (0, import_node_fs.statSync)(this.dbPath).size;
+      dbSizeBytes = (0, import_node_fs2.statSync)(this.dbPath).size;
     } catch {
     }
     return {
@@ -2168,7 +4276,6 @@ var SearchIndex = class {
       indexedSessions,
       indexedSubagents,
       totalRows,
-      watcherRunning: this._watcherRunning,
       lastFullBuild: this._lastFullBuild,
       lastUpdate: this._lastUpdate
     };
@@ -2229,13 +4336,11 @@ var SearchIndex = class {
    * All inserts run in a single transaction for performance.
    */
   indexFile(filePath, sessionId, mtimeMs, opts) {
-    if (!sessionId) {
-      sessionId = (0, import_node_path.basename)(filePath, ".jsonl");
-    }
+    const resolvedSessionId = sessionId ?? identifyTranscript(filePath).sessionId;
     if (mtimeMs == null) {
-      mtimeMs = (0, import_node_fs.statSync)(filePath).mtimeMs;
+      mtimeMs = (0, import_node_fs2.statSync)(filePath).mtimeMs;
     }
-    const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
     const session = parseSession(content, { skipStats: true });
     const isSubagent = opts?.isSubagent ? 1 : 0;
     const parentSessionId = opts?.parentSessionId ?? null;
@@ -2254,12 +4359,34 @@ var SearchIndex = class {
     const txn = this.db.transaction(() => {
       deleteContent.run(filePath);
       deleteFile.run(filePath);
-      this.insertSessionContent(insert, sessionId, filePath, session);
-      insertFile.run(filePath, mtimeMs, sessionId, isSubagent, parentSessionId);
+      this.insertSessionContent(insert, resolvedSessionId, filePath, session);
+      insertFile.run(filePath, mtimeMs, resolvedSessionId, isSubagent, parentSessionId);
     });
     txn();
     this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
   }
+  pruneMissingFiles() {
+    const files = this.db.prepare("SELECT file_path FROM indexed_files").all();
+    const missing = files.filter(({ file_path }) => {
+      try {
+        (0, import_node_fs2.statSync)(file_path);
+        return false;
+      } catch (error) {
+        const code = error.code;
+        return code === "ENOENT" || code === "ENOTDIR";
+      }
+    });
+    if (missing.length === 0) return 0;
+    this.db.transaction(() => {
+      this.db.exec("CREATE TEMP TABLE missing_transcripts (file_path TEXT PRIMARY KEY)");
+      const insert = this.db.prepare("INSERT INTO missing_transcripts VALUES (?)");
+      for (const { file_path } of missing) insert.run(file_path);
+      this.db.exec("DELETE FROM search_content WHERE source_file IN (SELECT file_path FROM missing_transcripts)");
+      this.db.exec("DELETE FROM indexed_files WHERE file_path IN (SELECT file_path FROM missing_transcripts)");
+      this.db.exec("DROP TABLE missing_transcripts");
+    })();
+    return missing.length;
+  }
   /**
    * Query the FTS5 index and return structured search results.
    *
@@ -2272,6 +4399,7 @@ var SearchIndex = class {
    * - `limit` defaults to 200 and is clamped to a max of 200.
    */
   search(query, opts) {
+    this.pruneMissingFiles();
     const limit = Math.min(Math.max(1, opts?.limit ?? 200), 200);
     const sessionId = opts?.sessionId;
     const maxAgeMs = opts?.maxAgeMs;
@@ -2294,6 +4422,10 @@ var SearchIndex = class {
       conditions.push("sc.session_id = ?");
       params.push(sessionId);
     }
+    if (opts?.excludeSessionId) {
+      conditions.push("sc.session_id != ?");
+      params.push(opts.excludeSessionId);
+    }
     sql += " WHERE " + conditions.join(" AND ");
     sql += " ORDER BY sc.rowid DESC";
     sql += " LIMIT ?";
@@ -2335,27 +4467,26 @@ var SearchIndex = class {
       conditions.push("sc.session_id = ?");
       params.push(opts.sessionId);
     }
+    if (opts?.excludeSessionId) {
+      conditions.push("sc.session_id != ?");
+      params.push(opts.excludeSessionId);
+    }
     sql += " WHERE " + conditions.join(" AND ");
     const row = this.db.prepare(sql).get(...params);
     return { totalHits: row.total, sessionsSearched: row.sessions };
   }
   /**
-   * Clear all indexed data and re-index every JSONL file under `projectsDir`.
-   * Structure: projectsDir/{projectName}/{sessionId}.jsonl
-   * Subagents:  projectsDir/{projectName}/{sessionId}/subagents/agent-{id}.jsonl
+   * Clear all indexed data and re-index every transcript, from every agent.
    *
    * Optimized: discovers all files first, then processes them in a single
    * SQLite transaction with pre-prepared statements. This avoids the overhead
    * of 3000+ individual transactions (each forcing a disk sync).
-   *
-   * Stores `projectsDir` as a class field so `rebuild()` can reuse it.
    */
-  buildFull(projectsDir) {
-    this.projectsDir = projectsDir;
+  buildFull() {
     this.db.close();
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
-        (0, import_node_fs.unlinkSync)(this.dbPath + suffix);
+        (0, import_node_fs2.unlinkSync)(this.dbPath + suffix);
       } catch {
       }
     }
@@ -2367,8 +4498,8 @@ var SearchIndex = class {
     this.db.exec("PRAGMA mmap_size = 268435456");
     this.initSchema();
     const files = [];
-    this.discoverFiles(projectsDir, (filePath, sessionId, mtimeMs, isSubagent, parentSessionId) => {
-      files.push({ path: filePath, sessionId, mtimeMs, isSubagent, parentSessionId });
+    this.discoverFiles((file) => {
+      files.push(file);
     });
     const insert = this.db.prepare(
       "INSERT INTO search_content (session_id, source_file, location, content) VALUES (?, ?, ?, ?)"
@@ -2379,7 +4510,7 @@ var SearchIndex = class {
     const txn = this.db.transaction(() => {
       for (const file of files) {
         try {
-          const content = (0, import_node_fs.readFileSync)(file.path, "utf-8");
+          const content = (0, import_node_fs2.readFileSync)(file.path, "utf-8");
           const session = parseSession(content, { skipStats: true });
           this.insertSessionContent(insert, file.sessionId, file.path, session);
           insertFile.run(file.path, file.mtimeMs, file.sessionId, file.isSubagent ? 1 : 0, file.parentSessionId);
@@ -2392,39 +4523,6 @@ var SearchIndex = class {
     this._lastFullBuild = (/* @__PURE__ */ new Date()).toISOString();
     this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
   }
-  /**
-   * Incrementally re-index only files whose mtime has changed since last index.
-   * New files (not in indexed_files) are always indexed.
-   *
-   * WARNING: This walks ALL files under projectsDir and stats each one.
-   * On large session stores (3000+ files) this can take minutes.
-   * Prefer `updateRecent()` for CLI search paths.
-   */
-  updateStale(projectsDir) {
-    this.projectsDir = projectsDir;
-    const getIndexed = this.db.prepare(
-      "SELECT mtime_ms FROM indexed_files WHERE file_path = ?"
-    );
-    const filesToIndex = [];
-    this.discoverFiles(projectsDir, (filePath, sessionId, mtimeMs, isSubagent, parentSessionId) => {
-      const existing = getIndexed.get(filePath);
-      if (!existing || existing.mtime_ms < mtimeMs) {
-        filesToIndex.push({ path: filePath, sessionId, mtimeMs, isSubagent, parentSessionId });
-      }
-    });
-    for (const file of filesToIndex) {
-      try {
-        this.indexFile(file.path, file.sessionId, file.mtimeMs, {
-          isSubagent: file.isSubagent,
-          parentSessionId: file.parentSessionId
-        });
-      } catch {
-      }
-    }
-    if (filesToIndex.length > 0) {
-      this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
   /**
    * Lightweight incremental update for CLI search paths.
    *
@@ -2433,8 +4531,7 @@ var SearchIndex = class {
    * Caps re-indexing to `maxFiles` to prevent blocking on large backlogs
    * (run `index rebuild` for a full catch-up).
    */
-  updateRecent(projectsDir, maxFiles = 50) {
-    this.projectsDir = projectsDir;
+  updateRecent(maxFiles = 50) {
     const row = this.db.prepare(
       "SELECT MAX(mtime_ms) as max_mtime FROM indexed_files"
     ).get();
@@ -2443,12 +4540,12 @@ var SearchIndex = class {
       "SELECT mtime_ms FROM indexed_files WHERE file_path = ?"
     );
     const filesToIndex = [];
-    this.discoverFiles(projectsDir, (filePath, sessionId, mtimeMs, isSubagent, parentSessionId) => {
-      if (mtimeMs <= highWater) {
-        const existing = getIndexed.get(filePath);
-        if (existing && existing.mtime_ms >= mtimeMs) return;
+    this.discoverFiles((file) => {
+      if (file.mtimeMs <= highWater) {
+        const existing = getIndexed.get(file.path);
+        if (existing && existing.mtime_ms >= file.mtimeMs) return;
       }
-      filesToIndex.push({ path: filePath, sessionId, mtimeMs, isSubagent, parentSessionId });
+      filesToIndex.push(file);
     });
     filesToIndex.sort((a, b) => b.mtimeMs - a.mtimeMs);
     const batch = filesToIndex.slice(0, maxFiles);
@@ -2465,179 +4562,19 @@ var SearchIndex = class {
       this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
     }
   }
-  /**
-   * Re-run buildFull using the previously stored projectsDir.
-   * No-op if projectsDir was never set.
-   */
-  rebuild() {
-    if (!this.projectsDir) return;
-    this.buildFull(this.projectsDir);
-  }
-  /**
-   * Walk the projects directory tree and invoke `callback` for every JSONL file.
-   *
-   * Directory structure:
-   *   projectsDir/
-   *     {projectName}/
-   *       {sessionId}.jsonl              <- session file
-   *       {sessionId}/subagents/
-   *         agent-{agentId}.jsonl        <- subagent file (recursive)
-   *
-   * Skips the "memory" directory.
-   */
-  discoverFiles(projectsDir, callback) {
-    let entries;
-    try {
-      entries = (0, import_node_fs.readdirSync)(projectsDir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === "memory" || !entry.isDirectory()) continue;
-      const projectDir = (0, import_node_path.join)(projectsDir, entry.name);
-      let files;
-      try {
-        files = (0, import_node_fs.readdirSync)(projectDir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const file of files) {
-        if (!file.name.endsWith(".jsonl") || !file.isFile()) continue;
-        const filePath = (0, import_node_path.join)(projectDir, file.name);
-        const sessionId = (0, import_node_path.basename)(file.name, ".jsonl");
-        try {
-          const s = (0, import_node_fs.statSync)(filePath);
-          callback(filePath, sessionId, s.mtimeMs, false, null);
-        } catch {
-          continue;
-        }
-        this.discoverSubagents(filePath, sessionId, callback, 0, 4);
-      }
-    }
-  }
-  /**
-   * Recursively discover subagent JSONL files under the subagents directory
-   * that corresponds to `parentPath`.
-   *
-   * For a parent at `/path/to/session-1.jsonl`, looks for subagents at
-   * `/path/to/session-1/subagents/agent-*.jsonl`.
-   *
-   * Recurses up to `maxDepth` levels (default 4).
-   */
-  discoverSubagents(parentPath, parentSessionId, callback, depth, maxDepth) {
-    if (depth >= maxDepth) return;
-    const subDir = parentPath.replace(/\.jsonl$/, "") + "/subagents";
-    let files;
-    try {
-      files = (0, import_node_fs.readdirSync)(subDir);
-    } catch {
-      return;
-    }
-    for (const file of files) {
-      if (!file.startsWith("agent-") || !file.endsWith(".jsonl")) continue;
-      const filePath = (0, import_node_path.join)(subDir, file);
-      try {
-        const s = (0, import_node_fs.statSync)(filePath);
-        callback(filePath, parentSessionId, s.mtimeMs, true, parentSessionId);
-      } catch {
-        continue;
-      }
-      this.discoverSubagents(filePath, parentSessionId, callback, depth + 1, maxDepth);
-    }
-  }
-  /**
-   * Start watching `projectsDir` for JSONL file changes.
-   * Runs `updateStale()` immediately for an initial sync, then sets up
-   * `fs.watch` with `{ recursive: true }` (macOS-compatible) to detect
-   * subsequent file changes and trigger debounced re-indexing.
-   */
-  startWatching(projectsDir) {
-    this.projectsDir = projectsDir;
-    this.updateStale(projectsDir);
-    try {
-      this.watcher = (0, import_node_fs.watch)(projectsDir, { recursive: true }, (_event, filename) => {
-        if (!filename || !filename.endsWith(".jsonl")) return;
-        this.debouncedReindex((0, import_node_path.join)(projectsDir, filename));
-      });
-      this._watcherRunning = true;
-    } catch (err) {
-      console.warn("[search-index] fs.watch failed (recursive may not be supported):", err);
-      this._watcherRunning = false;
-    }
-  }
-  /**
-   * Stop the file watcher and clear any pending debounce timers.
-   * Safe to call even when not watching (no-op).
-   */
-  stopWatching() {
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.debounceTimers.clear();
-    this._watcherRunning = false;
-  }
-  /**
-   * Private helper: debounce re-indexing of a single file.
-   * Waits 2 seconds after the last change event for a given file path
-   * before actually calling `indexFile()`. This coalesces rapid writes
-   * (e.g. streaming JSONL appends) into a single index operation.
-   */
-  debouncedReindex(filePath) {
-    const existing = this.debounceTimers.get(filePath);
-    if (existing) clearTimeout(existing);
-    this.debounceTimers.set(
-      filePath,
-      setTimeout(() => {
-        this.debounceTimers.delete(filePath);
-        try {
-          const s = (0, import_node_fs.statSync)(filePath);
-          const parts = filePath.split("/");
-          const fileName = parts[parts.length - 1];
-          const isSubagent = parts.includes("subagents");
-          let sessionId;
-          let parentSessionId = null;
-          if (isSubagent) {
-            const subagentsIdx = parts.lastIndexOf("subagents");
-            const parentDir = parts[subagentsIdx - 1];
-            sessionId = parentDir;
-            parentSessionId = parentDir;
-          } else {
-            sessionId = (0, import_node_path.basename)(fileName, ".jsonl");
-          }
-          this.indexFile(filePath, sessionId, s.mtimeMs, {
-            isSubagent,
-            parentSessionId
-          });
-        } catch {
-        }
-      }, 2e3)
-    );
+  /** Every transcript from every agent, tagged with the session it belongs to. */
+  discoverFiles(callback) {
+    for (const store of allStores()) for (const file of store.list(0)) callback(file);
   }
   close() {
-    this.stopWatching();
     this.db.close();
   }
 };
 
-// src/lib/dirs.ts
-var import_node_path2 = require("node:path");
-var import_node_os = require("node:os");
-var dirs = {
-  PROJECTS_DIR: (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "projects"),
-  TEAMS_DIR: (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "teams"),
-  TASKS_DIR: (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "tasks"),
-  CODEX_SESSIONS_DIR: (0, import_node_path2.join)((0, import_node_os.homedir)(), ".codex", "sessions")
-};
-var DEFAULT_DB_PATH = (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "cogpit-memory", "search-index.db");
-
 // src/commands/search.ts
-var import_node_fs2 = require("node:fs");
-var import_promises2 = require("node:fs/promises");
-var import_node_path4 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_path3 = require("node:path");
 
 // src/lib/response.ts
 function parseMaxAge(raw) {
@@ -2657,98 +4594,6 @@ function parseMaxAge(raw) {
   }
 }
 
-// src/lib/helpers.ts
-var import_promises = require("node:fs/promises");
-var import_node_path3 = require("node:path");
-var import_node_os2 = require("node:os");
-async function findJsonlPath(sessionId) {
-  const targetFile = `${sessionId}.jsonl`;
-  try {
-    const entries = await (0, import_promises.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name === "memory") continue;
-      const projectDir = (0, import_node_path3.join)(dirs.PROJECTS_DIR, entry.name);
-      try {
-        const files = await (0, import_promises.readdir)(projectDir);
-        if (files.includes(targetFile)) {
-          return (0, import_node_path3.join)(projectDir, targetFile);
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-  }
-  const codexRoot = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".codex", "sessions");
-  const walk = async (dir, depth) => {
-    if (depth > 4) return null;
-    let entries;
-    try {
-      entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
-    } catch {
-      return null;
-    }
-    for (const entry of entries) {
-      const filePath = (0, import_node_path3.join)(dir, entry.name);
-      if (entry.isDirectory()) {
-        const match = await walk(filePath, depth + 1);
-        if (match) return match;
-        continue;
-      }
-      if (!entry.name.endsWith(".jsonl")) continue;
-      if (entry.name.endsWith(`${sessionId}.jsonl`)) return filePath;
-    }
-    return null;
-  };
-  const codexMatch = await walk(codexRoot, 0);
-  if (codexMatch) return codexMatch;
-  return null;
-}
-async function matchSubagentToMember(leadSessionId, subagentFileName, members) {
-  const entries = await (0, import_promises.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name === "memory") continue;
-    const filePath = (0, import_node_path3.join)(
-      dirs.PROJECTS_DIR,
-      entry.name,
-      leadSessionId,
-      "subagents",
-      subagentFileName
-    );
-    try {
-      const fh = await (0, import_promises.open)(filePath, "r");
-      try {
-        const buf = Buffer.alloc(16384);
-        const { bytesRead } = await fh.read(buf, 0, 16384, 0);
-        const firstLine = buf.subarray(0, bytesRead).toString("utf-8").split("\n")[0] || "";
-        for (const member of members) {
-          if (member.agentType === "team-lead") continue;
-          const prompt = member.prompt || "";
-          const snippet = prompt.slice(0, 120);
-          const terms = [
-            member.name,
-            member.name.replace(/-/g, " "),
-            ...snippet ? [snippet, snippet.replace(/"/g, '\\"')] : []
-          ];
-          if (terms.some((t) => firstLine.includes(t))) {
-            return member.name;
-          }
-        }
-      } finally {
-        await fh.close();
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function encodeClaudeDirName(cwd) {
-  const normalized = cwd.replace(/[\\/]+$/, "") || cwd;
-  return normalized.replace(/[^a-zA-Z0-9]/g, "-");
-}
-var HOME_PREFIX = encodeClaudeDirName((0, import_node_os2.homedir)()).replace(/^-/, "").toLowerCase();
-
 // src/commands/search.ts
 async function searchSessions(query, opts, searchIndex) {
   if (!query || query.length < 2) {
@@ -2757,21 +4602,20 @@ async function searchSessions(query, opts, searchIndex) {
   const limit = Math.min(Math.max(1, opts.limit ?? 20), 200);
   const caseSensitive = opts.caseSensitive ?? false;
   const maxAgeMs = parseMaxAge(opts.maxAge ?? "5d");
-  const depth = Math.min(Math.max(1, opts.depth ?? 4), 4);
   let index = searchIndex ?? null;
   let ownedIndex = false;
   if (!index && searchIndex === void 0) {
     try {
-      const dbExists = (0, import_node_fs2.existsSync)(DEFAULT_DB_PATH);
+      const dbExists = (0, import_node_fs3.existsSync)(DEFAULT_DB_PATH);
       if (!dbExists) {
-        (0, import_node_fs2.mkdirSync)((0, import_node_path4.dirname)(DEFAULT_DB_PATH), { recursive: true });
+        (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(DEFAULT_DB_PATH), { recursive: true });
       }
       index = new SearchIndex(DEFAULT_DB_PATH);
       ownedIndex = true;
       if (!dbExists) {
-        index.buildFull(dirs.PROJECTS_DIR);
+        index.buildFull();
       } else {
-        index.updateRecent(dirs.PROJECTS_DIR);
+        index.updateRecent();
       }
     } catch {
     }
@@ -2781,9 +4625,14 @@ async function searchSessions(query, opts, searchIndex) {
       const hits = index.search(query, {
         limit,
         sessionId: opts.sessionId,
+        excludeSessionId: opts.excludeSessionId,
         maxAgeMs,
         caseSensitive
       });
+      if (opts.sessionId && hits.length === 0) {
+        if (ownedIndex) index.close();
+        return rawScanSearch(query, opts.sessionId, maxAgeMs, limit, caseSensitive, opts.excludeSessionId);
+      }
       const grouped = /* @__PURE__ */ new Map();
       for (const hit of hits) {
         let entry = grouped.get(hit.sessionId);
@@ -2807,6 +4656,7 @@ async function searchSessions(query, opts, searchIndex) {
       if (hits.length >= limit) {
         const counts = index.countMatches(query, {
           sessionId: opts.sessionId,
+          excludeSessionId: opts.excludeSessionId,
           maxAgeMs
         });
         totalHits = counts.totalHits;
@@ -2824,7 +4674,7 @@ async function searchSessions(query, opts, searchIndex) {
       if (ownedIndex) index.close();
     }
   }
-  return rawScanSearch(query, opts.sessionId ?? null, maxAgeMs, limit, caseSensitive, depth);
+  return rawScanSearch(query, opts.sessionId ?? null, maxAgeMs, limit, caseSensitive, opts.excludeSessionId);
 }
 var CWD_READ_BYTES = 4096;
 var cwdCache = /* @__PURE__ */ new Map();
@@ -2832,30 +4682,16 @@ async function cwdFromFilePath(filePath) {
   const cached = cwdCache.get(filePath);
   if (cached !== void 0) return cached;
   try {
-    const fh = await (0, import_promises2.open)(filePath, "r");
+    const fh = await (0, import_promises.open)(filePath, "r");
     try {
       const buf = Buffer.alloc(CWD_READ_BYTES);
       const { bytesRead } = await fh.read(buf, 0, CWD_READ_BYTES, 0);
       const head = buf.subarray(0, bytesRead).toString("utf-8");
-      const lines = head.split("\n", 10);
-      for (const line of lines) {
-        if (!line) continue;
-        try {
-          const obj = JSON.parse(line);
-          if (obj.cwd) {
-            cwdCache.set(filePath, obj.cwd);
-            return obj.cwd;
-          }
-          if (obj.type === "session_meta" && obj.payload?.cwd) {
-            cwdCache.set(filePath, obj.payload.cwd);
-            return obj.payload.cwd;
-          }
-          if (obj.type === "turn_context" && obj.payload?.cwd) {
-            cwdCache.set(filePath, obj.payload.cwd);
-            return obj.payload.cwd;
-          }
-        } catch {
-        }
+      const lines = head.split("\n", 10).filter(Boolean);
+      const cwd = formatForText(lines.join("\n")).metadataFromLines(lines).cwd;
+      if (cwd) {
+        cwdCache.set(filePath, cwd);
+        return cwd;
       }
     } finally {
       await fh.close();
@@ -2866,6 +4702,7 @@ async function cwdFromFilePath(filePath) {
   return "";
 }
 var SNIPPET_WINDOW = 150;
+var MAX_SUBAGENT_DEPTH = 4;
 function generateSnippet(text, matchIdx, queryLen) {
   if (matchIdx === -1) return text.slice(0, SNIPPET_WINDOW);
   const halfWindow = Math.floor((SNIPPET_WINDOW - queryLen) / 2);
@@ -2901,49 +4738,17 @@ function searchField(text, location, query, caseSensitive, extras) {
   };
 }
 async function discoverSingleSession(sessionId) {
-  const jsonlPath = await findJsonlPath(sessionId);
+  const jsonlPath = await findSessionFile(sessionId);
   if (!jsonlPath) return [];
-  const s = await (0, import_promises2.stat)(jsonlPath);
-  return [{ path: jsonlPath, mtimeMs: s.mtimeMs }];
+  const s = await (0, import_promises.stat)(jsonlPath);
+  return [{ path: jsonlPath, mtimeMs: s.mtimeMs, sessionId }];
 }
-async function discoverAllSessions(maxAgeMs) {
-  const cutoff = Date.now() - maxAgeMs;
-  let entries;
-  try {
-    entries = await (0, import_promises2.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const projectDirs = entries.filter((e) => e.isDirectory() && e.name !== "memory").map((e) => (0, import_node_path4.join)(dirs.PROJECTS_DIR, e.name));
-  const nested = await Promise.all(
-    projectDirs.map(async (projectDir) => {
-      try {
-        const files = await (0, import_promises2.readdir)(projectDir);
-        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-        const statResults = await Promise.all(
-          jsonlFiles.map(async (f) => {
-            const filePath = (0, import_node_path4.join)(projectDir, f);
-            try {
-              const s = await (0, import_promises2.stat)(filePath);
-              return s.mtimeMs >= cutoff ? { path: filePath, mtimeMs: s.mtimeMs } : null;
-            } catch {
-              return null;
-            }
-          })
-        );
-        return statResults.filter((r) => r !== null);
-      } catch {
-        return [];
-      }
-    })
-  );
-  const results = nested.flat();
-  results.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  return results;
+function discoverAllSessions(maxAgeMs) {
+  return listAllSessionFiles(Date.now() - maxAgeMs).filter((file) => !file.isSubagent).map((file) => ({ path: file.path, mtimeMs: file.mtimeMs, sessionId: file.sessionId }));
 }
 async function rawTextMatch(filePath, query, caseSensitive) {
   try {
-    const content = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises.readFile)(filePath, "utf-8");
     const haystack = caseSensitive ? content : content.toLowerCase();
     const needle = caseSensitive ? query : query.toLowerCase();
     if (haystack.includes(needle)) return content;
@@ -3018,13 +4823,13 @@ async function walkSubagentFiles(parentJsonlPath, query, caseSensitive, currentD
   const subDir = parentJsonlPath.replace(/\.jsonl$/, "") + "/subagents";
   let files;
   try {
-    files = await (0, import_promises2.readdir)(subDir);
+    files = await (0, import_promises.readdir)(subDir);
   } catch {
     return [];
   }
   const agentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl")).map((f) => ({
     agentId: f.slice("agent-".length, -".jsonl".length),
-    filePath: (0, import_node_path4.join)(subDir, f)
+    filePath: (0, import_node_path3.join)(subDir, f)
   }));
   const matched = await Promise.all(
     agentFiles.map(async ({ agentId, filePath }) => ({
@@ -3043,26 +4848,27 @@ async function walkSubagentFiles(parentJsonlPath, query, caseSensitive, currentD
   );
   return hitArrays.flat();
 }
-async function rawScanSearch(query, sessionId, maxAgeMs, limit, caseSensitive, depth) {
+async function rawScanSearch(query, sessionId, maxAgeMs, limit, caseSensitive, excludeSessionId) {
   try {
-    const files = sessionId ? await discoverSingleSession(sessionId) : await discoverAllSessions(maxAgeMs);
+    const files = sessionId ? await discoverSingleSession(sessionId) : discoverAllSessions(maxAgeMs);
     let totalHits = 0;
     let returnedHits = 0;
     const results = [];
     let sessionsSearched = 0;
     for (const file of files) {
+      if (file.sessionId === excludeSessionId) continue;
       if (returnedHits >= limit) break;
       const rawContent = await rawTextMatch(file.path, query, caseSensitive);
       sessionsSearched++;
       if (!rawContent) continue;
       const session = parseSession(rawContent);
       const sessionHits = walkSession(session, query, caseSensitive);
-      const subagentHits = await walkSubagentFiles(file.path, query, caseSensitive, 0, depth);
+      const subagentHits = await walkSubagentFiles(file.path, query, caseSensitive, 0, MAX_SUBAGENT_DEPTH);
       const allHits = [...sessionHits, ...subagentHits];
       if (allHits.length === 0) continue;
       totalHits += allHits.length;
       const sessionResult = {
-        sessionId: session.sessionId || (0, import_node_path4.basename)(file.path, ".jsonl"),
+        sessionId: session.sessionId || (0, import_node_path3.basename)(file.path, ".jsonl"),
         cwd: session.cwd || "",
         hits: []
       };
@@ -3097,6 +4903,51 @@ async function rawScanSearch(query, sessionId, maxAgeMs, limit, caseSensitive, d
 // src/commands/context.ts
 var import_promises3 = require("node:fs/promises");
 var import_node_path5 = require("node:path");
+
+// src/lib/helpers.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
+async function matchSubagentToMember(leadSessionId, subagentFileName, members) {
+  const entries = await (0, import_promises2.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === "memory") continue;
+    const filePath = (0, import_node_path4.join)(
+      dirs.PROJECTS_DIR,
+      entry.name,
+      leadSessionId,
+      "subagents",
+      subagentFileName
+    );
+    try {
+      const fh = await (0, import_promises2.open)(filePath, "r");
+      try {
+        const buf = Buffer.alloc(16384);
+        const { bytesRead } = await fh.read(buf, 0, 16384, 0);
+        const firstLine = buf.subarray(0, bytesRead).toString("utf-8").split("\n")[0] || "";
+        for (const member of members) {
+          if (member.agentType === "team-lead") continue;
+          const prompt = member.prompt || "";
+          const snippet = prompt.slice(0, 120);
+          const terms = [
+            member.name,
+            member.name.replace(/-/g, " "),
+            ...snippet ? [snippet, snippet.replace(/"/g, '\\"')] : []
+          ];
+          if (terms.some((t) => firstLine.includes(t))) {
+            return member.name;
+          }
+        }
+      } finally {
+        await fh.close();
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/commands/context.ts
 var RESULT_TRUNCATE_LIMIT = 1e4;
 var L1_RESPONSE_LIMIT = 15e4;
 var COMPACTION_SUMMARY_PREVIEW = 400;
@@ -3268,562 +5119,236 @@ function mapContentBlock(block) {
     }
   }
 }
-async function findSubagentFile(parentJsonlPath, agentId) {
-  const subagentsDir = parentJsonlPath.replace(/\.jsonl$/, "") + "/subagents";
-  try {
-    const files = await (0, import_promises3.readdir)(subagentsDir);
-    for (const f of files) {
-      if (!f.startsWith("agent-") || !f.endsWith(".jsonl")) continue;
-      const fileAgentId = f.replace("agent-", "").replace(".jsonl", "");
-      if (fileAgentId === agentId) {
-        return { filePath: (0, import_node_path5.join)(subagentsDir, f), fileName: f };
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-async function findTeamContext(sessionId, subagentFileName) {
-  try {
-    const teamEntries = await (0, import_promises3.readdir)(dirs.TEAMS_DIR, { withFileTypes: true });
-    for (const entry of teamEntries) {
-      if (!entry.isDirectory()) continue;
-      const configPath = (0, import_node_path5.join)(dirs.TEAMS_DIR, entry.name, "config.json");
-      try {
-        const raw = await (0, import_promises3.readFile)(configPath, "utf-8");
-        const config = JSON.parse(raw);
-        if (config.leadSessionId !== sessionId) continue;
-        const members = config.members ?? [];
-        const memberName = await matchSubagentToMember(sessionId, subagentFileName, members);
-        if (!memberName) continue;
-        let currentTask = null;
-        try {
-          const taskDir = (0, import_node_path5.join)(dirs.TASKS_DIR, entry.name);
-          const taskFiles = await (0, import_promises3.readdir)(taskDir);
-          for (const tf of taskFiles) {
-            if (!tf.endsWith(".json")) continue;
-            const taskRaw = await (0, import_promises3.readFile)((0, import_node_path5.join)(taskDir, tf), "utf-8");
-            const task = JSON.parse(taskRaw);
-            if (task.owner === memberName && task.status === "in_progress") {
-              currentTask = { id: task.id, subject: task.subject, status: task.status };
-              break;
-            }
-          }
-        } catch {
-        }
-        return { teamName: entry.name, role: memberName, currentTask };
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-function findParentToolCallId(session, agentId) {
-  for (const turn of session.turns) {
-    for (const msg of turn.subAgentActivity) {
-      if (msg.agentId === agentId) {
-        for (const tc of turn.toolCalls) {
-          if (tc.name === "Task" || tc.name === "Agent") {
-            return tc.id;
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-function findAgentMetadata(session, agentId) {
-  for (const turn of session.turns) {
-    for (const msg of turn.subAgentActivity) {
-      if (msg.agentId === agentId) {
-        return {
-          name: msg.agentName,
-          type: msg.subagentType,
-          isBackground: msg.isBackground
-        };
-      }
-    }
-  }
-  return { name: null, type: null, isBackground: false };
-}
-async function getSessionOverview(sessionId) {
-  const jsonlPath = await findJsonlPath(sessionId);
-  if (!jsonlPath) return { error: "Session not found" };
-  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
-  const session = parseSession(content);
-  return mapSessionToOverview(session);
-}
-async function getTurnDetail(sessionId, turnIndex) {
-  const jsonlPath = await findJsonlPath(sessionId);
-  if (!jsonlPath) return { error: "Session not found" };
-  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
-  const session = parseSession(content);
-  if (turnIndex < 0 || turnIndex >= session.turns.length) return { error: "Turn not found" };
-  return mapTurnToDetail(session, turnIndex);
-}
-async function getAgentOverview(sessionId, agentId) {
-  const jsonlPath = await findJsonlPath(sessionId);
-  if (!jsonlPath) return { error: "Session not found" };
-  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
-  const session = parseSession(content);
-  const subagentFile = await findSubagentFile(jsonlPath, agentId);
-  if (!subagentFile) return { error: "Agent not found" };
-  const subagentContent = await (0, import_promises3.readFile)(subagentFile.filePath, "utf-8");
-  const subagentSession = parseSession(subagentContent);
-  const metadata = findAgentMetadata(session, agentId);
-  const parentToolCallId = findParentToolCallId(session, agentId);
-  const teamContext = await findTeamContext(sessionId, subagentFile.fileName);
-  return {
-    sessionId,
-    agentId,
-    name: metadata.name,
-    type: metadata.type,
-    parentToolCallId,
-    isBackground: metadata.isBackground,
-    teamContext,
-    overview: mapSessionToOverview(subagentSession)
-  };
-}
-async function getAgentTurnDetail(sessionId, agentId, turnIndex) {
-  const jsonlPath = await findJsonlPath(sessionId);
-  if (!jsonlPath) return { error: "Session not found" };
-  const subagentFile = await findSubagentFile(jsonlPath, agentId);
-  if (!subagentFile) return { error: "Agent not found" };
-  const subagentContent = await (0, import_promises3.readFile)(subagentFile.filePath, "utf-8");
-  const subagentSession = parseSession(subagentContent);
-  if (turnIndex < 0 || turnIndex >= subagentSession.turns.length) return { error: "Turn not found" };
-  return mapTurnToDetail(subagentSession, turnIndex);
-}
-
-// src/commands/sessions.ts
-var import_promises5 = require("node:fs/promises");
-var import_node_path6 = require("node:path");
-
-// src/lib/metadata.ts
-var import_promises4 = require("node:fs/promises");
-
-// src/lib/sessionStatus.ts
-var TASK_NOTIFICATION_MARKER = "<task-notification>";
-var TASK_ID_RE = /<task-id>([^<]+)<\/task-id>/g;
-var TOOL_USE_ID_RE = /<tool-use-id>([^<]+)<\/tool-use-id>/g;
-function isObject3(value) {
-  return typeof value === "object" && value !== null;
-}
-function userMessageTexts(msg) {
-  const message = isObject3(msg.message) ? msg.message : null;
-  const content = message?.content;
-  if (typeof content === "string") return [content];
-  if (!Array.isArray(content)) return [];
-  return content.filter((block) => isObject3(block) && typeof block.text === "string").map((block) => block.text);
-}
-function collectClaudeBackgroundWork(rawMessages) {
-  const launches = [];
-  const resolved = /* @__PURE__ */ new Set();
-  const queuedIds = /* @__PURE__ */ new Set();
-  const deliveredIds = /* @__PURE__ */ new Set();
-  function noteNotifications(text, sink) {
-    if (!text.includes(TASK_NOTIFICATION_MARKER)) return;
-    for (const match of text.matchAll(TASK_ID_RE)) {
-      resolved.add(match[1]);
-      sink?.add(match[1]);
-    }
-    for (const match of text.matchAll(TOOL_USE_ID_RE)) {
-      resolved.add(match[1]);
-      sink?.add(match[1]);
-    }
-  }
-  for (const msg of rawMessages) {
-    if (msg.type === "user") {
-      const toolUseResult = isObject3(msg.toolUseResult) ? msg.toolUseResult : null;
-      if (toolUseResult?.status === "async_launched") {
-        const message = isObject3(msg.message) ? msg.message : null;
-        const blocks = Array.isArray(message?.content) ? message.content : [];
-        const toolUseIds = blocks.filter((block) => isObject3(block) && block.type === "tool_result").map((block) => block.tool_use_id);
-        const ids = [toolUseResult.agentId, toolUseResult.taskId, ...toolUseIds].filter((id) => typeof id === "string" && id.length > 0);
-        const description = [toolUseResult.description, toolUseResult.workflowName, toolUseResult.summary].find((value) => typeof value === "string" && value.length > 0) ?? "";
-        if (ids.length > 0) launches.push({ ids, description });
-      }
-      for (const text of userMessageTexts(msg)) noteNotifications(text, deliveredIds);
-      continue;
-    }
-    if (msg.type === "assistant") {
-      const message = isObject3(msg.message) ? msg.message : null;
-      const blocks = Array.isArray(message?.content) ? message.content : [];
-      for (const block of blocks) {
-        if (!isObject3(block) || block.type !== "tool_use" || block.name !== "TaskStop") continue;
-        const input = isObject3(block.input) ? block.input : null;
-        const taskId = input?.task_id ?? input?.shell_id;
-        if (typeof taskId === "string") resolved.add(taskId);
-      }
-      continue;
-    }
-    if (msg.type === "attachment") {
-      const attachment = isObject3(msg.attachment) ? msg.attachment : null;
-      if (typeof attachment?.prompt === "string") noteNotifications(attachment.prompt, deliveredIds);
-      continue;
-    }
-    if (msg.type === "queue-operation" && typeof msg.content === "string") {
-      const op = msg.operation;
-      noteNotifications(msg.content, op === "enqueue" ? queuedIds : deliveredIds);
-    }
-  }
-  return {
-    pendingDescriptions: launches.filter((launch) => !launch.ids.some((id) => resolved.has(id))).map((launch) => launch.description),
-    undeliveredNotifications: [...queuedIds].filter((id) => !deliveredIds.has(id)).length
-  };
-}
-function awaitingAgentsResult(pendingDescriptions, pendingQueue) {
-  return {
-    status: "awaiting_agents",
-    pendingQueue,
-    pendingAgents: pendingDescriptions.length,
-    pendingAgentDescriptions: pendingDescriptions.filter((description) => description.length > 0)
-  };
-}
-function deriveSessionStatus(rawMessages) {
-  const firstType = rawMessages[0]?.type;
-  if (firstType === "session_meta" || firstType === "turn_context" || firstType === "event_msg" || firstType === "response_item") {
-    return deriveCodexSessionStatus(rawMessages);
-  }
-  let pendingEnqueues = 0;
-  let backgroundWork = null;
-  let deliveringNotification = false;
-  function result(status, toolName) {
-    const info = { status, pendingQueue: Math.max(0, pendingEnqueues) };
-    if (toolName) info.toolName = toolName;
-    return info;
-  }
-  function getBackgroundWork() {
-    return backgroundWork ??= collectClaudeBackgroundWork(rawMessages);
-  }
-  for (let i = rawMessages.length - 1; i >= 0; i--) {
-    const msg = rawMessages[i];
-    if (msg.type === "queue-operation") continue;
-    if (msg.type === "progress") {
-      const data = msg.data;
-      if (data?.type === "hook_progress") {
-        const decision = data.decision ?? data.hookSpecificOutput?.permissionDecision;
-        if (decision === "defer") return result("deferred");
-      }
-      break;
-    }
-    break;
-  }
-  for (let i = rawMessages.length - 1; i >= 0; i--) {
-    const msg = rawMessages[i];
-    if (msg.type === "queue-operation") {
-      if (typeof msg.content === "string" && msg.content.includes(TASK_NOTIFICATION_MARKER)) continue;
-      const op = msg.operation;
-      if (op === "enqueue") pendingEnqueues++;
-      else if (op === "dequeue" || op === "remove") pendingEnqueues--;
-      continue;
-    }
-    if (msg.type === "attachment") {
-      const attachment = isObject3(msg.attachment) ? msg.attachment : null;
-      if (attachment?.commandMode === "task-notification") deliveringNotification = true;
-      continue;
-    }
-    if (msg.type === "assistant") {
-      const message = msg.message;
-      const stopReason = message?.stop_reason;
-      if (stopReason === "end_turn") {
-        const work = getBackgroundWork();
-        if (deliveringNotification || work.undeliveredNotifications > 0) return result("processing");
-        if (work.pendingDescriptions.length > 0) {
-          return awaitingAgentsResult(work.pendingDescriptions, Math.max(0, pendingEnqueues));
-        }
-        let hasActivity = false;
-        for (let j = i - 1; j >= 0; j--) {
-          const m = rawMessages[j];
-          if (m.type === "user" && !m.isMeta) {
-            hasActivity = true;
-            break;
-          }
-        }
-        return result(hasActivity ? "completed" : "idle");
-      }
-      if (stopReason === "tool_use") {
-        const content = message?.content;
-        const toolUseBlock = content?.findLast?.((b) => b.type === "tool_use");
-        return result("tool_use", toolUseBlock?.name);
-      }
-      return result("thinking");
-    }
-    if (msg.type === "user") {
-      const isMeta = msg.isMeta;
-      if (isMeta) continue;
-      return result("processing");
-    }
-    if (msg.type === "system" && msg.subtype === "terminal_reason") {
-      const reason = msg.reason;
-      if (reason) {
-        return { status: "completed", terminalReason: reason, pendingQueue: Math.max(0, pendingEnqueues) };
-      }
-      continue;
-    }
-    if (msg.type === "summary") continue;
-    if (msg.type === "system" && msg.subtype === "compact_boundary") continue;
-  }
-  return { status: "idle" };
-}
-var TERMINAL_INTER_AGENT_TYPES = /* @__PURE__ */ new Set(["FINAL_ANSWER", "ERROR", "FAILED", "INTERRUPTED"]);
-function codexPayloadText(payload) {
-  const content = payload.content;
-  if (!Array.isArray(content)) return "";
-  return content.filter((block) => isObject3(block) && block.type === "input_text" && typeof block.text === "string").map((block) => block.text).join("\n");
-}
-function parseJsonObject(value) {
-  if (typeof value !== "string") return null;
-  try {
-    const parsed = JSON.parse(value);
-    return isObject3(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function collectCodexPendingAgents(rawMessages) {
-  const alive = /* @__PURE__ */ new Map();
-  const done = /* @__PURE__ */ new Set();
-  const agentIdByPath = /* @__PURE__ */ new Map();
-  const spawnCalls = /* @__PURE__ */ new Map();
-  const waitCalls = /* @__PURE__ */ new Set();
-  const interruptCalls = /* @__PURE__ */ new Map();
-  function markAlive(agentId, description) {
-    if (!done.has(agentId)) alive.set(agentId, alive.get(agentId) || description);
-  }
-  for (const msg of rawMessages) {
-    const payload = isObject3(msg.payload) ? msg.payload : null;
-    if (!payload) continue;
-    if (msg.type === "event_msg" && payload.type === "sub_agent_activity" && typeof payload.agent_thread_id === "string" && typeof payload.agent_path === "string") {
-      const agentId = payload.agent_thread_id;
-      const kind = typeof payload.kind === "string" ? payload.kind : "started";
-      const eventId = typeof payload.event_id === "string" ? payload.event_id : "";
-      const existingId = agentIdByPath.get(payload.agent_path);
-      const known = alive.has(agentId) || done.has(agentId) || existingId !== void 0 || spawnCalls.has(eventId);
-      if (kind !== "started" && !known) continue;
-      if (existingId && existingId !== agentId) {
-        if (alive.has(existingId)) {
-          markAlive(agentId, alive.get(existingId) ?? "");
-          alive.delete(existingId);
-        }
-        if (done.has(existingId)) done.add(agentId);
-      }
-      agentIdByPath.set(payload.agent_path, agentId);
-      if (kind === "interrupted") {
-        done.add(agentId);
-        alive.delete(agentId);
-      } else {
-        markAlive(agentId, spawnCalls.get(eventId) ?? "");
-      }
-      continue;
-    }
-    if (msg.type !== "response_item") continue;
-    if (payload.type === "function_call" && typeof payload.call_id === "string") {
-      const name = normalizeFunctionName(typeof payload.name === "string" ? payload.name : "");
-      if (name === "spawn_agent") {
-        const input = parseJsonObject(payload.arguments);
-        spawnCalls.set(payload.call_id, typeof input?.task_name === "string" ? input.task_name : "");
-      } else if (name === "wait_agent") {
-        waitCalls.add(payload.call_id);
-      } else if (name === "interrupt_agent") {
-        const input = parseJsonObject(payload.arguments);
-        const targets = [input?.agent_id, ...Array.isArray(input?.agent_ids) ? input.agent_ids : []].filter((id) => typeof id === "string");
-        interruptCalls.set(payload.call_id, targets);
-      }
-      continue;
-    }
-    if (payload.type === "function_call_output" && typeof payload.call_id === "string") {
-      const callId = payload.call_id;
-      if (spawnCalls.has(callId)) {
-        const output = parseJsonObject(payload.output);
-        const agentId = typeof output?.agent_id === "string" ? output.agent_id : "";
-        if (agentId) {
-          markAlive(agentId, spawnCalls.get(callId) ?? "");
-          const agentPath = typeof output?.task_name === "string" ? output.task_name : "";
-          if (agentPath && !agentIdByPath.has(agentPath)) agentIdByPath.set(agentPath, agentId);
-        }
-      } else if (waitCalls.has(callId)) {
-        const output = parseJsonObject(payload.output);
-        const statusMap = isObject3(output?.status) ? output.status : {};
-        for (const [agentId, status] of Object.entries(statusMap)) {
-          const statusValue = isObject3(status) ? status : {};
-          const lifecycle = typeof statusValue.status === "string" ? statusValue.status : "";
-          const isTerminal = typeof statusValue.completed === "string" || typeof statusValue.failed === "string" || typeof statusValue.error === "string" || typeof statusValue.interrupted === "string" || lifecycle === "completed" || lifecycle === "failed" || lifecycle === "interrupted";
-          if (isTerminal) {
-            done.add(agentId);
-            alive.delete(agentId);
+async function findSubagentFile(parentJsonlPath, agentId) {
+  const subagentsDir = parentJsonlPath.replace(/\.jsonl$/, "") + "/subagents";
+  try {
+    const files = await (0, import_promises3.readdir)(subagentsDir);
+    for (const f of files) {
+      if (!f.startsWith("agent-") || !f.endsWith(".jsonl")) continue;
+      const fileAgentId = f.replace("agent-", "").replace(".jsonl", "");
+      if (fileAgentId === agentId) {
+        return { filePath: (0, import_node_path5.join)(subagentsDir, f), fileName: f };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function findTeamContext(sessionId, subagentFileName) {
+  try {
+    const teamEntries = await (0, import_promises3.readdir)(dirs.TEAMS_DIR, { withFileTypes: true });
+    for (const entry of teamEntries) {
+      if (!entry.isDirectory()) continue;
+      const configPath = (0, import_node_path5.join)(dirs.TEAMS_DIR, entry.name, "config.json");
+      try {
+        const raw = await (0, import_promises3.readFile)(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        if (config.leadSessionId !== sessionId) continue;
+        const members = config.members ?? [];
+        const memberName = await matchSubagentToMember(sessionId, subagentFileName, members);
+        if (!memberName) continue;
+        let currentTask = null;
+        try {
+          const taskDir = (0, import_node_path5.join)(dirs.TASKS_DIR, entry.name);
+          const taskFiles = await (0, import_promises3.readdir)(taskDir);
+          for (const tf of taskFiles) {
+            if (!tf.endsWith(".json")) continue;
+            const taskRaw = await (0, import_promises3.readFile)((0, import_node_path5.join)(taskDir, tf), "utf-8");
+            const task = JSON.parse(taskRaw);
+            if (task.owner === memberName && task.status === "in_progress") {
+              currentTask = { id: task.id, subject: task.subject, status: task.status };
+              break;
+            }
           }
+        } catch {
         }
-      } else if (interruptCalls.has(callId)) {
-        for (const agentId of interruptCalls.get(callId) ?? []) {
-          done.add(agentId);
-          alive.delete(agentId);
-        }
+        return { teamName: entry.name, role: memberName, currentTask };
+      } catch {
       }
-      continue;
-    }
-    if (payload.type === "agent_message" && typeof payload.author === "string") {
-      const text = codexPayloadText(payload);
-      const messageType = text.match(/^Message Type:\s*([^\r\n]+)/)?.[1]?.trim().toUpperCase() ?? "";
-      if (!TERMINAL_INTER_AGENT_TYPES.has(messageType)) continue;
-      const agentId = agentIdByPath.get(payload.author) ?? payload.author;
-      done.add(agentId);
-      alive.delete(agentId);
     }
+  } catch {
   }
-  return [...alive.entries()].filter(([agentId]) => !done.has(agentId)).map(([, description]) => description);
+  return null;
 }
-function deriveCodexSessionStatus(rawMessages) {
-  for (let i = rawMessages.length - 1; i >= 0; i--) {
-    const msg = rawMessages[i];
-    if (msg.type === "event_msg") {
-      const payload = msg.payload;
-      switch (payload?.type) {
-        case "task_complete": {
-          const pending = collectCodexPendingAgents(rawMessages);
-          if (pending.length > 0) return awaitingAgentsResult(pending, 0);
-          return { status: "completed" };
+function findParentToolCallId(session, agentId) {
+  for (const turn of session.turns) {
+    for (const msg of turn.subAgentActivity) {
+      if (msg.agentId === agentId) {
+        for (const tc of turn.toolCalls) {
+          if (tc.name === "Task" || tc.name === "Agent") {
+            return tc.id;
+          }
         }
-        case "task_started":
-          return { status: "processing" };
-        case "agent_message":
-          return { status: "thinking" };
-        case "token_count":
-          continue;
       }
     }
-    if (msg.type === "response_item") {
-      const payload = msg.payload;
-      if (!payload) continue;
-      if (payload.type === "function_call") {
-        return { status: "tool_use", toolName: payload.name ? normalizeFunctionName(payload.name) : payload.name };
-      }
-      if (payload.type === "message") {
-        if (payload.role === "assistant") return { status: "thinking" };
-        if (payload.role === "user") return { status: "processing" };
+  }
+  return null;
+}
+function findAgentMetadata(session, agentId) {
+  for (const turn of session.turns) {
+    for (const msg of turn.subAgentActivity) {
+      if (msg.agentId === agentId) {
+        return {
+          name: msg.agentName,
+          type: msg.subagentType,
+          isBackground: msg.isBackground
+        };
       }
     }
   }
-  return { status: "idle" };
+  return { name: null, type: null, isBackground: false };
+}
+async function getSessionOverview(sessionId) {
+  const jsonlPath = await findSessionFile(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
+  const session = parseSession(content);
+  return mapSessionToOverview(session);
+}
+async function getTurnDetail(sessionId, turnIndex) {
+  const jsonlPath = await findSessionFile(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
+  const session = parseSession(content);
+  if (turnIndex < 0 || turnIndex >= session.turns.length) return { error: "Turn not found" };
+  return mapTurnToDetail(session, turnIndex);
+}
+async function getAgentOverview(sessionId, agentId) {
+  const jsonlPath = await findSessionFile(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
+  const session = parseSession(content);
+  const subagentFile = await findSubagentFile(jsonlPath, agentId);
+  if (!subagentFile) return { error: "Agent not found" };
+  const subagentContent = await (0, import_promises3.readFile)(subagentFile.filePath, "utf-8");
+  const subagentSession = parseSession(subagentContent);
+  const metadata = findAgentMetadata(session, agentId);
+  const parentToolCallId = findParentToolCallId(session, agentId);
+  const teamContext = await findTeamContext(sessionId, subagentFile.fileName);
+  return {
+    sessionId,
+    agentId,
+    name: metadata.name,
+    type: metadata.type,
+    parentToolCallId,
+    isBackground: metadata.isBackground,
+    teamContext,
+    overview: mapSessionToOverview(subagentSession)
+  };
+}
+async function getAgentTurnDetail(sessionId, agentId, turnIndex) {
+  const jsonlPath = await findSessionFile(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const subagentFile = await findSubagentFile(jsonlPath, agentId);
+  if (!subagentFile) return { error: "Agent not found" };
+  const subagentContent = await (0, import_promises3.readFile)(subagentFile.filePath, "utf-8");
+  const subagentSession = parseSession(subagentContent);
+  if (turnIndex < 0 || turnIndex >= subagentSession.turns.length) return { error: "Turn not found" };
+  return mapTurnToDetail(subagentSession, turnIndex);
 }
 
+// src/commands/sessions.ts
+var import_node_path6 = require("node:path");
+
 // src/lib/metadata.ts
-async function getSessionMeta(filePath) {
-  let lines;
-  let isPartialRead = false;
-  const fileStat = await (0, import_promises4.stat)(filePath);
-  if (fileStat.size > 65536) {
-    const fh = await (0, import_promises4.open)(filePath, "r");
-    try {
-      const buf = Buffer.alloc(32768);
-      const { bytesRead } = await fh.read(buf, 0, 32768, 0);
-      const text = buf.subarray(0, bytesRead).toString("utf-8");
-      const lastNewline = text.lastIndexOf("\n");
-      lines = (lastNewline > 0 ? text.slice(0, lastNewline) : text).split("\n").filter(Boolean);
-      isPartialRead = true;
-    } finally {
-      await fh.close();
-    }
-  } else {
-    const content = await (0, import_promises4.readFile)(filePath, "utf-8");
-    lines = content.split("\n").filter(Boolean);
-  }
-  let firstParsed = null;
-  if (lines.length > 0) {
+var import_promises4 = require("node:fs/promises");
+
+// src/lib/sessionStatus.ts
+function deriveSessionStatus(rawMessages) {
+  return formatForRecords(rawMessages).status(rawMessages);
+}
+
+// src/lib/metadata.ts
+var FULL_READ_LIMIT = 65536;
+var HEAD_READ_BYTES = 32768;
+function readHeader(format, lines) {
+  return format.metadataFromLines(lines);
+}
+function cleanUserText(text) {
+  const cleaned = text.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, "").trim();
+  return cleaned.length > 5 ? cleaned.slice(0, 120) : "";
+}
+function scanClaudeMessages(lines) {
+  const meta = {
+    firstUserMessage: "",
+    lastUserMessage: "",
+    timestamp: "",
+    turnCount: 0
+  };
+  for (const line of lines) {
+    let record;
     try {
-      firstParsed = JSON.parse(lines[0]);
+      record = JSON.parse(line);
     } catch {
-      firstParsed = null;
+      continue;
     }
-  }
-  const isCodex = firstParsed?.type === "session_meta" || firstParsed?.type === "turn_context";
-  if (isCodex) {
-    if (isPartialRead) {
-      const content = await (0, import_promises4.readFile)(filePath, "utf-8");
-      lines = content.split("\n").filter(Boolean);
+    if (record.type !== "user" || record.isMeta) continue;
+    if (!meta.timestamp) meta.timestamp = record.timestamp || "";
+    const content = record.message?.content;
+    let extracted = "";
+    if (typeof content === "string") {
+      extracted = cleanUserText(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type !== "text" || typeof block.text !== "string") continue;
+        extracted = cleanUserText(block.text);
+        if (extracted) break;
+      }
     }
-    const meta = extractCodexMetadataFromLines(lines);
+    if (extracted) {
+      if (!meta.firstUserMessage) meta.firstUserMessage = extracted;
+      meta.lastUserMessage = extracted;
+    }
+    meta.turnCount += 1;
+  }
+  return meta;
+}
+async function readLines(filePath, size) {
+  if (size <= FULL_READ_LIMIT) {
+    const content = await (0, import_promises4.readFile)(filePath, "utf-8");
+    return { lines: content.split("\n").filter(Boolean), isPartialRead: false };
+  }
+  const handle = await (0, import_promises4.open)(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(HEAD_READ_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, HEAD_READ_BYTES, 0);
+    const text = buffer.subarray(0, bytesRead).toString("utf-8");
+    const lastNewline = text.lastIndexOf("\n");
     return {
-      sessionId: meta.sessionId,
-      version: meta.version,
-      gitBranch: meta.gitBranch,
-      model: meta.model,
-      slug: meta.slug,
-      cwd: meta.cwd,
-      firstUserMessage: meta.firstUserMessage,
-      lastUserMessage: meta.lastUserMessage,
-      timestamp: meta.timestamp,
-      turnCount: meta.turnCount,
-      lineCount: lines.length,
-      branchedFrom: meta.branchedFrom
+      lines: (lastNewline > 0 ? text.slice(0, lastNewline) : text).split("\n").filter(Boolean),
+      isPartialRead: true
     };
+  } finally {
+    await handle.close();
   }
-  let sessionId = "";
-  let version = "";
-  let gitBranch = "";
-  let model = "";
-  let slug = "";
-  let cwd = "";
-  let firstUserMessage = "";
-  let lastUserMessage = "";
-  let timestamp = "";
-  let turnCount = 0;
-  let branchedFrom;
-  for (const line of lines) {
-    try {
-      const obj = JSON.parse(line);
-      if (obj.sessionId && !sessionId) sessionId = obj.sessionId;
-      if (obj.version && !version) version = obj.version;
-      if (obj.gitBranch && !gitBranch) gitBranch = obj.gitBranch;
-      if (obj.slug && !slug) slug = obj.slug;
-      if (obj.cwd && !cwd) cwd = obj.cwd;
-      if (obj.branchedFrom && !branchedFrom) branchedFrom = obj.branchedFrom;
-      if (obj.type === "assistant" && obj.message?.model && !model) {
-        model = obj.message.model;
-      }
-      if (obj.type === "user" && !obj.isMeta && !timestamp) {
-        timestamp = obj.timestamp || "";
-      }
-      if (obj.type === "user" && !obj.isMeta) {
-        const c = obj.message?.content;
-        let extracted = "";
-        if (typeof c === "string") {
-          const cleaned = c.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, "").trim();
-          if (cleaned && cleaned.length > 5) extracted = cleaned.slice(0, 120);
-        } else if (Array.isArray(c)) {
-          for (const block of c) {
-            if (block.type === "text") {
-              const cleaned = block.text.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, "").trim();
-              if (cleaned && cleaned.length > 5) {
-                extracted = cleaned.slice(0, 120);
-                break;
-              }
-            }
-          }
-        }
-        if (extracted) {
-          if (!firstUserMessage) firstUserMessage = extracted;
-          lastUserMessage = extracted;
-        }
-        turnCount++;
-      }
-    } catch {
-    }
+}
+async function getSessionMeta(filePath) {
+  const fileStat = await (0, import_promises4.stat)(filePath);
+  let { lines, isPartialRead } = await readLines(filePath, fileStat.size);
+  const format = formatForText(lines.join("\n"));
+  if (isPartialRead && !format.descriptor.metadataFromHead) {
+    lines = (await (0, import_promises4.readFile)(filePath, "utf-8")).split("\n").filter(Boolean);
+    isPartialRead = false;
   }
+  const header = readHeader(format, lines);
+  const conversation = header.turnCount === void 0 ? scanClaudeMessages(lines) : {
+    firstUserMessage: header.firstUserMessage ?? "",
+    lastUserMessage: header.lastUserMessage ?? "",
+    timestamp: header.timestamp ?? "",
+    turnCount: header.turnCount
+  };
   return {
-    sessionId,
-    version,
-    gitBranch,
-    model,
-    slug,
-    cwd,
-    firstUserMessage,
-    lastUserMessage,
-    timestamp,
-    turnCount,
-    lineCount: isPartialRead ? Math.round(fileStat.size / (32768 / lines.length)) : lines.length,
-    branchedFrom
+    sessionId: header.sessionId,
+    version: header.version,
+    gitBranch: header.gitBranch,
+    model: header.model,
+    slug: header.slug,
+    cwd: header.cwd,
+    ...conversation,
+    // A head read saw a known number of lines in a known number of bytes;
+    // scaling that by the file size is the only estimate available.
+    lineCount: isPartialRead ? Math.round(fileStat.size / (HEAD_READ_BYTES / lines.length)) : lines.length,
+    branchedFrom: header.branchedFrom
   };
 }
 async function getSessionStatus(filePath) {
@@ -3837,6 +5362,7 @@ async function getSessionStatus(filePath) {
       const meaningful = [];
       let cursor = fileStat.size;
       let leftover = "";
+      let copilotTurnEnded = false;
       for (let chunk = 0; chunk < MAX_CHUNKS && cursor > 0; chunk++) {
         const readSize = Math.min(CHUNK, cursor);
         cursor -= readSize;
@@ -3855,6 +5381,10 @@ async function getSessionStatus(filePath) {
           } catch {
             continue;
           }
+          if (obj.type.startsWith("subagent.") && typeof obj.agentId === "string" && obj.agentId.length > 0) {
+            meaningful.unshift(obj);
+            continue;
+          }
           if (obj.type === "event_msg") {
             const payload = obj.payload;
             switch (payload?.type) {
@@ -3879,6 +5409,20 @@ async function getSessionStatus(filePath) {
               if (role === "user") return { status: "processing" };
             }
           }
+          if (obj.type === "abort" || obj.type === "user.message" || obj.type.startsWith("assistant.") || obj.type.startsWith("permission.") || obj.type.startsWith("session.") || obj.type.startsWith("tool.") || obj.type.startsWith("user_input.")) {
+            if (typeof obj.agentId === "string" && obj.agentId) continue;
+            meaningful.unshift(obj);
+            if (obj.type === "assistant.turn_end") {
+              copilotTurnEnded = true;
+              continue;
+            }
+            if (copilotTurnEnded && obj.type !== "assistant.message" && obj.type !== "user.message") {
+              continue;
+            }
+            const status = deriveSessionStatus(meaningful);
+            if (status.status !== "idle") return status;
+            continue;
+          }
           if (obj.type === "assistant" || obj.type === "user" || obj.type === "queue-operation") {
             meaningful.unshift(obj);
             const isEndTurn = obj.type === "assistant" && obj.message?.stop_reason === "end_turn";
@@ -3911,75 +5455,15 @@ function toSessionSummary(file, meta, status) {
     turnCount: meta.turnCount,
     status,
     mtime: file.mtimeMs,
-    source: file.path.startsWith(dirs.CODEX_SESSIONS_DIR + "/") ? "codex" : "claude"
-  };
-}
-async function listCodexSessionFiles(cutoff) {
-  const walk = async (dir, depth) => {
-    if (depth > 4) return [];
-    let entries;
-    try {
-      entries = await (0, import_promises5.readdir)(dir, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    const results = [];
-    for (const entry of entries) {
-      const filePath = (0, import_node_path6.join)(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...await walk(filePath, depth + 1));
-        continue;
-      }
-      if (!entry.name.endsWith(".jsonl")) continue;
-      try {
-        const s = await (0, import_promises5.stat)(filePath);
-        if (s.mtimeMs >= cutoff) results.push({ path: filePath, mtimeMs: s.mtimeMs });
-      } catch {
-        continue;
-      }
-    }
-    return results;
+    // Which root the transcript came out of, which is known before it is read.
+    source: storeForPath(file.path)?.kind ?? descriptorFor("claude").kind
   };
-  return walk(dirs.CODEX_SESSIONS_DIR, 0);
 }
 async function listSessions(opts = {}) {
   const limit = Math.min(Math.max(1, opts.limit ?? 20), 100);
   const maxAgeMs = parseMaxAge(opts.maxAge ?? "7d");
   const cutoff = Date.now() - maxAgeMs;
-  let entries;
-  try {
-    entries = await (0, import_promises5.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const projectDirs = entries.filter((e) => e.isDirectory() && e.name !== "memory").map((e) => (0, import_node_path6.join)(dirs.PROJECTS_DIR, e.name));
-  const [nested, codexFiles] = await Promise.all([
-    Promise.all(
-      projectDirs.map(async (projectDir) => {
-        try {
-          const files = await (0, import_promises5.readdir)(projectDir);
-          const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-          const statResults = await Promise.all(
-            jsonlFiles.map(async (f) => {
-              const filePath = (0, import_node_path6.join)(projectDir, f);
-              try {
-                const s = await (0, import_promises5.stat)(filePath);
-                return s.mtimeMs >= cutoff ? { path: filePath, mtimeMs: s.mtimeMs } : null;
-              } catch {
-                return null;
-              }
-            })
-          );
-          return statResults.filter((r) => r !== null);
-        } catch {
-          return [];
-        }
-      })
-    ),
-    listCodexSessionFiles(cutoff)
-  ]);
-  const allFiles = [...nested.flat(), ...codexFiles];
-  allFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const allFiles = listAllSessionFiles(cutoff).filter((file) => !file.isSubagent);
   const results = [];
   for (const file of allFiles) {
     if (results.length >= limit) break;
@@ -3996,41 +5480,19 @@ async function listSessions(opts = {}) {
   return results;
 }
 async function currentSession(cwd) {
-  const projectDir = (0, import_node_path6.join)(dirs.PROJECTS_DIR, encodeClaudeDirName(cwd));
-  let files;
-  try {
-    files = await (0, import_promises5.readdir)(projectDir);
-  } catch {
-    files = [];
-  }
-  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-  const [statResults, codexCandidates] = await Promise.all([
-    Promise.all(
-      jsonlFiles.map(async (f) => {
-        const filePath = (0, import_node_path6.join)(projectDir, f);
-        try {
-          const s = await (0, import_promises5.stat)(filePath);
-          return { path: filePath, mtimeMs: s.mtimeMs };
-        } catch {
-          return null;
-        }
-      })
-    ),
-    listCodexSessionFiles(0)
-  ]);
-  const codexMatches = [];
-  for (const file of codexCandidates) {
+  const claude2 = storeFor("claude");
+  const projectDir = (0, import_node_path6.join)(claude2.root(), claude2.descriptor.dirName.encode(cwd));
+  const direct = claude2.list(0, claude2.root()).filter((file) => !file.isSubagent && file.path.startsWith(projectDir + import_node_path6.sep));
+  const searched = [];
+  for (const file of listAllSessionFiles(0)) {
+    if (file.isSubagent || storeForPath(file.path)?.kind === "claude") continue;
     try {
-      const meta2 = await getSessionMeta(file.path);
-      if (meta2.cwd === cwd) codexMatches.push(file);
+      if ((await getSessionMeta(file.path)).cwd === cwd) searched.push(file);
     } catch {
       continue;
     }
   }
-  const valid = [
-    ...statResults.filter((r) => r !== null),
-    ...codexMatches
-  ];
+  const valid = [...direct, ...searched];
   if (valid.length === 0) return null;
   valid.sort((a, b) => b.mtimeMs - a.mtimeMs);
   const latest = valid[0];
@@ -4043,11 +5505,11 @@ async function currentSession(cwd) {
 }
 
 // src/commands/index-cmd.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_node_path7 = require("node:path");
 async function indexStats(dbPath) {
   const path = dbPath ?? DEFAULT_DB_PATH;
-  if (!(0, import_node_fs3.existsSync)(path)) {
+  if (!(0, import_node_fs4.existsSync)(path)) {
     return { error: `Database not found at ${path}. Run 'cogpit-memory index rebuild' to create it.` };
   }
   const index = new SearchIndex(path);
@@ -4057,9 +5519,9 @@ async function indexStats(dbPath) {
 }
 async function indexRebuild(dbPath) {
   const path = dbPath ?? DEFAULT_DB_PATH;
-  (0, import_node_fs3.mkdirSync)((0, import_node_path7.dirname)(path), { recursive: true });
+  (0, import_node_fs4.mkdirSync)((0, import_node_path7.dirname)(path), { recursive: true });
   const index = new SearchIndex(path);
-  index.buildFull(dirs.PROJECTS_DIR);
+  index.buildFull();
   const stats = index.getStats();
   index.close();
   return { status: "rebuilt", stats };