pentesting 0.73.5 → 0.73.6

package/dist/main.js

@@ -42,11 +42,10 @@ import {
   rotateTurnRecords,
   setCurrentTurn,
   writePolicyDocument
-} from "./chunk-ULP6TF2X.js";
+} from "./chunk-HSZZHAGX.js";
 import {
   AGENT_ROLES,
   APP_DESCRIPTION,
-  APP_NAME,
   APP_VERSION,
   AUXILIARY_WORK_TYPES,
   COMMAND_EVENT_TYPES,
@@ -85,15 +84,15 @@ import {
   setActiveSessionRuntime,
   setTorEnabled,
   snapshotToPrompt
-} from "./chunk-EIPVHHPI.js";
+} from "./chunk-4HG57VDC.js";
 import {
   EXIT_CODES,
   getOptionalRuntimeSection,
   getRequiredRuntimeSection
-} from "./chunk-I52SWXYV.js";
+} from "./chunk-KAUE3MSR.js";
 
 // src/platform/tui/main.tsx
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 
 // src/shared/constants/theme.ts
 var HEX = {
@@ -946,8 +945,25 @@ async function executeLayer(layer, ctx) {
 }
 
 // src/agents/prompt-builder/prompt-section-builder.ts
+function getLayerSortKey(id) {
+  if (typeof id === "number") {
+    return { rank: id, tieBreak: "" };
+  }
+  const numericPrefix = Number.parseFloat(id);
+  if (Number.isFinite(numericPrefix)) {
+    return { rank: numericPrefix, tieBreak: id };
+  }
+  return { rank: Number.POSITIVE_INFINITY, tieBreak: id };
+}
 function sortLayersByPriority(layers) {
-  return [...layers].sort((a, b) => a.id - b.id);
+  return [...layers].sort((a, b) => {
+    const left = getLayerSortKey(a.id);
+    const right = getLayerSortKey(b.id);
+    if (left.rank !== right.rank) {
+      return left.rank - right.rank;
+    }
+    return left.tieBreak.localeCompare(right.tieBreak);
+  });
 }
 async function buildPromptSections(layers, ctx) {
   const sortedLayers = sortLayersByPriority(layers);
@@ -1476,7 +1492,7 @@ var makeRotateTurns = (_llm, _opts) => async (_ctx) => {
 };
 var makeSaveSession = (_llm, _opts) => async (ctx) => {
   try {
-    const { saveState: saveState2 } = await import("./persistence-EFKMGPYS.js");
+    const { saveState: saveState2 } = await import("./persistence-TBJPBHKF.js");
     saveState2(ctx.state);
   } catch {
   }
@@ -3479,7 +3495,8 @@ var MainAgent = class extends CoreAgent {
       agentType: AGENT_ROLES.ORCHESTRATOR,
       state: options.state,
       events: options.events,
-      toolRegistry: options.toolRegistry
+      toolRegistry: options.toolRegistry,
+      maxIterations: options.maxIterations
     });
     this.approvalGate = options.approvalGate;
     this.scopeGuard = options.scopeGuard;
@@ -3721,10 +3738,10 @@ import { render } from "ink";
 import { Box as Box18 } from "ink";
 
 // src/platform/tui/hooks/useAgent.ts
-import { useState as useState6, useEffect as useEffect2, useCallback as useCallback6, useRef as useRef6 } from "react";
+import { useState as useState6, useEffect as useEffect2, useCallback as useCallback7, useRef as useRef7 } from "react";
 
 // src/agents/factory.ts
-function createMainAgent(autoApproveTools = false) {
+function createMainAgent(autoApproveTools = false, maxIterations) {
   const state = new SharedState();
   const events = new AgentEventEmitter();
   const approvalGate = new ApprovalGate(autoApproveTools);
@@ -3735,7 +3752,14 @@ function createMainAgent(autoApproveTools = false) {
     approvalGate,
     events
   );
-  return AgentRuntime.build({ state, events, toolRegistry, approvalGate, scopeGuard });
+  return AgentRuntime.build({
+    state,
+    events,
+    toolRegistry,
+    approvalGate,
+    scopeGuard,
+    maxIterations
+  });
 }
 
 // src/platform/tui/hooks/useAgentState.ts
@@ -4864,6 +4888,83 @@ var useAgentEvents = (agent, eventsRef, state, isTyping = false) => {
   ]);
 };
 
+// src/platform/tui/hooks/useAgentTaskRunner.ts
+import { useCallback as useCallback6, useRef as useRef6 } from "react";
+function shouldContinueWithQueuedInput(agent, isAborted) {
+  return isAborted && agent.hasPendingUserInput();
+}
+async function runAgentTaskLoop({
+  agent,
+  initialTask,
+  state,
+  clearAborted,
+  isAborted
+}) {
+  let currentTask = initialTask;
+  while (true) {
+    clearAborted();
+    state.setTurnCount((n) => n + 1);
+    state.setIsProcessing(true);
+    state.manageTimer("start");
+    state.setCurrentStatus(UI_MESSAGES.STATUS_THINKING);
+    state.resetCumulativeCounters();
+    let continuing = false;
+    try {
+      await agent.execute(currentTask);
+      if (shouldContinueWithQueuedInput(agent, isAborted())) {
+        currentTask = "";
+        continuing = true;
+        continue;
+      }
+      if (agent.hasPendingUserInput()) {
+        currentTask = "";
+        continuing = true;
+        continue;
+      }
+      break;
+    } catch (error) {
+      if (shouldContinueWithQueuedInput(agent, isAborted())) {
+        currentTask = "";
+        continuing = true;
+        continue;
+      }
+      if (!isAborted()) {
+        state.addMessage("error", error instanceof Error ? error.message : String(error));
+      }
+      break;
+    } finally {
+      if (!isAborted() && !continuing) {
+        state.manageTimer("stop");
+        state.setIsProcessing(false);
+        state.setCurrentStatus("");
+      }
+    }
+  }
+}
+function useAgentTaskRunner(agent, state) {
+  const abortedRef = useRef6(false);
+  const executeTask = useCallback6(async (task) => {
+    await runAgentTaskLoop({
+      agent,
+      initialTask: task,
+      state,
+      clearAborted: () => {
+        abortedRef.current = false;
+      },
+      isAborted: () => abortedRef.current
+    });
+  }, [agent, state]);
+  const abort = useCallback6(() => {
+    abortedRef.current = true;
+    agent.abort();
+    state.setIsProcessing(false);
+    state.manageTimer("stop");
+    state.setCurrentStatus("");
+    state.addMessage("system", UI_MESSAGES.INTERRUPTED);
+  }, [agent, state]);
+  return { abort, executeTask };
+}
+
 // src/platform/tui/hooks/useAgent.ts
 function trimQueuedMessages(queue, maxLength, maxItems) {
   const trimmed = queue.map((text) => truncate(text, maxLength));
@@ -4872,7 +4973,7 @@ function trimQueuedMessages(queue, maxLength, maxItems) {
 }
 var useAgent = (shouldAutoApprove, target, isTyping = false) => {
   const [agent] = useState6(() => createMainAgent(shouldAutoApprove));
-  const eventsRef = useRef6(agent.getEventEmitter());
+  const eventsRef = useRef7(agent.getEventEmitter());
   const state = useAgentState(isTyping);
   const {
     messages,
@@ -4898,8 +4999,8 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
     cancelAllInputRequests
   } = state;
   const [messageQueue, setMessageQueue] = useState6([]);
-  const messageQueueLengthRef = useRef6(0);
-  const setMessageQueueSafe = useCallback6((value) => {
+  const messageQueueLengthRef = useRef7(0);
+  const setMessageQueueSafe = useCallback7((value) => {
     setMessageQueue((prev) => {
       const next = typeof value === "function" ? value(prev) : value;
       return trimQueuedMessages(
@@ -4935,76 +5036,29 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
     };
   }, [agent, addMessage, setMessageQueueSafe]);
   useAgentEvents(agent, eventsRef, state, isTyping);
-  const abortedRef = useRef6(false);
-  const executeTask = useCallback6(async (task) => {
-    let currentTask = task;
-    while (true) {
-      abortedRef.current = false;
-      setTurnCount((n) => n + 1);
-      setIsProcessing(true);
-      manageTimer("start");
-      setCurrentStatus(UI_MESSAGES.STATUS_THINKING);
-      resetCumulativeCounters();
-      let continuing = false;
-      try {
-        const response = await agent.execute(currentTask);
-        if (abortedRef.current) {
-          if (agent.hasPendingUserInput()) {
-            currentTask = "";
-            continuing = true;
-            continue;
-          }
-          return;
-        }
-        if (agent.hasPendingUserInput()) {
-          currentTask = "";
-          continuing = true;
-          continue;
-        }
-        break;
-      } catch (e) {
-        if (abortedRef.current) {
-          if (agent.hasPendingUserInput()) {
-            currentTask = "";
-            continuing = true;
-            continue;
-          }
-          return;
-        }
-        addMessage("error", e instanceof Error ? e.message : String(e));
-        break;
-      } finally {
-        if (!abortedRef.current && !continuing) {
-          manageTimer("stop");
-          setIsProcessing(false);
-          setCurrentStatus("");
-        }
-      }
-    }
-  }, [agent, addMessage, manageTimer, resetCumulativeCounters, setIsProcessing, setCurrentStatus, setTurnCount]);
-  const abort = useCallback6(() => {
-    abortedRef.current = true;
-    agent.abort();
-    setIsProcessing(false);
-    manageTimer("stop");
-    setCurrentStatus("");
-    addMessage("system", UI_MESSAGES.INTERRUPTED);
-  }, [agent, addMessage, manageTimer, setIsProcessing, setCurrentStatus]);
-  const recallQueuedInput = useCallback6(() => {
+  const { executeTask, abort } = useAgentTaskRunner(agent, {
+    addMessage,
+    manageTimer,
+    resetCumulativeCounters,
+    setCurrentStatus,
+    setIsProcessing,
+    setTurnCount
+  });
+  const recallQueuedInput = useCallback7(() => {
     const recalled = agent.dequeueLastUserInput();
     if (!recalled) return null;
     return recalled;
   }, [agent]);
-  const inputRequestRef = useRef6(inputRequest);
+  const inputRequestRef = useRef7(inputRequest);
   inputRequestRef.current = inputRequest;
-  const cancelInputRequest = useCallback6(() => {
+  const cancelInputRequest = useCallback7(() => {
     const ir = inputRequestRef.current;
     if (ir.status === "active") {
       settleActiveInputRequest(null);
       addMessage("system", UI_MESSAGES.INPUT_CANCELLED);
     }
   }, [settleActiveInputRequest, addMessage]);
-  const refreshStats = useCallback6(() => {
+  const refreshStats = useCallback7(() => {
     const s = agent.getState();
     setStats({
       phase: s.getPhase() || PHASES.RECON,
@@ -5042,7 +5096,7 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
 };
 
 // src/platform/tui/hooks/commands/index.ts
-import { useCallback as useCallback7, useMemo } from "react";
+import { useCallback as useCallback8, useMemo } from "react";
 
 // src/platform/tui/constants/commands.ts
 var COMMAND_DEFINITIONS = [
@@ -5619,7 +5673,7 @@ var useCommands = (props) => {
     ...createDisplayCommands(ctx),
     ...createToggleCommands(ctx)
   }), [ctx]);
-  const handleCommand = useCallback7(async (cmd, args) => {
+  const handleCommand = useCallback8(async (cmd, args) => {
     const handler = handlers[cmd];
     if (handler) {
       await handler(args);
@@ -5631,15 +5685,15 @@ var useCommands = (props) => {
 };
 
 // src/platform/tui/hooks/useKeyboardShortcuts.ts
-import { useCallback as useCallback10, useEffect as useEffect4 } from "react";
+import { useCallback as useCallback11, useEffect as useEffect4 } from "react";
 import { useInput } from "ink";
 
 // src/platform/tui/hooks/keyboard/useDoubleTap.ts
-import { useRef as useRef7, useCallback as useCallback8, useEffect as useEffect3 } from "react";
+import { useRef as useRef8, useCallback as useCallback9, useEffect as useEffect3 } from "react";
 var useDoubleTap = ({ onFirstTap, onSecondTap, windowMs }) => {
-  const timerRef = useRef7(null);
-  const pressedRef = useRef7(false);
-  const trigger = useCallback8(() => {
+  const timerRef = useRef8(null);
+  const pressedRef = useRef8(false);
+  const trigger = useCallback9(() => {
     if (pressedRef.current) {
       if (timerRef.current) clearTimeout(timerRef.current);
       pressedRef.current = false;
@@ -5654,7 +5708,7 @@ var useDoubleTap = ({ onFirstTap, onSecondTap, windowMs }) => {
       timerRef.current = null;
     }, windowMs);
   }, [onFirstTap, onSecondTap, windowMs]);
-  const reset = useCallback8(() => {
+  const reset = useCallback9(() => {
     if (timerRef.current) clearTimeout(timerRef.current);
     pressedRef.current = false;
     timerRef.current = null;
@@ -5687,7 +5741,7 @@ var useExitHandler = ({
 };
 
 // src/platform/tui/hooks/keyboard/useEscHandler.ts
-import { useCallback as useCallback9 } from "react";
+import { useCallback as useCallback10 } from "react";
 var useEscHandler = ({
   cancelInputRequest,
   abort,
@@ -5710,7 +5764,7 @@ var useEscHandler = ({
     },
     windowMs
   });
-  const handleEsc = useCallback9(() => {
+  const handleEsc = useCallback10(() => {
     if (inputRequestRef.current.status === "active") {
       cancelInputRequest();
       return;
@@ -5756,7 +5810,7 @@ var useKeyboardShortcuts = ({
     inputRef,
     windowMs: DOUBLE_TAP_WINDOW
   });
-  useInput(useCallback10((ch, key) => {
+  useInput(useCallback11((ch, key) => {
     if (isModalOpenRef.current) return;
     if (key.escape) handleEsc();
     if (key.ctrl && ch === "c") handleCtrlC();
@@ -5774,8 +5828,11 @@ var useKeyboardShortcuts = ({
 };
 
 // src/platform/tui/hooks/useAppLogic.ts
-import { useState as useState7, useCallback as useCallback11, useRef as useRef8 } from "react";
+import { useState as useState7, useCallback as useCallback13, useRef as useRef9 } from "react";
 import { useApp } from "ink";
+
+// src/platform/tui/hooks/useAppSubmission.ts
+import { useCallback as useCallback12 } from "react";
 function sanitizeInput(value) {
   return value.replace(/(?:\x1b)?\[<\d+;\d+;\d+[mM]/g, "").replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/[\x00-\x08\x0B-\x1F\x7F-\x9F]/g, "").trim();
 }
@@ -5795,6 +5852,80 @@ function parseSlashCommandInput(value) {
     args
   };
 }
+function prepareSubmittedInput(value, maxChars) {
+  const trimmed = sanitizeInput(value);
+  if (!trimmed) return null;
+  return {
+    safeInput: trimmed.slice(0, maxChars),
+    wasTruncated: trimmed.length > maxChars
+  };
+}
+function resolveSubmissionRoute(parsedCommand, inputRequestStatus, isProcessing) {
+  if (parsedCommand) return "command";
+  if (inputRequestStatus === "active") return "active_input_request";
+  return isProcessing ? "queue" : "execute";
+}
+function useAppSubmission({
+  addMessage,
+  agent,
+  executeTask,
+  handleCommand,
+  inputRequestRef,
+  isProcessingRef,
+  recallQueuedInput,
+  setInput,
+  setSecretInput,
+  settleActiveInputRequest
+}) {
+  const handleRecallQueuedInput = useCallback12(() => {
+    return recallQueuedInput();
+  }, [recallQueuedInput]);
+  const handleSecretSubmit = useCallback12((value) => {
+    const ir = inputRequestRef.current;
+    if (ir.status !== "active") return;
+    const sanitized = sanitizeInput(value).slice(0, TUI_DISPLAY_LIMITS.MAX_INPUT_CHARS);
+    const displayText = ir.isPassword ? "\u2022".repeat(Math.min(sanitized.length, TUI_DISPLAY_LIMITS.PASSWORD_MASK_MAX)) : sanitized;
+    addMessage("user", displayText);
+    settleActiveInputRequest(sanitized);
+    setSecretInput("");
+  }, [addMessage, inputRequestRef, setSecretInput, settleActiveInputRequest]);
+  const handleSubmit = useCallback12(async (value) => {
+    const preparedInput = prepareSubmittedInput(value, TUI_DISPLAY_LIMITS.MAX_INPUT_CHARS);
+    if (!preparedInput) return;
+    setInput("");
+    if (preparedInput.wasTruncated) {
+      addMessage("system", `Input truncated to ${TUI_DISPLAY_LIMITS.MAX_INPUT_CHARS} chars for terminal stability.`);
+    }
+    const parsedCommand = parseSlashCommandInput(preparedInput.safeInput);
+    const route = resolveSubmissionRoute(
+      parsedCommand,
+      inputRequestRef.current.status,
+      isProcessingRef.current
+    );
+    if (route === "command" && parsedCommand) {
+      addMessage("command", parsedCommand.normalized);
+      await handleCommand(parsedCommand.cmd, parsedCommand.args);
+      return;
+    }
+    if (route === "active_input_request") {
+      handleSecretSubmit(preparedInput.safeInput);
+      return;
+    }
+    if (route === "queue") {
+      agent.enqueueUserInput(preparedInput.safeInput);
+      return;
+    }
+    addMessage("user", preparedInput.safeInput);
+    await executeTask(preparedInput.safeInput);
+  }, [addMessage, agent, executeTask, handleCommand, handleSecretSubmit, inputRequestRef, isProcessingRef, setInput]);
+  return {
+    handleRecallQueuedInput,
+    handleSecretSubmit,
+    handleSubmit
+  };
+}
+
+// src/platform/tui/hooks/useAppLogic.ts
 var useAppLogic = ({ autoApprove = false, target }) => {
   const { exit } = useApp();
   const { columns: terminalWidth, rows: terminalHeight } = useTerminalSize();
@@ -5828,26 +5959,26 @@ var useAppLogic = ({ autoApprove = false, target }) => {
     addMessage,
     refreshStats
   } = useAgent(autoApproveMode, target, isTyping);
-  const isProcessingRef = useRef8(isProcessing);
+  const isProcessingRef = useRef9(isProcessing);
   isProcessingRef.current = isProcessing;
-  const autoApproveModeRef = useRef8(autoApproveMode);
+  const autoApproveModeRef = useRef9(autoApproveMode);
   autoApproveModeRef.current = autoApproveMode;
-  const inputRequestRef = useRef8(inputRequest);
+  const inputRequestRef = useRef9(inputRequest);
   inputRequestRef.current = inputRequest;
-  const isModalOpenRef = useRef8(!!modal.type);
+  const isModalOpenRef = useRef9(!!modal.type);
   isModalOpenRef.current = !!modal.type;
-  const inputRef = useRef8(input);
+  const inputRef = useRef9(input);
   inputRef.current = input;
-  const clearInput = useCallback11(() => {
+  const clearInput = useCallback13(() => {
     setInput("");
   }, []);
-  const showModal = useCallback11((type, content) => {
+  const showModal = useCallback13((type, content) => {
     setModal({ type, content, scrollOffset: 0 });
   }, []);
-  const closeModal = useCallback11(() => {
+  const closeModal = useCallback13(() => {
     setModal({ type: null, content: "", scrollOffset: 0 });
   }, []);
-  const handleModalScroll = useCallback11((delta) => {
+  const handleModalScroll = useCallback13((delta) => {
     setModal((prev) => {
       const lines = prev.content.split("\n");
       const maxHeight = terminalHeight - TUI_DISPLAY_LIMITS.MODAL_CHROME_HEIGHT;
@@ -5856,7 +5987,7 @@ var useAppLogic = ({ autoApprove = false, target }) => {
       return { ...prev, scrollOffset: newOffset };
     });
   }, [terminalHeight]);
-  const handleExit = useCallback11(() => {
+  const handleExit = useCallback13(() => {
     cancelAllInputRequests();
     cleanupAllProcesses().catch(() => {
     });
@@ -5884,39 +6015,18 @@ var useAppLogic = ({ autoApprove = false, target }) => {
     isProcessingRef,
     autoApproveModeRef
   });
-  const handleRecallQueuedInput = useCallback11(() => {
-    return recallQueuedInput();
-  }, [recallQueuedInput]);
-  const handleSecretSubmit = useCallback11((value) => {
-    const ir = inputRequestRef.current;
-    if (ir.status !== "active") return;
-    const sanitized = sanitizeInput(value).slice(0, TUI_DISPLAY_LIMITS.MAX_INPUT_CHARS);
-    const displayText = ir.isPassword ? "\u2022".repeat(Math.min(sanitized.length, TUI_DISPLAY_LIMITS.PASSWORD_MASK_MAX)) : sanitized;
-    addMessage("user", displayText);
-    settleActiveInputRequest(sanitized);
-    setSecretInput("");
-  }, [addMessage, settleActiveInputRequest]);
-  const handleSubmit = useCallback11(async (value) => {
-    const trimmed = sanitizeInput(value);
-    if (!trimmed) return;
-    setInput("");
-    const safeInput = trimmed.slice(0, TUI_DISPLAY_LIMITS.MAX_INPUT_CHARS);
-    if (safeInput.length < trimmed.length) {
-      addMessage("system", `Input truncated to ${TUI_DISPLAY_LIMITS.MAX_INPUT_CHARS} chars for terminal stability.`);
-    }
-    const parsedCommand = parseSlashCommandInput(safeInput);
-    if (parsedCommand) {
-      addMessage("command", parsedCommand.normalized);
-      await handleCommand(parsedCommand.cmd, parsedCommand.args);
-    } else if (inputRequestRef.current.status === "active") {
-      handleSecretSubmit(safeInput);
-    } else if (isProcessingRef.current) {
-      agent.enqueueUserInput(safeInput);
-    } else {
-      addMessage("user", safeInput);
-      await executeTask(safeInput);
-    }
-  }, [agent, addMessage, executeTask, handleCommand, handleSecretSubmit]);
+  const { handleRecallQueuedInput, handleSecretSubmit, handleSubmit } = useAppSubmission({
+    addMessage,
+    agent,
+    executeTask,
+    handleCommand,
+    inputRequestRef,
+    isProcessingRef,
+    recallQueuedInput,
+    setInput,
+    setSecretInput,
+    settleActiveInputRequest
+  });
   useKeyboardShortcuts({
     addMessage,
     handleExit,
@@ -6580,10 +6690,10 @@ var MessageList = memo6(({
 import { memo as memo9 } from "react";
 
 // src/platform/tui/hooks/useStatusTimer.ts
-import { useState as useState10, useEffect as useEffect7, useRef as useRef9 } from "react";
+import { useState as useState10, useEffect as useEffect7, useRef as useRef10 } from "react";
 var useStatusTimer = (currentStatus, isProcessing) => {
   const [statusElapsed, setStatusElapsed] = useState10(0);
-  const lastStatusRef = useRef9("");
+  const lastStatusRef = useRef10("");
   useEffect7(() => {
     if (!isProcessing || !currentStatus) {
       lastStatusRef.current = "";
@@ -6838,7 +6948,7 @@ var StatusDisplay = memo9(({
 });
 
 // src/platform/tui/components/ChatInput.tsx
-import { useMemo as useMemo4, useCallback as useCallback12, useRef as useRef11, memo as memo10, useState as useState12 } from "react";
+import { useMemo as useMemo4, useCallback as useCallback14, useRef as useRef12, memo as memo10, useState as useState12 } from "react";
 import { Box as Box14, Text as Text15 } from "ink";
 
 // src/platform/tui/components/input/AutocompletePreview.tsx
@@ -6881,7 +6991,7 @@ var AutocompletePreview = ({
 import { Box as Box12, Text as Text13 } from "ink";
 
 // src/platform/tui/components/input/SimpleTextInput.tsx
-import { useState as useState11, useEffect as useEffect8, useRef as useRef10, useMemo as useMemo3 } from "react";
+import { useState as useState11, useEffect as useEffect8, useRef as useRef11, useMemo as useMemo3 } from "react";
 import { Box as Box11, Text as Text12, useInput as useInput2, useStdout as useStdout2 } from "ink";
 import { jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
 var MOUSE_SEQUENCE_RE = /(?:\x1b)?\[<\d+;\d+;\d+[mM]/g;
@@ -6917,12 +7027,12 @@ var SimpleTextInput = ({
       write?.("\x1B[?25l");
     };
   }, [write]);
-  const lastInputRef = useRef10("");
-  const lastInputTimeRef = useRef10(0);
-  const valueRef = useRef10(value || "");
+  const lastInputRef = useRef11("");
+  const lastInputTimeRef = useRef11(0);
+  const valueRef = useRef11(value || "");
   valueRef.current = value || "";
-  const mouseFragmentRef = useRef10("");
-  const cursorRef = useRef10(cursor);
+  const mouseFragmentRef = useRef11("");
+  const cursorRef = useRef11(cursor);
   cursorRef.current = cursor;
   useEffect8(() => {
     setCursor((prev) => {
@@ -7115,38 +7225,38 @@ var ChatInput = memo10(({
   const showCommandHelp = isSlashMode && !hasArgs && suggestions.length === 0 && value.length > 1;
   const [selectedIdx, setSelectedIdx] = useState12(0);
   const clampedIdx = Math.min(selectedIdx, Math.max(0, suggestions.length - 1));
-  const selectedIdxRef = useRef11(clampedIdx);
+  const selectedIdxRef = useRef12(clampedIdx);
   selectedIdxRef.current = clampedIdx;
-  const suggestionsRef = useRef11(suggestions);
+  const suggestionsRef = useRef12(suggestions);
   suggestionsRef.current = suggestions;
-  const isSlashModeRef = useRef11(isSlashMode);
+  const isSlashModeRef = useRef12(isSlashMode);
   isSlashModeRef.current = isSlashMode;
-  const hasArgsRef = useRef11(hasArgs);
+  const hasArgsRef = useRef12(hasArgs);
   hasArgsRef.current = hasArgs;
-  const showPreviewRef = useRef11(showPreview);
+  const showPreviewRef = useRef12(showPreview);
   showPreviewRef.current = showPreview;
-  const inputRequestRef = useRef11(inputRequest);
+  const inputRequestRef = useRef12(inputRequest);
   inputRequestRef.current = inputRequest;
-  const onChangeRef = useRef11(onChange);
+  const onChangeRef = useRef12(onChange);
   onChangeRef.current = onChange;
-  const onRecallQueuedInputRef = useRef11(onRecallQueuedInput);
+  const onRecallQueuedInputRef = useRef12(onRecallQueuedInput);
   onRecallQueuedInputRef.current = onRecallQueuedInput;
-  const queuedCountRef = useRef11(queuedCount);
+  const queuedCountRef = useRef12(queuedCount);
   queuedCountRef.current = queuedCount;
-  const latestValueRef = useRef11(value);
+  const latestValueRef = useRef12(value);
   latestValueRef.current = value;
-  const handleLocalChange = useCallback12((newVal) => {
+  const handleLocalChange = useCallback14((newVal) => {
     latestValueRef.current = newVal;
     onChange(newVal);
   }, [onChange]);
-  const latestSecretRef = useRef11(secretInput);
+  const latestSecretRef = useRef12(secretInput);
   latestSecretRef.current = secretInput;
-  const handleSecretChange = useCallback12((newVal) => {
+  const handleSecretChange = useCallback14((newVal) => {
     latestSecretRef.current = newVal;
     setSecretInput(newVal);
   }, [setSecretInput]);
   const [inputKey, setInputKey] = useState12(0);
-  const completeCommand = useCallback12((idx) => {
+  const completeCommand = useCallback14((idx) => {
     const sug = suggestionsRef.current;
     if (!sug.length) return;
     const best = sug[Math.min(idx, sug.length - 1)];
@@ -7156,9 +7266,9 @@ var ChatInput = memo10(({
     setSelectedIdx(0);
     setInputKey((k) => k + 1);
   }, []);
-  const onSubmitRef = useRef11(onSubmit);
+  const onSubmitRef = useRef12(onSubmit);
   onSubmitRef.current = onSubmit;
-  const wrappedOnSubmit = useCallback12((_staleVal) => {
+  const wrappedOnSubmit = useCallback14((_staleVal) => {
     const finalValue = latestValueRef.current;
     if (showPreviewRef.current) {
       const sug = suggestionsRef.current;
@@ -7178,12 +7288,12 @@ var ChatInput = memo10(({
     }
     onSubmitRef.current(finalValue);
   }, [completeCommand]);
-  const onSecretSubmitRef = useRef11(onSecretSubmit);
+  const onSecretSubmitRef = useRef12(onSecretSubmit);
   onSecretSubmitRef.current = onSecretSubmit;
-  const wrappedSecretSubmit = useCallback12((_staleVal) => {
+  const wrappedSecretSubmit = useCallback14((_staleVal) => {
     onSecretSubmitRef.current(latestSecretRef.current);
   }, []);
-  const handleSpecialKey = useCallback12((key) => {
+  const handleSpecialKey = useCallback14((key) => {
     if (inputRequestRef.current.status === "active") return false;
     const sug = suggestionsRef.current;
     const visible = showPreviewRef.current;
@@ -7333,7 +7443,7 @@ var Footer = memo11(({
 var footer_default = Footer;
 
 // src/platform/tui/components/Modal.tsx
-import { useMemo as useMemo5, memo as memo12, useCallback as useCallback13, useRef as useRef12 } from "react";
+import { useMemo as useMemo5, memo as memo12, useCallback as useCallback15, useRef as useRef13 } from "react";
 import { Box as Box16, Text as Text17, useInput as useInput3 } from "ink";
 import { jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
 var MODAL_TITLES = {
@@ -7348,9 +7458,9 @@ var Modal = memo12(({
   onScroll,
   onClose
 }) => {
-  const onScrollRef = useRef12(onScroll);
+  const onScrollRef = useRef13(onScroll);
   onScrollRef.current = onScroll;
-  const onCloseRef = useRef12(onClose);
+  const onCloseRef = useRef13(onClose);
   onCloseRef.current = onClose;
   const { columns, rows } = useTerminalSize();
   const terminalHeight = rows;
@@ -7362,7 +7472,7 @@ var Modal = memo12(({
     () => lines.slice(scrollOffset, scrollOffset + maxHeight),
     [lines, scrollOffset, maxHeight]
   );
-  useInput3(useCallback13((input, key) => {
+  useInput3(useCallback15((input, key) => {
     if (key.escape || input === "q") {
       onCloseRef.current();
     } else if (key.upArrow || input === "k") {
@@ -8465,57 +8575,6 @@ async function scanAction(target, options) {
   }
 }
 
-// src/platform/tui/cli/commands/help.ts
-import chalk4 from "chalk";
-function helpExtendedAction() {
-  console.log(`
-${chalk4.hex(HEX.primary)(APP_NAME + " - Autonomous Penetration Testing AI")}
-
-  ${chalk4.hex(HEX.yellow)("Usage:")}
-
-  ${chalk4.hex(HEX.gray)("$ pentesting")}                                   Start interactive mode
-  ${chalk4.hex(HEX.gray)("$ pentesting -t 192.168.1.1")}                     Start with target
-  ${chalk4.hex(HEX.gray)("$ pentesting --dangerously-skip-permissions")}    Enable tool auto-approve in strict mode
-
-${chalk4.hex(HEX.yellow)("Commands:")}
-
-  ${chalk4.hex(HEX.primary)("pentesting")}                       Interactive TUI mode
-  ${chalk4.hex(HEX.primary)("pentesting run <objective>")}       Run single objective
-  ${chalk4.hex(HEX.primary)("pentesting scan <target>")}         Quick scan target
-
-${chalk4.hex(HEX.yellow)("Options:")}
-
-  ${chalk4.hex(HEX.primary)("--dangerously-skip-permissions")}    Bypass strict approval mode by auto-approving tools
-  ${chalk4.hex(HEX.primary)("-t, --target <ip>")}                 Set target
-  ${chalk4.hex(HEX.primary)("-o, --output <file>")}               Save results to file
-
-${chalk4.hex(HEX.yellow)("Interactive Commands:")}
-
-  ${chalk4.hex(HEX.primary)("/target <ip>")}     Set target
-  ${chalk4.hex(HEX.primary)("/start")}           Start autonomous mode
-  ${chalk4.hex(HEX.primary)("/hint <text>")}     Provide hint
-  ${chalk4.hex(HEX.primary)("/findings")}        Show findings
-  ${chalk4.hex(HEX.primary)("/clear")}           Reset session
-
-${chalk4.hex(HEX.yellow)("Examples:")}
-
-  ${chalk4.hex(HEX.gray)("# Full autonomous mode")}
-  $ pentesting --dangerously-skip-permissions -t 10.10.10.5
-
-  ${chalk4.hex(HEX.gray)("# Run specific objective")}
-  $ pentesting run "Find SQL injection" -t http://target.com -o report.json
-
-  ${chalk4.hex(HEX.gray)("# Quick vulnerability scan")}
-  $ pentesting scan 192.168.1.1 -s vuln
-
-${chalk4.hex(HEX.yellow)("Environment:")}
-
-  ${chalk4.hex(HEX.primary)("PENTEST_API_KEY")}      Required - LLM API key
-  ${chalk4.hex(HEX.primary)("PENTEST_BASE_URL")}     Optional - AI API base URL
-  ${chalk4.hex(HEX.primary)("PENTEST_MODEL")}        Optional - Model override
-`);
-}
-
 // src/platform/tui/cli/args.ts
 import { InvalidArgumentError } from "commander";
 function parsePositiveInt(value) {
@@ -8552,9 +8611,6 @@ function createProgram() {
       dangerouslySkipPermissions: opts.dangerouslySkipPermissions
     });
   });
-  program2.command("help-extended").description("Show extended help with examples").action(() => {
-    helpExtendedAction();
-  });
   return program2;
 }
 
@@ -8565,7 +8621,7 @@ if (process.env.PENTEST_TOR === "true" && isContainerizedRuntime()) {
 }
 var _configErrors = validateRequiredConfig();
 if (_configErrors.length > 0) {
-  _configErrors.forEach((e) => console.error(chalk5.hex(HEX.red)(e)));
+  _configErrors.forEach((e) => console.error(chalk4.hex(HEX.red)(e)));
   process.exit(EXIT_CODES.CONFIG_ERROR);
 }
 var program = createProgram();