@pensar/apex 0.0.14 → 0.0.16

package/build/benchmark.js

@@ -44495,6 +44495,143 @@ function saveSubagentMessages(orchestratorSession, subagentId, messages) {
   fs.writeFileSync(`${subagentDir}/messages.json`, JSON.stringify(messages, null, 2));
 }
 
+// node_modules/yocto-queue/index.js
+class Node {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  validateConcurrency(concurrency);
+  const queue = new Queue;
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue()();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve2, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve2(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve2, arguments_) => {
+    new Promise((internalResolve) => {
+      queue.enqueue(internalResolve);
+    }).then(run.bind(undefined, function_, resolve2, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve2) => {
+    enqueue(function_, resolve2, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
 // src/core/agent/thoroughPentestAgent/agent.ts
 function runAgent3(opts) {
   const {
@@ -44608,9 +44745,13 @@ Objective: ${objective}`,
             currentAssistantText += delta.text;
             const lastMessage = allMessages[allMessages.length - 1];
             if (lastMessage && lastMessage.role === "assistant") {
-              lastMessage.content = currentAssistantText;
+              const updatedMessage = {
+                ...lastMessage,
+                content: currentAssistantText
+              };
+              allMessages[allMessages.length - 1] = updatedMessage;
               if (onSubagentMessage) {
-                onSubagentMessage(subagentId, lastMessage);
+                onSubagentMessage(subagentId, updatedMessage);
               }
             } else {
               const newMessage = {
@@ -44644,10 +44785,14 @@ Objective: ${objective}`,
             const existingToolMessageIndex = allMessages.findIndex((msg) => msg.role === "tool" && msg.toolCallId === delta.toolCallId);
             if (existingToolMessageIndex !== -1) {
               const existingMessage = allMessages[existingToolMessageIndex];
-              existingMessage.status = "completed";
-              existingMessage.content = delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`;
+              const updatedMessage = {
+                ...existingMessage,
+                status: "completed",
+                content: delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`
+              };
+              allMessages[existingToolMessageIndex] = updatedMessage;
               if (onSubagentMessage) {
-                onSubagentMessage(subagentId, existingMessage);
+                onSubagentMessage(subagentId, updatedMessage);
               }
             }
           }
@@ -44735,7 +44880,8 @@ You can spawn multiple agents in parallel - they will run concurrently.`,
     execute: async ({ targets }) => {
       try {
         logger?.log(`[Orchestrator] Spawning ${targets.length} pentest agents...`);
-        const promises = targets.map(async (targetInfo, index) => {
+        const limit = pLimit(5);
+        const promises = targets.map((targetInfo, index) => limit(async () => {
           try {
             const { streamResult: result } = runAgent({
               session,
@@ -44775,9 +44921,13 @@ Objective: ${targetInfo.objective}`,
                 currentAssistantText += delta.text;
                 const lastMessage = allMessages[allMessages.length - 1];
                 if (lastMessage && lastMessage.role === "assistant") {
-                  lastMessage.content = currentAssistantText;
+                  const updatedMessage = {
+                    ...lastMessage,
+                    content: currentAssistantText
+                  };
+                  allMessages[allMessages.length - 1] = updatedMessage;
                   if (onSubagentMessage) {
-                    onSubagentMessage(subagentId, lastMessage);
+                    onSubagentMessage(subagentId, updatedMessage);
                   }
                 } else {
                   const newMessage = {
@@ -44811,10 +44961,14 @@ Objective: ${targetInfo.objective}`,
                 const existingToolMessageIndex = allMessages.findIndex((msg) => msg.role === "tool" && msg.toolCallId === delta.toolCallId);
                 if (existingToolMessageIndex !== -1) {
                   const existingMessage = allMessages[existingToolMessageIndex];
-                  existingMessage.status = "completed";
-                  existingMessage.content = delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`;
+                  const updatedMessage = {
+                    ...existingMessage,
+                    status: "completed",
+                    content: delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`
+                  };
+                  allMessages[existingToolMessageIndex] = updatedMessage;
                   if (onSubagentMessage) {
-                    onSubagentMessage(subagentId, existingMessage);
+                    onSubagentMessage(subagentId, updatedMessage);
                   }
                 }
               }
@@ -44855,7 +45009,7 @@ Objective: ${targetInfo.objective}`,
               error: error46.message
             };
           }
-        });
+        }));
         const results = await Promise.all(promises);
         const successful = results.filter((r) => r.success).length;
         const failed = results.filter((r) => !r.success).length;

package/build/index.js

@@ -74997,32 +74997,24 @@ var Qt = b.parse;
 var Ut = x.lex;
 
 // src/tui/components/agent-display.tsx
-var messageIdCacheByContext = new Map;
-var idCounter2 = 0;
-function getCacheForContext(contextId) {
-  let cache = messageIdCacheByContext.get(contextId);
-  if (!cache) {
-    cache = new WeakMap;
-    messageIdCacheByContext.set(contextId, cache);
-  }
-  return cache;
+import fs3 from "fs";
+var LOG_FILE = "/tmp/apex-debug.log";
+function logToFile(message, data) {
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] ${message} ${data ? JSON.stringify(data, null, 2) : ""}
+`;
+  fs3.appendFileSync(LOG_FILE, logLine);
 }
 function getStableKey(item, contextId = "root") {
-  const cache = getCacheForContext(contextId);
-  let cachedId = cache.get(item);
-  if (cachedId) {
-    return cachedId;
-  }
-  let newId;
   if ("messages" in item) {
-    newId = `subagent-${item.id}`;
+    return `subagent-${item.id}`;
   } else if (item.role === "tool" && "toolCallId" in item) {
-    newId = `${contextId}-tool-${item.toolCallId}`;
+    return `${contextId}-tool-${item.toolCallId}`;
   } else {
-    newId = `${contextId}-${item.role}-${item.createdAt.getTime()}-${idCounter2++}`;
+    const content = typeof item.content === "string" ? item.content : JSON.stringify(item.content);
+    const contentHash = content.length;
+    return `${contextId}-${item.role}-${item.createdAt.getTime()}-${contentHash}`;
   }
-  cache.set(item, newId);
-  return newId;
 }
 function markdownToStyledText(content) {
   try {
@@ -75195,8 +75187,14 @@ function AgentDisplay({
     ]
   }, undefined, true, undefined, this);
 }
-function SubAgentDisplay({ subagent }) {
+var SubAgentDisplay = import_react19.memo(function SubAgentDisplay2({ subagent }) {
   const [open, setOpen] = import_react19.useState(false);
+  logToFile(`[Render] SubAgentDisplay for ${subagent.id}:`, {
+    name: subagent.name,
+    nameLength: subagent.name?.length || 0,
+    status: subagent.status,
+    messageCount: subagent.messages.length
+  });
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
     height: open ? 40 : "auto",
     onMouseDown: () => setOpen(!open),
@@ -75242,8 +75240,8 @@ function SubAgentDisplay({ subagent }) {
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
-}
-function AgentMessage({ message }) {
+});
+var AgentMessage = import_react19.memo(function AgentMessage2({ message }) {
   let content = "";
   if (typeof message.content === "string") {
     content = message.content;
@@ -75258,6 +75256,15 @@ function AgentMessage({ message }) {
   } else {
     content = JSON.stringify(message.content, null, 2);
   }
+  if (message.role === "tool") {
+    logToFile(`[Render] AgentMessage (tool):`, {
+      toolCallId: message.toolCallId,
+      content: content.substring(0, 50),
+      contentLength: content.length,
+      isEmpty: content === "",
+      status: message.status
+    });
+  }
   const displayContent = message.role === "assistant" ? markdownToStyledText(content) : content;
   const isPendingTool = message.role === "tool" && message.status === "pending";
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
@@ -75304,7 +75311,7 @@ function AgentMessage({ message }) {
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
-}
+});
 function ToolArgs({ message }) {
   const [open, setOpen] = import_react19.useState(false);
   if (message.role !== "tool" || !("args" in message)) {
@@ -75312,7 +75319,10 @@ function ToolArgs({ message }) {
   }
   const args = message.args;
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
-    onMouseDown: () => setOpen(!open),
+    onMouseDown: (e) => {
+      e.stopPropagation();
+      setOpen(!open);
+    },
     children: [
       /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
         flexDirection: "row",
@@ -75330,28 +75340,28 @@ function ToolArgs({ message }) {
 }
 
 // src/tui/components/commands/pentest-agent-display.tsx
-import fs4 from "fs";
+import fs5 from "fs";
 
 // src/core/messages/index.ts
-import fs3 from "fs";
+import fs4 from "fs";
 function getMessages(session) {
-  const messages = fs3.readFileSync(session.rootPath + "/messages.json", "utf8");
+  const messages = fs4.readFileSync(session.rootPath + "/messages.json", "utf8");
   return JSON.parse(messages);
 }
 function saveMessages(session, messages) {
-  fs3.writeFileSync(session.rootPath + "/messages.json", JSON.stringify(messages, null, 2));
+  fs4.writeFileSync(session.rootPath + "/messages.json", JSON.stringify(messages, null, 2));
 }
 function saveSubagentMessages(orchestratorSession, subagentId, messages) {
   const subagentDir = `${orchestratorSession.rootPath}/subagents/${subagentId}`;
-  if (!fs3.existsSync(`${orchestratorSession.rootPath}/subagents`)) {
-    fs3.mkdirSync(`${orchestratorSession.rootPath}/subagents`, {
+  if (!fs4.existsSync(`${orchestratorSession.rootPath}/subagents`)) {
+    fs4.mkdirSync(`${orchestratorSession.rootPath}/subagents`, {
       recursive: true
     });
   }
-  if (!fs3.existsSync(subagentDir)) {
-    fs3.mkdirSync(subagentDir, { recursive: true });
+  if (!fs4.existsSync(subagentDir)) {
+    fs4.mkdirSync(subagentDir, { recursive: true });
   }
-  fs3.writeFileSync(`${subagentDir}/messages.json`, JSON.stringify(messages, null, 2));
+  fs4.writeFileSync(`${subagentDir}/messages.json`, JSON.stringify(messages, null, 2));
 }
 
 // src/tui/components/commands/pentest-agent-display.tsx
@@ -75492,7 +75502,7 @@ Path: ${result.session.rootPath}`,
           }
           saveMessages(result.session, allMessages);
         }
-        if (fs4.existsSync(result.session.rootPath + "/pentest-report.md")) {
+        if (fs5.existsSync(result.session.rootPath + "/pentest-report.md")) {
           setIsCompleted(true);
         }
         setThinking(false);
@@ -75664,7 +75674,7 @@ var import_react23 = __toESM(require_react(), 1);
 
 // src/tui/components/hooks/thoroughPentestAgent.ts
 var import_react22 = __toESM(require_react(), 1);
-import fs5 from "fs";
+import fs6 from "fs";
 
 // src/core/agent/thoroughPentestAgent/prompts.ts
 var SYSTEM2 = `You are an expert penetration testing orchestrator agent specializing in coordinating comprehensive security assessments. Your role is to AUTONOMOUSLY manage a complete penetration testing engagement by coordinating specialized sub-agents.
@@ -77501,6 +77511,143 @@ You MUST provide the details final report using create_attack_surface_report too
   return { streamResult, session };
 }
 
+// node_modules/yocto-queue/index.js
+class Node {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  validateConcurrency(concurrency);
+  const queue = new Queue;
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue()();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve4, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve4(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve4, arguments_) => {
+    new Promise((internalResolve) => {
+      queue.enqueue(internalResolve);
+    }).then(run.bind(undefined, function_, resolve4, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve4) => {
+    enqueue(function_, resolve4, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
 // src/core/agent/thoroughPentestAgent/agent.ts
 function runAgent3(opts) {
   const {
@@ -77614,9 +77761,13 @@ Objective: ${objective}`,
             currentAssistantText += delta.text;
             const lastMessage = allMessages[allMessages.length - 1];
             if (lastMessage && lastMessage.role === "assistant") {
-              lastMessage.content = currentAssistantText;
+              const updatedMessage = {
+                ...lastMessage,
+                content: currentAssistantText
+              };
+              allMessages[allMessages.length - 1] = updatedMessage;
               if (onSubagentMessage) {
-                onSubagentMessage(subagentId, lastMessage);
+                onSubagentMessage(subagentId, updatedMessage);
               }
             } else {
               const newMessage = {
@@ -77650,10 +77801,14 @@ Objective: ${objective}`,
             const existingToolMessageIndex = allMessages.findIndex((msg) => msg.role === "tool" && msg.toolCallId === delta.toolCallId);
             if (existingToolMessageIndex !== -1) {
               const existingMessage = allMessages[existingToolMessageIndex];
-              existingMessage.status = "completed";
-              existingMessage.content = delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`;
+              const updatedMessage = {
+                ...existingMessage,
+                status: "completed",
+                content: delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`
+              };
+              allMessages[existingToolMessageIndex] = updatedMessage;
               if (onSubagentMessage) {
-                onSubagentMessage(subagentId, existingMessage);
+                onSubagentMessage(subagentId, updatedMessage);
               }
             }
           }
@@ -77741,7 +77896,8 @@ You can spawn multiple agents in parallel - they will run concurrently.`,
     execute: async ({ targets }) => {
       try {
         logger?.log(`[Orchestrator] Spawning ${targets.length} pentest agents...`);
-        const promises = targets.map(async (targetInfo, index) => {
+        const limit = pLimit(5);
+        const promises = targets.map((targetInfo, index) => limit(async () => {
           try {
             const { streamResult: result } = runAgent({
               session,
@@ -77781,9 +77937,13 @@ Objective: ${targetInfo.objective}`,
                 currentAssistantText += delta.text;
                 const lastMessage = allMessages[allMessages.length - 1];
                 if (lastMessage && lastMessage.role === "assistant") {
-                  lastMessage.content = currentAssistantText;
+                  const updatedMessage = {
+                    ...lastMessage,
+                    content: currentAssistantText
+                  };
+                  allMessages[allMessages.length - 1] = updatedMessage;
                   if (onSubagentMessage) {
-                    onSubagentMessage(subagentId, lastMessage);
+                    onSubagentMessage(subagentId, updatedMessage);
                   }
                 } else {
                   const newMessage = {
@@ -77817,10 +77977,14 @@ Objective: ${targetInfo.objective}`,
                 const existingToolMessageIndex = allMessages.findIndex((msg) => msg.role === "tool" && msg.toolCallId === delta.toolCallId);
                 if (existingToolMessageIndex !== -1) {
                   const existingMessage = allMessages[existingToolMessageIndex];
-                  existingMessage.status = "completed";
-                  existingMessage.content = delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`;
+                  const updatedMessage = {
+                    ...existingMessage,
+                    status: "completed",
+                    content: delta.input.toolCallDescription ? `✓ ${delta.input.toolCallDescription}` : `✓ Tool ${delta.toolName}`
+                  };
+                  allMessages[existingToolMessageIndex] = updatedMessage;
                   if (onSubagentMessage) {
-                    onSubagentMessage(subagentId, existingMessage);
+                    onSubagentMessage(subagentId, updatedMessage);
                   }
                 }
               }
@@ -77861,7 +78025,7 @@ Objective: ${targetInfo.objective}`,
               error: error46.message
             };
           }
-        });
+        }));
         const results = await Promise.all(promises);
         const successful = results.filter((r) => r.success).length;
         const failed = results.filter((r) => !r.success).length;
@@ -78015,6 +78179,13 @@ ${pentestSessionPaths.map((path5, idx) => `${idx + 1}. ${path5}`).join(`
 
 // src/tui/components/hooks/thoroughPentestAgent.ts
 import { exec as exec5 } from "child_process";
+var LOG_FILE2 = "/tmp/apex-debug.log";
+function logToFile2(message, data) {
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] ${message} ${data ? JSON.stringify(data, null, 2) : ""}
+`;
+  fs6.appendFileSync(LOG_FILE2, logLine);
+}
 function useThoroughPentestAgent() {
   const [target, setTarget] = import_react22.useState("");
   const [messages, setMessages] = import_react22.useState([]);
@@ -78034,7 +78205,7 @@ function useThoroughPentestAgent() {
   function openReport() {
     if (sessionPath) {
       const reportPath = `${sessionPath}/comprehensive-pentest-report.md`;
-      if (fs5.existsSync(reportPath)) {
+      if (fs6.existsSync(reportPath)) {
         exec5(`open "${reportPath}"`, (error46) => {
           if (error46) {
             console.error("Error opening report:", error46);
@@ -78080,30 +78251,76 @@ function useThoroughPentestAgent() {
             ]);
           },
           onSubagentMessage: (subagentId, message) => {
-            setSubagents((prev) => prev.map((sub) => {
-              if (sub.id !== subagentId)
-                return sub;
+            logToFile2(`[Hook] Received message for ${subagentId}:`, {
+              role: message.role,
+              content: typeof message.content === "string" ? message.content.substring(0, 50) : message.content,
+              contentLength: typeof message.content === "string" ? message.content.length : "not-string",
+              hasContent: !!message.content,
+              toolCallId: message.role === "tool" ? message.toolCallId : "n/a"
+            });
+            setSubagents((prev) => {
+              const subIndex = prev.findIndex((s) => s.id === subagentId);
+              if (subIndex === -1) {
+                logToFile2(`[Hook] Subagent ${subagentId} not found!`);
+                return prev;
+              }
+              const sub = prev[subIndex];
               const messages2 = [...sub.messages];
+              const getMessageId = (msg) => {
+                if (msg.role === "tool" && "toolCallId" in msg) {
+                  return `tool-${msg.toolCallId}`;
+                } else if (msg.role === "assistant") {
+                  const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+                  return `assistant-${msg.createdAt.getTime()}-${content.length}`;
+                } else {
+                  return `${msg.role}-${msg.createdAt.getTime()}`;
+                }
+              };
+              const messageId = getMessageId(message);
               if (message.role === "tool") {
                 const toolMsg = message;
                 const existingIndex = messages2.findIndex((m2) => m2.role === "tool" && m2.toolCallId === toolMsg.toolCallId);
                 if (existingIndex !== -1) {
                   messages2[existingIndex] = message;
                 } else {
-                  messages2.push(message);
+                  const insertIndex = messages2.findIndex((m2) => m2.createdAt.getTime() > message.createdAt.getTime());
+                  if (insertIndex === -1) {
+                    messages2.push(message);
+                  } else {
+                    messages2.splice(insertIndex, 0, message);
+                  }
                 }
               } else if (message.role === "assistant") {
                 const lastMessage = messages2[messages2.length - 1];
                 if (lastMessage && lastMessage.role === "assistant") {
-                  messages2[messages2.length - 1] = message;
+                  if (lastMessage.createdAt.getTime() === message.createdAt.getTime()) {
+                    messages2[messages2.length - 1] = message;
+                  } else {
+                    messages2.push(message);
+                  }
                 } else {
                   messages2.push(message);
                 }
               } else {
-                messages2.push(message);
+                const existingIndex = messages2.findIndex((m2) => getMessageId(m2) === messageId);
+                if (existingIndex === -1) {
+                  messages2.push(message);
+                }
               }
-              return { ...sub, messages: messages2 };
-            }));
+              const updatedSub = { ...sub, messages: messages2 };
+              logToFile2(`[Hook] Updated ${subagentId}, now has ${messages2.length} messages`);
+              if (message.role === "tool") {
+                const toolInArray = messages2.find((m2) => m2.role === "tool" && m2.toolCallId === message.toolCallId);
+                logToFile2(`[Hook] Tool message in array:`, {
+                  found: !!toolInArray,
+                  content: toolInArray?.content,
+                  contentLength: typeof toolInArray?.content === "string" ? toolInArray.content.length : "not-string"
+                });
+              }
+              const newSubagents = [...prev];
+              newSubagents[subIndex] = updatedSub;
+              return newSubagents;
+            });
           },
           onSubagentComplete: (subagentId, success2) => {
             setSubagents((prev) => prev.map((sub) => sub.id === subagentId ? { ...sub, status: success2 ? "completed" : "failed" } : sub));
@@ -78169,7 +78386,7 @@ Mode: Pentest (Orchestrator)`,
           }
           saveMessages(result.session, allMessages);
         }
-        if (fs5.existsSync(result.session.rootPath + "/comprehensive-pentest-report.md")) {
+        if (fs6.existsSync(result.session.rootPath + "/comprehensive-pentest-report.md")) {
           setIsCompleted(true);
         }
         setThinking(false);

package/build/swarm.js

@@ -42390,6 +42390,145 @@ Remember to follow a systematic methodology and explain your reasoning for each
 }
 // scripts/swarm.ts
 import { readFileSync as readFileSync4 } from "fs";
+
+// node_modules/yocto-queue/index.js
+class Node {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  validateConcurrency(concurrency);
+  const queue = new Queue;
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue()();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve2, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve2(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve2, arguments_) => {
+    new Promise((internalResolve) => {
+      queue.enqueue(internalResolve);
+    }).then(run.bind(undefined, function_, resolve2, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve2) => {
+    enqueue(function_, resolve2, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
+// scripts/swarm.ts
 var TargetSchema = exports_external.array(exports_external.object({
   target: exports_external.string().describe("The target to perform a pentest on"),
   objective: exports_external.string().describe("The objective of the pentest")
@@ -42433,7 +42572,8 @@ async function swarm(options) {
   }
   const session = createSession("swarm", "Multi-target swarm pentest");
   const results = [];
-  const promises = targetsArray.map(async (target, idx) => {
+  const limit = pLimit(5);
+  const promises = targetsArray.map((target, idx) => limit(async () => {
     if (!silent) {
       console.log("=".repeat(80));
       console.log(`[${idx + 1}/${targetsArray.length}] Starting pentest for: ${target.target}`);
@@ -42473,8 +42613,8 @@ async function swarm(options) {
         error: error46.message
       });
     }
-  });
-  await Promise.all(promises);
+  }));
+  await Promise.allSettled(promises);
   if (!silent) {
     console.log("=".repeat(80));
     console.log("SWARM PENTEST SUMMARY");
@@ -42571,7 +42711,9 @@ async function main() {
       objective: session.objective
     }, null, 2));
   } catch (error46) {
-    console.error("Fatal error:", error46.message);
+    if (!silent) {
+      console.error("Fatal error:", error46.message);
+    }
     process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pensar/apex",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "AI-powered penetration testing CLI tool with terminal UI",
   "module": "src/tui/index.tsx",
   "main": "build/index.js",
@@ -59,6 +59,7 @@
     "@opentui/react": "0.1.26",
     "ai": "^5.0.68",
     "marked": "^16.4.0",
+    "p-limit": "^7.2.0",
     "react": "^19.2.0",
     "sharp": "^0.34.4",
     "zod": "^4.1.12"