cogpit-memory 0.1.9 → 0.2.1

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,45 @@ function isSystemMessage(msg) {
 function isSummaryMessage(msg) {
   return msg.type === "summary";
 }
+function isQueueOperationMessage(msg) {
+  return msg.type === "queue-operation";
+}
+function isAttachmentMessage(msg) {
+  return msg.type === "attachment";
+}
+function isCompactSummaryMessage(msg) {
+  return msg.type === "user" && msg.isCompactSummary === true;
+}
 function isCompactBoundary(msg) {
   return msg.type === "system" && msg.subtype === "compact_boundary";
 }
+
+// src/lib/agentEnvelope.ts
+var ENVELOPE_RE = /<(agent-message|teammate-message)([^>]*)>([\s\S]*?)<\/\1>/g;
+var SENDER_PATTERNS = [
+  /\bteammate_id=(?:"([^"]*)"|'([^']*)')/,
+  /\bfrom=(?:"([^"]*)"|'([^']*)')/
+];
+function readSender(attrs) {
+  for (const pattern of SENDER_PATTERNS) {
+    const m = attrs.match(pattern);
+    const value = m?.[1] ?? m?.[2];
+    if (value) return value;
+  }
+  return null;
+}
+function parseAgentEnvelope(text) {
+  let sender = null;
+  let matched = false;
+  const unwrapped = text.replace(ENVELOPE_RE, (_full, _tag, attrs, inner) => {
+    matched = true;
+    if (sender === null) sender = readSender(attrs);
+    return inner.trim();
+  });
+  return { sender, matched, body: matched ? unwrapped.trim() : text };
+}
+
+// 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 +124,62 @@ function extractToolResultText(content) {
     return "";
   }).filter(Boolean).join("\n");
 }
+function isVisibleQueuedPrompt(content) {
+  if (!content?.trim()) return false;
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("<")) return true;
+  return !trimmed.includes("<task-notification>") && !trimmed.startsWith("<system-reminder>") && !trimmed.startsWith("<local-command-");
+}
+var TASK_NOTIFICATION_BLOCK_RE = /<task-notification>[\s\S]*?<\/task-notification>/g;
+var ANY_TAG_RE = /<[^>]*>/g;
+function isTaskNotificationRecord(msg) {
+  if (msg.origin?.kind === "task-notification") return true;
+  const text = extractTextFromContent(msg.message.content);
+  if (!text.includes("<task-notification>")) return false;
+  return text.replace(TASK_NOTIFICATION_BLOCK_RE, "").replace(ANY_TAG_RE, "").trim() === "";
+}
+function queuedCommandPrompt(msg) {
+  if (!isAttachmentMessage(msg)) return null;
+  const attachment = msg.attachment;
+  if (!attachment || attachment.type !== "queued_command") return null;
+  if (attachment.commandMode !== "prompt") return null;
+  const prompt = attachment.prompt;
+  if (prompt == null) return null;
+  const raw = typeof prompt === "string" ? prompt : extractTextFromContent(prompt);
+  if (!isVisibleQueuedPrompt(raw)) return null;
+  const origin = attachment.origin;
+  if (origin?.kind === "peer") {
+    const sender = origin.name ?? origin.from ?? null;
+    if (sender) {
+      return {
+        raw,
+        sender,
+        body: origin.body ?? parseAgentEnvelope(raw).body
+      };
+    }
+  }
+  if (origin?.kind === "human") {
+    return { raw, sender: null, body: raw };
+  }
+  const parsed = parseAgentEnvelope(raw);
+  return { raw, sender: parsed.sender, body: parsed.body };
+}
+var ATTRIBUTION_FIELDS = [
+  ["attributionAgent", "agent"],
+  ["attributionSkill", "skill"],
+  ["attributionPlugin", "plugin"],
+  ["attributionMcpServer", "mcpServer"],
+  ["attributionMcpTool", "mcpTool"]
+];
+function mergeAttribution(current, msg) {
+  let merged = current;
+  for (const [field, key] of ATTRIBUTION_FIELDS) {
+    const value = msg[field];
+    if (typeof value !== "string" || !value) continue;
+    merged = { ...merged, [key]: value };
+  }
+  return merged;
+}
 function mergeTokenUsage(existing, incoming) {
   if (!existing) {
     return { ...incoming };
@@ -96,49 +188,234 @@ 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) {
-  if (turns.length === 0) return title;
-  const toolCounts = {};
-  for (const turn of turns) {
-    for (const tc of turn.toolCalls) {
-      toolCounts[tc.name] = (toolCounts[tc.name] || 0) + 1;
+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) {
+  const text = extractTextFromContent(content).trim();
+  return text.replace(RESUME_PREAMBLE_RE, "").replace(RESUME_INSTRUCTIONS_RE, "").trim();
+}
+function normalizeCompactionMeta(meta) {
+  if (!meta) return void 0;
+  return { trigger: meta.trigger, preTokens: meta.preTokens, postTokens: meta.postTokens };
+}
+function createTurn(msg, userMessage) {
+  return {
+    id: msg.uuid ?? crypto.randomUUID(),
+    userMessage,
+    contentBlocks: [],
+    thinking: [],
+    assistantText: [],
+    toolCalls: [],
+    subAgentActivity: [],
+    timestamp: msg.timestamp ?? "",
+    durationMs: null,
+    tokenUsage: null,
+    model: null
+  };
+}
+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" || next.kind === "agent_message") {
+              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++;
   }
-  const prompts = [];
-  for (const turn of turns) {
-    if (!turn.userMessage) continue;
-    const text = extractTextFromContent(
-      typeof turn.userMessage === "string" ? turn.userMessage : turn.userMessage
-    );
-    const firstLine = text.split("\n")[0].trim();
-    if (firstLine.length > 0) {
-      prompts.push(firstLine.length > 120 ? firstLine.slice(0, 117) + "..." : firstLine);
+  return result;
+}
+function clearAgentMessageReplies(turn) {
+  if (!turn.contentBlocks.some((b) => b.kind === "agent_message")) return turn;
+  return {
+    ...turn,
+    contentBlocks: turn.contentBlocks.map((block) => {
+      if (block.kind !== "agent_message") return block;
+      const { reply: _paired, ...unpaired } = block;
+      return unpaired;
+    })
+  };
+}
+function pairAgentMessageReplies(turns) {
+  const repaired = turns.map(clearAgentMessageReplies);
+  const unanswered = /* @__PURE__ */ new Map();
+  for (const turn of repaired) {
+    for (const block of turn.contentBlocks) {
+      if (block.kind === "agent_message") {
+        const waiting = unanswered.get(block.sender);
+        if (waiting) waiting.push(block);
+        else unanswered.set(block.sender, [block]);
+        continue;
+      }
+      if (block.kind !== "tool_calls") continue;
+      for (const call of block.toolCalls) {
+        if (call.name !== "SendMessage") continue;
+        const to = call.input.to;
+        if (typeof to !== "string" || !to) continue;
+        const target = unanswered.get(to)?.shift();
+        if (!target) continue;
+        const summary = call.input.summary;
+        target.reply = {
+          summary: typeof summary === "string" ? summary : "",
+          timestamp: call.timestamp || block.timestamp || ""
+        };
+      }
     }
   }
-  const topTools = Object.entries(toolCounts).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name, count]) => `${name} x${count}`).join(", ");
-  const parts = [`**${title}**`, `${turns.length} turns compacted`];
-  if (topTools) parts.push(`Tools: ${topTools}`);
-  if (prompts.length > 0) {
-    parts.push("Prompts:");
-    const shown = prompts.slice(0, 6);
-    for (const p of shown) parts.push(`- ${p}`);
-    if (prompts.length > 6) parts.push(`- ...and ${prompts.length - 6} more`);
+  return repaired;
+}
+function findTurnStartIndices(messages) {
+  const starts = [];
+  let hasOpenTurn = false;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (isSummaryMessage(msg) || isCompactBoundary(msg)) {
+      hasOpenTurn = false;
+      continue;
+    }
+    if (isUserMessage(msg) && !msg.isMeta) {
+      const content = msg.message.content;
+      const continuesOpenTurn = hasOpenTurn && Array.isArray(content) && content.some((b) => b.type === "tool_result");
+      if (continuesOpenTurn) continue;
+      starts.push(i);
+      hasOpenTurn = true;
+      continue;
+    }
+    if (isAssistantMessage(msg) && !hasOpenTurn) {
+      starts.push(i);
+      hasOpenTurn = true;
+    }
   }
-  return parts.join("\n");
+  return starts;
 }
 function buildTurns(messages) {
   const turns = [];
   let current = null;
   let pendingCompaction = null;
+  function attachPendingCompaction(turn) {
+    if (!pendingCompaction) return;
+    turn.compactionSummary = pendingCompaction.summary;
+    turn.compactionMeta = pendingCompaction.meta;
+    pendingCompaction = null;
+  }
+  let pendingRecap = null;
   const pendingToolUses = /* @__PURE__ */ new Map();
   const seenMessageIds = /* @__PURE__ */ new Set();
   const subAgentMap = /* @__PURE__ */ new Map();
   const agentBlockMap = /* @__PURE__ */ new Map();
   const backgroundAgentParentIds = /* @__PURE__ */ new Set();
   const taskMetaMap = /* @__PURE__ */ new Map();
+  const pendingQueuedPrompts = [];
+  const enqueueSourcedPrompts = /* @__PURE__ */ new Map();
+  function noteEnqueueSourced(turn, content) {
+    let counts = enqueueSourcedPrompts.get(turn);
+    if (!counts) {
+      counts = /* @__PURE__ */ new Map();
+      enqueueSourcedPrompts.set(turn, counts);
+    }
+    counts.set(content, (counts.get(content) ?? 0) + 1);
+  }
+  function consumeEnqueueSourced(turn, content) {
+    const counts = enqueueSourcedPrompts.get(turn);
+    const remaining = counts?.get(content);
+    if (!counts || !remaining) return false;
+    if (remaining === 1) counts.delete(content);
+    else counts.set(content, remaining - 1);
+    return true;
+  }
+  function flushPendingQueuedPrompts() {
+    for (const prompt of pendingQueuedPrompts) {
+      prompt.turn.contentBlocks.push(
+        prompt.sender ? {
+          kind: "agent_message",
+          sender: prompt.sender,
+          body: prompt.body,
+          timestamp: prompt.timestamp
+        } : {
+          kind: "queued_prompt",
+          content: prompt.content,
+          timestamp: prompt.timestamp
+        }
+      );
+    }
+    pendingQueuedPrompts.length = 0;
+  }
   function flushSubAgentMessages(parentId) {
     if (!current) return;
     const agentMsgs = subAgentMap.get(parentId);
@@ -163,6 +440,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();
@@ -170,20 +463,66 @@ function buildTurns(messages) {
   for (const msg of messages) {
     if (isSummaryMessage(msg)) {
       finalizeTurn2();
-      pendingCompaction = buildCompactionSummary(
-        turns,
-        msg.summary ?? "Conversation compacted"
-      );
+      pendingCompaction = { summary: msg.summary };
       continue;
     }
     if (isCompactBoundary(msg)) {
       finalizeTurn2();
-      pendingCompaction = buildCompactionSummary(
-        turns,
-        msg.content ?? "Conversation compacted"
-      );
+      pendingCompaction = { meta: normalizeCompactionMeta(msg.compactMetadata) };
+      continue;
+    }
+    if (isCompactSummaryMessage(msg)) {
+      finalizeTurn2();
+      current = createTurn(msg, null);
+      current.compactionSummary = extractCompactionSummary(msg.message.content);
+      current.compactionMeta = pendingCompaction?.meta;
+      pendingCompaction = null;
+      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)) {
+        const parsed = parseAgentEnvelope(msg.content);
+        pendingQueuedPrompts.push({
+          turn: current,
+          content: msg.content,
+          timestamp: msg.timestamp,
+          sender: parsed.sender,
+          body: parsed.body
+        });
+        noteEnqueueSourced(current, msg.content);
+      }
+      continue;
+    }
+    if (isAttachmentMessage(msg)) {
+      const queued = queuedCommandPrompt(msg);
+      if (current && queued !== null && !consumeEnqueueSourced(current, queued.raw)) {
+        pendingQueuedPrompts.push({
+          turn: current,
+          content: queued.raw,
+          timestamp: msg.attachment?.timestamp ?? msg.timestamp,
+          sender: queued.sender,
+          body: queued.body
+        });
+      }
       continue;
     }
+    if (pendingQueuedPrompts.length > 0) {
+      const userContent = isUserMessage(msg) && !msg.isMeta ? msg.message.content : null;
+      if (typeof userContent === "string") {
+        const duplicateIndex = pendingQueuedPrompts.findIndex(
+          (prompt) => prompt.content === userContent
+        );
+        if (duplicateIndex >= 0) {
+          const [dropped] = pendingQueuedPrompts.splice(duplicateIndex, 1);
+          consumeEnqueueSourced(dropped.turn, dropped.content);
+        }
+      }
+      flushPendingQueuedPrompts();
+    }
     if (isUserMessage(msg) && !msg.isMeta) {
       const content = msg.message.content;
       if (typeof content !== "string" && Array.isArray(content)) {
@@ -194,7 +533,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 +551,7 @@ function buildTurns(messages) {
             }
             const agentMsg = {
               agentId: toolUseResult.agentId,
+              parentToolUseId: toolUseId || void 0,
               agentName: taskMeta?.name ?? null,
               subagentType: taskMeta?.subagentType ?? null,
               type: "assistant",
@@ -245,23 +585,27 @@ function buildTurns(messages) {
           continue;
         }
       }
+      if (isTaskNotificationRecord(msg)) {
+        const notification = {
+          kind: "task_notification",
+          content: extractTextFromContent(content),
+          timestamp: msg.timestamp
+        };
+        if (current) {
+          current.contentBlocks.push(notification);
+          continue;
+        }
+        current = createTurn(msg, null);
+        current.contentBlocks.push(notification);
+        attachPendingCompaction(current);
+        continue;
+      }
       finalizeTurn2();
-      current = {
-        id: msg.uuid ?? crypto.randomUUID(),
-        userMessage: msg.message.content,
-        contentBlocks: [],
-        thinking: [],
-        assistantText: [],
-        toolCalls: [],
-        subAgentActivity: [],
-        timestamp: msg.timestamp ?? "",
-        durationMs: null,
-        tokenUsage: null,
-        model: null
-      };
-      if (pendingCompaction) {
-        current.compactionSummary = pendingCompaction;
-        pendingCompaction = null;
+      current = createTurn(msg, msg.message.content);
+      attachPendingCompaction(current);
+      if (pendingRecap) {
+        current.contentBlocks.push({ kind: "recap", content: pendingRecap.content, timestamp: pendingRecap.timestamp });
+        pendingRecap = null;
       }
       continue;
     }
@@ -284,21 +628,12 @@ function buildTurns(messages) {
       };
       var flushToolCalls = flushToolCalls2, flushThinking = flushThinking2;
       if (!current) {
-        current = {
-          id: msg.uuid ?? crypto.randomUUID(),
-          userMessage: null,
-          contentBlocks: [],
-          thinking: [],
-          assistantText: [],
-          toolCalls: [],
-          subAgentActivity: [],
-          timestamp: msg.timestamp ?? "",
-          durationMs: null,
-          tokenUsage: null,
-          model: null
-        };
+        current = createTurn(msg, null);
+        attachPendingCompaction(current);
       }
       current.model = msg.message.model;
+      if (msg.effort) current.effort = msg.effort;
+      current.attribution = mergeAttribution(current.attribution, msg);
       const msgId = msg.message.id;
       if (!seenMessageIds.has(msgId)) {
         seenMessageIds.add(msgId);
@@ -312,6 +647,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 +727,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 +773,7 @@ function buildTurns(messages) {
                   );
                   if (match) {
                     match.result = extractToolResultText(block.content);
-                    match.isError = block.is_error;
+                    match.isError = block.is_error === true;
                   }
                 }
               }
@@ -455,118 +792,46 @@ 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;
+      if (msg.durationMs !== void 0 && msg.durationMs !== null) {
+        current.durationMs = (current.durationMs ?? 0) + msg.durationMs;
+      }
       continue;
     }
   }
+  flushPendingQueuedPrompts();
   finalizeTurn2();
-  return turns;
-}
-
-// 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_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 MODEL_TIERS = [
-  // 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 },
-  // 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 FAMILY_FALLBACKS = [
-  { match: "haiku", tier: TIER_HAIKU_45 },
-  { match: "sonnet", tier: TIER_SONNET_LATEST },
-  { match: "opus", tier: TIER_SONNET_LATEST }
-];
-function resolveTier(model, totalInputTokens) {
-  const isExtended = (totalInputTokens ?? 0) > EXTENDED_CONTEXT_THRESHOLD;
-  for (const entry of MODEL_TIERS) {
-    if (model.includes(entry.match)) {
-      return isExtended && entry.extendedTier ? entry.extendedTier : entry.tier;
-    }
-  }
-  for (const entry of FAMILY_FALLBACKS) {
-    if (model.includes(entry.match)) return entry.tier;
-  }
-  return isExtended ? DEFAULT_EXTENDED_TIER : DEFAULT_TIER;
-}
-
-// 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);
-  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) {
-  return Math.ceil(chars / CHARS_PER_TOKEN);
-}
-function totalLength(strings) {
-  let n = 0;
-  for (const s of strings) n += s.length;
-  return n;
-}
-function totalToolInputLength(toolCalls) {
-  let n = 0;
-  for (const tc of toolCalls) n += JSON.stringify(tc.input).length;
-  return n;
-}
-function estimateThinkingTokens(turn) {
-  return charsToTokens(totalLength(turn.thinking.map((b) => b.thinking)));
-}
-function estimateVisibleOutputTokens(turn) {
-  return charsToTokens(totalLength(turn.assistantText) + totalToolInputLength(turn.toolCalls));
-}
-function estimateTotalOutputTokens(turn) {
-  const estimated = estimateThinkingTokens(turn) + estimateVisibleOutputTokens(turn);
-  return Math.max(estimated, turn.tokenUsage?.output_tokens ?? 0);
-}
-function estimateSubAgentOutput(sa) {
-  const chars = totalLength(sa.thinking) + totalLength(sa.text) + totalToolInputLength(sa.toolCalls);
-  return Math.max(charsToTokens(chars), sa.tokenUsage?.output_tokens ?? 0);
-}
-function calculateTurnCostEstimated(turn) {
-  if (!turn.tokenUsage) return 0;
-  const u = turn.tokenUsage;
-  return calculateCost({
-    model: turn.model,
-    inputTokens: u.input_tokens,
-    outputTokens: estimateTotalOutputTokens(turn),
-    cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
-    cacheReadTokens: u.cache_read_input_tokens ?? 0
-  });
-}
-function calculateSubAgentCostEstimated(sa) {
-  if (!sa.tokenUsage) return 0;
-  const u = sa.tokenUsage;
-  return calculateCost({
-    model: sa.model,
-    inputTokens: u.input_tokens,
-    outputTokens: estimateSubAgentOutput(sa),
-    cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
-    cacheReadTokens: u.cache_read_input_tokens ?? 0
-  });
+  return pairAgentMessageReplies(turns);
 }
 
 // src/lib/sessionStats.ts
@@ -578,43 +843,325 @@ function countToolCalls(toolCalls, counts) {
   }
   return errors;
 }
-function addUsageToStats(stats, usage, estimatedOutput, cost) {
+function addUsageToStats(stats, usage) {
   stats.totalInputTokens += usage.input_tokens;
-  stats.totalOutputTokens += estimatedOutput;
+  stats.totalOutputTokens += usage.output_tokens;
   stats.totalCacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
   stats.totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
-  stats.totalCostUSD += cost;
 }
-function computeStats(turns) {
-  const stats = {
+function createEmptySessionStats(turnCount) {
+  return {
     totalInputTokens: 0,
     totalOutputTokens: 0,
     totalCacheCreationTokens: 0,
     totalCacheReadTokens: 0,
-    totalCostUSD: 0,
     toolCallCounts: {},
     errorCount: 0,
     totalDurationMs: 0,
-    turnCount: turns.length
+    turnCount
   };
+}
+function computeStats(turns) {
+  const stats = createEmptySessionStats(turns.length);
   for (const turn of turns) {
-    if (turn.tokenUsage) {
-      addUsageToStats(stats, turn.tokenUsage, estimateTotalOutputTokens(turn), calculateTurnCostEstimated(turn));
-    }
+    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, estimateSubAgentOutput(sa), calculateSubAgentCostEstimated(sa));
-      }
+      if (sa.tokenUsage) addUsageToStats(stats, sa.tokenUsage);
     }
   }
   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++;
+      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/codex-patches.ts
+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;
+  const base = cwd.replace(/[\\/]+$/, "");
+  const relative = filePath.replace(/^\.[\\/]/, "");
+  return /^[A-Za-z]:[\\/]/.test(cwd) ? `${base}\\${relative.replace(/\//g, "\\")}` : `${base}/${relative}`;
+}
+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;
+}
+var COLLABORATION_TOOL_NAMES = /* @__PURE__ */ new Map([
+  ["spawn_agent", "spawn_agent"],
+  ["spawnAgent", "spawn_agent"],
+  ["wait_agent", "wait_agent"],
+  ["waitAgent", "wait_agent"],
+  ["send_message", "send_message"],
+  ["sendMessage", "send_message"],
+  ["followup_task", "followup_task"],
+  ["followupTask", "followup_task"],
+  ["list_agents", "list_agents"],
+  ["listAgents", "list_agents"],
+  ["interrupt_agent", "interrupt_agent"],
+  ["interruptAgent", "interrupt_agent"]
+]);
+function normalizeFunctionName(rawName) {
+  const leaf = rawName.split(/(?:__|[.:/])+/).filter(Boolean).at(-1) ?? rawName;
+  return COLLABORATION_TOOL_NAMES.get(leaf) ?? rawName;
+}
+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 +1177,98 @@ 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 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 +1286,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 +1333,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,20 +1349,40 @@ 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 safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value ?? "");
+  }
+}
+function findString(...values) {
+  return values.find((value) => typeof value === "string");
+}
+function isCodeModeChild(callId) {
+  return callId.startsWith("exec-");
+}
+function parseMcpEventResult(value) {
+  if (!isObject2(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;
+  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));
+  return {
+    text,
+    isError: ok.isError === true || parsedContent.isError
+  };
 }
-function createTurn(turnId, timestamp, model) {
+function createTurn2(turnId, timestamp, model) {
   return {
-    id: turnId || randomTurnId("codex-turn"),
+    id: turnId ? `${turnId}@${timestamp}` : randomTurnId("codex-turn"),
     userMessage: null,
     contentBlocks: [],
     thinking: [],
@@ -746,14 +1396,25 @@ 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 "";
 }
+function recordOpensTurn(record, payload) {
+  if (record.type === "session_meta") return false;
+  if (record.type === "event_msg" && payload?.type === "task_started") return false;
+  if (record.type === "response_item" && payload?.type === "message") {
+    if (payload.role === "developer" || payload.role === "system") return false;
+    if (payload.role === "user") {
+      return extractPromptFromRecord(record) !== "" || extractResponseMessageImages(payload).length > 0 || extractResponseMessageAudio(payload).length > 0;
+    }
+  }
+  return true;
+}
 function extractMetadataFromRecords(records) {
   let sessionId = "";
   let version = "";
@@ -766,14 +1427,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 +1446,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 +1482,16 @@ function extractMetadataFromRecords(records) {
     cwd,
     model,
     slug: "",
+    name: "",
     branchedFrom,
     firstUserMessage,
     lastUserMessage,
     timestamp,
     lastTimestamp,
-    turnCount
+    turnCount,
+    isSubagent,
+    parentSessionId,
+    agentPath
   };
 }
 function isCodexSessionText(jsonlText) {
@@ -827,47 +1506,229 @@ 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;
+  let sawTurnStart = false;
+  function createActiveTurn(turnId, timestamp, model) {
+    const turn = createTurn2(turnId, timestamp, model);
+    if (!sawTurnStart) turn.isFragment = true;
+    if (pendingCompaction) {
+      turn.compactionSummary = pendingCompaction;
+      pendingCompaction = null;
+    }
+    return turn;
+  }
+  function upsertWebSearchCall(targetTurn, id, input, status, timestamp) {
+    const existing = webSearchCalls.get(id);
+    if (existing) {
+      existing.input = { ...existing.input, ...input };
+      existing.result = status;
+      existing.isError = status === "failed";
+      return;
+    }
+    const toolCall = {
+      id,
+      name: "WebSearch",
+      input,
+      result: status,
+      isError: status === "failed",
+      timestamp
+    };
+    webSearchCalls.set(id, toolCall);
+    appendToolCall(targetTurn, toolCall, timestamp);
+  }
   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;
       currentModel = typeof payload?.model === "string" ? payload.model : currentModel;
       lastTurnTimestamp = timestamp;
+      sawTurnStart = true;
       continue;
     }
     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 ??= createTurn(currentTurnId, timestamp, currentModel);
-      current.userMessage = payload.message;
+      sawTurnStart = true;
+      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.isFragment = false;
       current.timestamp = current.timestamp || timestamp;
       lastTurnTimestamp = timestamp;
       continue;
     }
-    current ??= createTurn(currentTurnId, timestamp, currentModel);
+    if (!current && !recordOpensTurn(record, payload)) continue;
+    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;
+      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)) {
+      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 result = parseMcpEventResult(payload.result);
+      const existing = pendingToolCalls.get(payload.call_id);
+      if (existing) {
+        existing.result = result.text;
+        existing.isError = result.isError;
+        pendingToolCalls.delete(payload.call_id);
+      } else if (!isCodeModeChild(payload.call_id)) {
+        appendToolCall(current, {
+          id: payload.call_id,
+          name: `mcp__${server}__${tool}`,
+          input,
+          result: result.text,
+          isError: result.isError,
+          timestamp
+        }, 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 +1741,110 @@ 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);
+        current.isFragment = false;
+        sawTurnStart = true;
+      }
+      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";
+      upsertWebSearchCall(current, payload.id, input, status, timestamp);
+      continue;
+    }
+    if (payload.type === "tool_search_call") {
+      const callId = findString(payload.call_id, payload.id) ?? "";
+      if (callId) {
+        const toolCall = {
+          id: callId,
+          name: "ToolSearch",
+          input: isObject2(payload.arguments) ? payload.arguments : {},
+          result: null,
+          isError: false,
+          timestamp
+        };
+        pendingToolCalls.set(callId, toolCall);
+        appendToolCall(current, toolCall, timestamp);
+      }
+      continue;
+    }
+    if (payload.type === "tool_search_output" && typeof payload.call_id === "string") {
+      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 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;
+        toolCall.isError = payload.status === "failed";
+        pendingToolCalls.delete(payload.call_id);
+      }
+      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 +1860,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 +1980,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 +2009,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,62 +2057,31 @@ ${newJsonlText}` : newJsonlText);
   }
   const newMessages = parseLines(newJsonlText);
   if (newMessages.length === 0) return existing;
-  const allRawMessages = [...existing.rawMessages, ...newMessages];
-  let lastTurnStartIdx = existing.rawMessages.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];
-      if (msg.type === "user" && !msg.isMeta) {
-        const content = msg.message?.content;
-        if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) {
-          continue;
-        }
-        userMsgCount++;
-        if (userMsgCount === 1) {
-          lastTurnStartIdx = i;
-          break;
-        }
-      }
-    }
-    const progressParentIds = /* @__PURE__ */ new Set();
-    for (const msg of newMessages) {
-      if (msg.type === "progress") {
-        const parentId = msg.parentToolUseID;
-        if (parentId) progressParentIds.add(parentId);
-      }
-    }
-    if (progressParentIds.size > 0) {
-      for (let t = existing.turns.length - 2; t >= 0; t--) {
-        const turn = existing.turns[t];
-        const ownsProgressParent = turn.toolCalls.some((tc) => progressParentIds.has(tc.id));
-        if (ownsProgressParent) {
-          turnsToKeep = t;
-          let found = 0;
-          for (let i = 0; i < existing.rawMessages.length; i++) {
-            const msg = existing.rawMessages[i];
-            if (msg.type === "user" && !msg.isMeta) {
-              const content = msg.message?.content;
-              if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) {
-                continue;
-              }
-              if (found === t) {
-                lastTurnStartIdx = i;
-                break;
-              }
-              found++;
-            }
-          }
-          break;
-        }
+  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);
+    }
+  }
+  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 keptTurns = existing.turns.slice(0, turnsToKeep);
-  const tailMessages = allRawMessages.slice(lastTurnStartIdx);
-  const tailTurns = buildTurns(tailMessages);
-  const allTurns = [...keptTurns, ...tailTurns];
+  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,
@@ -1067,11 +2089,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 +2353,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 +2629,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");
 
@@ -1724,7 +2743,11 @@ async function matchSubagentToMember(leadSessionId, subagentFileName, members) {
   }
   return null;
 }
-var HOME_PREFIX = (0, import_node_os2.homedir)().replace(/\//g, "-").replace(/^-/, "").toLowerCase();
+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) {
@@ -2076,6 +3099,7 @@ var import_promises3 = require("node:fs/promises");
 var import_node_path5 = require("node:path");
 var RESULT_TRUNCATE_LIMIT = 1e4;
 var L1_RESPONSE_LIMIT = 15e4;
+var COMPACTION_SUMMARY_PREVIEW = 400;
 function extractUserMessageText(userMessage) {
   if (userMessage === null) return null;
   if (typeof userMessage === "string") return userMessage;
@@ -2083,6 +3107,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;
 }
@@ -2165,9 +3191,13 @@ function mapTurnToSummary(turn, turnIndex) {
     subAgents,
     hasThinking: turn.thinking.length > 0,
     isError: turn.toolCalls.some((tc) => tc.isError),
-    compactionSummary: turn.compactionSummary ?? null
+    compactionSummary: truncateCompactionSummary(turn.compactionSummary)
   };
 }
+function truncateCompactionSummary(summary) {
+  if (!summary) return null;
+  return summary.length > COMPACTION_SUMMARY_PREVIEW ? summary.slice(0, COMPACTION_SUMMARY_PREVIEW) + "... [truncated, use L2 for full text]" : summary;
+}
 function mapTurnToDetail(session, turnIndex) {
   const turn = session.turns[turnIndex];
   const contentBlocks = turn.contentBlocks.map((block) => mapContentBlock(block));
@@ -2175,12 +3205,17 @@ function mapTurnToDetail(session, turnIndex) {
     sessionId: session.sessionId,
     turnIndex,
     userMessage: extractUserMessageText(turn.userMessage),
+    compactionSummary: turn.compactionSummary ?? null,
     contentBlocks,
     tokenUsage: turn.tokenUsage ? { input: turn.tokenUsage.input_tokens, output: turn.tokenUsage.output_tokens } : null,
     model: turn.model,
     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 +3227,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 +3237,35 @@ 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 "agent_message":
+      return {
+        kind: "agent_message",
+        sender: block.sender,
+        body: block.body,
+        reply: block.reply ?? null,
+        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 };
+    case "task_notification":
+      return { kind: "task_notification", content: block.content, timestamp: block.timestamp ?? null };
+    default: {
+      const exhaustive = block;
+      return exhaustive;
+    }
   }
 }
 async function findSubagentFile(parentJsonlPath, agentId) {
@@ -2327,7 +3388,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,35 +3399,140 @@ 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");
 
 // 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];
@@ -2390,19 +3555,136 @@ 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;
   }
   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);
+          }
+        }
+      } 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":
+        case "task_complete": {
+          const pending = collectCodexPendingAgents(rawMessages);
+          if (pending.length > 0) return awaitingAgentsResult(pending, 0);
           return { status: "completed" };
+        }
         case "task_started":
           return { status: "processing" };
         case "agent_message":
@@ -2415,7 +3697,7 @@ function deriveCodexSessionStatus(rawMessages) {
       const payload = msg.payload;
       if (!payload) continue;
       if (payload.type === "function_call") {
-        return { status: "tool_use", toolName: payload.name };
+        return { status: "tool_use", toolName: payload.name ? normalizeFunctionName(payload.name) : payload.name };
       }
       if (payload.type === "message") {
         if (payload.role === "assistant") return { status: "thinking" };
@@ -2615,7 +3897,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 +3940,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 +3953,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,29 +3989,14 @@ 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 {
     }
   }
   return results;
 }
 async function currentSession(cwd) {
-  const projectDirName = cwd.replace(/[/.]/g, "-");
-  const projectDir = (0, import_node_path6.join)(dirs.PROJECTS_DIR, projectDirName);
+  const projectDir = (0, import_node_path6.join)(dirs.PROJECTS_DIR, encodeClaudeDirName(cwd));
   let files;
   try {
     files = await (0, import_promises5.readdir)(projectDir);
@@ -2719,18 +4004,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 +4039,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