@pensar/apex 0.0.83-canary.623a32d3 → 0.0.83

package/build/index.js

@@ -31956,7 +31956,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@pensar/apex",
-    version: "0.0.83-canary.623a32d3",
+    version: "0.0.83",
     description: "AI-powered penetration testing CLI tool with terminal UI",
     module: "src/tui/index.tsx",
     main: "build/index.js",
@@ -84374,6 +84374,47 @@ function parseAnthropicResponse(response, usage) {
   return { content, finishReason, usage: finalUsage };
 }
 
+// src/core/ai/providers/pensarSSE.ts
+async function* parseSSE(stream) {
+  const reader = stream.getReader();
+  const decoder2 = new TextDecoder;
+  let buffer = "";
+  let currentEvent = "message";
+  let currentData = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder2.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (let line of lines) {
+        line = line.replace(/\r$/, "");
+        if (line === "") {
+          if (currentData.length > 0) {
+            yield { event: currentEvent, data: currentData.join(`
+`) };
+          }
+          currentEvent = "message";
+          currentData = [];
+        } else if (line.startsWith("event:")) {
+          currentEvent = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          currentData.push(line.slice(5).trim());
+        }
+      }
+    }
+    if (currentData.length > 0) {
+      yield { event: currentEvent, data: currentData.join(`
+`) };
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
 // src/core/ai/providers/pensar.ts
 function log(...args) {
   if (DEBUG)
@@ -84472,63 +84513,248 @@ function createPensarModel(bedrockModelId, config2) {
       };
     },
     async doStream(options) {
-      log(`doStream → wrapping doGenerate for ${bedrockModelId}`);
-      const generateResult = await model.doGenerate(options);
-      const parts = [];
-      parts.push({
-        type: "stream-start",
-        warnings: generateResult.warnings
-      });
-      for (const item of generateResult.content) {
-        if (item.type === "text") {
-          const id = `text-${Date.now()}`;
-          parts.push({ type: "text-start", id });
-          parts.push({ type: "text-delta", id, delta: item.text });
-          parts.push({ type: "text-end", id });
-        } else if (item.type === "tool-call") {
-          const id = item.toolCallId;
-          parts.push({
-            type: "tool-input-start",
-            id,
-            toolName: item.toolName
-          });
-          parts.push({
-            type: "tool-input-delta",
-            id,
-            delta: item.input
-          });
-          parts.push({ type: "tool-input-end", id });
-          parts.push({
-            type: "tool-call",
-            toolCallId: id,
-            toolName: item.toolName,
-            input: item.input
-          });
+      const body = convertToBedrockFormat(bedrockModelId, options);
+      const url2 = `${config2.baseUrl}/bedrock/stream`;
+      log(`doStream → SSE streaming for ${bedrockModelId}`);
+      log(`  URL: ${url2}`);
+      const headers = await buildHeaders();
+      let response;
+      try {
+        response = await fetch(url2, {
+          method: "POST",
+          headers,
+          signal: options.abortSignal,
+          body: JSON.stringify({
+            modelId: bedrockModelId,
+            body
+          })
+        });
+      } catch (err) {
+        logError(`  SSE fetch failed, falling back to doGenerate:`, err);
+        return doStreamFallback(model, options);
+      }
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let errorMessage;
+        try {
+          const parsed = JSON.parse(errorBody);
+          errorMessage = parsed.error || parsed.message || errorBody;
+        } catch {
+          errorMessage = errorBody;
+        }
+        logError(`  SSE FAILED ${response.status}: ${errorMessage}`);
+        if (response.status === 402) {
+          throw new Error(`Insufficient Pensar credits: ${errorMessage}. ` + `Top up at https://console.pensar.dev`);
         }
+        throw new Error(`Pensar streaming error (${response.status}): ${errorMessage}`);
       }
-      parts.push({
-        type: "finish",
-        finishReason: generateResult.finishReason,
-        usage: generateResult.usage
-      });
+      if (!response.body) {
+        logError(`  SSE response has no body, falling back to doGenerate`);
+        return doStreamFallback(model, options);
+      }
+      const sseStream = response.body;
       const stream = new ReadableStream({
-        start(controller) {
-          for (const part of parts) {
-            controller.enqueue(part);
+        async start(controller) {
+          let inputTokens = 0;
+          let outputTokens = 0;
+          let finishReason = "unknown";
+          let startEmitted = false;
+          let activeTextId = null;
+          let activeToolId = null;
+          let activeToolName = null;
+          let activeToolInput = "";
+          try {
+            for await (const sse of parseSSE(sseStream)) {
+              let parsed;
+              try {
+                parsed = JSON.parse(sse.data);
+              } catch {
+                continue;
+              }
+              if (sse.event === "error") {
+                const msg = parsed.error ?? "Unknown streaming error";
+                controller.error(new Error(msg));
+                return;
+              }
+              if (sse.event === "pensar:usage") {
+                if (parsed.totalCost != null) {
+                  log(`  cost: $${Number(parsed.totalCost).toFixed(6)}`);
+                }
+                continue;
+              }
+              const type = parsed.type;
+              switch (type) {
+                case "message_start": {
+                  if (!startEmitted) {
+                    controller.enqueue({ type: "stream-start", warnings: [] });
+                    startEmitted = true;
+                  }
+                  const msg = parsed.message;
+                  const usage = msg?.usage;
+                  if (usage?.input_tokens) {
+                    inputTokens = usage.input_tokens;
+                  }
+                  break;
+                }
+                case "content_block_start": {
+                  if (!startEmitted) {
+                    controller.enqueue({ type: "stream-start", warnings: [] });
+                    startEmitted = true;
+                  }
+                  const cb = parsed.content_block;
+                  const cbType = cb?.type;
+                  if (cbType === "text") {
+                    activeTextId = `text-${Date.now()}-${parsed.index}`;
+                    controller.enqueue({
+                      type: "text-start",
+                      id: activeTextId
+                    });
+                  } else if (cbType === "tool_use") {
+                    activeToolId = cb?.id ?? `tool-${Date.now()}`;
+                    activeToolName = cb?.name ?? "unknown";
+                    activeToolInput = "";
+                    controller.enqueue({
+                      type: "tool-input-start",
+                      id: activeToolId,
+                      toolName: activeToolName
+                    });
+                  }
+                  break;
+                }
+                case "content_block_delta": {
+                  const delta = parsed.delta;
+                  const deltaType = delta?.type;
+                  if (deltaType === "text_delta" && activeTextId) {
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: activeTextId,
+                      delta: delta?.text ?? ""
+                    });
+                  } else if (deltaType === "input_json_delta" && activeToolId) {
+                    const jsonDelta = delta?.partial_json ?? "";
+                    activeToolInput += jsonDelta;
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: activeToolId,
+                      delta: jsonDelta
+                    });
+                  }
+                  break;
+                }
+                case "content_block_stop": {
+                  if (activeTextId) {
+                    controller.enqueue({ type: "text-end", id: activeTextId });
+                    activeTextId = null;
+                  } else if (activeToolId && activeToolName) {
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: activeToolId
+                    });
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: activeToolId,
+                      toolName: activeToolName,
+                      input: activeToolInput
+                    });
+                    activeToolId = null;
+                    activeToolName = null;
+                    activeToolInput = "";
+                  }
+                  break;
+                }
+                case "message_delta": {
+                  const delta = parsed.delta;
+                  const stopReason = delta?.stop_reason;
+                  if (stopReason) {
+                    finishReason = mapStopReason(stopReason);
+                  }
+                  const usage = parsed.usage;
+                  if (usage?.output_tokens) {
+                    outputTokens = usage.output_tokens;
+                  }
+                  break;
+                }
+                case "message_stop": {
+                  break;
+                }
+              }
+            }
+            log(`  stream done: ${finishReason}, ${inputTokens}in/${outputTokens}out`);
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage: {
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens + outputTokens
+              }
+            });
+            controller.close();
+          } catch (err) {
+            controller.error(err);
           }
-          controller.close();
         }
       });
       return {
         stream,
-        request: {
-          body: generateResult.request?.body
-        }
+        request: { body }
       };
     }
   };
   return model;
 }
+function mapStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool-calls";
+    case "stop_sequence":
+      return "stop";
+    default:
+      return "unknown";
+  }
+}
+async function doStreamFallback(model, options) {
+  const generateResult = await model.doGenerate(options);
+  const parts = [];
+  parts.push({ type: "stream-start", warnings: generateResult.warnings });
+  for (const item of generateResult.content) {
+    if (item.type === "text") {
+      const id = `text-${Date.now()}`;
+      parts.push({ type: "text-start", id });
+      parts.push({ type: "text-delta", id, delta: item.text });
+      parts.push({ type: "text-end", id });
+    } else if (item.type === "tool-call") {
+      const id = item.toolCallId;
+      parts.push({ type: "tool-input-start", id, toolName: item.toolName });
+      parts.push({ type: "tool-input-delta", id, delta: item.input });
+      parts.push({ type: "tool-input-end", id });
+      parts.push({
+        type: "tool-call",
+        toolCallId: id,
+        toolName: item.toolName,
+        input: item.input
+      });
+    }
+  }
+  parts.push({
+    type: "finish",
+    finishReason: generateResult.finishReason,
+    usage: generateResult.usage
+  });
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const part of parts) {
+        controller.enqueue(part);
+      }
+      controller.close();
+    }
+  });
+  return { stream, request: { body: generateResult.request?.body } };
+}
 var DEBUG;
 var init_pensar2 = __esm(() => {
   DEBUG = process.env.PENSAR_DEBUG === "1" || process.env.PENSAR_DEBUG === "true";
@@ -107948,6 +108174,11 @@ They are organised into categories:
   - "framework" — framework-specific notes (e.g. Rails tricks, Django patterns)
   - "general"   — catch-all (default when category is omitted)
 
+IMPORTANT: Before adding a new memory, always use list_memories first to check
+for existing memories that overlap with what you intend to save. If a relevant
+memory already exists, update it (delete + re-add) rather than creating a
+duplicate. This keeps the memory store clean and avoids conflicting entries.
+
 Use this to record reusable techniques, target-specific notes, credential
 patterns, useful payloads, or any information worth remembering for future
 engagements.`,
@@ -189828,6 +190059,7 @@ You can perform the full lifecycle of a penetration test and support a wide rang
 4. **Use the right level of automation.** For large tasks (e.g., "pentest this entire application"), use orchestration tools like \`run_attack_surface\` and \`spawn_pentest_swarm\` to parallelize the work. For focused tasks (e.g., "check if this parameter is vulnerable to XSS"), work directly with \`http_request\`, \`execute_command\`, or the browser tools.
 5. **Authenticate when needed.** If the user provides credentials or auth instructions, use them. Try \`authenticate_session\` first; fall back to \`delegate_to_auth_subagent\` for complex flows (OAuth, SAML, CSRF-protected SPAs).
 6. **Document as you go.** Call \`document_asset\` when you discover assets. Call \`document_finding\` when you confirm vulnerabilities. Create PoCs with \`create_poc\` to demonstrate exploitability. Don't defer documentation to the end.
+7. **Consult memories first.** When you begin testing a specific application, framework, or path, call \`list_memories\` to check for saved knowledge from previous sessions — past findings, useful payloads, endpoint patterns, or target-specific notes. Use relevant memories to inform your approach before starting from scratch.
 
 # Command Execution
 
@@ -270639,6 +270871,7 @@ var PromptInput = import_react29.forwardRef(function PromptInput2({
   enableCommands = false,
   onCommandExecute,
   commandHistory = [],
+  disableHistoryNavigation = false,
   showPromptIndicator = false
 }, ref) {
   const { colors: colors2 } = useTheme();
@@ -270713,6 +270946,8 @@ var PromptInput = import_react29.forwardRef(function PromptInput2({
       }
       return;
     }
+    if (disableHistoryNavigation)
+      return;
     const history = historyRef.current;
     const currentState = {
       historyIndex,
@@ -280690,13 +280925,13 @@ function NormalInputAreaInner({
   autocompleteOptions = [],
   enableCommands = false,
   onCommandExecute,
-  commandHistory = []
+  commandHistory = [],
+  disableHistoryNavigation = false
 }) {
   const { colors: colors2 } = useTheme();
   const { inputValue, setInputValue } = useInput();
   const promptRef = import_react77.useRef(null);
   const isExternalUpdate = import_react77.useRef(false);
-  const isDisabled = status === "running";
   import_react77.useEffect(() => {
     if (value !== inputValue) {
       isExternalUpdate.current = true;
@@ -280733,7 +280968,7 @@ function NormalInputAreaInner({
         backgroundColor: "transparent",
         children: [
           /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-            fg: isDisabled ? colors2.textMuted : colors2.primary,
+            fg: !focused ? colors2.textMuted : colors2.primary,
             children: ">"
           }, undefined, false, undefined, this),
           /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(PromptInput, {
@@ -280742,14 +280977,15 @@ function NormalInputAreaInner({
             minHeight: 1,
             maxHeight: 3,
             textColor: colors2.text,
-            focused: focused && !isDisabled,
-            placeholder: isDisabled ? "Processing..." : placeholder,
+            focused,
+            placeholder,
             onSubmit: handleSubmit,
             enableAutocomplete,
             autocompleteOptions,
             enableCommands,
             onCommandExecute,
-            commandHistory
+            commandHistory,
+            disableHistoryNavigation
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
@@ -280836,6 +281072,7 @@ function InputArea(props) {
     enableCommands,
     onCommandExecute,
     commandHistory,
+    disableHistoryNavigation,
     ...normalProps
   } = props;
   if (pendingApproval) {
@@ -280859,6 +281096,7 @@ function InputArea(props) {
       enableCommands,
       onCommandExecute,
       commandHistory,
+      disableHistoryNavigation,
       ...normalProps
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
@@ -281074,6 +281312,89 @@ function accumulateTokenUsage(current, stepInputTokens, stepOutputTokens) {
   };
 }
 
+// src/tui/components/operator-dashboard/queued-messages.tsx
+function QueuedMessages({
+  messages,
+  selectedIndex
+}) {
+  const { colors: colors2 } = useTheme();
+  if (messages.length === 0)
+    return null;
+  return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+    flexDirection: "column",
+    paddingLeft: 2,
+    paddingRight: 2,
+    paddingBottom: 1,
+    flexShrink: 0,
+    children: [
+      /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+        flexDirection: "row",
+        gap: 1,
+        marginBottom: 0,
+        children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+          fg: colors2.textMuted,
+          children: [
+            "Queued (",
+            messages.length,
+            ")"
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      messages.map((msg, index) => {
+        const isSelected = index === selectedIndex;
+        const displayText = msg.length > 80 ? msg.slice(0, 77) + "…" : msg;
+        return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+          flexDirection: "row",
+          gap: 1,
+          children: [
+            /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+              fg: isSelected ? colors2.primary : colors2.textMuted,
+              children: isSelected ? "▸" : " "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+              fg: isSelected ? colors2.text : colors2.textMuted,
+              children: displayText
+            }, undefined, false, undefined, this)
+          ]
+        }, `q-${index}`, true, undefined, this);
+      }),
+      /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+        flexDirection: "row",
+        gap: 2,
+        marginTop: 0,
+        children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+          fg: colors2.textMuted,
+          children: "↑↓ select • Enter send now • ⌫ delete • e edit"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/tui/components/operator-dashboard/queue.ts
+function selectionAfterRemove(prevQueueLength, selectedIndex) {
+  const newLen = prevQueueLength - 1;
+  if (newLen === 0)
+    return -1;
+  return Math.min(selectedIndex, newLen - 1);
+}
+function navigateUp(selectedIndex, queueLength) {
+  if (queueLength === 0)
+    return -1;
+  if (selectedIndex === -1)
+    return queueLength - 1;
+  if (selectedIndex === 0)
+    return 0;
+  return selectedIndex - 1;
+}
+function navigateDown(selectedIndex, queueLength) {
+  if (selectedIndex === -1)
+    return -1;
+  if (selectedIndex >= queueLength - 1)
+    return -1;
+  return selectedIndex + 1;
+}
+
 // src/tui/components/operator-dashboard/index.tsx
 import { existsSync as existsSync26, readFileSync as readFileSync13 } from "fs";
 import { join as join27 } from "path";
@@ -281127,6 +281448,17 @@ function OperatorDashboard({
   const textRef = import_react79.useRef("");
   const conversationRef = import_react79.useRef([]);
   const [inputValue, setInputValue] = import_react79.useState("");
+  const [queuedMessages, setQueuedMessages] = import_react79.useState([]);
+  const [selectedQueueIndex, setSelectedQueueIndex] = import_react79.useState(-1);
+  const queuedMessagesRef = import_react79.useRef([]);
+  import_react79.useEffect(() => {
+    queuedMessagesRef.current = queuedMessages;
+    if (queuedMessages.length === 0) {
+      setSelectedQueueIndex(-1);
+    } else if (selectedQueueIndex >= queuedMessages.length) {
+      setSelectedQueueIndex(queuedMessages.length - 1);
+    }
+  }, [queuedMessages, selectedQueueIndex]);
   const [operatorState, setOperatorState] = import_react79.useState(() => createInitialOperatorState("manual", true));
   const approvalGateRef = import_react79.useRef(new ApprovalGate({ requireApproval: true }));
   const [pendingApprovals, setPendingApprovals] = import_react79.useState([]);
@@ -281616,6 +281948,11 @@ function OperatorDashboard({
         approvalGateRef.current.deny(p.id);
       }
     }
+    if (result.action === "blocked" && value.trim()) {
+      setQueuedMessages((prev) => [...prev, value.trim()]);
+      setInputValue("");
+      return;
+    }
     if (result.action !== "run" || !result.prompt)
       return;
     setInputValue("");
@@ -281630,6 +281967,17 @@ function OperatorDashboard({
       runAgentRef.current(initialMessage);
     }
   }, [loading, initialMessage]);
+  import_react79.useEffect(() => {
+    if (status !== "idle")
+      return;
+    const queue = queuedMessagesRef.current;
+    if (queue.length === 0)
+      return;
+    const next = queue[0];
+    setQueuedMessages((prev) => prev.slice(1));
+    setSelectedQueueIndex(-1);
+    runAgentRef.current(next);
+  }, [status]);
   const showModelPicker = import_react79.useCallback(() => {
     setDialogSize("large");
     showDialog(/* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
@@ -281730,6 +282078,9 @@ function OperatorDashboard({
     abortControllerRef.current.abort();
     abortControllerRef.current = null;
     commandCancelledRef.current = false;
+    setQueuedMessages([]);
+    queuedMessagesRef.current = [];
+    setSelectedQueueIndex(-1);
     setStatus("idle");
     setThinking(false);
     setIsExecuting(false);
@@ -281765,6 +282116,51 @@ function OperatorDashboard({
     });
   }, []);
   useKeyboard((key) => {
+    if (status === "running" && queuedMessages.length > 0 && !inputValue.trim()) {
+      if (key.name === "up") {
+        key.preventDefault?.();
+        setSelectedQueueIndex((prev) => navigateUp(prev, queuedMessages.length));
+        return;
+      }
+      if (selectedQueueIndex >= 0) {
+        if (key.name === "down") {
+          key.preventDefault?.();
+          setSelectedQueueIndex((prev) => navigateDown(prev, queuedMessages.length));
+          return;
+        }
+        if (key.name === "backspace" || key.name === "delete") {
+          key.preventDefault?.();
+          const removeIdx = selectedQueueIndex;
+          setQueuedMessages((prev) => prev.filter((_3, i2) => i2 !== removeIdx));
+          setSelectedQueueIndex(() => selectionAfterRemove(queuedMessages.length, removeIdx));
+          return;
+        }
+        if (key.name === "return") {
+          key.preventDefault?.();
+          const msg = queuedMessages[selectedQueueIndex];
+          const removeIdx = selectedQueueIndex;
+          setQueuedMessages((prev) => prev.filter((_3, i2) => i2 !== removeIdx));
+          setSelectedQueueIndex(-1);
+          flushCommandOutput();
+          if (cmdFlushTimerRef.current) {
+            clearInterval(cmdFlushTimerRef.current);
+            cmdFlushTimerRef.current = null;
+          }
+          setMessages((prev) => prev.map((m4) => isToolMessage(m4) && m4.status === "pending" ? { ...m4, status: "error", result: "Interrupted" } : m4));
+          runAgentRef.current(msg);
+          return;
+        }
+        if (key.raw === "e" || key.raw === "E") {
+          key.preventDefault?.();
+          const msg = queuedMessages[selectedQueueIndex];
+          const removeIdx = selectedQueueIndex;
+          setQueuedMessages((prev) => prev.filter((_3, i2) => i2 !== removeIdx));
+          setInputValue(msg);
+          setSelectedQueueIndex(-1);
+          return;
+        }
+      }
+    }
     const dialogOpen = stack.length > 0 || externalDialogOpen;
     const action = resolveKeyboardShortcut(key, status, inputValue, pendingApprovals.length > 0, dialogOpen);
     switch (action.type) {
@@ -281916,12 +282312,16 @@ function OperatorDashboard({
         pendingApprovals,
         lastApprovedAction
       }, undefined, false, undefined, this),
+      /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(QueuedMessages, {
+        messages: queuedMessages,
+        selectedIndex: selectedQueueIndex
+      }, undefined, false, undefined, this),
       /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(InputArea, {
         value: inputValue,
         onChange: setInputValue,
         onSubmit: handleSubmit,
-        placeholder: status === "running" ? "Agent is working..." : status === "waiting" ? "Type to redirect agent, or Y/A to approve..." : "Enter directive or / for commands & skills...",
-        focused: resolveInputFocused(status, stack.length, externalDialogOpen),
+        placeholder: status === "running" ? "Queue a follow-up message..." : status === "waiting" ? "Type to redirect agent, or Y/A to approve..." : "Enter directive or / for commands & skills...",
+        focused: status === "running" ? selectedQueueIndex < 0 : resolveInputFocused(status, stack.length, externalDialogOpen),
         status: status === "waiting" ? "running" : status,
         mode: "operator",
         operatorMode: operatorState.mode,
@@ -281933,7 +282333,8 @@ function OperatorDashboard({
         enableAutocomplete: true,
         autocompleteOptions,
         enableCommands: true,
-        onCommandExecute: handleCommandExecute
+        onCommandExecute: handleCommandExecute,
+        disableHistoryNavigation: status === "running" && queuedMessages.length > 0
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pensar/apex",
-  "version": "0.0.83-canary.623a32d3",
+  "version": "0.0.83",
   "description": "AI-powered penetration testing CLI tool with terminal UI",
   "module": "src/tui/index.tsx",
   "main": "build/index.js",