cogpit-memory 0.1.9 → 0.1.10

package/dist/index.js

@@ -57,7 +57,7 @@ var Database = import_better_sqlite3.default;
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 
-// src/lib/turnBuilder.ts
+// src/lib/messageTypeGuards.ts
 function isUserMessage(msg) {
   return msg.type === "user";
 }
@@ -73,9 +73,14 @@ function isSystemMessage(msg) {
 function isSummaryMessage(msg) {
   return msg.type === "summary";
 }
+function isQueueOperationMessage(msg) {
+  return msg.type === "queue-operation";
+}
 function isCompactBoundary(msg) {
   return msg.type === "system" && msg.subtype === "compact_boundary";
 }
+
+// src/lib/turnBuilder.ts
 function extractTextFromContent(content) {
   if (typeof content === "string") return content;
   return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
@@ -88,6 +93,11 @@ function extractToolResultText(content) {
     return "";
   }).filter(Boolean).join("\n");
 }
+function isVisibleQueuedPrompt(content) {
+  if (!content?.trim()) return false;
+  const trimmed = content.trimStart();
+  return !trimmed.startsWith("<task-notification>") && !trimmed.startsWith("<local-command-");
+}
 function mergeTokenUsage(existing, incoming) {
   if (!existing) {
     return { ...incoming };
@@ -96,7 +106,8 @@ function mergeTokenUsage(existing, incoming) {
     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)
+    cache_read_input_tokens: (existing.cache_read_input_tokens ?? 0) + (incoming.cache_read_input_tokens ?? 0),
+    speed: incoming.speed ?? existing.speed
   };
 }
 function buildCompactionSummary(turns, title) {
@@ -129,10 +140,95 @@ function buildCompactionSummary(turns, title) {
   }
   return parts.join("\n");
 }
+function groupPlanModeBlocks(blocks) {
+  const result = [];
+  let i = 0;
+  while (i < blocks.length) {
+    const block = blocks[i];
+    if (block.kind === "tool_calls") {
+      const enterIdx = block.toolCalls.findIndex((tc) => tc.name === "EnterPlanMode");
+      if (enterIdx !== -1) {
+        const enterCall = block.toolCalls[enterIdx];
+        const plan = String(enterCall.input.plan ?? "");
+        const timestamp = block.timestamp;
+        const before = block.toolCalls.slice(0, enterIdx);
+        if (before.length > 0) {
+          result.push({ kind: "tool_calls", toolCalls: before, timestamp: block.timestamp });
+        }
+        const embedded = [];
+        const afterEnterInSameBlock = block.toolCalls.slice(enterIdx + 1);
+        const exitInSameBlock = afterEnterInSameBlock.findIndex((tc) => tc.name === "ExitPlanMode");
+        if (exitInSameBlock !== -1) {
+          embedded.push(...afterEnterInSameBlock.slice(0, exitInSameBlock));
+          const exitCall = afterEnterInSameBlock[exitInSameBlock];
+          const planFilePath = exitCall.input.path ? String(exitCall.input.path) : void 0;
+          let status = "pending";
+          if (exitCall.result !== null) {
+            status = exitCall.isError ? "rejected" : "approved";
+          }
+          result.push({ kind: "plan_mode", plan, planFilePath, status, toolCalls: embedded, timestamp });
+          const after = afterEnterInSameBlock.slice(exitInSameBlock + 1);
+          if (after.length > 0) {
+            result.push({ kind: "tool_calls", toolCalls: after, timestamp: block.timestamp });
+          }
+          i++;
+          continue;
+        } else {
+          embedded.push(...afterEnterInSameBlock);
+          let exitCall;
+          let planFilePath;
+          let status = "pending";
+          let j = i + 1;
+          const passthroughBlocks = [];
+          while (j < blocks.length) {
+            const next = blocks[j];
+            if (next.kind === "tool_calls") {
+              const exitIdx = next.toolCalls.findIndex((tc) => tc.name === "ExitPlanMode");
+              if (exitIdx !== -1) {
+                embedded.push(...next.toolCalls.slice(0, exitIdx));
+                exitCall = next.toolCalls[exitIdx];
+                planFilePath = exitCall.input.path ? String(exitCall.input.path) : void 0;
+                if (exitCall.result !== null) {
+                  status = exitCall.isError ? "rejected" : "approved";
+                }
+                const tail = next.toolCalls.slice(exitIdx + 1);
+                result.push({ kind: "plan_mode", plan, planFilePath, status, toolCalls: embedded, timestamp });
+                result.push(...passthroughBlocks);
+                if (tail.length > 0) {
+                  result.push({ kind: "tool_calls", toolCalls: tail, timestamp: next.timestamp });
+                }
+                i = j + 1;
+                break;
+              } else {
+                embedded.push(...next.toolCalls);
+                j++;
+              }
+            } else if (next.kind === "hook_event" || next.kind === "text" || next.kind === "queued_prompt") {
+              passthroughBlocks.push(next);
+              j++;
+            } else {
+              break;
+            }
+          }
+          if (!exitCall) {
+            result.push({ kind: "plan_mode", plan, planFilePath: void 0, status: "pending", toolCalls: embedded, timestamp });
+            result.push(...passthroughBlocks);
+            i = j;
+          }
+          continue;
+        }
+      }
+    }
+    result.push(block);
+    i++;
+  }
+  return result;
+}
 function buildTurns(messages) {
   const turns = [];
   let current = null;
   let pendingCompaction = null;
+  let pendingRecap = null;
   const pendingToolUses = /* @__PURE__ */ new Map();
   const seenMessageIds = /* @__PURE__ */ new Set();
   const subAgentMap = /* @__PURE__ */ new Map();
@@ -163,6 +259,22 @@ function buildTurns(messages) {
     for (const [parentId] of subAgentMap) {
       flushSubAgentMessages(parentId);
     }
+    for (const block of current.contentBlocks) {
+      if (block.kind !== "hook_event") continue;
+      for (const ev of block.events) {
+        const isPostToolUse = ev.eventName === "PostToolUse" || ev.eventName.startsWith("PostToolUse:");
+        if (!isPostToolUse || !ev.toolUseId) continue;
+        const toolCall = current.toolCalls.find((tc) => tc.id === ev.toolUseId);
+        if (!toolCall) continue;
+        if (ev.updatedToolOutput) {
+          toolCall.outputReplacedByHook = true;
+        }
+        if (ev.durationMs !== void 0) {
+          toolCall.hookDurationMs = (toolCall.hookDurationMs ?? 0) + ev.durationMs;
+        }
+      }
+    }
+    current.contentBlocks = groupPlanModeBlocks(current.contentBlocks);
     turns.push(current);
     current = null;
     agentBlockMap.clear();
@@ -184,6 +296,20 @@ function buildTurns(messages) {
       );
       continue;
     }
+    if (isSystemMessage(msg) && msg.subtype === "away_summary" && msg.content) {
+      pendingRecap = { content: msg.content, timestamp: msg.timestamp };
+      continue;
+    }
+    if (isQueueOperationMessage(msg)) {
+      if (current && msg.operation === "enqueue" && isVisibleQueuedPrompt(msg.content)) {
+        current.contentBlocks.push({
+          kind: "queued_prompt",
+          content: msg.content,
+          timestamp: msg.timestamp
+        });
+      }
+      continue;
+    }
     if (isUserMessage(msg) && !msg.isMeta) {
       const content = msg.message.content;
       if (typeof content !== "string" && Array.isArray(content)) {
@@ -194,7 +320,7 @@ function buildTurns(messages) {
               const pending = pendingToolUses.get(block.tool_use_id);
               if (pending) {
                 pending.turn.toolCalls[pending.index].result = extractToolResultText(block.content);
-                pending.turn.toolCalls[pending.index].isError = block.is_error;
+                pending.turn.toolCalls[pending.index].isError = block.is_error === true;
                 pendingToolUses.delete(block.tool_use_id);
               }
             }
@@ -212,6 +338,7 @@ function buildTurns(messages) {
             }
             const agentMsg = {
               agentId: toolUseResult.agentId,
+              parentToolUseId: toolUseId || void 0,
               agentName: taskMeta?.name ?? null,
               subagentType: taskMeta?.subagentType ?? null,
               type: "assistant",
@@ -263,6 +390,10 @@ function buildTurns(messages) {
         current.compactionSummary = pendingCompaction;
         pendingCompaction = null;
       }
+      if (pendingRecap) {
+        current.contentBlocks.push({ kind: "recap", content: pendingRecap.content, timestamp: pendingRecap.timestamp });
+        pendingRecap = null;
+      }
       continue;
     }
     if (isAssistantMessage(msg)) {
@@ -312,6 +443,7 @@ function buildTurns(messages) {
         if (block.type === "thinking") {
           flushToolCalls2();
           const tb = block;
+          if (!tb.thinking) continue;
           current.thinking.push(tb);
           msgThinking.push(tb);
         } else if (block.type === "text") {
@@ -391,6 +523,7 @@ function buildTurns(messages) {
       const taskMeta = taskMetaMap.get(parentId);
       const agentMsg = {
         agentId: data.agentId,
+        parentToolUseId: parentId || void 0,
         agentName: taskMeta?.name ?? null,
         subagentType: taskMeta?.subagentType ?? null,
         type: data.message.type,
@@ -436,7 +569,7 @@ function buildTurns(messages) {
                   );
                   if (match) {
                     match.result = extractToolResultText(block.content);
-                    match.isError = block.is_error;
+                    match.isError = block.is_error === true;
                   }
                 }
               }
@@ -455,6 +588,36 @@ function buildTurns(messages) {
       }
       continue;
     }
+    if (isProgressMessage(msg) && msg.data.type === "hook_progress") {
+      const data = msg.data;
+      const eventName = String(data.hook_event_name ?? data.hookEvent ?? "unknown");
+      const hookSpecific = data.hookSpecificOutput;
+      const ev = {
+        eventName,
+        source: data.source !== void 0 ? String(data.source) : void 0,
+        toolName: data.tool_name !== void 0 ? String(data.tool_name) : void 0,
+        toolUseId: data.tool_use_id !== void 0 ? String(data.tool_use_id) : void 0,
+        command: data.command !== void 0 ? String(data.command) : void 0,
+        output: data.output !== void 0 ? String(data.output) : void 0,
+        stderr: data.stderr !== void 0 ? String(data.stderr) : void 0,
+        exitCode: data.exit_code !== void 0 ? Number(data.exit_code) : void 0,
+        decision: data.decision !== void 0 ? String(data.decision) : void 0,
+        durationMs: data.duration_ms !== void 0 ? Number(data.duration_ms) : void 0,
+        updatedToolOutput: hookSpecific?.updatedToolOutput !== void 0 ? String(hookSpecific.updatedToolOutput) : void 0,
+        sessionTitle: hookSpecific?.sessionTitle !== void 0 ? String(hookSpecific.sessionTitle) : void 0,
+        worktreePath: hookSpecific?.worktreePath !== void 0 ? String(hookSpecific.worktreePath) : void 0,
+        timestamp: msg.timestamp ?? ""
+      };
+      if (current) {
+        const last = current.contentBlocks[current.contentBlocks.length - 1];
+        if (last && last.kind === "hook_event") {
+          last.events.push(ev);
+        } else {
+          current.contentBlocks.push({ kind: "hook_event", events: [ev], timestamp: msg.timestamp });
+        }
+      }
+      continue;
+    }
     if (isSystemMessage(msg) && msg.subtype === "turn_duration" && current) {
       current.durationMs = msg.durationMs ?? null;
       continue;
@@ -465,58 +628,84 @@ function buildTurns(messages) {
 }
 
 // src/lib/pricingTiers.ts
-var EXTENDED_CONTEXT_THRESHOLD = 2e5;
 var TIER_HAIKU_35 = { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08, webSearch: 0.01 };
 var TIER_HAIKU_45 = { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1, webSearch: 0.01 };
-var TIER_SONNET_LEGACY = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, webSearch: 0.01 };
-var TIER_SONNET_LATEST = { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, webSearch: 0.01 };
+var TIER_SONNET = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, webSearch: 0.01 };
+var TIER_OPUS_MID = { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, webSearch: 0.01 };
+var TIER_FRONTIER = { input: 10, output: 50, cacheWrite: 12.5, cacheRead: 1, webSearch: 0.01 };
 var TIER_OPUS_LEGACY = { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5, webSearch: 0.01 };
-var TIER_SONNET_LEGACY_EXT = { input: 6, output: 22.5, cacheWrite: 7.5, cacheRead: 0.6, webSearch: 0.01 };
-var TIER_EXTENDED = { input: 10, output: 37.5, cacheWrite: 12.5, cacheRead: 1, webSearch: 0.01 };
+var TIER_GPT_56_SOL = { input: 5, output: 30, cacheWrite: 6.25, cacheRead: 0.5, webSearch: 0.01 };
+var TIER_GPT_56_TERRA = { input: 2.5, output: 15, cacheWrite: 3.125, cacheRead: 0.25, webSearch: 0.01 };
+var TIER_GPT_56_LUNA = { input: 1, output: 6, cacheWrite: 1.25, cacheRead: 0.1, webSearch: 0.01 };
+var TIER_GPT_55 = { input: 5, output: 30, cacheWrite: 5, cacheRead: 0.5, webSearch: 0.01 };
+var TIER_GPT_54 = { input: 2.5, output: 15, cacheWrite: 2.5, cacheRead: 0.25, webSearch: 0.01 };
+var TIER_GPT_54_MINI = { input: 0.75, output: 4.5, cacheWrite: 0.75, cacheRead: 0.075, webSearch: 0.01 };
+var TIER_FAST = { input: 30, output: 150, cacheWrite: 37.5, cacheRead: 3, webSearch: 0.01 };
 var MODEL_TIERS = [
+  // OpenAI GPT models. Keep variants before their shared family prefixes.
+  { match: "gpt-5.6-sol", tier: TIER_GPT_56_SOL },
+  { match: "gpt-5.6-terra", tier: TIER_GPT_56_TERRA },
+  { match: "gpt-5.6-luna", tier: TIER_GPT_56_LUNA },
+  { match: "gpt-5.6", tier: TIER_GPT_56_SOL },
+  { match: "gpt-5.4-mini", tier: TIER_GPT_54_MINI },
+  { match: "gpt-5.5", tier: TIER_GPT_55 },
+  { match: "gpt-5.4", tier: TIER_GPT_54 },
+  // Frontier (Fable 5 / Mythos 5 / Opus 4.8)
+  { match: "fable-5", tier: TIER_FRONTIER },
+  { match: "mythos-5", tier: TIER_FRONTIER },
+  { match: "opus-4-8", tier: TIER_FRONTIER },
   // Haiku
   { match: "haiku-4-5", tier: TIER_HAIKU_45 },
   { match: "haiku-4-0", tier: TIER_HAIKU_35 },
   { match: "3-5-haiku", tier: TIER_HAIKU_35 },
-  // Sonnet latest (4.5+)
-  { match: "sonnet-4-6", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
-  { match: "sonnet-4-5", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
-  // Sonnet legacy (3.5, 3.7, 4.0)
-  { match: "sonnet-4-0", tier: TIER_SONNET_LEGACY, extendedTier: TIER_SONNET_LEGACY_EXT },
-  { match: "3-7-sonnet", tier: TIER_SONNET_LEGACY, extendedTier: TIER_SONNET_LEGACY_EXT },
-  { match: "3-5-sonnet", tier: TIER_SONNET_LEGACY, extendedTier: TIER_SONNET_LEGACY_EXT },
-  // Opus latest (4.5+) — same tier as sonnet latest
-  { match: "opus-4-6", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
-  { match: "opus-4-5", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
+  // Sonnet (3.5 through 4.6 — all one tier in current CC)
+  { match: "sonnet-4-7", tier: TIER_SONNET },
+  { match: "sonnet-4-6", tier: TIER_SONNET },
+  { match: "sonnet-4-5", tier: TIER_SONNET },
+  { match: "sonnet-4-0", tier: TIER_SONNET },
+  { match: "3-7-sonnet", tier: TIER_SONNET },
+  { match: "3-5-sonnet", tier: TIER_SONNET },
+  // Opus 4.5–4.7
+  { match: "opus-4-7", tier: TIER_OPUS_MID },
+  { match: "opus-4-6", tier: TIER_OPUS_MID },
+  { match: "opus-4-5", tier: TIER_OPUS_MID },
   // Opus legacy (4.0, 4.1)
   { match: "opus-4-1", tier: TIER_OPUS_LEGACY },
   { match: "opus-4-0", tier: TIER_OPUS_LEGACY }
 ];
-var DEFAULT_TIER = TIER_SONNET_LATEST;
-var DEFAULT_EXTENDED_TIER = TIER_EXTENDED;
+var FAST_MODE_MODELS = ["opus-4-6", "opus-4-7"];
+var DEFAULT_TIER = TIER_OPUS_MID;
 var FAMILY_FALLBACKS = [
+  { match: "fable", tier: TIER_FRONTIER },
+  { match: "mythos", tier: TIER_FRONTIER },
   { match: "haiku", tier: TIER_HAIKU_45 },
-  { match: "sonnet", tier: TIER_SONNET_LATEST },
-  { match: "opus", tier: TIER_SONNET_LATEST }
+  { match: "sonnet", tier: TIER_SONNET },
+  { match: "opus", tier: TIER_OPUS_MID }
 ];
-function resolveTier(model, totalInputTokens) {
-  const isExtended = (totalInputTokens ?? 0) > EXTENDED_CONTEXT_THRESHOLD;
+function resolveTier(model, speed) {
+  if (speed === "fast" && FAST_MODE_MODELS.some((m) => model.includes(m))) {
+    return TIER_FAST;
+  }
   for (const entry of MODEL_TIERS) {
-    if (model.includes(entry.match)) {
-      return isExtended && entry.extendedTier ? entry.extendedTier : entry.tier;
-    }
+    if (model.includes(entry.match)) return entry.tier;
   }
   for (const entry of FAMILY_FALLBACKS) {
     if (model.includes(entry.match)) return entry.tier;
   }
-  return isExtended ? DEFAULT_EXTENDED_TIER : DEFAULT_TIER;
+  return DEFAULT_TIER;
+}
+function hasKnownPricing(model) {
+  if (!model) return true;
+  const normalized = model.toLowerCase();
+  if (!normalized.startsWith("gpt-")) return true;
+  return MODEL_TIERS.some((entry) => normalized.includes(entry.match));
 }
 
 // src/lib/token-costs.ts
 var CHARS_PER_TOKEN = 4;
 function calculateCost(c) {
-  const totalInput = c.inputTokens + c.cacheWriteTokens + c.cacheReadTokens;
-  const p = resolveTier(c.model ?? "", totalInput);
+  if (!hasKnownPricing(c.model)) return Number.NaN;
+  const p = resolveTier(c.model ?? "", c.speed);
   return c.inputTokens / 1e6 * p.input + c.outputTokens / 1e6 * p.output + c.cacheWriteTokens / 1e6 * p.cacheWrite + c.cacheReadTokens / 1e6 * p.cacheRead + (c.webSearchRequests ?? 0) * p.webSearch;
 }
 function charsToTokens(chars) {
@@ -554,7 +743,8 @@ function calculateTurnCostEstimated(turn) {
     inputTokens: u.input_tokens,
     outputTokens: estimateTotalOutputTokens(turn),
     cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
-    cacheReadTokens: u.cache_read_input_tokens ?? 0
+    cacheReadTokens: u.cache_read_input_tokens ?? 0,
+    speed: u.speed
   });
 }
 function calculateSubAgentCostEstimated(sa) {
@@ -565,7 +755,8 @@ function calculateSubAgentCostEstimated(sa) {
     inputTokens: u.input_tokens,
     outputTokens: estimateSubAgentOutput(sa),
     cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
-    cacheReadTokens: u.cache_read_input_tokens ?? 0
+    cacheReadTokens: u.cache_read_input_tokens ?? 0,
+    speed: u.speed
   });
 }
 
@@ -585,6 +776,19 @@ function addUsageToStats(stats, usage, estimatedOutput, cost) {
   stats.totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
   stats.totalCostUSD += cost;
 }
+function createEmptySessionStats(turnCount) {
+  return {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheCreationTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCostUSD: 0,
+    toolCallCounts: {},
+    errorCount: 0,
+    totalDurationMs: 0,
+    turnCount
+  };
+}
 function computeStats(turns) {
   const stats = {
     totalInputTokens: 0,
@@ -613,8 +817,271 @@ function computeStats(turns) {
   return stats;
 }
 
+// src/lib/codex-patches.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;
+}
+function isApplyPatchText(value) {
+  return value.includes("*** Begin Patch") && value.includes("*** End Patch");
+}
+function extractApplyPatchInputs(execSource) {
+  if (!execSource.includes("apply_patch") || !execSource.includes("*** Begin Patch")) return [];
+  const assignedPatches = /* @__PURE__ */ new Map();
+  for (let index = 0; index < execSource.length; index++) {
+    const literal = readJsStringLiteral(execSource, index);
+    if (!literal) continue;
+    if (isApplyPatchText(literal.value)) {
+      const assignment = execSource.slice(0, index).match(/(?:^|[;\n])\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*$/);
+      if (assignment) assignedPatches.set(assignment[1], literal.value);
+    }
+    index = literal.endIndex - 1;
+  }
+  const patches = [];
+  const seen = /* @__PURE__ */ new Set();
+  const applyCall = /\btools\s*\.\s*apply_patch\s*\(/g;
+  let match;
+  while ((match = applyCall.exec(execSource)) !== null) {
+    let argumentIndex = match.index + match[0].length;
+    while (/\s/.test(execSource[argumentIndex] ?? "")) argumentIndex++;
+    const literal = readJsStringLiteral(execSource, argumentIndex);
+    const identifier = literal ? null : execSource.slice(argumentIndex).match(/^([A-Za-z_$][\w$]*)/);
+    const patch = literal?.value ?? (identifier ? assignedPatches.get(identifier[1]) : void 0);
+    if (!patch || !isApplyPatchText(patch) || seen.has(patch)) continue;
+    seen.add(patch);
+    patches.push(patch);
+  }
+  return patches;
+}
+function resolveCodexPatchPath(filePath, cwd) {
+  if (!cwd || filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath)) return filePath;
+  return `${cwd.replace(/[\\/]+$/, "")}/${filePath.replace(/^\.\//, "")}`;
+}
+function parseApplyPatch(patchText, callId, timestamp, cwd = "") {
+  const toolCalls = [];
+  const filePattern = /^\*\*\*\s+(Update File|Add File|Delete File):\s*(.+)$/gm;
+  const sections = [];
+  let match;
+  while ((match = filePattern.exec(patchText)) !== null) {
+    sections.push({
+      action: match[1],
+      filePath: match[2].trim(),
+      headerIdx: match.index,
+      startIdx: match.index + match[0].length
+    });
+  }
+  for (let i = 0; i < sections.length; i++) {
+    const section = sections[i];
+    const endIdx = i + 1 < sections.length ? sections[i + 1].headerIdx : patchText.length;
+    const body = patchText.slice(section.startIdx, endIdx);
+    const movedTo = body.match(/^\*\*\*\s+Move to:\s*(.+)$/m)?.[1]?.trim();
+    const sourcePath = resolveCodexPatchPath(section.filePath, cwd);
+    const filePath = resolveCodexPatchPath(movedTo || section.filePath, cwd);
+    const hunkBodies = body.split(/^@@.*$/m).filter((s) => s.trim());
+    const oldLines = [];
+    const newLines = [];
+    for (const hunk of hunkBodies) {
+      for (const line of hunk.split("\n")) {
+        if (line.startsWith("-")) {
+          oldLines.push(line.slice(1));
+        } else if (line.startsWith("+")) {
+          newLines.push(line.slice(1));
+        } else if (line.startsWith(" ")) {
+          oldLines.push(line.slice(1));
+          newLines.push(line.slice(1));
+        }
+      }
+    }
+    const fileId = sections.length > 1 ? `${callId}:file-${i}` : callId;
+    if (section.action === "Add File") {
+      toolCalls.push({
+        id: fileId,
+        name: "Write",
+        input: { file_path: filePath, content: newLines.join("\n") },
+        result: null,
+        isError: false,
+        timestamp
+      });
+    } else if (section.action === "Delete File") {
+      toolCalls.push({
+        id: fileId,
+        name: "Edit",
+        input: { file_path: filePath, old_string: oldLines.join("\n"), new_string: "" },
+        result: null,
+        isError: false,
+        timestamp
+      });
+    } else {
+      toolCalls.push({
+        id: fileId,
+        name: "Edit",
+        input: {
+          file_path: filePath,
+          ...movedTo ? { old_path: sourcePath } : {},
+          old_string: oldLines.join("\n"),
+          new_string: newLines.join("\n")
+        },
+        result: null,
+        isError: false,
+        timestamp
+      });
+    }
+  }
+  return toolCalls;
+}
+function parseCodexToolPatches(toolName, rawInput, callId, timestamp, cwd = "") {
+  if (toolName === "apply_patch") {
+    return parseApplyPatch(rawInput, callId, timestamp, cwd);
+  }
+  return extractApplyPatchInputs(rawInput).flatMap(
+    (patch, patchIndex) => parseApplyPatch(patch, `${callId}:patch-${patchIndex}`, timestamp, cwd)
+  );
+}
+function findFailedNestedPatchCallIds(output, wrapperIsError, calls) {
+  if (!wrapperIsError || !/(?:apply[_ ]patch|invalid patch|invalid context|failed to (?:apply|find)|could not apply)/i.test(output)) {
+    return /* @__PURE__ */ new Set();
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const patchIndex = call.id.match(/:patch-(\d+)(?::file-\d+)?$/)?.[1];
+    if (patchIndex === void 0) continue;
+    const index = Number(patchIndex);
+    const group = groups.get(index) ?? [];
+    group.push(call);
+    groups.set(index, group);
+  }
+  if (groups.size === 0) return new Set(calls.map((call) => call.id));
+  const normalizedOutput = output.toLowerCase().replaceAll("\\", "/");
+  const mentionedGroups = /* @__PURE__ */ new Set();
+  for (const [index, group] of groups) {
+    if (group.some((call) => {
+      const filePath = String(call.input.file_path ?? "").toLowerCase().replaceAll("\\", "/");
+      if (!filePath) return false;
+      const segments = filePath.split("/").filter(Boolean);
+      const suffix = segments.slice(-2).join("/");
+      return normalizedOutput.includes(filePath) || suffix.includes("/") && normalizedOutput.includes(suffix);
+    })) {
+      mentionedGroups.add(index);
+    }
+  }
+  for (const match of normalizedOutput.matchAll(/\bpatch\s*(?:#|-)?\s*(\d+)\b/g)) {
+    const index = Number(match[1]);
+    if (groups.has(index)) mentionedGroups.add(index);
+  }
+  if (mentionedGroups.size === 0) mentionedGroups.add(Math.max(...groups.keys()));
+  const firstFailedIndex = Math.min(...mentionedGroups);
+  for (const index of groups.keys()) {
+    if (index >= firstFailedIndex) mentionedGroups.add(index);
+  }
+  return new Set(
+    [...mentionedGroups].flatMap((index) => groups.get(index)?.map((call) => call.id) ?? [])
+  );
+}
+
+// src/lib/codex-tool-normalization.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+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 normalizePlanToTodos(input) {
+  const plan = Array.isArray(input.plan) ? input.plan : [];
+  const todos = plan.filter((item) => isObject(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 parseCustomToolOutput(output) {
+  const rawOutput = extractCustomToolOutputText(output);
+  if (!rawOutput) return { text: "", isError: false };
+  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 };
+  } catch {
+    return { text: rawOutput, isError: inferToolError(rawOutput) };
+  }
+}
+
 // src/lib/codex.ts
 var SKIP_PROMPT_PREFIXES = [
+  "# AGENTS.md instructions for ",
+  "<recommended_plugins>",
   "<environment_context>",
   "<permissions instructions>",
   "<collaboration_mode>",
@@ -630,17 +1097,120 @@ function safeParseLine(line) {
     return null;
   }
 }
-function isObject(value) {
+function isObject2(value) {
   return typeof value === "object" && value !== null;
 }
 function isCodexRecord(record) {
   if (!record || typeof record.type !== "string") return false;
-  return record.type === "session_meta" || record.type === "turn_context" || record.type === "event_msg" || record.type === "response_item";
+  return record.type === "session_meta" || record.type === "turn_context" || record.type === "event_msg" || record.type === "response_item" || record.type === "inter_agent_communication_metadata" || record.type === "compacted" || record.type === "world_state";
 }
 function extractMessageText(payload, blockType) {
   const content = payload?.content;
   if (!Array.isArray(content)) return "";
-  return content.filter((block) => isObject(block) && block.type === blockType && typeof block.text === "string").map((block) => block.text).join("\n").trim();
+  return content.filter((block) => isObject2(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;
+function parseImageDataUrl(value) {
+  if (typeof value !== "string") return null;
+  const match = CODEX_IMAGE_DATA_URL.exec(value);
+  if (!match?.[1] || !match[2]) return null;
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: match[1].toLowerCase(),
+      data: match[2]
+    }
+  };
+}
+function parseAudioDataUrl(value) {
+  if (typeof value !== "string") return null;
+  const match = CODEX_AUDIO_DATA_URL.exec(value);
+  if (!match?.[1] || !match[2]) return null;
+  return {
+    type: "audio",
+    source: {
+      type: "base64",
+      media_type: match[1].toLowerCase(),
+      data: match[2]
+    }
+  };
+}
+function extractEventMessageImages(payload) {
+  if (!Array.isArray(payload.images)) return [];
+  return payload.images.map(parseImageDataUrl).filter((image) => image !== null);
+}
+function extractEventMessageAudio(payload) {
+  if (!Array.isArray(payload.audio)) return [];
+  return payload.audio.map(parseAudioDataUrl).filter((audio) => audio !== null);
+}
+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);
+}
+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);
+}
+function buildCodexUserContent(message, images, audio = [], localImages = [], localAudio = []) {
+  const attachmentSuffix = [
+    ...localImages.map((path) => `
+![image](<${path}>)`),
+    ...localAudio.map((path) => `
+[audio attachment](<${path}>)`)
+  ].join("");
+  const text = message + attachmentSuffix;
+  if (images.length === 0 && audio.length === 0) return text;
+  return [
+    ...images,
+    ...audio,
+    ...text ? [{ type: "text", text }] : []
+  ];
+}
+function normalizeFunctionName(rawName) {
+  const leaf = rawName.split(/(?:__|[.:/])+/).filter(Boolean).at(-1) ?? rawName;
+  const aliases = {
+    spawnAgent: "spawn_agent",
+    waitAgent: "wait_agent",
+    sendMessage: "send_message",
+    followupTask: "followup_task",
+    listAgents: "list_agents",
+    interruptAgent: "interrupt_agent"
+  };
+  const canonicalCollaborationNames = /* @__PURE__ */ new Set([
+    "spawn_agent",
+    "wait_agent",
+    "send_message",
+    "followup_task",
+    "list_agents",
+    "interrupt_agent"
+  ]);
+  if (aliases[leaf]) return aliases[leaf];
+  if (canonicalCollaborationNames.has(leaf)) return leaf;
+  return rawName;
+}
+function extractInterAgentMessage(payload) {
+  const rawText = extractMessageText(payload, "input_text");
+  if (!rawText) return { messageType: null, text: "" };
+  const headerEnd = rawText.match(/\r?\nPayload:\s*(?:\r?\n|$)/);
+  if (!rawText.startsWith("Message Type:") || !headerEnd || headerEnd.index === void 0) {
+    return { messageType: null, text: rawText.trim() };
+  }
+  const header = rawText.slice(0, headerEnd.index);
+  const messageType = header.match(/^Message Type:\s*([^\r\n]+)/)?.[1]?.trim().toUpperCase() ?? null;
+  const text = rawText.slice(headerEnd.index + headerEnd[0].length).trim();
+  return { messageType, text };
+}
+function agentNameFromPath(agentPath) {
+  const segments = agentPath.split("/").filter(Boolean);
+  return segments.at(-1) ?? null;
+}
+function readableAgentPrompt(value) {
+  if (typeof value !== "string") return "";
+  const prompt = value.trim();
+  if (/^gAAAAA[A-Za-z0-9_-]+$/.test(prompt)) return "";
+  return prompt;
 }
 function normalizePromptText(text) {
   const trimmed = text.trim();
@@ -658,11 +1228,13 @@ function mergeTokenUsage2(existing, incoming) {
   };
 }
 function parseTokenUsage(value) {
-  if (!isObject(value)) return null;
-  const inputTokens = typeof value.input_tokens === "number" ? value.input_tokens : 0;
+  if (!isObject2(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_creation_input_tokens === "number" ? value.cache_creation_input_tokens : 0;
-  const cacheRead = typeof value.cache_read_input_tokens === "number" ? value.cache_read_input_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;
+  const nativeCachedInput = typeof value.cached_input_tokens === "number" ? Math.max(0, value.cached_input_tokens) : null;
+  const cacheRead = nativeCachedInput ?? (typeof value.cache_read_input_tokens === "number" ? value.cache_read_input_tokens : 0);
+  const inputTokens = nativeCachedInput === null ? reportedInputTokens : Math.max(0, reportedInputTokens - nativeCachedInput);
   if (inputTokens === 0 && outputTokens === 0 && cacheCreation === 0 && cacheRead === 0) return null;
   return {
     input_tokens: inputTokens,
@@ -703,7 +1275,7 @@ function appendToolCall(turn, toolCall, timestamp) {
 }
 function finalizeTurn(turns, current, lastTimestamp) {
   if (!current) return null;
-  const hasContent = current.userMessage !== null || current.assistantText.length > 0 || current.toolCalls.length > 0 || current.thinking.length > 0;
+  const hasContent = current.userMessage !== null || current.assistantText.length > 0 || current.toolCalls.length > 0 || current.thinking.length > 0 || current.subAgentActivity.length > 0;
   if (!hasContent) return null;
   if (current.timestamp && lastTimestamp) {
     const start = new Date(current.timestamp).getTime();
@@ -719,17 +1291,11 @@ function parseToolInput(argumentsText) {
   if (typeof argumentsText !== "string" || !argumentsText.trim()) return {};
   try {
     const parsed = JSON.parse(argumentsText);
-    return isObject(parsed) ? parsed : { value: parsed };
+    return isObject2(parsed) ? parsed : { value: parsed };
   } catch {
     return { raw: argumentsText };
   }
 }
-function inferToolError(output) {
-  if (!output) return false;
-  const exitMatch = output.match(/Process exited with code (\d+)/);
-  if (exitMatch) return exitMatch[1] !== "0";
-  return /\b(error|failed|exception)\b/i.test(output);
-}
 function createTurn(turnId, timestamp, model) {
   return {
     id: turnId || randomTurnId("codex-turn"),
@@ -746,10 +1312,10 @@ function createTurn(turnId, timestamp, model) {
   };
 }
 function extractPromptFromRecord(record) {
-  if (record.type === "event_msg" && isObject(record.payload) && record.payload.type === "user_message" && typeof record.payload.message === "string") {
+  if (record.type === "event_msg" && isObject2(record.payload) && record.payload.type === "user_message" && typeof record.payload.message === "string") {
     return normalizePromptText(record.payload.message);
   }
-  if (record.type === "response_item" && isObject(record.payload) && record.payload.type === "message" && record.payload.role === "user") {
+  if (record.type === "response_item" && isObject2(record.payload) && record.payload.type === "message" && record.payload.role === "user") {
     return normalizePromptText(extractMessageText(record.payload, "input_text"));
   }
   return "";
@@ -766,14 +1332,17 @@ function extractMetadataFromRecords(records) {
   let timestamp = "";
   let lastTimestamp = "";
   let turnCount = 0;
+  let isSubagent = false;
+  let parentSessionId = null;
+  let agentPath = "/root";
   let previousPrompt = "";
   for (const record of records) {
-    if (!isObject(record.payload)) continue;
+    if (!isObject2(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 && isObject(record.payload.branchedFrom)) {
+      if (!branchedFrom && isObject2(record.payload.branchedFrom)) {
         const sourceId = typeof record.payload.branchedFrom.sessionId === "string" ? record.payload.branchedFrom.sessionId : "";
         if (sourceId) {
           branchedFrom = {
@@ -782,7 +1351,18 @@ function extractMetadataFromRecords(records) {
           };
         }
       }
-      const git = isObject(record.payload.git) ? record.payload.git : null;
+      const source = isObject2(record.payload.source) ? record.payload.source : null;
+      if (source && isObject2(source.subagent)) {
+        isSubagent = true;
+        const threadSpawn = isObject2(source.subagent.thread_spawn) ? source.subagent.thread_spawn : null;
+        if (threadSpawn && typeof threadSpawn.agent_path === "string") {
+          agentPath = threadSpawn.agent_path;
+        }
+      }
+      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;
       gitBranch ||= git && typeof git.branch === "string" ? git.branch : "";
     }
     if (record.type === "turn_context") {
@@ -807,12 +1387,16 @@ function extractMetadataFromRecords(records) {
     cwd,
     model,
     slug: "",
+    name: "",
     branchedFrom,
     firstUserMessage,
     lastUserMessage,
     timestamp,
     lastTimestamp,
-    turnCount
+    turnCount,
+    isSubagent,
+    parentSessionId,
+    agentPath
   };
 }
 function isCodexSessionText(jsonlText) {
@@ -827,18 +1411,99 @@ function extractCodexMetadataFromLines(lines) {
   const records = lines.map(safeParseLine).filter(isCodexRecord);
   return extractMetadataFromRecords(records);
 }
-function parseCodexSession(jsonlText) {
+function parseCodexSession(jsonlText, options) {
   const records = jsonlText.split("\n").map((line) => line.trim()).filter(Boolean).map(safeParseLine).filter(isCodexRecord);
   const metadata = extractMetadataFromRecords(records);
   const turns = [];
   const pendingToolCalls = /* @__PURE__ */ new Map();
+  const webSearchCalls = /* @__PURE__ */ new Map();
+  const patchCallIds = /* @__PURE__ */ new Map();
+  const spawnAgentCalls = /* @__PURE__ */ new Map();
+  const agentRegistry = /* @__PURE__ */ new Map();
+  const agentIdByPath = /* @__PURE__ */ new Map();
+  const agentIdBySpawnCall = /* @__PURE__ */ new Map();
+  const agentMessages = /* @__PURE__ */ new Map();
+  function upsertAgentMessage(agentId, targetTurn, eventTimestamp, update = {}) {
+    const info = agentRegistry.get(agentId);
+    let entry = agentMessages.get(agentId);
+    if (!entry) {
+      const agentMessage2 = {
+        agentId,
+        parentToolUseId: info?.parentToolCallId || void 0,
+        agentName: info?.nickname ?? (info?.agentPath ? agentNameFromPath(info.agentPath) : null),
+        subagentType: info?.agentType ?? null,
+        type: "assistant",
+        content: null,
+        toolCalls: [],
+        thinking: [],
+        text: [],
+        timestamp: info?.timestamp ?? eventTimestamp,
+        tokenUsage: null,
+        model: info?.model ?? null,
+        isBackground: false,
+        prompt: info?.message || void 0,
+        status: update.status ?? "running"
+      };
+      targetTurn.subAgentActivity.push(agentMessage2);
+      const lastBlock = targetTurn.contentBlocks[targetTurn.contentBlocks.length - 1];
+      if (lastBlock?.kind === "sub_agent") {
+        lastBlock.messages.push(agentMessage2);
+      } else {
+        targetTurn.contentBlocks.push({ kind: "sub_agent", messages: [agentMessage2], timestamp: eventTimestamp });
+      }
+      entry = { message: agentMessage2, turn: targetTurn };
+      agentMessages.set(agentId, entry);
+    }
+    const agentMessage = entry.message;
+    if (info) {
+      agentMessage.parentToolUseId = info.parentToolCallId || agentMessage.parentToolUseId;
+      agentMessage.agentName = info.nickname ?? (info.agentPath ? agentNameFromPath(info.agentPath) : agentMessage.agentName);
+      agentMessage.subagentType = info.agentType;
+      agentMessage.model = info.model;
+      agentMessage.prompt = info.message || agentMessage.prompt;
+    }
+    if (update.text && !agentMessage.text.includes(update.text)) {
+      agentMessage.text.push(update.text);
+      agentMessage.content = agentMessage.text.join("\n\n");
+    }
+    if (update.status) {
+      const terminalStatuses = /* @__PURE__ */ new Set(["completed", "failed", "interrupted"]);
+      if (!(update.status === "running" && agentMessage.status && terminalStatuses.has(agentMessage.status))) {
+        agentMessage.status = update.status;
+      }
+      if (terminalStatuses.has(update.status) && agentMessage.timestamp && eventTimestamp) {
+        const startedAt = new Date(agentMessage.timestamp).getTime();
+        const endedAt = new Date(eventTimestamp).getTime();
+        if (Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt) {
+          agentMessage.durationMs = endedAt - startedAt;
+        }
+      }
+    }
+    return agentMessage;
+  }
   let current = null;
   let currentTurnId = null;
   let currentModel = metadata.model || null;
   let lastTurnTimestamp = "";
+  let pendingCompaction = null;
+  function createActiveTurn(turnId, timestamp, model) {
+    const turn = createTurn(turnId, timestamp, model);
+    if (pendingCompaction) {
+      turn.compactionSummary = pendingCompaction;
+      pendingCompaction = null;
+    }
+    return turn;
+  }
   for (const record of records) {
-    const payload = isObject(record.payload) ? record.payload : void 0;
+    const payload = isObject2(record.payload) ? record.payload : void 0;
     const timestamp = record.timestamp ?? "";
+    if (record.type === "compacted") {
+      current = finalizeTurn(turns, current, lastTurnTimestamp);
+      pendingCompaction = "Conversation compacted";
+      lastTurnTimestamp = timestamp;
+      continue;
+    }
+    if (record.type === "world_state") continue;
     if (record.type === "turn_context") {
       current = finalizeTurn(turns, current, lastTurnTimestamp);
       currentTurnId = typeof payload?.turn_id === "string" ? payload.turn_id : null;
@@ -850,24 +1515,93 @@ function parseCodexSession(jsonlText) {
       if (current && (current.assistantText.length > 0 || current.toolCalls.length > 0 || current.thinking.length > 0)) {
         current = finalizeTurn(turns, current, lastTurnTimestamp);
       }
-      current ??= createTurn(currentTurnId, timestamp, currentModel);
-      current.userMessage = payload.message;
+      current ??= createActiveTurn(currentTurnId, timestamp, currentModel);
+      const localImages = (Array.isArray(payload.local_images) ? payload.local_images : []).filter(
+        (p) => typeof p === "string" && p.length > 0
+      );
+      const localAudio = (Array.isArray(payload.local_audio) ? payload.local_audio : []).filter(
+        (p) => typeof p === "string" && p.length > 0
+      );
+      current.userMessage = buildCodexUserContent(
+        payload.message,
+        extractEventMessageImages(payload),
+        extractEventMessageAudio(payload),
+        localImages,
+        localAudio
+      );
       current.timestamp = current.timestamp || timestamp;
       lastTurnTimestamp = timestamp;
       continue;
     }
-    current ??= createTurn(currentTurnId, timestamp, currentModel);
+    current ??= createActiveTurn(currentTurnId, timestamp, currentModel);
     if (!current.model && currentModel) current.model = currentModel;
     if (!current.timestamp) current.timestamp = timestamp;
     if (timestamp) lastTurnTimestamp = timestamp;
     if (record.type === "event_msg" && payload?.type === "token_count") {
-      const info = isObject(payload.info) ? payload.info : null;
+      const info = isObject2(payload.info) ? payload.info : null;
       const lastUsage = info ? parseTokenUsage(info.last_token_usage) : null;
       if (lastUsage) {
         current.tokenUsage = mergeTokenUsage2(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;
+      const existing = webSearchCalls.get(payload.call_id);
+      if (existing) {
+        existing.input = { ...existing.input, ...input };
+        existing.result = "completed";
+        existing.isError = false;
+      } else {
+        const toolCall = {
+          id: payload.call_id,
+          name: "WebSearch",
+          input,
+          result: "completed",
+          isError: false,
+          timestamp
+        };
+        webSearchCalls.set(toolCall.id, toolCall);
+        appendToolCall(current, toolCall, timestamp);
+      }
+      continue;
+    }
+    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 kind = typeof payload.kind === "string" ? payload.kind : "started";
+      const spawnInfo = eventId ? spawnAgentCalls.get(eventId) : 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;
+      if (existingId && existingId !== agentId && !agentMessages.has(agentId)) {
+        const provisionalEntry = agentMessages.get(existingId);
+        if (provisionalEntry) {
+          provisionalEntry.message.agentId = agentId;
+          agentMessages.delete(existingId);
+          agentMessages.set(agentId, provisionalEntry);
+        }
+        agentRegistry.delete(existingId);
+      }
+      const info = {
+        agentId,
+        nickname: existing?.nickname ?? agentNameFromPath(payload.agent_path) ?? spawnInfo?.taskName ?? null,
+        agentPath: payload.agent_path,
+        message: existing?.message ?? spawnInfo?.message ?? "",
+        model: existing?.model ?? spawnInfo?.model ?? null,
+        agentType: existing?.agentType ?? spawnInfo?.agentType ?? null,
+        timestamp: existing?.timestamp ?? (timestamp || spawnInfo?.timestamp || ""),
+        parentToolCallId: existing?.parentToolCallId ?? eventId
+      };
+      agentRegistry.set(agentId, info);
+      agentIdByPath.set(payload.agent_path, agentId);
+      if (eventId && (kind === "started" || spawnInfo)) agentIdBySpawnCall.set(eventId, agentId);
+      const status = kind === "interrupted" ? "interrupted" : "running";
+      upsertAgentMessage(agentId, current, timestamp, { status });
+      continue;
+    }
     if (record.type !== "response_item" || !payload) continue;
     if (payload.type === "reasoning") {
       const summary = Array.isArray(payload.summary) ? payload.summary.filter((item) => typeof item === "string").join("\n") : "";
@@ -880,14 +1614,95 @@ function parseCodexSession(jsonlText) {
     }
     if (payload.type === "message" && payload.role === "user" && current.userMessage === null) {
       const text = normalizePromptText(extractMessageText(payload, "input_text"));
-      if (text) current.userMessage = text;
+      const images = extractResponseMessageImages(payload);
+      const audio = extractResponseMessageAudio(payload);
+      if (text || images.length > 0 || audio.length > 0) {
+        current.userMessage = buildCodexUserContent(text, images, audio);
+      }
+      continue;
+    }
+    if (payload.type === "web_search_call" && typeof payload.id === "string") {
+      const input = {};
+      if (isObject2(payload.action)) input.action = payload.action;
+      const status = typeof payload.status === "string" ? payload.status : "completed";
+      const existing = webSearchCalls.get(payload.id);
+      if (existing) {
+        existing.input = { ...existing.input, ...input };
+        existing.result = status;
+        existing.isError = status === "failed";
+      } else {
+        const toolCall = {
+          id: payload.id,
+          name: "WebSearch",
+          input,
+          result: status,
+          isError: status === "failed",
+          timestamp
+        };
+        webSearchCalls.set(toolCall.id, toolCall);
+        appendToolCall(current, toolCall, timestamp);
+      }
+      continue;
+    }
+    if (payload.type === "agent_message" && typeof payload.author === "string") {
+      const author = payload.author;
+      const recipient = typeof payload.recipient === "string" ? payload.recipient : null;
+      const interAgentMessage = extractInterAgentMessage(payload);
+      if (interAgentMessage.messageType === "NEW_TASK") continue;
+      const knownAgentId = agentIdByPath.get(author);
+      const isPotentialChild = author.startsWith(`${metadata.agentPath}/`) && (recipient === null || recipient === metadata.agentPath);
+      if (!knownAgentId && !isPotentialChild) continue;
+      const agentId = knownAgentId ?? author;
+      if (!knownAgentId) {
+        agentRegistry.set(agentId, {
+          agentId,
+          nickname: agentNameFromPath(author),
+          agentPath: author,
+          message: "",
+          model: null,
+          agentType: null,
+          timestamp,
+          parentToolCallId: ""
+        });
+        agentIdByPath.set(author, agentId);
+      }
+      let status;
+      if (interAgentMessage.messageType === "FINAL_ANSWER") status = "completed";
+      else if (interAgentMessage.messageType === "ERROR" || interAgentMessage.messageType === "FAILED") status = "failed";
+      else if (interAgentMessage.messageType === "INTERRUPTED") status = "interrupted";
+      else if (interAgentMessage.messageType === "MESSAGE") status = "running";
+      upsertAgentMessage(agentId, current, timestamp, {
+        status,
+        text: interAgentMessage.text || void 0
+      });
       continue;
     }
     if (payload.type === "function_call" && typeof payload.call_id === "string") {
+      const rawName = typeof payload.name === "string" ? payload.name : "tool";
+      const functionName = normalizeFunctionName(rawName);
+      const parsedInput = parseToolInput(payload.arguments);
+      let name = functionName;
+      let input = parsedInput;
+      if (functionName === "exec_command") {
+        name = "Bash";
+      } else if (functionName === "update_plan") {
+        name = "TodoWrite";
+        input = normalizePlanToTodos(parsedInput);
+      }
+      if (functionName === "spawn_agent") {
+        spawnAgentCalls.set(payload.call_id, {
+          callId: payload.call_id,
+          message: readableAgentPrompt(parsedInput.message),
+          taskName: typeof parsedInput.task_name === "string" ? parsedInput.task_name : null,
+          model: typeof parsedInput.model === "string" ? parsedInput.model : null,
+          agentType: typeof parsedInput.agent_type === "string" ? parsedInput.agent_type : null,
+          timestamp
+        });
+      }
       const toolCall = {
         id: payload.call_id,
-        name: typeof payload.name === "string" ? payload.name : "tool",
-        input: parseToolInput(payload.arguments),
+        name,
+        input,
         result: null,
         isError: false,
         timestamp
@@ -903,6 +1718,116 @@ function parseCodexSession(jsonlText) {
       toolCall.result = output;
       toolCall.isError = inferToolError(output);
       pendingToolCalls.delete(payload.call_id);
+      if (toolCall.name === "spawn_agent" && output) {
+        try {
+          const result = JSON.parse(output);
+          const agentId = typeof result.agent_id === "string" ? result.agent_id : agentIdBySpawnCall.get(toolCall.id) ?? "";
+          const agentPath = typeof result.task_name === "string" ? result.task_name : null;
+          const nickname = typeof result.nickname === "string" ? result.nickname : agentPath ? agentNameFromPath(agentPath) : null;
+          if (agentId) {
+            const spawnInfo = spawnAgentCalls.get(toolCall.id);
+            const existing = agentRegistry.get(agentId);
+            const info = {
+              agentId,
+              nickname: nickname ?? existing?.nickname ?? spawnInfo?.taskName ?? null,
+              agentPath: agentPath ?? existing?.agentPath ?? null,
+              message: existing?.message ?? spawnInfo?.message ?? "",
+              model: existing?.model ?? spawnInfo?.model ?? null,
+              agentType: existing?.agentType ?? spawnInfo?.agentType ?? null,
+              timestamp: existing?.timestamp ?? spawnInfo?.timestamp ?? timestamp,
+              parentToolCallId: existing?.parentToolCallId ?? toolCall.id
+            };
+            agentRegistry.set(agentId, info);
+            agentIdBySpawnCall.set(toolCall.id, agentId);
+            if (info.agentPath) agentIdByPath.set(info.agentPath, agentId);
+            upsertAgentMessage(agentId, current, timestamp, { status: "running" });
+          }
+        } catch {
+        }
+      }
+      if (toolCall.name === "wait_agent" && output && current) {
+        try {
+          const result = JSON.parse(output);
+          const statusMap = isObject2(result.status) ? result.status : {};
+          for (const [agentId, status] of Object.entries(statusMap)) {
+            const statusValue = isObject2(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 : "";
+            const lifecycle = completedText ? "completed" : failedText ? "failed" : interruptedText ? "interrupted" : typeof statusValue.status === "string" ? statusValue.status : "running";
+            if (!agentRegistry.has(agentId)) {
+              agentRegistry.set(agentId, {
+                agentId,
+                nickname: null,
+                agentPath: null,
+                message: "",
+                model: null,
+                agentType: null,
+                timestamp,
+                parentToolCallId: ""
+              });
+            }
+            upsertAgentMessage(agentId, current, timestamp, {
+              status: lifecycle,
+              text: completedText || failedText || interruptedText || void 0
+            });
+          }
+        } catch {
+        }
+      }
+      continue;
+    }
+    if (payload.type === "custom_tool_call" && typeof payload.call_id === "string") {
+      const name = 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) : [];
+      if (name !== "apply_patch") {
+        const toolCall = {
+          id: callId,
+          name: name === "exec_command" ? "Bash" : name,
+          input: parseToolInput(rawInput),
+          result: null,
+          isError: false,
+          timestamp
+        };
+        pendingToolCalls.set(toolCall.id, toolCall);
+        appendToolCall(current, toolCall, timestamp);
+      }
+      for (const tc of perFileCalls) {
+        pendingToolCalls.set(tc.id, tc);
+        appendToolCall(current, tc, timestamp);
+      }
+      if (perFileCalls.length > 0) {
+        patchCallIds.set(callId, {
+          calls: perFileCalls,
+          direct: name === "apply_patch"
+        });
+      }
+      continue;
+    }
+    if (payload.type === "custom_tool_call_output" && typeof payload.call_id === "string") {
+      const callId = payload.call_id;
+      const { text, isError } = 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);
+        for (const patchCall of patchCalls.calls) {
+          const tc = pendingToolCalls.get(patchCall.id);
+          if (tc) {
+            tc.result = text;
+            tc.isError = failedIds.has(tc.id);
+            pendingToolCalls.delete(tc.id);
+          }
+        }
+        patchCallIds.delete(callId);
+      }
+      const toolCall = pendingToolCalls.get(callId);
+      if (toolCall) {
+        toolCall.result = text;
+        toolCall.isError = isError;
+        pendingToolCalls.delete(callId);
+      }
       continue;
     }
   }
@@ -913,19 +1838,17 @@ function parseCodexSession(jsonlText) {
     gitBranch: metadata.gitBranch,
     cwd: metadata.cwd,
     slug: metadata.slug,
+    name: "",
     model: metadata.model,
     turns,
-    stats: computeStats(turns),
-    rawMessages: records,
+    stats: options?.skipStats ? createEmptySessionStats(turns.length) : computeStats(turns),
+    rawMessages: options?.skipStats ? [] : records,
     branchedFrom: metadata.branchedFrom,
     agentKind: "codex"
   };
 }
 
 // src/lib/parser.ts
-function isAssistantMessage2(msg) {
-  return msg.type === "assistant";
-}
 function extractTextFromContent2(content) {
   if (typeof content === "string") return content;
   return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
@@ -944,55 +1867,43 @@ function parseLines(jsonlText) {
 }
 function isCodexRawMessages(rawMessages) {
   const firstType = rawMessages[0]?.type;
-  return firstType === "session_meta" || firstType === "turn_context" || firstType === "event_msg" || firstType === "response_item";
+  return firstType === "session_meta" || firstType === "turn_context" || firstType === "event_msg" || firstType === "response_item" || firstType === "compacted" || firstType === "world_state" || firstType === "inter_agent_communication_metadata";
 }
 function serializeRawMessages(rawMessages) {
   return rawMessages.map((msg) => JSON.stringify(msg)).join("\n");
 }
 function extractSessionMetadata(messages) {
-  const meta = { sessionId: "", version: "", gitBranch: "", cwd: "", slug: "", model: "", branchedFrom: void 0 };
+  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 (isAssistantMessage2(msg) && msg.message.model && !meta.model) {
+    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 emptyStats(turnCount) {
-  return {
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    totalCacheCreationTokens: 0,
-    totalCacheReadTokens: 0,
-    totalCostUSD: 0,
-    toolCallCounts: {},
-    errorCount: 0,
-    totalDurationMs: 0,
-    turnCount
-  };
-}
-function parseSession(jsonlText, opts) {
+function parseSession(jsonlText, options) {
   if (isCodexSessionText(jsonlText)) {
-    return parseCodexSession(jsonlText);
+    return parseCodexSession(jsonlText, options);
   }
   const rawMessages = parseLines(jsonlText);
   const metadata = extractSessionMetadata(rawMessages);
   const turns = buildTurns(rawMessages);
-  const stats = opts?.skipStats ? emptyStats(turns.length) : computeStats(turns);
+  const stats = options?.skipStats ? createEmptySessionStats(turns.length) : computeStats(turns);
   return {
     ...metadata,
     turns,
     stats,
-    rawMessages: opts?.skipStats ? [] : rawMessages,
+    rawMessages: options?.skipStats ? [] : rawMessages,
     agentKind: "claude"
   };
 }
@@ -1004,13 +1915,14 @@ ${newJsonlText}` : newJsonlText);
   }
   const newMessages = parseLines(newJsonlText);
   if (newMessages.length === 0) return existing;
-  const allRawMessages = [...existing.rawMessages, ...newMessages];
-  let lastTurnStartIdx = existing.rawMessages.length;
+  const existingRawMessages = existing.rawMessages;
+  const allRawMessages = [...existingRawMessages, ...newMessages];
+  let lastTurnStartIdx = existingRawMessages.length;
   let turnsToKeep = existing.turns.length > 0 ? existing.turns.length - 1 : 0;
   if (existing.turns.length > 0) {
     let userMsgCount = 0;
-    for (let i = existing.rawMessages.length - 1; i >= 0; i--) {
-      const msg = existing.rawMessages[i];
+    for (let i = existingRawMessages.length - 1; i >= 0; i--) {
+      const msg = existingRawMessages[i];
       if (msg.type === "user" && !msg.isMeta) {
         const content = msg.message?.content;
         if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) {
@@ -1037,8 +1949,8 @@ ${newJsonlText}` : newJsonlText);
         if (ownsProgressParent) {
           turnsToKeep = t;
           let found = 0;
-          for (let i = 0; i < existing.rawMessages.length; i++) {
-            const msg = existing.rawMessages[i];
+          for (let i = 0; i < existingRawMessages.length; i++) {
+            const msg = existingRawMessages[i];
             if (msg.type === "user" && !msg.isMeta) {
               const content = msg.message?.content;
               if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) {
@@ -1067,11 +1979,13 @@ ${newJsonlText}` : newJsonlText);
     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
+    branchedFrom: existing.branchedFrom,
+    agentKind: existing.agentKind
   };
 }
 function getUserMessageText(content) {
@@ -1329,17 +2243,11 @@ var SearchIndex = class {
   buildFull(projectsDir) {
     this.projectsDir = projectsDir;
     this.db.close();
-    try {
-      (0, import_node_fs.unlinkSync)(this.dbPath);
-    } catch {
-    }
-    try {
-      (0, import_node_fs.unlinkSync)(this.dbPath + "-wal");
-    } catch {
-    }
-    try {
-      (0, import_node_fs.unlinkSync)(this.dbPath + "-shm");
-    } catch {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        (0, import_node_fs.unlinkSync)(this.dbPath + suffix);
+      } catch {
+      }
     }
     this.db = new Database(this.dbPath);
     this.db.exec("PRAGMA journal_mode = WAL");
@@ -1611,7 +2519,8 @@ 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")
+  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");
 
@@ -2083,6 +2992,8 @@ function extractUserMessageText(userMessage) {
   for (const block of userMessage) {
     if (block.type === "text") parts.push(block.text);
     else if (block.type === "image") parts.push("[image attached]");
+    else if (block.type === "document") parts.push("[document attached]");
+    else if (block.type === "audio") parts.push("[audio attached]");
   }
   return parts.length > 0 ? parts.join("\n") : null;
 }
@@ -2181,6 +3092,10 @@ function mapTurnToDetail(session, turnIndex) {
     durationMs: turn.durationMs
   };
 }
+function mapToolCall(tc) {
+  const { result, resultTruncated } = truncateResult(tc.result);
+  return { id: tc.id, name: tc.name, input: tc.input, result, resultTruncated, isError: tc.isError };
+}
 function mapContentBlock(block) {
   switch (block.kind) {
     case "thinking": {
@@ -2192,10 +3107,7 @@ function mapContentBlock(block) {
     case "tool_calls":
       return {
         kind: "tool_calls",
-        toolCalls: block.toolCalls.map((tc) => {
-          const { result, resultTruncated } = truncateResult(tc.result);
-          return { id: tc.id, name: tc.name, input: tc.input, result, resultTruncated, isError: tc.isError };
-        }),
+        toolCalls: block.toolCalls.map(mapToolCall),
         timestamp: block.timestamp ?? null
       };
     case "sub_agent":
@@ -2205,6 +3117,21 @@ function mapContentBlock(block) {
         agents: block.messages.map(mapSubAgentDetail),
         timestamp: block.timestamp ?? null
       };
+    case "queued_prompt":
+      return { kind: "queued_prompt", content: block.content, timestamp: block.timestamp ?? null };
+    case "hook_event":
+      return { kind: "hook_event", events: block.events, timestamp: block.timestamp ?? null };
+    case "plan_mode":
+      return {
+        kind: "plan_mode",
+        plan: block.plan,
+        planFilePath: block.planFilePath ?? null,
+        status: block.status,
+        toolCalls: block.toolCalls.map(mapToolCall),
+        timestamp: block.timestamp ?? null
+      };
+    case "recap":
+      return { kind: "recap", content: block.content, timestamp: block.timestamp ?? null };
   }
 }
 async function findSubagentFile(parentJsonlPath, agentId) {
@@ -2327,7 +3254,6 @@ async function getAgentOverview(sessionId, agentId) {
 async function getAgentTurnDetail(sessionId, agentId, turnIndex) {
   const jsonlPath = await findJsonlPath(sessionId);
   if (!jsonlPath) return { error: "Session not found" };
-  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
   const subagentFile = await findSubagentFile(jsonlPath, agentId);
   if (!subagentFile) return { error: "Agent not found" };
   const subagentContent = await (0, import_promises3.readFile)(subagentFile.filePath, "utf-8");
@@ -2339,7 +3265,6 @@ async function getAgentTurnDetail(sessionId, agentId, turnIndex) {
 // src/commands/sessions.ts
 var import_promises5 = require("node:fs/promises");
 var import_node_path6 = require("node:path");
-var import_node_os3 = require("node:os");
 
 // src/lib/metadata.ts
 var import_promises4 = require("node:fs/promises");
@@ -2356,6 +3281,19 @@ function deriveSessionStatus(rawMessages) {
     if (toolName) info.toolName = toolName;
     return info;
   }
+  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") {
@@ -2390,6 +3328,13 @@ function deriveSessionStatus(rawMessages) {
       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;
   }
@@ -2615,7 +3560,23 @@ async function getSessionStatus(filePath) {
 }
 
 // src/commands/sessions.ts
-var CODEX_SESSIONS_DIR = (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".codex", "sessions");
+function toSessionSummary(file, meta, status) {
+  return {
+    sessionId: meta.sessionId,
+    filePath: file.path,
+    timestamp: meta.timestamp,
+    model: meta.model,
+    cwd: meta.cwd,
+    gitBranch: meta.gitBranch,
+    slug: meta.slug,
+    firstMessage: meta.firstUserMessage,
+    lastMessage: meta.lastUserMessage,
+    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 [];
@@ -2642,7 +3603,7 @@ async function listCodexSessionFiles(cutoff) {
     }
     return results;
   };
-  return walk(CODEX_SESSIONS_DIR, 0);
+  return walk(dirs.CODEX_SESSIONS_DIR, 0);
 }
 async function listSessions(opts = {}) {
   const limit = Math.min(Math.max(1, opts.limit ?? 20), 100);
@@ -2655,29 +3616,31 @@ async function listSessions(opts = {}) {
     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 = await 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 [];
-      }
-    })
-  );
-  const codexFiles = await listCodexSessionFiles(cutoff);
+  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 results = [];
@@ -2689,21 +3652,7 @@ async function listSessions(opts = {}) {
         getSessionStatus(file.path)
       ]);
       if (opts.cwd && meta.cwd !== opts.cwd) continue;
-      results.push({
-        sessionId: meta.sessionId,
-        filePath: file.path,
-        timestamp: meta.timestamp,
-        model: meta.model,
-        cwd: meta.cwd,
-        gitBranch: meta.gitBranch,
-        slug: meta.slug,
-        firstMessage: meta.firstUserMessage,
-        lastMessage: meta.lastUserMessage,
-        turnCount: meta.turnCount,
-        status: statusInfo.status,
-        mtime: file.mtimeMs,
-        source: file.path.startsWith(CODEX_SESSIONS_DIR + "/") ? "codex" : "claude"
-      });
+      results.push(toSessionSummary(file, meta, statusInfo.status));
     } catch {
     }
   }
@@ -2719,18 +3668,20 @@ async function currentSession(cwd) {
     files = [];
   }
   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 { path: filePath, mtimeMs: s.mtimeMs };
-      } catch {
-        return null;
-      }
-    })
-  );
-  const codexCandidates = await listCodexSessionFiles(0);
+  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) {
     try {
@@ -2752,21 +3703,7 @@ async function currentSession(cwd) {
     getSessionMeta(latest.path),
     getSessionStatus(latest.path)
   ]);
-  return {
-    sessionId: meta.sessionId,
-    filePath: latest.path,
-    timestamp: meta.timestamp,
-    model: meta.model,
-    cwd: meta.cwd,
-    gitBranch: meta.gitBranch,
-    slug: meta.slug,
-    firstMessage: meta.firstUserMessage,
-    lastMessage: meta.lastUserMessage,
-    turnCount: meta.turnCount,
-    status: statusInfo.status,
-    mtime: latest.mtimeMs,
-    source: latest.path.startsWith(CODEX_SESSIONS_DIR + "/") ? "codex" : "claude"
-  };
+  return toSessionSummary(latest, meta, statusInfo.status);
 }
 
 // src/commands/index-cmd.ts