cogpit-memory 0.1.10 → 0.2.1

package/dist/cli.js

@@ -67,10 +67,41 @@ function isSummaryMessage(msg) {
 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;
@@ -87,7 +118,58 @@ function extractToolResultText(content) {
 function isVisibleQueuedPrompt(content) {
   if (!content?.trim()) return false;
   const trimmed = content.trimStart();
-  return !trimmed.startsWith("<task-notification>") && !trimmed.startsWith("<local-command-");
+  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) {
@@ -101,35 +183,30 @@ function mergeTokenUsage(existing, incoming) {
     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;
-    }
-  }
-  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);
-    }
-  }
-  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 parts.join("\n");
+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 = [];
@@ -194,7 +271,7 @@ function groupPlanModeBlocks(blocks) {
                 embedded.push(...next.toolCalls);
                 j++;
               }
-            } else if (next.kind === "hook_event" || next.kind === "text" || next.kind === "queued_prompt") {
+            } else if (next.kind === "hook_event" || next.kind === "text" || next.kind === "queued_prompt" || next.kind === "agent_message") {
               passthroughBlocks.push(next);
               j++;
             } else {
@@ -215,10 +292,55 @@ function groupPlanModeBlocks(blocks) {
   }
   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 || ""
+        };
+      }
+    }
+  }
+  return repaired;
+}
 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();
@@ -226,6 +348,41 @@ function buildTurns(messages) {
   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);
@@ -273,18 +430,20 @@ 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) {
@@ -293,14 +452,44 @@ function buildTurns(messages) {
     }
     if (isQueueOperationMessage(msg)) {
       if (current && msg.operation === "enqueue" && isVisibleQueuedPrompt(msg.content)) {
-        current.contentBlocks.push({
-          kind: "queued_prompt",
+        const parsed = parseAgentEnvelope(msg.content);
+        pendingQueuedPrompts.push({
+          turn: current,
           content: msg.content,
-          timestamp: msg.timestamp
+          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)) {
@@ -363,24 +552,24 @@ function buildTurns(messages) {
           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;
+      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 = createTurn(msg, msg.message.content);
+      attachPendingCompaction(current);
       if (pendingRecap) {
         current.contentBlocks.push({ kind: "recap", content: pendingRecap.content, timestamp: pendingRecap.timestamp });
         pendingRecap = null;
@@ -406,21 +595,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);
@@ -610,145 +790,15 @@ function buildTurns(messages) {
       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 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 = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, webSearch: 0.01 };
-var TIER_OPUS_MID = { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, webSearch: 0.01 };
-var TIER_FRONTIER = { input: 10, output: 50, cacheWrite: 12.5, cacheRead: 1, webSearch: 0.01 };
-var TIER_OPUS_LEGACY = { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5, webSearch: 0.01 };
-var TIER_GPT_56_SOL = { input: 5, output: 30, cacheWrite: 6.25, cacheRead: 0.5, webSearch: 0.01 };
-var TIER_GPT_56_TERRA = { input: 2.5, output: 15, cacheWrite: 3.125, cacheRead: 0.25, webSearch: 0.01 };
-var TIER_GPT_56_LUNA = { input: 1, output: 6, cacheWrite: 1.25, cacheRead: 0.1, webSearch: 0.01 };
-var TIER_GPT_55 = { input: 5, output: 30, cacheWrite: 5, cacheRead: 0.5, webSearch: 0.01 };
-var TIER_GPT_54 = { input: 2.5, output: 15, cacheWrite: 2.5, cacheRead: 0.25, webSearch: 0.01 };
-var TIER_GPT_54_MINI = { input: 0.75, output: 4.5, cacheWrite: 0.75, cacheRead: 0.075, webSearch: 0.01 };
-var TIER_FAST = { input: 30, output: 150, cacheWrite: 37.5, cacheRead: 3, webSearch: 0.01 };
-var MODEL_TIERS = [
-  // OpenAI GPT models. Keep variants before their shared family prefixes.
-  { match: "gpt-5.6-sol", tier: TIER_GPT_56_SOL },
-  { match: "gpt-5.6-terra", tier: TIER_GPT_56_TERRA },
-  { match: "gpt-5.6-luna", tier: TIER_GPT_56_LUNA },
-  { match: "gpt-5.6", tier: TIER_GPT_56_SOL },
-  { match: "gpt-5.4-mini", tier: TIER_GPT_54_MINI },
-  { match: "gpt-5.5", tier: TIER_GPT_55 },
-  { match: "gpt-5.4", tier: TIER_GPT_54 },
-  // Frontier (Fable 5 / Mythos 5 / Opus 4.8)
-  { match: "fable-5", tier: TIER_FRONTIER },
-  { match: "mythos-5", tier: TIER_FRONTIER },
-  { match: "opus-4-8", tier: TIER_FRONTIER },
-  // Haiku
-  { match: "haiku-4-5", tier: TIER_HAIKU_45 },
-  { match: "haiku-4-0", tier: TIER_HAIKU_35 },
-  { match: "3-5-haiku", tier: TIER_HAIKU_35 },
-  // Sonnet (3.5 through 4.6 — all one tier in current CC)
-  { match: "sonnet-4-7", tier: TIER_SONNET },
-  { match: "sonnet-4-6", tier: TIER_SONNET },
-  { match: "sonnet-4-5", tier: TIER_SONNET },
-  { match: "sonnet-4-0", tier: TIER_SONNET },
-  { match: "3-7-sonnet", tier: TIER_SONNET },
-  { match: "3-5-sonnet", tier: TIER_SONNET },
-  // Opus 4.5–4.7
-  { match: "opus-4-7", tier: TIER_OPUS_MID },
-  { match: "opus-4-6", tier: TIER_OPUS_MID },
-  { match: "opus-4-5", tier: TIER_OPUS_MID },
-  // Opus legacy (4.0, 4.1)
-  { match: "opus-4-1", tier: TIER_OPUS_LEGACY },
-  { match: "opus-4-0", tier: TIER_OPUS_LEGACY }
-];
-var FAST_MODE_MODELS = ["opus-4-6", "opus-4-7"];
-var DEFAULT_TIER = TIER_OPUS_MID;
-var FAMILY_FALLBACKS = [
-  { match: "fable", tier: TIER_FRONTIER },
-  { match: "mythos", tier: TIER_FRONTIER },
-  { match: "haiku", tier: TIER_HAIKU_45 },
-  { match: "sonnet", tier: TIER_SONNET },
-  { match: "opus", tier: TIER_OPUS_MID }
-];
-function resolveTier(model, speed) {
-  if (speed === "fast" && FAST_MODE_MODELS.some((m) => model.includes(m))) {
-    return TIER_FAST;
-  }
-  for (const entry of MODEL_TIERS) {
-    if (model.includes(entry.match)) return entry.tier;
-  }
-  for (const entry of FAMILY_FALLBACKS) {
-    if (model.includes(entry.match)) return entry.tier;
-  }
-  return DEFAULT_TIER;
-}
-function hasKnownPricing(model) {
-  if (!model) return true;
-  const normalized = model.toLowerCase();
-  if (!normalized.startsWith("gpt-")) return true;
-  return MODEL_TIERS.some((entry) => normalized.includes(entry.match));
-}
-
-// src/lib/token-costs.ts
-var CHARS_PER_TOKEN = 4;
-function calculateCost(c) {
-  if (!hasKnownPricing(c.model)) return Number.NaN;
-  const p = resolveTier(c.model ?? "", c.speed);
-  return c.inputTokens / 1e6 * p.input + c.outputTokens / 1e6 * p.output + c.cacheWriteTokens / 1e6 * p.cacheWrite + c.cacheReadTokens / 1e6 * p.cacheRead + (c.webSearchRequests ?? 0) * p.webSearch;
-}
-function charsToTokens(chars) {
-  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,
-    speed: u.speed
-  });
-}
-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,
-    speed: u.speed
-  });
+  return pairAgentMessageReplies(turns);
 }
 
 // src/lib/sessionStats.ts
@@ -760,12 +810,11 @@ 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 createEmptySessionStats(turnCount) {
   return {
@@ -773,7 +822,6 @@ function createEmptySessionStats(turnCount) {
     totalOutputTokens: 0,
     totalCacheCreationTokens: 0,
     totalCacheReadTokens: 0,
-    totalCostUSD: 0,
     toolCallCounts: {},
     errorCount: 0,
     totalDurationMs: 0,
@@ -781,34 +829,20 @@ function createEmptySessionStats(turnCount) {
   };
 }
 function computeStats(turns) {
-  const stats = {
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    totalCacheCreationTokens: 0,
-    totalCacheReadTokens: 0,
-    totalCostUSD: 0,
-    toolCallCounts: {},
-    errorCount: 0,
-    totalDurationMs: 0,
-    turnCount: turns.length
-  };
+  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-patches.ts
+// src/lib/codex-exec.ts
 var JS_SIMPLE_ESCAPES = {
   "0": "\0",
   b: "\b",
@@ -874,6 +908,8 @@ function readJsStringLiteral(source, startIndex) {
   }
   return null;
 }
+
+// src/lib/codex-patches.ts
 function isApplyPatchText(value) {
   return value.includes("*** Begin Patch") && value.includes("*** End Patch");
 }
@@ -907,7 +943,9 @@ function extractApplyPatchInputs(execSource) {
 }
 function resolveCodexPatchPath(filePath, cwd) {
   if (!cwd || filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath)) return filePath;
-  return `${cwd.replace(/[\\/]+$/, "")}/${filePath.replace(/^\.\//, "")}`;
+  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 = [];
@@ -1034,6 +1072,24 @@ function findFailedNestedPatchCallIds(output, wrapperIsError, calls) {
 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+)/);
@@ -1159,28 +1215,6 @@ function buildCodexUserContent(message, images, audio = [], localImages = [], lo
     ...text ? [{ type: "text", text }] : []
   ];
 }
-function normalizeFunctionName(rawName) {
-  const leaf = rawName.split(/(?:__|[.:/])+/).filter(Boolean).at(-1) ?? rawName;
-  const aliases = {
-    spawnAgent: "spawn_agent",
-    waitAgent: "wait_agent",
-    sendMessage: "send_message",
-    followupTask: "followup_task",
-    listAgents: "list_agents",
-    interruptAgent: "interrupt_agent"
-  };
-  const canonicalCollaborationNames = /* @__PURE__ */ new Set([
-    "spawn_agent",
-    "wait_agent",
-    "send_message",
-    "followup_task",
-    "list_agents",
-    "interrupt_agent"
-  ]);
-  if (aliases[leaf]) return aliases[leaf];
-  if (canonicalCollaborationNames.has(leaf)) return leaf;
-  return rawName;
-}
 function extractInterAgentMessage(payload) {
   const rawText = extractMessageText(payload, "input_text");
   if (!rawText) return { messageType: null, text: "" };
@@ -1194,7 +1228,7 @@ function extractInterAgentMessage(payload) {
   return { messageType, text };
 }
 function agentNameFromPath(agentPath) {
-  const segments = agentPath.split("/").filter(Boolean);
+  const segments = agentPath.split(/[\\/]/).filter(Boolean);
   return segments.at(-1) ?? null;
 }
 function readableAgentPrompt(value) {
@@ -1287,9 +1321,35 @@ function parseToolInput(argumentsText) {
     return { raw: argumentsText };
   }
 }
-function createTurn(turnId, timestamp, model) {
+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 createTurn2(turnId, timestamp, model) {
   return {
-    id: turnId || randomTurnId("codex-turn"),
+    id: turnId ? `${turnId}@${timestamp}` : randomTurnId("codex-turn"),
     userMessage: null,
     contentBlocks: [],
     thinking: [],
@@ -1311,6 +1371,17 @@ function extractPromptFromRecord(record) {
   }
   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 = "";
@@ -1477,14 +1548,35 @@ function parseCodexSession(jsonlText, options) {
   let currentModel = metadata.model || null;
   let lastTurnTimestamp = "";
   let pendingCompaction = null;
+  let sawTurnStart = false;
   function createActiveTurn(turnId, timestamp, model) {
-    const turn = createTurn(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 = isObject2(record.payload) ? record.payload : void 0;
     const timestamp = record.timestamp ?? "";
@@ -1500,12 +1592,14 @@ function parseCodexSession(jsonlText, options) {
       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);
       }
+      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
@@ -1520,10 +1614,12 @@ function parseCodexSession(jsonlText, options) {
         localImages,
         localAudio
       );
+      current.isFragment = false;
       current.timestamp = current.timestamp || timestamp;
       lastTurnTimestamp = timestamp;
       continue;
     }
+    if (!current && !recordOpensTurn(record, payload)) continue;
     current ??= createActiveTurn(currentTurnId, timestamp, currentModel);
     if (!current.model && currentModel) current.model = currentModel;
     if (!current.timestamp) current.timestamp = timestamp;
@@ -1540,22 +1636,29 @@ function parseCodexSession(jsonlText, options) {
       const input = {};
       if (typeof payload.query === "string" && payload.query) input.query = payload.query;
       if (isObject2(payload.action)) input.action = payload.action;
-      const existing = webSearchCalls.get(payload.call_id);
+      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.input = { ...existing.input, ...input };
-        existing.result = "completed";
-        existing.isError = false;
-      } else {
-        const toolCall = {
+        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: "WebSearch",
+          name: `mcp__${server}__${tool}`,
           input,
-          result: "completed",
-          isError: false,
+          result: result.text,
+          isError: result.isError,
           timestamp
-        };
-        webSearchCalls.set(toolCall.id, toolCall);
-        appendToolCall(current, toolCall, timestamp);
+        }, timestamp);
       }
       continue;
     }
@@ -1609,6 +1712,8 @@ function parseCodexSession(jsonlText, options) {
       const audio = extractResponseMessageAudio(payload);
       if (text || images.length > 0 || audio.length > 0) {
         current.userMessage = buildCodexUserContent(text, images, audio);
+        current.isFragment = false;
+        sawTurnStart = true;
       }
       continue;
     }
@@ -1616,25 +1721,38 @@ function parseCodexSession(jsonlText, options) {
       const input = {};
       if (isObject2(payload.action)) input.action = payload.action;
       const status = typeof payload.status === "string" ? payload.status : "completed";
-      const existing = webSearchCalls.get(payload.id);
-      if (existing) {
-        existing.input = { ...existing.input, ...input };
-        existing.result = status;
-        existing.isError = status === "failed";
-      } else {
+      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: payload.id,
-          name: "WebSearch",
-          input,
-          result: status,
-          isError: status === "failed",
+          id: callId,
+          name: "ToolSearch",
+          input: isObject2(payload.arguments) ? payload.arguments : {},
+          result: null,
+          isError: false,
           timestamp
         };
-        webSearchCalls.set(toolCall.id, toolCall);
+        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;
@@ -2527,7 +2645,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) {
@@ -2879,6 +3001,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;
@@ -2970,9 +3093,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));
@@ -2980,6 +3107,7 @@ 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,
@@ -3013,6 +3141,14 @@ function mapContentBlock(block) {
       };
     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":
@@ -3026,6 +3162,12 @@ function mapContentBlock(block) {
       };
     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) {
@@ -3164,17 +3306,99 @@ var import_node_path6 = require("node:path");
 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;
@@ -3191,15 +3415,26 @@ function deriveSessionStatus(rawMessages) {
   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];
@@ -3234,14 +3469,124 @@ function deriveSessionStatus(rawMessages) {
   }
   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":
@@ -3254,7 +3599,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" };
@@ -3553,8 +3898,7 @@ async function listSessions(opts = {}) {
   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);