snow-ai 0.6.32 → 0.6.33

package/bundle/cli.mjs

@@ -81929,6 +81929,7 @@ var init_en = __esm({
         description: "This checkpoint has",
         filesCount: "{count} file(s) will be rolled back",
         filesCountWithSelection: "{count} file(s) will be rolled back ({selected}/{total} selected)",
+        notebookCount: "{count} notebook(s) will also be rolled back",
         question: "Do you want to rollback the files as well?",
         yesRollbackFiles: "Yes, rollback files and conversation",
         noConversationOnly: "No, rollback conversation only",
@@ -83179,6 +83180,7 @@ var init_zh = __esm({
         description: "\u6B64\u68C0\u67E5\u70B9\u5305\u542B",
         filesCount: "{count} \u4E2A\u6587\u4EF6\u5C06\u88AB\u56DE\u6EDA",
         filesCountWithSelection: "{count} \u4E2A\u6587\u4EF6\u5C06\u88AB\u56DE\u6EDA ({selected}/{total} \u5DF2\u9009\u62E9)",
+        notebookCount: "{count} \u6761\u5907\u5FD8\u5F55\u4E5F\u5C06\u88AB\u56DE\u6EDA",
         question: "\u662F\u5426\u540C\u65F6\u56DE\u6EDA\u6587\u4EF6\uFF1F",
         yesRollbackFiles: "\u662F\uFF0C\u56DE\u6EDA\u6587\u4EF6\u548C\u5BF9\u8BDD",
         noConversationOnly: "\u5426\uFF0C\u4EC5\u56DE\u6EDA\u5BF9\u8BDD",
@@ -84428,6 +84430,7 @@ var init_zh_TW = __esm({
         description: "\u6B64\u6AA2\u67E5\u9EDE\u5305\u542B",
         filesCount: "{count} \u500B\u6A94\u6848\u5C07\u88AB\u56DE\u6EFE",
         filesCountWithSelection: "{count} \u500B\u6A94\u6848\u5C07\u88AB\u56DE\u6EFE ({selected}/{total} \u5DF2\u9078\u64C7)",
+        notebookCount: "{count} \u689D\u5099\u5FD8\u9304\u4E5F\u5C07\u88AB\u56DE\u6EFE",
         question: "\u662F\u5426\u540C\u6642\u56DE\u6EFE\u6A94\u6848\uFF1F",
         yesRollbackFiles: "\u662F\uFF0C\u56DE\u6EFE\u6A94\u6848\u548C\u5C0D\u8A71",
         noConversationOnly: "\u5426\uFF0C\u50C5\u56DE\u6EFE\u5C0D\u8A71",
@@ -352053,6 +352056,16 @@ function getNotebooksByFile(filePath) {
   const data = readNotebookData();
   return data[normalizedPath] || [];
 }
+function findNotebookById(notebookId) {
+  const data = readNotebookData();
+  for (const [, entries] of Object.entries(data)) {
+    const entry = entries.find((e) => e.id === notebookId);
+    if (entry) {
+      return { ...entry };
+    }
+  }
+  return null;
+}
 function updateNotebook(notebookId, newNote) {
   const data = readNotebookData();
   let updatedEntry = null;
@@ -352087,6 +352100,141 @@ function deleteNotebook(notebookId) {
   }
   return found;
 }
+function getNotebookSnapshotFilePath() {
+  const projectRoot = process.cwd();
+  const projectName = path16.basename(projectRoot);
+  const notebookDir = getNotebookDir();
+  return path16.join(notebookDir, `${projectName}_snapshots.json`);
+}
+function readNotebookSnapshotData() {
+  const filePath = getNotebookSnapshotFilePath();
+  if (!fs16.existsSync(filePath)) {
+    return {};
+  }
+  try {
+    const content = fs16.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveNotebookSnapshotData(data) {
+  const filePath = getNotebookSnapshotFilePath();
+  try {
+    fs16.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch (error) {
+    console.error("Failed to save notebook snapshot data:", error);
+  }
+}
+function appendNotebookOperation(sessionId, messageIndex, operation) {
+  const data = readNotebookSnapshotData();
+  const key = `${sessionId}:${messageIndex}`;
+  if (!data[key]) {
+    data[key] = [];
+  }
+  data[key].push(operation);
+  saveNotebookSnapshotData(data);
+}
+function recordNotebookAddition(sessionId, messageIndex, notebookId) {
+  appendNotebookOperation(sessionId, messageIndex, {
+    op: "add",
+    notebookId
+  });
+}
+function recordNotebookUpdate(sessionId, messageIndex, notebookId, previousNote) {
+  appendNotebookOperation(sessionId, messageIndex, {
+    op: "update",
+    notebookId,
+    previousNote
+  });
+}
+function recordNotebookDeletion(sessionId, messageIndex, entry) {
+  appendNotebookOperation(sessionId, messageIndex, {
+    op: "delete",
+    entry
+  });
+}
+function getNotebookOpsToRollback(sessionId, targetMessageIndex) {
+  const data = readNotebookSnapshotData();
+  const ops = [];
+  for (const [key, operations] of Object.entries(data)) {
+    if (!key.startsWith(`${sessionId}:`))
+      continue;
+    const msgIndex = parseInt(key.split(":")[1] || "", 10);
+    if (!isNaN(msgIndex) && msgIndex >= targetMessageIndex) {
+      ops.push(...operations);
+    }
+  }
+  return ops;
+}
+function getNotebookRollbackCount(sessionId, targetMessageIndex) {
+  return getNotebookOpsToRollback(sessionId, targetMessageIndex).length;
+}
+function rollbackNotebooks(sessionId, targetMessageIndex) {
+  const ops = getNotebookOpsToRollback(sessionId, targetMessageIndex);
+  let rolledBackCount = 0;
+  for (let i = ops.length - 1; i >= 0; i--) {
+    const op2 = ops[i];
+    if (!op2)
+      continue;
+    try {
+      switch (op2.op) {
+        case "add":
+          deleteNotebook(op2.notebookId);
+          rolledBackCount++;
+          break;
+        case "update":
+          updateNotebook(op2.notebookId, op2.previousNote);
+          rolledBackCount++;
+          break;
+        case "delete": {
+          const data = readNotebookData();
+          const fp = op2.entry.filePath;
+          if (!data[fp]) {
+            data[fp] = [];
+          }
+          data[fp].unshift(op2.entry);
+          saveNotebookData(data);
+          rolledBackCount++;
+          break;
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to rollback notebook operation:`, error);
+    }
+  }
+  deleteNotebookSnapshotsFromIndex(sessionId, targetMessageIndex);
+  return rolledBackCount;
+}
+function deleteNotebookSnapshotsFromIndex(sessionId, targetMessageIndex) {
+  const data = readNotebookSnapshotData();
+  let changed = false;
+  for (const key of Object.keys(data)) {
+    if (!key.startsWith(`${sessionId}:`))
+      continue;
+    const msgIndex = parseInt(key.split(":")[1] || "", 10);
+    if (!isNaN(msgIndex) && msgIndex >= targetMessageIndex) {
+      delete data[key];
+      changed = true;
+    }
+  }
+  if (changed) {
+    saveNotebookSnapshotData(data);
+  }
+}
+function clearAllNotebookSnapshots(sessionId) {
+  const data = readNotebookSnapshotData();
+  let changed = false;
+  for (const key of Object.keys(data)) {
+    if (key.startsWith(`${sessionId}:`)) {
+      delete data[key];
+      changed = true;
+    }
+  }
+  if (changed) {
+    saveNotebookSnapshotData(data);
+  }
+}
 var MAX_ENTRIES_PER_FILE;
 var init_notebookManager = __esm({
   "dist/utils/core/notebookManager.js"() {
@@ -361462,7 +361610,7 @@ var require_lib12 = __commonJS({
     module2.exports._canonicalizeEncoding = function(encoding) {
       return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
     };
-    module2.exports.getEncoder = function getEncoder(encoding, options3) {
+    module2.exports.getEncoder = function getEncoder2(encoding, options3) {
       var codec = module2.exports.getCodec(encoding);
       var encoder = new codec.encoder(options3, codec);
       if (codec.bomAware && options3 && options3.addBOM) {
@@ -438009,11 +438157,11 @@ var init_compactAgent = __esm({
           let chunkCount = 0;
           let encoder;
           try {
-            const { encoding_for_model: encoding_for_model2 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
-            encoder = encoding_for_model2("gpt-5");
+            const { encoding_for_model: encoding_for_model3 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
+            encoder = encoding_for_model3("gpt-5");
           } catch (e) {
-            const { encoding_for_model: encoding_for_model2 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
-            encoder = encoding_for_model2("gpt-5");
+            const { encoding_for_model: encoding_for_model3 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
+            encoder = encoding_for_model3("gpt-5");
           }
           try {
             for await (const chunk2 of streamGenerator) {
@@ -443046,6 +443194,13 @@ async function executeNotebookTool(toolName, args2) {
           };
         }
         const entry = addNotebook(filePath, note);
+        try {
+          const context2 = getConversationContext();
+          if (context2) {
+            recordNotebookAddition(context2.sessionId, context2.messageIndex, entry.id);
+          }
+        } catch {
+        }
         return {
           content: [
             {
@@ -443113,6 +443268,8 @@ async function executeNotebookTool(toolName, args2) {
             isError: true
           };
         }
+        const previousEntry = findNotebookById(notebookId);
+        const previousNote = previousEntry == null ? void 0 : previousEntry.note;
         const updatedEntry = updateNotebook(notebookId, note);
         if (!updatedEntry) {
           return {
@@ -443128,6 +443285,13 @@ async function executeNotebookTool(toolName, args2) {
             isError: true
           };
         }
+        try {
+          const context2 = getConversationContext();
+          if (context2 && previousNote !== void 0) {
+            recordNotebookUpdate(context2.sessionId, context2.messageIndex, notebookId, previousNote);
+          }
+        } catch {
+        }
         return {
           content: [
             {
@@ -443159,6 +443323,7 @@ async function executeNotebookTool(toolName, args2) {
             isError: true
           };
         }
+        const entryToDelete = findNotebookById(notebookId);
         const deleted = deleteNotebook(notebookId);
         if (!deleted) {
           return {
@@ -443174,6 +443339,13 @@ async function executeNotebookTool(toolName, args2) {
             isError: true
           };
         }
+        try {
+          const context2 = getConversationContext();
+          if (context2 && entryToDelete) {
+            recordNotebookDeletion(context2.sessionId, context2.messageIndex, entryToDelete);
+          }
+        } catch {
+        }
         return {
           content: [
             {
@@ -443247,6 +443419,7 @@ var init_notebook = __esm({
   "dist/mcp/notebook.js"() {
     "use strict";
     init_notebookManager();
+    init_conversationContext();
     mcpTools8 = [
       {
         name: "notebook-add",
@@ -444803,6 +444976,368 @@ var init_yoloPermissionChecker = __esm({
   }
 });
 
+// dist/utils/core/subAgentContextCompressor.js
+function getEncoder() {
+  if (!_encoder) {
+    try {
+      _encoder = (0, import_tiktoken.encoding_for_model)("gpt-4o");
+    } catch {
+      _encoder = (0, import_tiktoken.encoding_for_model)("gpt-3.5-turbo");
+    }
+  }
+  return _encoder;
+}
+function countMessagesTokens(messages) {
+  var _a21, _b14;
+  try {
+    const encoder = getEncoder();
+    let total = 0;
+    for (const msg of messages) {
+      if (msg.content) {
+        total += encoder.encode(msg.content).length;
+      }
+      if (msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          if ((_a21 = tc.function) == null ? void 0 : _a21.arguments) {
+            total += encoder.encode(tc.function.arguments).length;
+          }
+          if ((_b14 = tc.function) == null ? void 0 : _b14.name) {
+            total += encoder.encode(tc.function.name).length;
+          }
+        }
+      }
+      total += 4;
+    }
+    return total;
+  } catch (error) {
+    console.error("[SubAgentCompressor] tiktoken counting failed:", error);
+    const totalChars = messages.reduce((sum, m) => {
+      var _a22;
+      return sum + (((_a22 = m.content) == null ? void 0 : _a22.length) || 0);
+    }, 0);
+    return Math.round(totalChars / 4);
+  }
+}
+function getContextPercentage(totalTokens, maxContextTokens) {
+  if (!maxContextTokens || maxContextTokens <= 0)
+    return 0;
+  return Math.min(100, totalTokens / maxContextTokens * 100);
+}
+function shouldCompressSubAgentContext(totalTokens, maxContextTokens) {
+  return getContextPercentage(totalTokens, maxContextTokens) >= COMPRESS_THRESHOLD;
+}
+function getAdaptiveKeepRounds(percentage) {
+  if (percentage >= 95)
+    return 1;
+  if (percentage >= 85)
+    return 2;
+  return DEFAULT_KEEP_RECENT_ROUNDS;
+}
+function findRecentRoundsStartIndex(messages, keepRounds) {
+  var _a21, _b14, _c6, _d4;
+  let roundCount = 0;
+  let i = messages.length - 1;
+  while (i >= 0 && roundCount < keepRounds) {
+    const msg = messages[i];
+    if ((msg == null ? void 0 : msg.role) === "tool") {
+      while (i >= 0 && ((_a21 = messages[i]) == null ? void 0 : _a21.role) === "tool") {
+        i--;
+      }
+      if (i >= 0 && ((_b14 = messages[i]) == null ? void 0 : _b14.role) === "assistant" && ((_d4 = (_c6 = messages[i]) == null ? void 0 : _c6.tool_calls) == null ? void 0 : _d4.length)) {
+        roundCount++;
+        i--;
+      }
+    } else {
+      i--;
+    }
+  }
+  return Math.max(0, i + 1);
+}
+function formatMessageForTranscript(msg) {
+  var _a21, _b14;
+  if (msg.role === "tool") {
+    return null;
+  }
+  if (msg.role === "system") {
+    return null;
+  }
+  const parts = [];
+  const roleLabel = msg.role === "user" ? "[User]" : "[Assistant]";
+  if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+    if (msg.content) {
+      parts.push(`${roleLabel}
+${msg.content}`);
+    } else {
+      parts.push(roleLabel);
+    }
+    for (const tc of msg.tool_calls) {
+      const funcName = ((_a21 = tc.function) == null ? void 0 : _a21.name) || "unknown";
+      const args2 = ((_b14 = tc.function) == null ? void 0 : _b14.arguments) || "{}";
+      const truncatedArgs = args2.length > 500 ? args2.substring(0, 500) + "..." : args2;
+      parts.push(`  -> Tool Call: ${funcName}(${truncatedArgs})`);
+    }
+    return parts.join("\n");
+  }
+  if (msg.content) {
+    parts.push(`${roleLabel}
+${msg.content}`);
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function prepareMessagesForAICompression(conversationMessages) {
+  const messages = [];
+  messages.push({
+    role: "system",
+    content: "You are a technical summarization assistant. Your job is to compress a tool-using AI agent's conversation history into a concise but complete handover document."
+  });
+  const transcriptParts = [];
+  for (const msg of conversationMessages) {
+    const formatted = formatMessageForTranscript(msg);
+    if (formatted) {
+      transcriptParts.push(formatted);
+    }
+  }
+  const transcript = transcriptParts.join("\n\n---\n\n");
+  messages.push({
+    role: "user",
+    content: `## Sub-Agent Conversation History to Compress
+
+${transcript}`
+  });
+  messages.push({
+    role: "user",
+    content: SUB_AGENT_COMPRESSION_PROMPT
+  });
+  return messages;
+}
+async function aiSummaryCompress(messages, keepRounds, config3) {
+  const preserveStartIndex = findRecentRoundsStartIndex(messages, keepRounds);
+  if (preserveStartIndex === 0) {
+    return messages;
+  }
+  const messagesToCompress = messages.slice(0, preserveStartIndex);
+  const preservedMessages = messages.slice(preserveStartIndex);
+  const compressionMessages = prepareMessagesForAICompression(messagesToCompress);
+  let summary = "";
+  try {
+    switch (config3.requestMethod) {
+      case "gemini": {
+        for await (const chunk2 of createStreamingGeminiCompletion({
+          model: config3.model,
+          messages: compressionMessages,
+          configProfile: config3.configProfile
+        })) {
+          if (chunk2.type === "content" && chunk2.content) {
+            summary += chunk2.content;
+          }
+        }
+        break;
+      }
+      case "anthropic": {
+        for await (const chunk2 of createStreamingAnthropicCompletion({
+          model: config3.model,
+          messages: compressionMessages,
+          max_tokens: config3.maxTokens || 4096,
+          disableThinking: true,
+          configProfile: config3.configProfile
+        })) {
+          if (chunk2.type === "content" && chunk2.content) {
+            summary += chunk2.content;
+          }
+        }
+        break;
+      }
+      case "responses": {
+        for await (const chunk2 of createStreamingResponse({
+          model: config3.model,
+          messages: compressionMessages,
+          configProfile: config3.configProfile
+        })) {
+          if (chunk2.type === "content" && chunk2.content) {
+            summary += chunk2.content;
+          }
+        }
+        break;
+      }
+      case "chat":
+      default: {
+        for await (const chunk2 of createStreamingChatCompletion({
+          model: config3.model,
+          messages: compressionMessages,
+          stream: true,
+          configProfile: config3.configProfile
+        })) {
+          if (chunk2.type === "content" && chunk2.content) {
+            summary += chunk2.content;
+          }
+        }
+        break;
+      }
+    }
+  } catch (error) {
+    console.error("[SubAgentCompressor] AI compression failed:", error);
+    return messages;
+  }
+  if (!summary) {
+    console.warn("[SubAgentCompressor] AI compression returned empty summary");
+    return messages;
+  }
+  const newMessages = [
+    {
+      role: "user",
+      content: `## Previous Context (Auto-Compressed Summary)
+
+${summary}
+
+---
+
+*The above is a compressed summary of earlier conversation. Continue the task based on this context and the recent tool interactions below.*`
+    },
+    ...preservedMessages
+  ];
+  return newMessages;
+}
+function truncateToolResults(messages, keepRounds) {
+  if (messages.length === 0)
+    return [];
+  const preserveStartIndex = findRecentRoundsStartIndex(messages, keepRounds);
+  const result2 = [];
+  const MIN_TRUNCATION_LENGTH = 500;
+  const MAX_PRESERVED_CHARS = 2e3;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg)
+      continue;
+    const findToolName = () => {
+      for (let j = i - 1; j >= 0; j--) {
+        const prev = messages[j];
+        if ((prev == null ? void 0 : prev.role) === "assistant" && prev.tool_calls) {
+          const match2 = prev.tool_calls.find((tc) => tc.id === msg.tool_call_id);
+          if (match2)
+            return match2.function.name;
+        }
+        if ((prev == null ? void 0 : prev.role) !== "tool")
+          break;
+      }
+      return "unknown";
+    };
+    if (i < preserveStartIndex) {
+      if (msg.role === "tool" && msg.content && msg.content.length > MIN_TRUNCATION_LENGTH) {
+        result2.push({
+          ...msg,
+          content: `[Tool result truncated: ${findToolName()}, original ${msg.content.length} chars]`
+        });
+      } else {
+        result2.push(msg);
+      }
+      continue;
+    }
+    if (msg.role === "tool" && msg.content && msg.content.length > MAX_PRESERVED_CHARS) {
+      const toolName = findToolName();
+      const keepStart = Math.floor(MAX_PRESERVED_CHARS * 0.6);
+      const keepEnd = Math.floor(MAX_PRESERVED_CHARS * 0.3);
+      const truncated = msg.content.length - keepStart - keepEnd;
+      result2.push({
+        ...msg,
+        content: msg.content.substring(0, keepStart) + `
+
+[... ${truncated} chars truncated from ${toolName} result ...]
+
+` + msg.content.substring(msg.content.length - keepEnd)
+      });
+    } else {
+      result2.push(msg);
+    }
+  }
+  return result2;
+}
+async function compressSubAgentContext(messages, totalTokens, maxContextTokens, config3) {
+  const percentage = getContextPercentage(totalTokens, maxContextTokens);
+  if (percentage < COMPRESS_THRESHOLD) {
+    return {
+      compressed: false,
+      messages
+    };
+  }
+  const keepRounds = getAdaptiveKeepRounds(percentage);
+  const compressedMessages = await aiSummaryCompress(messages, keepRounds, config3);
+  if (compressedMessages !== messages) {
+    const afterTokens2 = countMessagesTokens(compressedMessages);
+    return {
+      compressed: true,
+      messages: compressedMessages,
+      beforeTokens: totalTokens,
+      afterTokensEstimate: afterTokens2
+    };
+  }
+  console.warn(`[SubAgentCompressor] AI compression ineffective, falling back to truncation`);
+  const truncatedMessages = truncateToolResults(messages, keepRounds);
+  const afterTokens = countMessagesTokens(truncatedMessages);
+  if (afterTokens < totalTokens) {
+    return {
+      compressed: true,
+      messages: truncatedMessages,
+      beforeTokens: totalTokens,
+      afterTokensEstimate: afterTokens
+    };
+  }
+  return {
+    compressed: false,
+    messages
+  };
+}
+var import_tiktoken, COMPRESS_THRESHOLD, DEFAULT_KEEP_RECENT_ROUNDS, SUB_AGENT_COMPRESSION_PROMPT, _encoder;
+var init_subAgentContextCompressor = __esm({
+  "dist/utils/core/subAgentContextCompressor.js"() {
+    "use strict";
+    import_tiktoken = __toESM(require_tiktoken(), 1);
+    init_chat();
+    init_responses();
+    init_gemini();
+    init_anthropic();
+    COMPRESS_THRESHOLD = 80;
+    DEFAULT_KEEP_RECENT_ROUNDS = 3;
+    SUB_AGENT_COMPRESSION_PROMPT = `**TASK: Create a concise handover document from the sub-agent conversation history above.**
+
+You are creating a technical handover document for a tool-using AI agent. Extract and preserve all critical information with rigorous detail.
+
+**OUTPUT FORMAT:**
+
+## Task Objective
+- What the agent was asked to do
+- Current completion status
+
+## Key Findings
+- Important information discovered via tool calls
+- **EXACT** file paths, function names, code identifiers
+- Search results, code patterns, architecture details
+
+## Actions Taken
+- Files read/modified (with exact paths)
+- Commands executed and their outcomes
+- Tools used and their results (key details only)
+
+## Work In Progress
+- Incomplete tasks with specific reasons
+- Planned next steps (concrete, actionable)
+- Known issues and blockers
+
+## Critical Reference Data
+- Important values, IDs, error messages (exact wording)
+- User requirements and constraints
+- Edge cases and special handling
+
+**QUALITY REQUIREMENTS:**
+1. Preserve EXACT technical terms \u2014 never paraphrase code/file names
+2. Include FULL context \u2014 paths, versions, configurations
+3. NO vague summaries \u2014 provide actionable, specific details
+4. Use markdown code blocks for code snippets
+
+**EXECUTE NOW \u2014 Output the handover document immediately.**`;
+    _encoder = null;
+  }
+});
+
 // dist/utils/execution/runningSubAgentTracker.js
 var runningSubAgentTracker_exports = {};
 __export(runningSubAgentTracker_exports, {
@@ -444838,6 +445373,24 @@ var init_runningSubAgentTracker = __esm({
           writable: true,
           value: /* @__PURE__ */ new Map()
         });
+        Object.defineProperty(this, "interAgentQueues", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: /* @__PURE__ */ new Map()
+        });
+        Object.defineProperty(this, "spawnedResults", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: []
+        });
+        Object.defineProperty(this, "interAgentListeners", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: /* @__PURE__ */ new Set()
+        });
       }
       /**
        * Register a running sub-agent
@@ -444845,6 +445398,7 @@ var init_runningSubAgentTracker = __esm({
       register(agent) {
         this.agents.set(agent.instanceId, agent);
         this.messageQueues.set(agent.instanceId, []);
+        this.interAgentQueues.set(agent.instanceId, []);
         this.rebuildSnapshot();
         this.notifyListeners();
       }
@@ -444854,6 +445408,7 @@ var init_runningSubAgentTracker = __esm({
       unregister(instanceId) {
         if (this.agents.delete(instanceId)) {
           this.messageQueues.delete(instanceId);
+          this.interAgentQueues.delete(instanceId);
           this.rebuildSnapshot();
           this.notifyListeners();
         }
@@ -444878,6 +445433,68 @@ var init_runningSubAgentTracker = __esm({
       isRunning(instanceId) {
         return this.agents.has(instanceId);
       }
+      /**
+       * Check if there are any spawned sub-agents still running.
+       * Spawned agents have instanceIds starting with "spawn-".
+       */
+      hasRunningSpawnedAgents() {
+        for (const instanceId of this.agents.keys()) {
+          if (instanceId.startsWith("spawn-")) {
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Wait for all spawned agents to complete, with a timeout.
+       * Resolves when all spawned agents finish or the timeout is reached.
+       * @param timeoutMs Maximum time to wait in milliseconds (default: 5 minutes)
+       * @param abortSignal Optional abort signal to cancel waiting early
+       * @returns true if all spawned agents completed, false if timed out or aborted
+       */
+      waitForSpawnedAgents(timeoutMs = 3e5, abortSignal) {
+        return new Promise((resolve12) => {
+          if (!this.hasRunningSpawnedAgents()) {
+            resolve12(true);
+            return;
+          }
+          const startTime = Date.now();
+          let unsubscribe;
+          const checkDone = () => {
+            if (abortSignal == null ? void 0 : abortSignal.aborted) {
+              cleanup();
+              resolve12(false);
+              return;
+            }
+            if (!this.hasRunningSpawnedAgents()) {
+              cleanup();
+              resolve12(true);
+              return;
+            }
+            if (Date.now() - startTime > timeoutMs) {
+              cleanup();
+              resolve12(false);
+              return;
+            }
+          };
+          const cleanup = () => {
+            if (unsubscribe) {
+              unsubscribe();
+              unsubscribe = void 0;
+            }
+          };
+          unsubscribe = this.subscribe(() => {
+            checkDone();
+          });
+          if (abortSignal) {
+            abortSignal.addEventListener("abort", () => {
+              cleanup();
+              resolve12(false);
+            }, { once: true });
+          }
+          checkDone();
+        });
+      }
       // ── Message queue for injecting user messages into running sub-agents ──
       /**
        * Enqueue a user message for a running sub-agent.
@@ -444906,6 +445523,120 @@ var init_runningSubAgentTracker = __esm({
         queue.length = 0;
         return messages;
       }
+      // ── Inter-agent messaging ──────────────────────────────────────────────
+      /**
+       * Send a message from one sub-agent to another.
+       * The message is queued for the target and also triggers a listener notification
+       * so that the UI can display the inter-agent communication.
+       * Returns true if the target agent is running and the message was enqueued.
+       */
+      sendInterAgentMessage(fromInstanceId, targetInstanceId, content) {
+        const queue = this.interAgentQueues.get(targetInstanceId);
+        if (!queue) {
+          return false;
+        }
+        const fromAgent = this.agents.get(fromInstanceId);
+        if (!fromAgent) {
+          return false;
+        }
+        const message = {
+          fromInstanceId,
+          fromAgentId: fromAgent.agentId,
+          fromAgentName: fromAgent.agentName,
+          content,
+          sentAt: /* @__PURE__ */ new Date()
+        };
+        queue.push(message);
+        this.notifyInterAgentListeners(fromAgent, targetInstanceId, message);
+        return true;
+      }
+      /**
+       * Dequeue all pending inter-agent messages for a sub-agent instance.
+       * Called by the sub-agent executor at the top of each while-loop iteration.
+       */
+      dequeueInterAgentMessages(instanceId) {
+        const queue = this.interAgentQueues.get(instanceId);
+        if (!queue || queue.length === 0) {
+          return [];
+        }
+        const messages = [...queue];
+        queue.length = 0;
+        return messages;
+      }
+      /**
+       * Find a running sub-agent instance by agentId (type).
+       * If multiple instances of the same type are running, returns the first match.
+       * Use this to resolve agentId -> instanceId for inter-agent messaging.
+       */
+      findInstanceByAgentId(agentId) {
+        for (const agent of this.agents.values()) {
+          if (agent.agentId === agentId) {
+            return agent;
+          }
+        }
+        return void 0;
+      }
+      /**
+       * Find all running sub-agent instances by agentId (type).
+       */
+      findAllInstancesByAgentId(agentId) {
+        const result2 = [];
+        for (const agent of this.agents.values()) {
+          if (agent.agentId === agentId) {
+            result2.push(agent);
+          }
+        }
+        return result2;
+      }
+      onInterAgentMessage(listener) {
+        this.interAgentListeners.add(listener);
+        return () => {
+          this.interAgentListeners.delete(listener);
+        };
+      }
+      notifyInterAgentListeners(fromAgent, targetInstanceId, message) {
+        const targetAgent = this.agents.get(targetInstanceId);
+        if (!targetAgent)
+          return;
+        for (const listener of this.interAgentListeners) {
+          try {
+            listener({
+              from: fromAgent,
+              to: targetAgent,
+              message
+            });
+          } catch {
+          }
+        }
+      }
+      // ── Spawned agent result storage ──────────────────────────────────────
+      /**
+       * Store the result of a sub-agent that was spawned by another sub-agent.
+       * The main conversation flow drains these between tool execution rounds.
+       */
+      storeSpawnedResult(result2) {
+        this.spawnedResults.push(result2);
+        this.notifyListeners();
+      }
+      /**
+       * Drain all completed spawned agent results.
+       * Called by the main conversation flow to inject results as context.
+       * Returns an empty array if no results are pending.
+       */
+      drainSpawnedResults() {
+        if (this.spawnedResults.length === 0) {
+          return [];
+        }
+        const results = [...this.spawnedResults];
+        this.spawnedResults.length = 0;
+        return results;
+      }
+      /**
+       * Check if there are any pending spawned agent results.
+       */
+      hasSpawnedResults() {
+        return this.spawnedResults.length > 0;
+      }
       /**
        * Subscribe to changes in the running agents list.
        * Returns an unsubscribe function.
@@ -444920,9 +445651,11 @@ var init_runningSubAgentTracker = __esm({
        * Clear all running agents (useful for cleanup)
        */
       clear() {
-        if (this.agents.size > 0) {
+        if (this.agents.size > 0 || this.spawnedResults.length > 0) {
           this.agents.clear();
           this.messageQueues.clear();
+          this.interAgentQueues.clear();
+          this.spawnedResults.length = 0;
           this.rebuildSnapshot();
           this.notifyListeners();
         }
@@ -444944,7 +445677,8 @@ var init_runningSubAgentTracker = __esm({
 });
 
 // dist/utils/execution/subAgentExecutor.js
-async function executeSubAgent(agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved, requestUserQuestion, instanceId) {
+async function executeSubAgent(agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved, requestUserQuestion, instanceId, spawnDepth = 0) {
+  var _a21, _b14, _c6;
   try {
     let agent;
     if (agentId === "agent_explore" || agentId === "agent_plan" || agentId === "agent_general" || agentId === "agent_analyze" || agentId === "agent_debug") {
@@ -445853,12 +446587,117 @@ Inserted log points:
         error: `Sub-agent "${agent.name}" has no valid tools configured`
       };
     }
+    const { runningSubAgentTracker: runningSubAgentTracker2 } = await Promise.resolve().then(() => (init_runningSubAgentTracker(), runningSubAgentTracker_exports));
+    const sendMessageTool = {
+      type: "function",
+      function: {
+        name: "send_message_to_agent",
+        description: "Send a message to another running sub-agent. Use this to share information, findings, or coordinate work with other agents that are executing in parallel. The message will be injected into the target agent's context. IMPORTANT: Use query_agents_status first to check if the target agent is still running before sending.",
+        parameters: {
+          type: "object",
+          properties: {
+            target_agent_id: {
+              type: "string",
+              description: 'The agent ID (type) of the target sub-agent (e.g., "agent_explore", "agent_general"). If multiple instances of the same type are running, the message is sent to the first found instance.'
+            },
+            target_instance_id: {
+              type: "string",
+              description: "(Optional) The specific instance ID of the target sub-agent. Use this for precise targeting when multiple instances of the same agent type are running."
+            },
+            message: {
+              type: "string",
+              description: "The message content to send to the target agent. Be clear and specific about what information you are sharing or what action you are requesting."
+            }
+          },
+          required: ["message"]
+        }
+      }
+    };
+    const queryAgentsStatusTool = {
+      type: "function",
+      function: {
+        name: "query_agents_status",
+        description: "Query the current status of all running sub-agents. Returns a list of currently active agents with their IDs, names, prompts, and how long they have been running. Use this to check if a target agent is still running before sending it a message, or to discover new agents that have started.",
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }
+    };
+    const spawnSubAgentTool = {
+      type: "function",
+      function: {
+        name: "spawn_sub_agent",
+        description: `Spawn a NEW sub-agent of a DIFFERENT type to get specialized help. The spawned agent runs in parallel and results are reported back automatically.
+
+**WHEN TO USE** \u2014 Only spawn when you genuinely need a different agent's specialization:
+- You are an Explore Agent and need code modifications \u2192 spawn agent_general
+- You are a General Purpose Agent and need deep code analysis \u2192 spawn agent_explore
+- You need a detailed implementation plan \u2192 spawn agent_plan
+- You need requirement clarification with user \u2192 spawn agent_analyze
+
+**WHEN NOT TO USE** \u2014 Do NOT spawn to offload YOUR OWN work:
+- NEVER spawn an agent of the same type as yourself to delegate your task \u2014 that is lazy and wasteful
+- NEVER spawn an agent just to "break work into pieces" if you can do it yourself
+- NEVER spawn when you are simply stuck \u2014 try harder or ask the user instead
+- If you can complete the task with your own tools, DO IT YOURSELF
+
+Available agent types: agent_explore (code exploration, read-only), agent_plan (planning, read-only), agent_general (full access, code modification), agent_analyze (requirement analysis), agent_debug (debug logging).`,
+        parameters: {
+          type: "object",
+          properties: {
+            agent_id: {
+              type: "string",
+              description: 'The agent type to spawn. Must be a DIFFERENT type from yourself unless you have a very strong justification. (e.g., "agent_explore", "agent_plan", "agent_general", "agent_analyze", "agent_debug", or a user-defined agent ID).'
+            },
+            prompt: {
+              type: "string",
+              description: "CRITICAL: The task prompt for the spawned agent. Must include COMPLETE context since the spawned agent has NO access to your conversation history. Include all relevant file paths, findings, constraints, and requirements."
+            }
+          },
+          required: ["agent_id", "prompt"]
+        }
+      }
+    };
+    allowedTools.push(sendMessageTool, queryAgentsStatusTool);
+    if (spawnDepth < MAX_SPAWN_DEPTH) {
+      allowedTools.push(spawnSubAgentTool);
+    }
+    const otherAgents = runningSubAgentTracker2.getRunningAgents().filter((a) => a.instanceId !== instanceId);
+    const canSpawn = spawnDepth < MAX_SPAWN_DEPTH;
+    let otherAgentsContext = "";
+    if (otherAgents.length > 0) {
+      const agentList = otherAgents.map((a) => `- ${a.agentName} (id: ${a.agentId}, instance: ${a.instanceId}): "${a.prompt ? a.prompt.substring(0, 120) : "N/A"}"`).join("\n");
+      const spawnHint = canSpawn ? ", or `spawn_sub_agent` to request a DIFFERENT type of agent for specialized help" : "";
+      const spawnAdvice = canSpawn ? "\n\n**Spawn rules**: Only spawn agents of a DIFFERENT type for work you CANNOT do with your own tools. Complete your own task first \u2014 do NOT delegate it." : "";
+      otherAgentsContext = `
+
+## Currently Running Peer Agents
+The following sub-agents are running in parallel with you. You can use \`query_agents_status\` to get real-time status, \`send_message_to_agent\` to communicate${spawnHint}.
+
+${agentList}
+
+If you discover information useful to another agent, proactively share it.${spawnAdvice}`;
+    } else {
+      const spawnToolLine = canSpawn ? "\n- `spawn_sub_agent`: Spawn a DIFFERENT type of agent for specialized help (do NOT spawn your own type to offload work)" : "";
+      const spawnUsage = canSpawn ? '\n\n**Spawn rules**: Only use `spawn_sub_agent` when you genuinely need a different agent\'s specialization (e.g., you are read-only but need code changes). NEVER spawn to delegate your own task or to "parallelize" work you should do yourself.' : "";
+      otherAgentsContext = `
+
+## Agent Collaboration Tools
+You have access to these collaboration tools:
+- \`query_agents_status\`: Check which sub-agents are currently running
+- \`send_message_to_agent\`: Send a message to a running peer agent (check status first!)${spawnToolLine}${spawnUsage}`;
+    }
     let finalPrompt = prompt;
     if (agent.role) {
       finalPrompt = `${prompt}
 
 ${agent.role}`;
     }
+    if (otherAgentsContext) {
+      finalPrompt = `${finalPrompt}${otherAgentsContext}`;
+    }
     const messages = [
       {
         role: "user",
@@ -445869,7 +446708,9 @@ ${agent.role}`;
     let hasError = false;
     let errorMessage = "";
     let totalUsage;
+    let latestTotalTokens = 0;
     const collectedInjectedMessages = [];
+    const spawnedChildInstanceIds = /* @__PURE__ */ new Set();
     const sessionApprovedTools = /* @__PURE__ */ new Set();
     while (true) {
       if (abortSignal == null ? void 0 : abortSignal.aborted) {
@@ -445890,7 +446731,6 @@ ${agent.role}`;
         };
       }
       if (instanceId) {
-        const { runningSubAgentTracker: runningSubAgentTracker2 } = await Promise.resolve().then(() => (init_runningSubAgentTracker(), runningSubAgentTracker_exports));
         const injectedMessages = runningSubAgentTracker2.dequeueMessages(instanceId);
         for (const injectedMsg of injectedMessages) {
           collectedInjectedMessages.push(injectedMsg);
@@ -445911,6 +446751,27 @@ ${injectedMsg}`
             });
           }
         }
+        const interAgentMessages = runningSubAgentTracker2.dequeueInterAgentMessages(instanceId);
+        for (const iaMsg of interAgentMessages) {
+          messages.push({
+            role: "user",
+            content: `[Inter-agent message from ${iaMsg.fromAgentName} (${iaMsg.fromAgentId})]
+${iaMsg.content}`
+          });
+          if (onMessage) {
+            onMessage({
+              type: "sub_agent_message",
+              agentId: agent.id,
+              agentName: agent.name,
+              message: {
+                type: "inter_agent_received",
+                fromAgentId: iaMsg.fromAgentId,
+                fromAgentName: iaMsg.fromAgentName,
+                content: iaMsg.content
+              }
+            });
+          }
+        }
       }
       const currentSession = sessionManager.getCurrentSession();
       let config3;
@@ -445981,6 +446842,7 @@ ${injectedMsg}`
         }
         if (event.type === "usage" && event.usage) {
           const eventUsage = event.usage;
+          latestTotalTokens = eventUsage.total_tokens || (eventUsage.prompt_tokens || 0) + (eventUsage.completion_tokens || 0);
           if (!totalUsage) {
             totalUsage = {
               inputTokens: eventUsage.prompt_tokens || 0,
@@ -445998,6 +446860,20 @@ ${injectedMsg}`
               totalUsage.cacheReadInputTokens = (totalUsage.cacheReadInputTokens || 0) + eventUsage.cache_read_input_tokens;
             }
           }
+          if (onMessage && config3.maxContextTokens && latestTotalTokens > 0) {
+            const ctxPct = getContextPercentage(latestTotalTokens, config3.maxContextTokens);
+            onMessage({
+              type: "sub_agent_message",
+              agentId: agent.id,
+              agentName: agent.name,
+              message: {
+                type: "context_usage",
+                percentage: Math.max(1, Math.round(ctxPct)),
+                inputTokens: latestTotalTokens,
+                maxTokens: config3.maxContextTokens
+              }
+            });
+          }
         }
         if (event.type === "content" && event.content) {
           currentContent += event.content;
@@ -446041,7 +446917,129 @@ ${injectedMsg}`
         messages.push(assistantMessage);
         finalResponse = currentContent;
       }
+      if (latestTotalTokens === 0 && config3.maxContextTokens) {
+        latestTotalTokens = countMessagesTokens(messages);
+        if (onMessage && latestTotalTokens > 0) {
+          const ctxPct = getContextPercentage(latestTotalTokens, config3.maxContextTokens);
+          onMessage({
+            type: "sub_agent_message",
+            agentId: agent.id,
+            agentName: agent.name,
+            message: {
+              type: "context_usage",
+              percentage: Math.max(1, Math.round(ctxPct)),
+              inputTokens: latestTotalTokens,
+              maxTokens: config3.maxContextTokens
+            }
+          });
+        }
+      }
+      let justCompressed = false;
+      if (latestTotalTokens > 0 && config3.maxContextTokens) {
+        if (shouldCompressSubAgentContext(latestTotalTokens, config3.maxContextTokens)) {
+          const ctxPercentage = getContextPercentage(latestTotalTokens, config3.maxContextTokens);
+          if (onMessage) {
+            onMessage({
+              type: "sub_agent_message",
+              agentId: agent.id,
+              agentName: agent.name,
+              message: {
+                type: "context_compressing",
+                percentage: Math.round(ctxPercentage)
+              }
+            });
+          }
+          try {
+            const compressionResult = await compressSubAgentContext(messages, latestTotalTokens, config3.maxContextTokens, {
+              model,
+              requestMethod: config3.requestMethod,
+              maxTokens: config3.maxTokens,
+              configProfile: agent.configProfile
+            });
+            if (compressionResult.compressed) {
+              messages.length = 0;
+              messages.push(...compressionResult.messages);
+              justCompressed = true;
+              if (compressionResult.afterTokensEstimate) {
+                latestTotalTokens = compressionResult.afterTokensEstimate;
+              }
+              if (onMessage) {
+                onMessage({
+                  type: "sub_agent_message",
+                  agentId: agent.id,
+                  agentName: agent.name,
+                  message: {
+                    type: "context_compressed",
+                    beforeTokens: compressionResult.beforeTokens,
+                    afterTokensEstimate: compressionResult.afterTokensEstimate
+                  }
+                });
+              }
+              console.log(`[SubAgent:${agent.name}] Context compressed: ${compressionResult.beforeTokens} \u2192 ~${compressionResult.afterTokensEstimate} tokens`);
+            }
+          } catch (compressError) {
+            console.error(`[SubAgent:${agent.name}] Context compression failed:`, compressError);
+          }
+        }
+      }
+      if (justCompressed && toolCalls.length === 0) {
+        while (messages.length > 0 && ((_a21 = messages[messages.length - 1]) == null ? void 0 : _a21.role) === "assistant") {
+          messages.pop();
+        }
+        messages.push({
+          role: "user",
+          content: "[System] Your context has been auto-compressed to free up space. Your task is NOT finished. Continue working based on the compressed context above. Pick up where you left off."
+        });
+        continue;
+      }
       if (toolCalls.length === 0) {
+        const runningChildren = Array.from(spawnedChildInstanceIds).filter((id) => runningSubAgentTracker2.isRunning(id));
+        if (runningChildren.length > 0 || runningSubAgentTracker2.hasSpawnedResults()) {
+          if (runningChildren.length > 0) {
+            await runningSubAgentTracker2.waitForSpawnedAgents(
+              3e5,
+              // 5 min timeout
+              abortSignal
+            );
+          }
+          const spawnedResults = runningSubAgentTracker2.drainSpawnedResults();
+          if (spawnedResults.length > 0) {
+            for (const sr of spawnedResults) {
+              const statusIcon = sr.success ? "\u2713" : "\u2717";
+              const resultSummary = sr.success ? sr.result.length > 800 ? sr.result.substring(0, 800) + "..." : sr.result : sr.error || "Unknown error";
+              messages.push({
+                role: "user",
+                content: `[Spawned Sub-Agent Result] ${statusIcon} ${sr.agentName} (${sr.agentId})
+Prompt: ${sr.prompt}
+Result: ${resultSummary}`
+              });
+              if (onMessage) {
+                onMessage({
+                  type: "sub_agent_message",
+                  agentId: agent.id,
+                  agentName: agent.name,
+                  message: {
+                    type: "spawned_agent_completed",
+                    spawnedAgentId: sr.agentId,
+                    spawnedAgentName: sr.agentName,
+                    success: sr.success
+                  }
+                });
+              }
+            }
+            if (onMessage) {
+              onMessage({
+                type: "sub_agent_message",
+                agentId: agent.id,
+                agentName: agent.name,
+                message: {
+                  type: "done"
+                }
+              });
+            }
+            continue;
+          }
+        }
         try {
           const hookResult = await unifiedHooksExecutor.executeHooks("onSubAgentComplete", {
             agentId: agent.id,
@@ -446095,6 +447093,238 @@ ${injectedMsg}`
         }
         break;
       }
+      const sendMsgTools = toolCalls.filter((tc) => tc.function.name === "send_message_to_agent");
+      if (sendMsgTools.length > 0 && instanceId) {
+        for (const sendMsgTool of sendMsgTools) {
+          let targetAgentId;
+          let targetInstanceId;
+          let msgContent = "";
+          try {
+            const args2 = JSON.parse(sendMsgTool.function.arguments);
+            targetAgentId = args2.target_agent_id;
+            targetInstanceId = args2.target_instance_id;
+            msgContent = args2.message || "";
+          } catch (error) {
+            console.error("Failed to parse send_message_to_agent arguments:", error);
+          }
+          let success = false;
+          let resultText = "";
+          if (!msgContent) {
+            resultText = "Error: message content is empty";
+          } else if (targetInstanceId) {
+            success = runningSubAgentTracker2.sendInterAgentMessage(instanceId, targetInstanceId, msgContent);
+            if (success) {
+              const targetAgent = runningSubAgentTracker2.getRunningAgents().find((a) => a.instanceId === targetInstanceId);
+              resultText = `Message sent to ${(targetAgent == null ? void 0 : targetAgent.agentName) || targetInstanceId}`;
+            } else {
+              resultText = `Error: Target agent instance "${targetInstanceId}" is not running`;
+            }
+          } else if (targetAgentId) {
+            const targetAgent = runningSubAgentTracker2.findInstanceByAgentId(targetAgentId);
+            if (targetAgent && targetAgent.instanceId !== instanceId) {
+              success = runningSubAgentTracker2.sendInterAgentMessage(instanceId, targetAgent.instanceId, msgContent);
+              if (success) {
+                resultText = `Message sent to ${targetAgent.agentName} (instance: ${targetAgent.instanceId})`;
+              } else {
+                resultText = `Error: Failed to send message to ${targetAgentId}`;
+              }
+            } else if (targetAgent && targetAgent.instanceId === instanceId) {
+              resultText = "Error: Cannot send a message to yourself";
+            } else {
+              resultText = `Error: No running agent found with ID "${targetAgentId}"`;
+            }
+          } else {
+            resultText = "Error: Either target_agent_id or target_instance_id must be provided";
+          }
+          const toolResultMessage = {
+            role: "tool",
+            tool_call_id: sendMsgTool.id,
+            content: JSON.stringify({ success, result: resultText })
+          };
+          messages.push(toolResultMessage);
+          if (onMessage) {
+            onMessage({
+              type: "sub_agent_message",
+              agentId: agent.id,
+              agentName: agent.name,
+              message: {
+                type: "inter_agent_sent",
+                targetAgentId: targetAgentId || targetInstanceId || "unknown",
+                targetAgentName: (targetInstanceId ? (_b14 = runningSubAgentTracker2.getRunningAgents().find((a) => a.instanceId === targetInstanceId)) == null ? void 0 : _b14.agentName : targetAgentId ? (_c6 = runningSubAgentTracker2.findInstanceByAgentId(targetAgentId)) == null ? void 0 : _c6.agentName : void 0) || targetAgentId || "unknown",
+                content: msgContent,
+                success
+              }
+            });
+          }
+        }
+        toolCalls = toolCalls.filter((tc) => tc.function.name !== "send_message_to_agent");
+        if (toolCalls.length === 0) {
+          continue;
+        }
+      }
+      const queryStatusTools = toolCalls.filter((tc) => tc.function.name === "query_agents_status");
+      if (queryStatusTools.length > 0) {
+        for (const queryTool of queryStatusTools) {
+          const allAgents = runningSubAgentTracker2.getRunningAgents();
+          const statusList = allAgents.map((a) => ({
+            instanceId: a.instanceId,
+            agentId: a.agentId,
+            agentName: a.agentName,
+            prompt: a.prompt ? a.prompt.substring(0, 150) : "N/A",
+            runningFor: `${Math.floor((Date.now() - a.startedAt.getTime()) / 1e3)}s`,
+            isSelf: a.instanceId === instanceId
+          }));
+          const toolResultMessage = {
+            role: "tool",
+            tool_call_id: queryTool.id,
+            content: JSON.stringify({
+              totalRunning: allAgents.length,
+              agents: statusList
+            })
+          };
+          messages.push(toolResultMessage);
+        }
+        toolCalls = toolCalls.filter((tc) => tc.function.name !== "query_agents_status");
+        if (toolCalls.length === 0) {
+          continue;
+        }
+      }
+      const spawnTools = toolCalls.filter((tc) => tc.function.name === "spawn_sub_agent");
+      if (spawnTools.length > 0 && instanceId) {
+        for (const spawnTool of spawnTools) {
+          let spawnAgentId = "";
+          let spawnPrompt = "";
+          try {
+            const args2 = JSON.parse(spawnTool.function.arguments);
+            spawnAgentId = args2.agent_id || "";
+            spawnPrompt = args2.prompt || "";
+          } catch (error) {
+            console.error("Failed to parse spawn_sub_agent arguments:", error);
+          }
+          if (!spawnAgentId || !spawnPrompt) {
+            const toolResultMessage2 = {
+              role: "tool",
+              tool_call_id: spawnTool.id,
+              content: JSON.stringify({
+                success: false,
+                error: "Both agent_id and prompt are required"
+              })
+            };
+            messages.push(toolResultMessage2);
+            continue;
+          }
+          if (spawnAgentId === agent.id) {
+            const toolResultMessage2 = {
+              role: "tool",
+              tool_call_id: spawnTool.id,
+              content: JSON.stringify({
+                success: false,
+                error: `REJECTED: You (${agent.name}) attempted to spawn another "${spawnAgentId}" which is the SAME type as yourself. This is not allowed because it wastes resources and delegates work you should complete yourself. If you need help from a DIFFERENT specialization, spawn a different agent type. If the task is within your capabilities, do it yourself.`
+              })
+            };
+            messages.push(toolResultMessage2);
+            continue;
+          }
+          let spawnAgentName = spawnAgentId;
+          try {
+            const agentConfig = getSubAgent(spawnAgentId);
+            if (agentConfig) {
+              spawnAgentName = agentConfig.name;
+            }
+          } catch {
+            const builtinNames = {
+              agent_explore: "Explore Agent",
+              agent_plan: "Plan Agent",
+              agent_general: "General Purpose Agent",
+              agent_analyze: "Requirement Analysis Agent",
+              agent_debug: "Debug Assistant"
+            };
+            spawnAgentName = builtinNames[spawnAgentId] || spawnAgentId;
+          }
+          const spawnInstanceId = `spawn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+          const spawnerInfo = {
+            instanceId,
+            agentId: agent.id,
+            agentName: agent.name
+          };
+          spawnedChildInstanceIds.add(spawnInstanceId);
+          runningSubAgentTracker2.register({
+            instanceId: spawnInstanceId,
+            agentId: spawnAgentId,
+            agentName: spawnAgentName,
+            prompt: spawnPrompt,
+            startedAt: /* @__PURE__ */ new Date()
+          });
+          executeSubAgent(
+            spawnAgentId,
+            spawnPrompt,
+            onMessage,
+            // Same UI callback — spawned agent's messages are visible
+            abortSignal,
+            // Same abort signal — ESC stops everything
+            requestToolConfirmation,
+            isToolAutoApproved,
+            yoloMode,
+            addToAlwaysApproved,
+            requestUserQuestion,
+            spawnInstanceId,
+            spawnDepth + 1
+          ).then((result2) => {
+            runningSubAgentTracker2.storeSpawnedResult({
+              instanceId: spawnInstanceId,
+              agentId: spawnAgentId,
+              agentName: spawnAgentName,
+              prompt: spawnPrompt.length > 200 ? spawnPrompt.substring(0, 200) + "..." : spawnPrompt,
+              success: result2.success,
+              result: result2.result,
+              error: result2.error,
+              completedAt: /* @__PURE__ */ new Date(),
+              spawnedBy: spawnerInfo
+            });
+          }).catch((error) => {
+            runningSubAgentTracker2.storeSpawnedResult({
+              instanceId: spawnInstanceId,
+              agentId: spawnAgentId,
+              agentName: spawnAgentName,
+              prompt: spawnPrompt.length > 200 ? spawnPrompt.substring(0, 200) + "..." : spawnPrompt,
+              success: false,
+              result: "",
+              error: error instanceof Error ? error.message : "Unknown error",
+              completedAt: /* @__PURE__ */ new Date(),
+              spawnedBy: spawnerInfo
+            });
+          }).finally(() => {
+            runningSubAgentTracker2.unregister(spawnInstanceId);
+          });
+          if (onMessage) {
+            onMessage({
+              type: "sub_agent_message",
+              agentId: agent.id,
+              agentName: agent.name,
+              message: {
+                type: "agent_spawned",
+                spawnedAgentId: spawnAgentId,
+                spawnedAgentName: spawnAgentName,
+                spawnedInstanceId: spawnInstanceId,
+                spawnedPrompt: spawnPrompt
+              }
+            });
+          }
+          const toolResultMessage = {
+            role: "tool",
+            tool_call_id: spawnTool.id,
+            content: JSON.stringify({
+              success: true,
+              result: `Agent "${spawnAgentName}" (${spawnAgentId}) has been spawned and is now running in the background with instance ID "${spawnInstanceId}". Its results will be automatically reported to the main workflow when it completes.`
+            })
+          };
+          messages.push(toolResultMessage);
+        }
+        toolCalls = toolCalls.filter((tc) => tc.function.name !== "spawn_sub_agent");
+        if (toolCalls.length === 0) {
+          continue;
+        }
+      }
       const askUserTool = toolCalls.find((tc) => tc.function.name.startsWith("askuser-"));
       if (askUserTool && requestUserQuestion) {
         let question = "Please select an option:";
@@ -446291,6 +447521,7 @@ ${injectedMsg}`
     };
   }
 }
+var MAX_SPAWN_DEPTH;
 var init_subAgentExecutor = __esm({
   "dist/utils/execution/subAgentExecutor.js"() {
     "use strict";
@@ -446304,6 +447535,8 @@ var init_subAgentExecutor = __esm({
     init_sessionManager();
     init_unifiedHooksExecutor();
     init_yoloPermissionChecker();
+    init_subAgentContextCompressor();
+    MAX_SPAWN_DEPTH = 1;
   }
 });
 
@@ -453611,6 +454844,12 @@ var init_LSPClient = __esm({
           writable: true,
           value: false
         });
+        Object.defineProperty(this, "isProcessAlive", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: false
+        });
         Object.defineProperty(this, "openDocuments", {
           enumerable: true,
           configurable: true,
@@ -453661,6 +454900,7 @@ var init_LSPClient = __esm({
         }
       }
       async start() {
+        var _a21;
         if (this.isInitialized) {
           return;
         }
@@ -453683,17 +454923,34 @@ var init_LSPClient = __esm({
             stdio: ["pipe", "pipe", "pipe"],
             cwd: this.config.rootPath
           });
+          this.isProcessAlive = true;
+          this.process.on("exit", () => {
+            this.isProcessAlive = false;
+          });
+          this.process.on("error", () => {
+            this.isProcessAlive = false;
+          });
+          (_a21 = this.process.stdin) == null ? void 0 : _a21.on("error", () => {
+            this.isProcessAlive = false;
+          });
           processManager.register(this.process);
           this.connection = (0, import_node.createMessageConnection)(new import_node.StreamMessageReader(this.process.stdout), new import_node.StreamMessageWriter(this.process.stdin));
+          this.connection.onError(([error]) => {
+            console.debug("LSP connection error:", (error == null ? void 0 : error.message) || error);
+          });
+          this.connection.onClose(() => {
+            this.isInitialized = false;
+            this.isProcessAlive = false;
+          });
           this.connection.onRequest("window/workDoneProgress/create", () => null);
           this.connection.onRequest("client/registerCapability", () => null);
           this.connection.onRequest("workspace/configuration", () => []);
           this.connection.onNotification("window/logMessage", (params) => {
-            var _a21;
+            var _a22;
             const message = typeof (params == null ? void 0 : params.message) === "string" ? params.message : "";
             if (!this.csharpSolutionLoaded && message.includes("Finished loading solution")) {
               this.csharpSolutionLoaded = true;
-              (_a21 = this.resolveCsharpSolutionLoad) == null ? void 0 : _a21.call(this);
+              (_a22 = this.resolveCsharpSolutionLoad) == null ? void 0 : _a22.call(this);
             }
           });
           this.connection.onNotification("window/showMessage", (_params) => {
@@ -453765,11 +455022,23 @@ var init_LSPClient = __esm({
           return;
         }
         try {
-          for (const uri of this.openDocuments) {
-            await this.closeDocument(uri);
+          if (this.isProcessAlive) {
+            for (const uri of [...this.openDocuments]) {
+              try {
+                await this.closeDocument(uri);
+              } catch {
+                break;
+              }
+            }
+            try {
+              await this.connection.sendRequest("shutdown", null);
+            } catch {
+            }
+            try {
+              await this.connection.sendNotification("exit", null);
+            } catch {
+            }
           }
-          await this.connection.sendRequest("shutdown", null);
-          await this.connection.sendNotification("exit", null);
         } catch (error) {
           console.debug("Error during LSP shutdown:", error);
         } finally {
@@ -453778,14 +455047,21 @@ var init_LSPClient = __esm({
       }
       async cleanup() {
         if (this.connection) {
-          this.connection.dispose();
+          try {
+            this.connection.dispose();
+          } catch {
+          }
           this.connection = void 0;
         }
         if (this.process) {
-          this.process.kill();
+          try {
+            this.process.kill();
+          } catch {
+          }
           this.process = void 0;
         }
         this.isInitialized = false;
+        this.isProcessAlive = false;
         this.openDocuments.clear();
         this.documentVersions.clear();
       }
@@ -453942,7 +455218,7 @@ var init_LSPClient = __esm({
         return this.capabilities;
       }
       isReady() {
-        return this.isInitialized;
+        return this.isInitialized && this.isProcessAlive;
       }
     };
   }
@@ -454190,6 +455466,11 @@ var init_LSPManager = __esm({
           if (client.isReady()) {
             return client;
           }
+          try {
+            await client.shutdown();
+          } catch {
+          }
+          this.clients.delete(language);
         }
         const config3 = LSPServerRegistry.getConfig(language);
         if (!config3) {
@@ -454653,8 +455934,8 @@ async function validateTokenLimit(content, maxTokens) {
     contentStr = String(contentWithoutImages);
   }
   try {
-    const { encoding_for_model: encoding_for_model2 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
-    const encoder = encoding_for_model2("gpt-4o");
+    const { encoding_for_model: encoding_for_model3 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
+    const encoder = encoding_for_model3("gpt-4o");
     try {
       const tokens2 = encoder.encode(contentStr);
       const tokenCount = tokens2.length;
@@ -454687,8 +455968,8 @@ Tip: Consider breaking down the operation into smaller chunks or filtering the d
 }
 async function truncateToTokenLimit(content, maxTokens) {
   try {
-    const { encoding_for_model: encoding_for_model2 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
-    const encoder = encoding_for_model2("gpt-4o");
+    const { encoding_for_model: encoding_for_model3 } = await Promise.resolve().then(() => __toESM(require_tiktoken(), 1));
+    const encoder = encoding_for_model3("gpt-4o");
     try {
       const tokens2 = encoder.encode(content);
       if (tokens2.length <= maxTokens) {
@@ -455804,19 +457085,48 @@ ${combinedOutput}`);
   result2 = await wrapToolResultWithTokenLimit2(result2, toolName);
   return result2;
 }
+function isConnectionError(error) {
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("stream") || msg.includes("destroyed") || msg.includes("closed") || msg.includes("ended") || msg.includes("econnreset") || msg.includes("econnrefused") || msg.includes("epipe") || msg.includes("not connected") || msg.includes("transport") || error.code === "ERR_STREAM_DESTROYED";
+  }
+  return false;
+}
 async function executeOnExternalMCPService(serviceName, server, toolName, args2) {
-  const client = await getPersistentClient(serviceName, server);
-  logger.debug(`Using persistent MCP client for ${serviceName} tool ${toolName}`);
-  const timeout2 = server.timeout ?? 3e5;
-  const result2 = await client.callTool({
-    name: toolName,
-    arguments: args2
-  }, void 0, {
-    timeout: timeout2,
-    resetTimeoutOnProgress: true
-  });
-  logger.debug(`result from ${serviceName} tool ${toolName}:`, result2);
-  return result2.content;
+  let retried = false;
+  const attemptCall = async () => {
+    const client = await getPersistentClient(serviceName, server);
+    logger.debug(`Using persistent MCP client for ${serviceName} tool ${toolName}`);
+    const timeout2 = server.timeout ?? 3e5;
+    const result2 = await client.callTool({
+      name: toolName,
+      arguments: args2
+    }, void 0, {
+      timeout: timeout2,
+      resetTimeoutOnProgress: true
+    });
+    logger.debug(`result from ${serviceName} tool ${toolName}:`, result2);
+    return result2.content;
+  };
+  try {
+    return await attemptCall();
+  } catch (error) {
+    if (!retried && isConnectionError(error)) {
+      retried = true;
+      logger.info(`Connection error for ${serviceName}, reconnecting and retrying...`);
+      const clientInfo = persistentClients.get(serviceName);
+      if (clientInfo) {
+        try {
+          await clientInfo.client.close();
+        } catch {
+        }
+        resourceMonitor.trackMCPConnectionClosed(serviceName);
+        persistentClients.delete(serviceName);
+      }
+      return await attemptCall();
+    }
+    throw error;
+  }
 }
 var toolsCache, CACHE_DURATION, todoService, persistentClients, CLIENT_IDLE_TIMEOUT;
 var init_mcpToolsManager = __esm({
@@ -549841,11 +551151,29 @@ function MessageRenderer({ message, index, filteredMessages, terminalWidth, show
               const lines = content.split("\n");
               const titleLine = lines[0] || "";
               const treeLines = lines.slice(1);
+              const ctxUsage = message.subAgentContextUsage;
+              const showCtxBar = ctxUsage && ctxUsage.percentage > 0;
               return import_react79.default.createElement(
                 import_react79.default.Fragment,
                 null,
                 import_react79.default.createElement(Text, { color: toolStatusColor }, removeAnsiCodes2(titleLine)),
-                treeLines.length > 0 && import_react79.default.createElement(Text, { color: theme14.colors.menuSecondary }, treeLines.map((line) => removeAnsiCodes2(line || "")).join("\n"))
+                treeLines.length > 0 && import_react79.default.createElement(Text, { color: theme14.colors.menuSecondary }, treeLines.map((line) => removeAnsiCodes2(line || "")).join("\n")),
+                showCtxBar && (() => {
+                  const pct = ctxUsage.percentage;
+                  const barWidth = 10;
+                  const filled = Math.round(pct / 100 * barWidth);
+                  const empty = barWidth - filled;
+                  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+                  const barColor = pct >= 80 ? "red" : pct >= 65 ? "yellow" : pct >= 50 ? "cyan" : "gray";
+                  return import_react79.default.createElement(
+                    Text,
+                    { color: barColor, dimColor: true },
+                    "\u2514\u2500 Context: ",
+                    pct,
+                    "% ",
+                    bar
+                  );
+                })()
               );
             }
             return import_react79.default.createElement(
@@ -559837,7 +561165,7 @@ var init_CustomCommandExecutionDisplay = __esm({
 });
 
 // dist/ui/components/tools/FileRollbackConfirmation.js
-function FileRollbackConfirmation({ fileCount, filePaths, previewSessionId, previewTargetMessageIndex, onConfirm }) {
+function FileRollbackConfirmation({ fileCount, filePaths, notebookCount, previewSessionId, previewTargetMessageIndex, onConfirm }) {
   const { t } = useI18n();
   const [selectedIndex, setSelectedIndex] = (0, import_react117.useState)(0);
   const [showFullList, setShowFullList] = (0, import_react117.useState)(false);
@@ -560060,6 +561388,11 @@ function FileRollbackConfirmation({ fileCount, filePaths, previewSessionId, prev
         remainingCountCompact > 1 ? "s" : ""
       )
     ),
+    notebookCount !== void 0 && notebookCount > 0 && import_react117.default.createElement(
+      Box_default,
+      { marginBottom: 1, marginLeft: 2 },
+      import_react117.default.createElement(Text, { color: "magenta" }, t.fileRollback.notebookCount.replace("{count}", String(notebookCount)))
+    ),
     !showFullList && import_react117.default.createElement(
       import_react117.default.Fragment,
       null,
@@ -565227,6 +566560,9 @@ function getToolResourceType(toolName) {
   if (toolName === "todo-update" || toolName === "todo-add" || toolName === "todo-delete") {
     return "todo-state";
   }
+  if (toolName === "notebook-add" || toolName === "notebook-update" || toolName === "notebook-delete" || toolName === "notebook-list" || toolName === "notebook-query") {
+    return "notebook-state";
+  }
   if (toolName === "terminal-execute") {
     return "terminal-execution";
   }
@@ -565241,6 +566577,9 @@ function getResourceIdentifier(toolCall) {
   if (resourceType === "todo-state") {
     return "todo-state";
   }
+  if (resourceType === "notebook-state") {
+    return "notebook-state";
+  }
   if (resourceType === "terminal-execution") {
     return "terminal-execution";
   }
@@ -565447,7 +566786,7 @@ function cleanOrphanedToolCalls(messages) {
     console.log(`[contextCompressor:cleanOrphanedToolCalls] Removed ${indicesToRemove.length} orphaned messages from compression input`);
   }
 }
-function formatMessageForTranscript(msg) {
+function formatMessageForTranscript2(msg) {
   var _a21, _b14;
   if (msg.role === "tool") {
     return null;
@@ -565504,7 +566843,7 @@ function prepareMessagesForCompression(conversationMessages, customSystemPrompt)
     if (msg.role === "system") {
       continue;
     }
-    const formatted = formatMessageForTranscript(msg);
+    const formatted = formatMessageForTranscript2(msg);
     if (formatted) {
       transcriptParts.push(formatted);
     }
@@ -567314,6 +568653,14 @@ var useConversation_exports = {};
 __export(useConversation_exports, {
   handleConversationWithTools: () => handleConversationWithTools
 });
+function formatTokenCount(tokens2) {
+  if (!tokens2)
+    return "0";
+  if (tokens2 >= 1e3) {
+    return `${(tokens2 / 1e3).toFixed(1)}K`;
+  }
+  return String(tokens2);
+}
 async function handleConversationWithTools(options3) {
   const {
     userContent,
@@ -567379,10 +568726,10 @@ async function handleConversationWithTools(options3) {
     }
   };
   try {
-    encoder = (0, import_tiktoken.encoding_for_model)("gpt-5");
+    encoder = (0, import_tiktoken2.encoding_for_model)("gpt-5");
     resourceMonitor.trackEncoderCreated();
   } catch (e) {
-    encoder = (0, import_tiktoken.encoding_for_model)("gpt-3.5-turbo");
+    encoder = (0, import_tiktoken2.encoding_for_model)("gpt-3.5-turbo");
     resourceMonitor.trackEncoderCreated();
   }
   setStreamTokenCount(0);
@@ -567677,18 +569024,147 @@ async function handleConversationWithTools(options3) {
         let subAgentTokenCount = 0;
         let lastSubAgentFlushTime = 0;
         const SUB_AGENT_FLUSH_INTERVAL = 100;
+        const latestSubAgentCtxUsage = {};
         const toolResults = await executeToolCalls(
           approvedTools,
           controller.signal,
           setStreamTokenCount,
           async (subAgentMessage) => {
             setMessages((prev) => {
+              var _a21;
+              if (subAgentMessage.message.type === "context_usage") {
+                const ctxData = {
+                  percentage: subAgentMessage.message.percentage,
+                  inputTokens: subAgentMessage.message.inputTokens,
+                  maxTokens: subAgentMessage.message.maxTokens
+                };
+                latestSubAgentCtxUsage[subAgentMessage.agentId] = ctxData;
+                let targetIndex = -1;
+                for (let i = prev.length - 1; i >= 0; i--) {
+                  const m = prev[i];
+                  if (m && m.role === "subagent" && ((_a21 = m.subAgent) == null ? void 0 : _a21.agentId) === subAgentMessage.agentId) {
+                    targetIndex = i;
+                    break;
+                  }
+                }
+                if (targetIndex !== -1) {
+                  const updated = [...prev];
+                  const existing = updated[targetIndex];
+                  if (existing) {
+                    updated[targetIndex] = {
+                      ...existing,
+                      subAgentContextUsage: ctxData
+                    };
+                  }
+                  return updated;
+                }
+                return prev;
+              }
+              if (subAgentMessage.message.type === "context_compressing") {
+                const uiMsg = {
+                  role: "subagent",
+                  content: `\x1B[36m\u2687 ${subAgentMessage.agentName}\x1B[0m \x1B[33m\u2735 Auto-compressing context (${subAgentMessage.message.percentage}%)...\x1B[0m`,
+                  streaming: false,
+                  subAgent: {
+                    agentId: subAgentMessage.agentId,
+                    agentName: subAgentMessage.agentName,
+                    isComplete: false
+                  },
+                  subAgentInternal: true
+                };
+                return [...prev, uiMsg];
+              }
+              if (subAgentMessage.message.type === "context_compressed") {
+                const msg = subAgentMessage.message;
+                const uiMsg = {
+                  role: "subagent",
+                  content: `\x1B[36m\u2687 ${subAgentMessage.agentName}\x1B[0m \x1B[32m\u2735 Context compressed (~${formatTokenCount(msg.beforeTokens)} \u2192 ~${formatTokenCount(msg.afterTokensEstimate)})\x1B[0m`,
+                  streaming: false,
+                  messageStatus: "success",
+                  subAgent: {
+                    agentId: subAgentMessage.agentId,
+                    agentName: subAgentMessage.agentName,
+                    isComplete: false
+                  },
+                  subAgentInternal: true
+                };
+                return [...prev, uiMsg];
+              }
+              if (subAgentMessage.message.type === "inter_agent_sent") {
+                const msg = subAgentMessage.message;
+                const statusIcon = msg.success ? "\u2192" : "\u2717";
+                const targetName = msg.targetAgentName || msg.targetAgentId;
+                const truncatedContent = msg.content.length > 80 ? msg.content.substring(0, 80) + "..." : msg.content;
+                const uiMsg = {
+                  role: "subagent",
+                  content: `\x1B[38;2;255;165;0m\u2687${statusIcon} [${subAgentMessage.agentName}] \u2192 [${targetName}]\x1B[0m: ${truncatedContent}`,
+                  streaming: false,
+                  messageStatus: msg.success ? "success" : "error",
+                  subAgent: {
+                    agentId: subAgentMessage.agentId,
+                    agentName: subAgentMessage.agentName,
+                    isComplete: false
+                  },
+                  subAgentInternal: true
+                };
+                return [...prev, uiMsg];
+              }
+              if (subAgentMessage.message.type === "inter_agent_received") {
+                return prev;
+              }
+              if (subAgentMessage.message.type === "agent_spawned") {
+                const msg = subAgentMessage.message;
+                const promptText = msg.spawnedPrompt ? msg.spawnedPrompt.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim() : "";
+                const truncatedPrompt = promptText.length > 100 ? promptText.substring(0, 100) + "..." : promptText;
+                const promptLine = truncatedPrompt ? `
+  \x1B[2m\u2514\u2500 prompt: "${truncatedPrompt}"\x1B[0m` : "";
+                const uiMsg = {
+                  role: "subagent",
+                  content: `\x1B[38;2;150;120;255m\u2687\u2295 [${subAgentMessage.agentName}] spawned [${msg.spawnedAgentName}]\x1B[0m${promptLine}`,
+                  streaming: false,
+                  messageStatus: "success",
+                  subAgent: {
+                    agentId: subAgentMessage.agentId,
+                    agentName: subAgentMessage.agentName,
+                    isComplete: false
+                  },
+                  subAgentInternal: true
+                };
+                return [...prev, uiMsg];
+              }
+              if (subAgentMessage.message.type === "spawned_agent_completed") {
+                const msg = subAgentMessage.message;
+                const statusIcon = msg.success ? "\u2713" : "\u2717";
+                const uiMsg = {
+                  role: "subagent",
+                  content: `\x1B[38;2;150;120;255m\u2687${statusIcon} Spawned [${msg.spawnedAgentName}] completed\x1B[0m (parent: ${subAgentMessage.agentName})`,
+                  streaming: false,
+                  messageStatus: msg.success ? "success" : "error",
+                  subAgent: {
+                    agentId: subAgentMessage.agentId,
+                    agentName: subAgentMessage.agentName,
+                    isComplete: false
+                  },
+                  subAgentInternal: true
+                };
+                return [...prev, uiMsg];
+              }
               if (subAgentMessage.message.type === "tool_calls") {
                 const toolCalls = subAgentMessage.message.tool_calls;
                 if (toolCalls && toolCalls.length > 0) {
-                  const timeConsumingTools = toolCalls.filter((tc) => isToolNeedTwoStepDisplay(tc.function.name));
-                  const quickTools = toolCalls.filter((tc) => !isToolNeedTwoStepDisplay(tc.function.name));
+                  const internalAgentTools = /* @__PURE__ */ new Set([
+                    "send_message_to_agent",
+                    "query_agents_status",
+                    "spawn_sub_agent"
+                  ]);
+                  const displayableToolCalls = toolCalls.filter((tc) => !internalAgentTools.has(tc.function.name));
+                  if (displayableToolCalls.length === 0) {
+                    return prev;
+                  }
+                  const timeConsumingTools = displayableToolCalls.filter((tc) => isToolNeedTwoStepDisplay(tc.function.name));
+                  const quickTools = displayableToolCalls.filter((tc) => !isToolNeedTwoStepDisplay(tc.function.name));
                   const newMessages = [];
+                  const inheritedCtxUsage = latestSubAgentCtxUsage[subAgentMessage.agentId];
                   for (const toolCall of timeConsumingTools) {
                     const toolDisplay = formatToolCallMessage(toolCall);
                     let toolArgs;
@@ -567720,7 +569196,8 @@ async function handleConversationWithTools(options3) {
                         agentName: subAgentMessage.agentName,
                         isComplete: false
                       },
-                      subAgentInternal: true
+                      subAgentInternal: true,
+                      subAgentContextUsage: inheritedCtxUsage
                     };
                     newMessages.push(uiMsg);
                   }
@@ -567744,7 +569221,8 @@ async function handleConversationWithTools(options3) {
                       },
                       subAgentInternal: true,
                       // Store pending tool call IDs for later status update
-                      pendingToolIds: quickTools.map((tc) => tc.id)
+                      pendingToolIds: quickTools.map((tc) => tc.id),
+                      subAgentContextUsage: inheritedCtxUsage
                     };
                     newMessages.push(uiMsg);
                   }
@@ -567863,8 +569341,8 @@ async function handleConversationWithTools(options3) {
                   return [...prev, uiMsg];
                 }
                 const pendingMsgIndex = prev.findIndex((m) => {
-                  var _a21, _b14, _c6;
-                  return m.role === "subagent" && ((_a21 = m.subAgent) == null ? void 0 : _a21.agentId) === subAgentMessage.agentId && !((_b14 = m.subAgent) == null ? void 0 : _b14.isComplete) && ((_c6 = m.pendingToolIds) == null ? void 0 : _c6.includes(msg.tool_call_id));
+                  var _a22, _b14, _c6;
+                  return m.role === "subagent" && ((_a22 = m.subAgent) == null ? void 0 : _a22.agentId) === subAgentMessage.agentId && !((_b14 = m.subAgent) == null ? void 0 : _b14.isComplete) && ((_c6 = m.pendingToolIds) == null ? void 0 : _c6.includes(msg.tool_call_id));
                 });
                 if (pendingMsgIndex !== -1) {
                   const updated = [...prev];
@@ -567881,8 +569359,8 @@ async function handleConversationWithTools(options3) {
                 return prev;
               }
               const existingIndex = prev.findIndex((m) => {
-                var _a21, _b14;
-                return m.role === "subagent" && ((_a21 = m.subAgent) == null ? void 0 : _a21.agentId) === subAgentMessage.agentId && !((_b14 = m.subAgent) == null ? void 0 : _b14.isComplete) && m.streaming === true && !m.pendingToolIds;
+                var _a22, _b14;
+                return m.role === "subagent" && ((_a22 = m.subAgent) == null ? void 0 : _a22.agentId) === subAgentMessage.agentId && !((_b14 = m.subAgent) == null ? void 0 : _b14.isComplete) && m.streaming === true && !m.pendingToolIds;
               });
               let contentToApply = "";
               if (subAgentMessage.message.type === "content") {
@@ -568146,6 +569624,46 @@ async function handleConversationWithTools(options3) {
         if (resultMessages.length > 0) {
           setMessages((prev) => [...prev, ...resultMessages]);
         }
+        try {
+          const { runningSubAgentTracker: runningSubAgentTracker2 } = await Promise.resolve().then(() => (init_runningSubAgentTracker(), runningSubAgentTracker_exports));
+          const spawnedResults = runningSubAgentTracker2.drainSpawnedResults();
+          if (spawnedResults.length > 0) {
+            for (const sr of spawnedResults) {
+              const statusIcon = sr.success ? "\u2713" : "\u2717";
+              const resultSummary = sr.success ? sr.result.length > 500 ? sr.result.substring(0, 500) + "..." : sr.result : sr.error || "Unknown error";
+              const spawnedContent = `[Spawned Sub-Agent Result] ${statusIcon} ${sr.agentName} (${sr.agentId}) \u2014 spawned by ${sr.spawnedBy.agentName}
+Prompt: ${sr.prompt}
+Result: ${resultSummary}`;
+              conversationMessages.push({
+                role: "user",
+                content: spawnedContent
+              });
+              try {
+                await saveMessage({
+                  role: "user",
+                  content: spawnedContent
+                });
+              } catch (error) {
+                console.error("Failed to save spawned agent result:", error);
+              }
+              const uiMsg = {
+                role: "subagent",
+                content: `\x1B[38;2;150;120;255m\u2687${statusIcon} Spawned ${sr.agentName}\x1B[0m (by ${sr.spawnedBy.agentName}): ${sr.success ? "completed" : "failed"}`,
+                streaming: false,
+                messageStatus: sr.success ? "success" : "error",
+                subAgent: {
+                  agentId: sr.agentId,
+                  agentName: sr.agentName,
+                  isComplete: true
+                },
+                subAgentInternal: true
+              };
+              setMessages((prev) => [...prev, uiMsg]);
+            }
+          }
+        } catch (error) {
+          console.error("Failed to process spawned agent results:", error);
+        }
         if (options3.getPendingMessages && options3.clearPendingMessages) {
           const pendingMessages = options3.getPendingMessages();
           if (pendingMessages.length > 0) {
@@ -568338,11 +569856,11 @@ async function handleConversationWithTools(options3) {
   }
   return { usage: accumulatedUsage };
 }
-var import_tiktoken;
+var import_tiktoken2;
 var init_useConversation = __esm({
   async "dist/hooks/conversation/useConversation.js"() {
     "use strict";
-    import_tiktoken = __toESM(require_tiktoken(), 1);
+    import_tiktoken2 = __toESM(require_tiktoken(), 1);
     init_chat();
     init_responses();
     init_gemini();
@@ -571862,10 +573380,12 @@ ${errorMsg}`,
       }
       if (totalFileCount > 0) {
         const filePaths2 = await hashBasedSnapshotManager.getFilesToRollback(currentSession.id, selectedIndex);
+        const nbCount2 = getNotebookRollbackCount(currentSession.id, selectedIndex);
         snapshotState.setPendingRollback({
           messageIndex: selectedIndex,
           fileCount: filePaths2.length,
           filePaths: filePaths2,
+          notebookCount: nbCount2,
           message: cleanIDEContext(message),
           images,
           crossSessionRollback: true,
@@ -571898,11 +573418,13 @@ ${errorMsg}`,
       }
     }
     const filePaths = await hashBasedSnapshotManager.getFilesToRollback(currentSession.id, selectedIndex);
-    if (filePaths.length > 0) {
+    const nbCount = getNotebookRollbackCount(currentSession.id, selectedIndex);
+    if (filePaths.length > 0 || nbCount > 0) {
       snapshotState.setPendingRollback({
         messageIndex: selectedIndex,
         fileCount: filePaths.length,
         filePaths,
+        notebookCount: nbCount,
         message: cleanIDEContext(message),
         images
       });
@@ -571923,6 +573445,11 @@ ${errorMsg}`,
       } else {
         await hashBasedSnapshotManager.rollbackToMessageIndex(currentSession.id, selectedIndex);
       }
+      try {
+        rollbackNotebooks(currentSession.id, selectedIndex);
+      } catch (error) {
+        console.error("Failed to rollback notebooks:", error);
+      }
     }
     if (currentSession) {
       const messagesAfterSelected = messages.slice(selectedIndex);
@@ -571960,6 +573487,7 @@ ${errorMsg}`,
       }
       if (sessionTruncateIndex === 0 && currentSession) {
         await hashBasedSnapshotManager.clearAllSnapshots(currentSession.id);
+        clearAllNotebookSnapshots(currentSession.id);
         await sessionManager.deleteSession(currentSession.id);
         sessionManager.clearCurrentSession();
         setMessages([]);
@@ -571972,6 +573500,9 @@ ${errorMsg}`,
         return;
       }
       await hashBasedSnapshotManager.deleteSnapshotsFromIndex(currentSession.id, selectedIndex);
+      if (!rollbackFiles) {
+        deleteNotebookSnapshotsFromIndex(currentSession.id, selectedIndex);
+      }
       const snapshots = await hashBasedSnapshotManager.listSnapshots(currentSession.id);
       const counts = /* @__PURE__ */ new Map();
       for (const snapshot of snapshots) {
@@ -572337,6 +573868,7 @@ var init_useChatLogic = __esm({
     init_vscodeConnection();
     init_reindexCodebase();
     init_runningSubAgentTracker();
+    init_notebookManager();
   }
 });
 
@@ -573918,7 +575450,7 @@ function ChatScreen({ autoResume, enableYolo, enablePlan }) {
         import_react143.default.createElement(PermissionsPanel2, { alwaysApprovedTools, onRemoveTool: removeFromAlwaysApproved, onClearAll: clearAllAlwaysApproved, onClose: () => setShowPermissionsPanel(false) })
       )
     ),
-    snapshotState.pendingRollback && import_react143.default.createElement(FileRollbackConfirmation, { fileCount: snapshotState.pendingRollback.fileCount, filePaths: snapshotState.pendingRollback.filePaths || [], previewSessionId: (_a21 = sessionManager.getCurrentSession()) == null ? void 0 : _a21.id, previewTargetMessageIndex: snapshotState.pendingRollback.messageIndex, onConfirm: handleRollbackConfirm }),
+    snapshotState.pendingRollback && import_react143.default.createElement(FileRollbackConfirmation, { fileCount: snapshotState.pendingRollback.fileCount, filePaths: snapshotState.pendingRollback.filePaths || [], notebookCount: snapshotState.pendingRollback.notebookCount, previewSessionId: (_a21 = sessionManager.getCurrentSession()) == null ? void 0 : _a21.id, previewTargetMessageIndex: snapshotState.pendingRollback.messageIndex, onConfirm: handleRollbackConfirm }),
     !pendingToolConfirmation && !pendingUserQuestion && !bashSensitiveCommand && !terminalExecutionState.state.needsInput && !(panelState.showSessionPanel || panelState.showMcpPanel || panelState.showUsagePanel || panelState.showModelsPanel || panelState.showCustomCommandConfig || panelState.showSkillsCreation || panelState.showRoleCreation || panelState.showRoleDeletion || panelState.showRoleList || panelState.showWorkingDirPanel || panelState.showBranchPanel || showPermissionsPanel) && !snapshotState.pendingRollback && import_react143.default.createElement(ChatFooter, { onSubmit: handleMessageSubmit, onCommand: handleCommandExecution, onHistorySelect: handleHistorySelect, onSwitchProfile: handleSwitchProfile, handleProfileSelect, handleHistorySelect, showReviewCommitPanel: panelState.showReviewCommitPanel, setShowReviewCommitPanel: panelState.setShowReviewCommitPanel, onReviewCommitConfirm: handleReviewCommitConfirm, disabled: !!pendingToolConfirmation || !!bashSensitiveCommand || isExecutingTerminalCommand || isCompressing || streamingState.isStopping, isStopping: streamingState.isStopping, isProcessing: streamingState.isStreaming || isSaving || bashMode.state.isExecuting || isCompressing, chatHistory: messages, yoloMode, setYoloMode, planMode, setPlanMode, vulnerabilityHuntingMode, setVulnerabilityHuntingMode, contextUsage: streamingState.contextUsage ? {
       inputTokens: streamingState.contextUsage.prompt_tokens,
       maxContextTokens: getOpenAiConfig().maxContextTokens || 4e3,