pentesting 0.53.0 → 0.54.0

package/dist/main.js

@@ -12,7 +12,7 @@ import { Command } from "commander";
 import chalk from "chalk";
 
 // src/platform/tui/app.tsx
-import { useState as useState5, useCallback as useCallback4, useEffect as useEffect4, useRef as useRef5 } from "react";
+import { useState as useState6, useCallback as useCallback4, useEffect as useEffect5, useRef as useRef6 } from "react";
 import { Box as Box6, useInput as useInput2, useApp, useStdout } from "ink";
 
 // src/platform/tui/hooks/useAgent.ts
@@ -33,6 +33,7 @@ var TOOL_TIMEOUTS = {
   /** Full web application scan */
   WEB_SCAN: 3e5
 };
+var CURL_MAX_TIME_SEC = 600;
 
 // src/shared/constants/limits.ts
 var DISPLAY_LIMITS = {
@@ -188,8 +189,6 @@ var MEMORY_LIMITS = {
   TECHNIQUE_FAILURE_DECAY: 30,
   /** Auto-prune threshold: techniques below this confidence are discarded */
   TECHNIQUE_PRUNE_THRESHOLD: 10,
-  /** @deprecated Superseded by fingerprint-based matching in extractFingerprint(). Kept for reference. */
-  COMMAND_MATCH_WORDS: 3,
   /** Maximum unverified techniques to show in prompt */
   PROMPT_UNVERIFIED_TECHNIQUES: 10,
   /**
@@ -197,13 +196,7 @@ var MEMORY_LIMITS = {
    * WHY: journal.ts had this as a module-local constant (50).
    * Centralizing enables consistent rotation across journal JSON + turn MD files.
    */
-  MAX_TURN_ENTRIES: 50,
-  /**
-   * Maximum raw output files kept in .pentesting/outputs/.
-   * WHY: journal.ts had this as a module-local constant (30).
-   * Output files are large raw dumps; the journal entries retain their summaries.
-   */
-  MAX_OUTPUT_FILES: 30
+  MAX_TURN_ENTRIES: 50
 };
 
 // src/shared/constants/patterns.ts
@@ -349,7 +342,7 @@ var ORPHAN_PROCESS_NAMES = [
 
 // src/shared/constants/agent.ts
 var APP_NAME = "Pentest AI";
-var APP_VERSION = "0.53.0";
+var APP_VERSION = "0.54.0";
 var APP_DESCRIPTION = "Autonomous Penetration Testing AI Agent";
 var LLM_ROLES = {
   SYSTEM: "system",
@@ -789,6 +782,7 @@ var UI_COMMANDS = {
   LOGS: "logs",
   LOGS_SHORT: "l",
   CTF: "ctf",
+  TOR: "tor",
   AUTO: "auto",
   GRAPH: "graph",
   GRAPH_SHORT: "g",
@@ -1738,8 +1732,7 @@ var ENV_KEYS = {
   SEARCH_API_KEY: "SEARCH_API_KEY",
   SEARCH_API_URL: "SEARCH_API_URL",
   THINKING: "PENTEST_THINKING",
-  THINKING_BUDGET: "PENTEST_THINKING_BUDGET",
-  TOR: "PENTEST_TOR"
+  THINKING_BUDGET: "PENTEST_THINKING_BUDGET"
 };
 var DEFAULT_SEARCH_API_URL = "https://api.search.brave.com/res/v1/web/search";
 var DEFAULT_MODEL = "glm-4.7";
@@ -1782,11 +1775,82 @@ var TOR_PROXY = {
   /** Flags for the wrapper command (-q = quiet, no banners) */
   WRAPPER_FLAGS: "-q"
 };
+var torEnabled = false;
 function isTorEnabled() {
-  return process.env[ENV_KEYS.TOR] === "true";
+  return torEnabled;
+}
+function setTorEnabled(enabled) {
+  torEnabled = enabled;
+}
+function checkTorLeakRisk(command) {
+  if (!isTorEnabled()) return { safe: true };
+  if (/\bping\b/.test(command)) {
+    return {
+      safe: false,
+      reason: "ping uses ICMP \u2014 bypasses Tor, real IP exposed to target",
+      suggestion: "Use TCP probe instead: curl --socks5-hostname 127.0.0.1:9050 -s --connect-timeout 5 http://<target>:<port>"
+    };
+  }
+  if (/\btraceroute\b|\btracepath\b|\bmtr\b/.test(command)) {
+    return {
+      safe: false,
+      reason: "traceroute/tracepath/mtr uses ICMP/UDP \u2014 bypasses Tor, real IP exposed",
+      suggestion: "Skip traceroute when Tor is enabled (reveals all hops including your IP)"
+    };
+  }
+  if (/\bdig\b/.test(command) || /\bnslookup\b/.test(command) || /(?:^|[;&|\s])host(?:\s|$)/.test(command)) {
+    return {
+      safe: false,
+      reason: "dig/host/nslookup use UDP \u2014 DNS query bypasses Tor, real IP visible to DNS server",
+      suggestion: `Use DNS-over-HTTPS: curl --socks5-hostname 127.0.0.1:9050 "https://dns.google/resolve?name=<host>&type=A"`
+    };
+  }
+  if (/\bnmap\b/.test(command) && /\s-sU\b/.test(command)) {
+    return {
+      safe: false,
+      reason: "nmap -sU (UDP scan) bypasses Tor \u2014 UDP is not routed through SOCKS5",
+      suggestion: "Skip UDP scan with Tor ON. Use TCP scan: proxychains4 -q nmap -sT -Pn"
+    };
+  }
+  return { safe: true };
 }
 function wrapCommandForTor(command) {
   if (!isTorEnabled()) return command;
+  const SOCKS = `${TOR_PROXY.SOCKS_HOST}:${TOR_PROXY.SOCKS_PORT}`;
+  if (/\bcurl\b/.test(command)) {
+    if (/--socks5|--proxy\b|-x\s/.test(command)) return command;
+    return command.replace(/\bcurl\b/, `curl --socks5-hostname ${SOCKS}`);
+  }
+  if (/\bwget\b/.test(command)) {
+    if (/--execute.*proxy|http_proxy|https_proxy/i.test(command)) return command;
+    return command.replace(
+      /\bwget\b/,
+      `wget -e use_proxy=yes -e http_proxy=socks5h://${SOCKS} -e https_proxy=socks5h://${SOCKS}`
+    );
+  }
+  if (/\bsqlmap\b/.test(command)) {
+    if (/--tor\b|--proxy\b/.test(command)) return command;
+    return command.replace(
+      /\bsqlmap\b/,
+      `sqlmap --tor --tor-type=SOCKS5 --tor-port=${TOR_PROXY.SOCKS_PORT}`
+    );
+  }
+  if (/\bgobuster\b/.test(command)) {
+    if (/--proxy\b/.test(command)) return command;
+    return command.replace(/\bgobuster\b/, `gobuster --proxy socks5://${SOCKS}`);
+  }
+  if (/\bffuf\b/.test(command)) {
+    if (/-x\s/.test(command)) return command;
+    return command.replace(/\bffuf\b/, `ffuf -x socks5://${SOCKS}`);
+  }
+  if (/\bnmap\b/.test(command)) {
+    let nmapCmd = command;
+    nmapCmd = nmapCmd.replace(/\s-s[SA]\b/g, " -sT");
+    if (!/\s-Pn\b/.test(nmapCmd)) {
+      nmapCmd = nmapCmd.replace(/\bnmap\b/, "nmap -Pn");
+    }
+    return `${TOR_PROXY.WRAPPER_CMD} ${TOR_PROXY.WRAPPER_FLAGS} ${nmapCmd}`;
+  }
   return `${TOR_PROXY.WRAPPER_CMD} ${TOR_PROXY.WRAPPER_FLAGS} ${command}`;
 }
 function getTorBrowserArgs() {
@@ -1840,6 +1904,16 @@ async function runCommand(command, args = [], options = {}) {
       error: `Command blocked: ${validation.error}`
     };
   }
+  const torLeak = checkTorLeakRisk(fullCommand);
+  if (!torLeak.safe) {
+    return {
+      success: false,
+      output: "",
+      error: `\u{1F6D1} TOR IP LEAK BLOCKED
+Reason: ${torLeak.reason}
+Suggestion: ${torLeak.suggestion}`
+    };
+  }
   const timeout = options.timeout ?? TOOL_TIMEOUTS.DEFAULT_COMMAND;
   const maxRetries = options.maxRetries ?? AGENT_LIMITS.MAX_INSTALL_RETRIES;
   const toolName = command.split(/[\s/]/).pop() || command;
@@ -1877,16 +1951,22 @@ async function runCommand(command, args = [], options = {}) {
   }
   return lastResult;
 }
+function injectCurlMaxTime(command, timeoutSec) {
+  if (!/\bcurl\b/.test(command)) return command;
+  if (/--max-time\b|-m\s+\d/.test(command)) return command;
+  return command.replace(/\bcurl\b/, `curl --max-time ${timeoutSec}`);
+}
 async function executeCommandOnce(command, options = {}) {
   return new Promise((resolve) => {
     const timeout = options.timeout ?? TOOL_TIMEOUTS.DEFAULT_COMMAND;
+    const safeCommand = injectCurlMaxTime(command, CURL_MAX_TIME_SEC);
     globalEventEmitter?.({
       type: COMMAND_EVENT_TYPES.COMMAND_START,
-      message: `Executing: ${command.slice(0, DISPLAY_LIMITS.COMMAND_PREVIEW)}${command.length > DISPLAY_LIMITS.COMMAND_PREVIEW ? "..." : ""}`
+      message: `Executing: ${safeCommand.slice(0, DISPLAY_LIMITS.COMMAND_PREVIEW)}${safeCommand.length > DISPLAY_LIMITS.COMMAND_PREVIEW ? "..." : ""}`
     });
-    const execCommand = wrapCommandForTor(command);
+    const execCommand = wrapCommandForTor(safeCommand);
     const child = spawn2("sh", ["-c", execCommand], {
-      timeout,
+      detached: true,
       env: { ...process.env, ...options.env },
       cwd: options.cwd
     });
@@ -1894,6 +1974,20 @@ async function executeCommandOnce(command, options = {}) {
     let stderr = "";
     let inputHandled = false;
     let processTerminated = false;
+    let timedOut = false;
+    const killTimer = setTimeout(() => {
+      if (processTerminated) return;
+      timedOut = true;
+      processTerminated = true;
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }
+    }, timeout);
     const checkForInputPrompt = async (data) => {
       if (inputHandled || !globalInputHandler || processTerminated) return;
       for (const pattern of INPUT_PROMPT_PATTERNS) {
@@ -1927,7 +2021,21 @@ async function executeCommandOnce(command, options = {}) {
       checkForInputPrompt(text);
     });
     child.on("close", (code) => {
+      clearTimeout(killTimer);
       processTerminated = true;
+      if (timedOut) {
+        globalEventEmitter?.({
+          type: COMMAND_EVENT_TYPES.COMMAND_FAILED,
+          message: `Command timed out after ${Math.round(timeout / 1e3)}s`
+        });
+        resolve({
+          success: false,
+          output: stdout.trim(),
+          error: `Command timed out after ${Math.round(timeout / 1e3)}s. Output so far:
+${(stdout + stderr).trim().slice(-500)}`
+        });
+        return;
+      }
       if (code === 0) {
         globalEventEmitter?.({
           type: COMMAND_EVENT_TYPES.COMMAND_SUCCESS,
@@ -1951,6 +2059,7 @@ async function executeCommandOnce(command, options = {}) {
       }
     });
     child.on("error", (err) => {
+      clearTimeout(killTimer);
       processTerminated = true;
       globalEventEmitter?.({
         type: COMMAND_EVENT_TYPES.COMMAND_ERROR,
@@ -2202,6 +2311,16 @@ function startBackgroundProcess(command, options = {}) {
   const stderrFile = createTempFile(FILE_EXTENSIONS.STDERR);
   const stdinFile = createTempFile(FILE_EXTENSIONS.STDIN);
   const { tags, port, role, isInteractive } = detectProcessRole(command);
+  const torLeak = checkTorLeakRisk(command);
+  if (!torLeak.safe) {
+    for (const f of [stdoutFile, stderrFile, stdinFile]) {
+      try {
+        unlinkSync2(f);
+      } catch {
+      }
+    }
+    throw new Error(`\u{1F6D1} TOR IP LEAK BLOCKED \u2014 ${torLeak.reason}. ${torLeak.suggestion}`);
+  }
   const torCommand = wrapCommandForTor(command);
   let wrappedCmd;
   if (isInteractive) {
@@ -2644,7 +2763,7 @@ var StateSerializer = class {
       lines.push(resourceInfo);
     }
     if (state.isCtfMode()) {
-      lines.push(`Mode: CTF \u{1F3F4}`);
+      lines.push(`Flag Detection: ON \u{1F3F4}`);
       const flags = state.getFlags();
       if (flags.length > 0) {
         lines.push(`Flags Found (${flags.length}):`);
@@ -2653,6 +2772,16 @@ var StateSerializer = class {
         }
       }
     }
+    if (isTorEnabled()) {
+      lines.push(
+        `Tor Proxy: ON \u{1F9C5}
+Standard tools auto-proxied (curl, wget, nmap, sqlmap, gobuster, ffuf, hydra, etc.)
+Custom scripts: route ALL target connections through SOCKS5 127.0.0.1:9050.
+BLOCKED (leak real IP): ping, traceroute, dig, nslookup, nmap -sU`
+      );
+    } else {
+      lines.push(`Tor Proxy: OFF \u2014 direct connections.`);
+    }
     lines.push(`Phase: ${state.getPhase()}`);
     return lines.join("\n");
   }
@@ -2815,10 +2944,6 @@ var AttackGraph = class {
     }
     this.failedPaths.push(`${fromId} \u2192 ${toId}${reason ? ` (${reason})` : ""}`);
   }
-  // Backward-compatible alias
-  markExploited(nodeId) {
-    this.markSucceeded(nodeId);
-  }
   // ─── Domain-Specific Registration ───────────────────────────
   /**
    * Record a host discovery.
@@ -2877,7 +3002,7 @@ var AttackGraph = class {
       hasExploit
     });
     for (const [id, node] of this.nodes) {
-      if (node.type === "service" && node.label.includes(target)) {
+      if (node.type === NODE_TYPE.SERVICE && node.label.includes(target)) {
         this.addEdge(id, vulnId, "has_vulnerability", 0.8);
       }
     }
@@ -2919,7 +3044,7 @@ var AttackGraph = class {
       ...data
     });
     for (const [id, node] of this.nodes) {
-      if (node.type === "host" || node.type === "service") {
+      if (node.type === NODE_TYPE.HOST || node.type === NODE_TYPE.SERVICE) {
         const hostIp = String(node.data.ip || node.data.host || "");
         const hostname = String(node.data.hostname || "");
         if (hostIp && detail.includes(hostIp) || hostname && detail.includes(hostname)) {
@@ -3339,23 +3464,6 @@ var WorkingMemory = class {
       (e) => e.category === "failure" && e.fingerprint != null && fingerprintsMatch(e.fingerprint, fp)
     );
   }
-  /**
-   * Get all previous attempts (success & failure) for a specific tool+target vector.
-   * Returns the full history so the LLM can see what parameter combinations were tried.
-   *
-   * TODO: Wire up in tools.ts to pass vector history to strategist for smarter retries.
-   */
-  getAttemptsForVector(tool, target) {
-    const lowerTool = tool.toLowerCase();
-    return this.entries.filter((e) => {
-      if (e.fingerprint) {
-        const matchTool = e.fingerprint.tool === lowerTool;
-        const matchTarget = !target || e.fingerprint.target.includes(target);
-        return matchTool && matchTarget;
-      }
-      return String(e.context.tool || "").toLowerCase() === lowerTool;
-    });
-  }
   /** Internal prune helper (used by both add() and recordFailure()) */
   pruneIfNeeded() {
     if (this.entries.length > this.maxEntries) {
@@ -3383,26 +3491,6 @@ var WorkingMemory = class {
     }
     return count;
   }
-  /**
-   * Get consecutive failures for a specific vector (tool+target).
-   * Returns count of sequential failures where all attempts used the same tool+target.
-   *
-   * TODO: Wire up in tools.ts for per-vector threshold checks alongside global consecutive count.
-   */
-  getConsecutiveVectorFailures(tool, target) {
-    const lowerTool = tool.toLowerCase();
-    let count = 0;
-    for (let i = this.entries.length - 1; i >= 0; i--) {
-      const e = this.entries[i];
-      if (e.category !== "failure") break;
-      if (e.fingerprint && e.fingerprint.tool === lowerTool && (!target || e.fingerprint.target.includes(target))) {
-        count++;
-      } else {
-        break;
-      }
-    }
-    return count;
-  }
   /**
    * Format for prompt injection.
    */
@@ -3842,7 +3930,7 @@ var SharedState = class {
       missionSummary: "",
       missionChecklist: [],
       ctfMode: true,
-      // CTF mode ON by default
+      // Flag auto-detection ON by default
       flags: [],
       startedAt: now,
       // Auto-configure from PENTEST_DURATION env (seconds).
@@ -4018,7 +4106,7 @@ var SharedState = class {
   getPhase() {
     return this.data.currentPhase;
   }
-  // --- CTF Mode ---
+  // --- Flag Detection ---
   setCtfMode(shouldEnable) {
     this.data.ctfMode = shouldEnable;
   }
@@ -5240,10 +5328,27 @@ All ports freed. All children killed.`
   },
   {
     name: TOOL_NAMES.WRITE_FILE,
-    description: "Write content to file (creates parent directories if needed)",
+    description: `Write content to a file. Creates parent directories automatically.
+
+Primary use: Write custom exploit scripts, fuzzers, scanners, payloads.
+
+Workflow:
+  1. write_file({ path: "/tmp/exploit.py", content: "..." })
+  2. run_cmd({ command: "python3 /tmp/exploit.py" })
+  3. read_file to review output
+
+\u{1F9C5} TOR ON \u2014 MANDATORY: Any script that opens a network connection to the target
+MUST route through Tor SOCKS5 (127.0.0.1:9050). No exceptions.
+You are responsible for using the correct proxy method for the language you choose.
+Proxy patterns are in <current-state>. Ignoring this leaks your real IP.
+
+\u26A1 TOR OFF: Write scripts normally. Direct connections are fine.
+
+Standard tools (curl/wget/nmap/sqlmap/hydra etc.) via run_cmd are
+auto-proxied by the system \u2014 no extra work needed for those.`,
     parameters: {
-      path: { type: "string", description: "Absolute path to the file" },
-      content: { type: "string", description: "File content" }
+      path: { type: "string", description: "Absolute file path (e.g., /tmp/exploit.py)" },
+      content: { type: "string", description: "File content to write" }
     },
     required: ["path", "content"],
     execute: async (params) => writeFileContent(params.path, params.content)
@@ -7544,16 +7649,20 @@ Common wordlists are automatically searched in /usr/share/wordlists (rockyou.txt
       if (wordlist === "rockyou") wordlistPath = WORDLISTS.ROCKYOU;
       const cmd = `hashcat -m ${format || HASHCAT_MODES.MD5} "${hashes}" "${wordlistPath}" --force`;
       if (background) {
-        const proc = startBackgroundProcess(cmd, {
-          description: `Cracking hashes: ${hashes.slice(0, DISPLAY_LIMITS.HASH_PREVIEW_LENGTH)}...`,
-          purpose: `Attempting to crack ${format || "unknown"} hashes using ${wordlist}`
-        });
-        return {
-          success: true,
-          output: `Hash cracking started in background (ID: ${proc.id}).
+        try {
+          const proc = startBackgroundProcess(cmd, {
+            description: `Cracking hashes: ${hashes.slice(0, DISPLAY_LIMITS.HASH_PREVIEW_LENGTH)}...`,
+            purpose: `Attempting to crack ${format || "unknown"} hashes using ${wordlist}`
+          });
+          return {
+            success: true,
+            output: `Hash cracking started in background (ID: ${proc.id}).
 Command: ${cmd}
 Check status with: bg_process({ action: "status", process_id: "${proc.id}" })`
-        };
+          };
+        } catch (err) {
+          return { success: false, output: "", error: `Failed to start: ${err}` };
+        }
       } else {
         return runCommand(cmd);
       }
@@ -10761,7 +10870,7 @@ var ToolExecutor = class _ToolExecutor {
     }
   }
   // ─────────────────────────────────────────────────────────────────
-  // SUBSECTION: CTF Flag Detection
+  // SUBSECTION: Flag Detection
   // ─────────────────────────────────────────────────────────────────
   scanForFlags(output) {
     if (!this.state.isCtfMode()) return;
@@ -11099,12 +11208,12 @@ Phase: ${phase} | Targets: ${targets} | Findings: ${findings}
 
 ${direction}
 
-ESCALATION:
-1. web_search for techniques
-2. Try alternative approaches
-3. Probe for unknown vulns
-4. Brute-force with wordlists
-5. ask_user for hints
+PICK ANY \u2014 do whatever fits best (no order, all are valid):
+\u2022 Brute-force with wordlists (hydra/hashcat/ffuf + rockyou/seclists)
+\u2022 web_search for techniques
+\u2022 Try a completely different approach
+\u2022 Probe for unknown vulns
+\u2022 ask_user for hints
 
 ACT NOW \u2014 EXECUTE.`;
   }
@@ -11211,7 +11320,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 // src/shared/constants/prompts.ts
 var PROMPT_PATHS = {
   BASE: "base.md",
-  CTF_MODE: "ctf-mode.md",
+  OFFENSIVE_PLAYBOOK: "offensive-playbook.md",
   AGENT_FILES: {
     ORCHESTRATOR: "orchestrator.md",
     RECON: "recon.md",
@@ -11689,9 +11798,9 @@ var PHASE_PROMPT_MAP = {
 };
 var CORE_KNOWLEDGE_FILES = [
   AGENT_FILES.STRATEGY,
-  // Attack prioritization, first-turn protocol, upgrade loop
+  // Attack prioritization, first-turn protocol, upgrade loop (~2K tok)
   AGENT_FILES.ORCHESTRATOR,
-  // Phase transitions, multi-target management
+  // Kill chain position, phase transitions, multi-target (~2K tok)
   AGENT_FILES.EVASION,
   // Detection avoidance (always relevant)
   AGENT_FILES.ZERO_DAY,
@@ -11731,9 +11840,10 @@ var PromptBuilder = class {
    * Build complete prompt for LLM iteration (async).
    *
    * Layers (phase-aware, enhanced with D-CIPHER meta-prompting):
-   * 1. base.md — Core identity, rules, autonomy, shell management (~7.6K tok)
+   * 1. base.md — Core identity, rules, OODA protocol, anti-hallucination (~2.7K tok)
+   * 1b. Offensive playbook — attack methodology, time management, aggression rules (~2K tok)
    * 2. Phase-specific prompt — current phase's full specialist knowledge (~2K tok)
-   * 3. Core methodology — strategy, orchestrator, evasion (always loaded, ~12K tok)
+   * 3. Core methodology — strategy, orchestrator, evasion (always loaded, ~8K tok)
    * 4. Phase-relevant techniques — only attack techniques for current phase (~4-8K tok)
    * 5. Scope constraints
    * 6. Current state (targets, findings, loot, active processes)
@@ -11753,7 +11863,7 @@ var PromptBuilder = class {
   async build(userInput, phase) {
     const fragments = [
       this.loadPromptFile(PROMPT_PATHS.BASE),
-      this.loadCtfModePrompt(),
+      this.loadOffensivePlaybook(),
       this.loadPhasePrompt(phase),
       this.loadCoreKnowledge(phase),
       this.loadPhaseRelevantTechniques(phase),
@@ -11786,15 +11896,14 @@ var PromptBuilder = class {
     return fragments.filter((f) => !!f).join("\n\n");
   }
   /**
-   * Load CTF mode prompt when CTF mode is active.
-   * Adds ~3K tokens of CTF-specific strategy and flag hunting protocol.
+   * Load offensive playbook — attack methodology always active.
+   * Adds ~3K tokens of time management, technique quick-starts, aggression rules.
    */
-  loadCtfModePrompt() {
-    if (!this.state.isCtfMode()) return "";
-    const content = this.loadPromptFile(PROMPT_PATHS.CTF_MODE);
-    return content ? `<ctf-mode active="true">
+  loadOffensivePlaybook() {
+    const content = this.loadPromptFile(PROMPT_PATHS.OFFENSIVE_PLAYBOOK);
+    return content ? `<offensive-playbook>
 ${content}
-</ctf-mode>` : "";
+</offensive-playbook>` : "";
   }
   /**
    * Load a prompt file from src/agents/prompts/
@@ -13017,7 +13126,8 @@ var COMMAND_DEFINITIONS = [
   { name: "paths", alias: "p", description: "Show ranked attack paths" },
   { name: "assets", alias: "a", description: "List background processes" },
   { name: "logs", alias: "l", args: "<id>", description: "Show logs for an asset" },
-  { name: "ctf", description: "Toggle CTF mode" },
+  { name: "ctf", description: "Toggle auto flag detection" },
+  { name: "tor", description: "Toggle Tor proxy routing" },
   { name: "auto", description: "Toggle auto-approve mode" },
   { name: "clear", alias: "c", description: "Reset session & clean workspace" },
   { name: "help", alias: "h", description: "Show detailed help" },
@@ -13042,7 +13152,8 @@ ${COMMAND_DEFINITIONS.map((cmd) => {
 \u2022 Auto-install missing tools (apt/brew)
 \u2022 Transparent command execution
 \u2022 Interactive sudo password input
-\u2022 CTF mode: Auto flag detection & CTF-specific prompts
+\u2022 Flag detection: Auto-detect flags/proofs in tool output (/ctf to toggle)
+\u2022 Tor proxy: Route all traffic through Tor SOCKS proxy (/tor to toggle, default OFF)
 \u2022 Attack graph: Tracks discovered paths & prevents repeating failures
 
 \u2500\u2500 Tips \u2500\u2500
@@ -13068,6 +13179,7 @@ var useAgentState = () => {
   const retryCountRef = useRef(0);
   const tokenAccumRef = useRef(0);
   const lastStepTokensRef = useRef(0);
+  const toolStartedAtRef = useRef(0);
   const addMessage = useCallback((type, content) => {
     const id = Math.random().toString(36).substring(7);
     setMessages((prev) => [...prev, { id, type, content, timestamp: /* @__PURE__ */ new Date() }]);
@@ -13130,7 +13242,8 @@ var useAgentState = () => {
     addMessage,
     resetCumulativeCounters,
     manageTimer,
-    clearAllTimers
+    clearAllTimers,
+    toolStartedAtRef
   };
 };
 
@@ -13149,19 +13262,22 @@ var useAgentEvents = (agent, eventsRef, state) => {
     retryCountRef,
     tokenAccumRef,
     lastStepTokensRef,
-    clearAllTimers
+    clearAllTimers,
+    toolStartedAtRef
   } = state;
   const reasoningBufferRef = useRef2("");
   useEffect(() => {
     const events = eventsRef.current;
     const onToolCall = (e) => {
       if (NOISE_CLASSIFICATION.LOW_VISIBILITY.includes(e.data.toolName)) return;
+      toolStartedAtRef.current = Date.now();
       setCurrentStatus(`${e.data.toolName}\u2026`);
       const inputStr = formatToolInput(e.data.toolName, e.data.input);
       const label = inputStr ? `${toDisplayName(e.data.toolName)}(${inputStr})` : `${toDisplayName(e.data.toolName)}`;
       addMessage("tool", label);
     };
     const onToolResult = (e) => {
+      toolStartedAtRef.current = 0;
       if (NOISE_CLASSIFICATION.LOW_VISIBILITY.includes(e.data.toolName)) {
         return;
       }
@@ -13320,6 +13436,7 @@ ${firstLine}`);
     tokenAccumRef,
     lastStepTokensRef,
     clearAllTimers,
+    toolStartedAtRef,
     eventsRef
   ]);
 };
@@ -13759,7 +13876,7 @@ var MessageList = memo(({ messages }) => {
 });
 
 // src/platform/tui/components/StatusDisplay.tsx
-import { memo as memo3 } from "react";
+import { memo as memo3, useEffect as useEffect4, useRef as useRef4, useState as useState4 } from "react";
 import { Box as Box3, Text as Text4 } from "ink";
 
 // src/platform/tui/components/MusicSpinner.tsx
@@ -13785,26 +13902,50 @@ var StatusDisplay = memo3(({
   retryState,
   isProcessing,
   currentStatus,
-  elapsedTime,
   currentTokens
 }) => {
   const truncateError = (err) => {
     return err.length > DISPLAY_LIMITS.RETRY_ERROR_PREVIEW ? err.substring(0, DISPLAY_LIMITS.RETRY_ERROR_TRUNCATED) + "..." : err;
   };
-  const meta = formatMeta(elapsedTime * 1e3, currentTokens);
+  const [statusElapsed, setStatusElapsed] = useState4(0);
+  const statusTimerRef = useRef4(null);
+  const statusStartRef = useRef4(Date.now());
+  useEffect4(() => {
+    if (statusTimerRef.current) clearInterval(statusTimerRef.current);
+    if (isProcessing && currentStatus) {
+      statusStartRef.current = Date.now();
+      setStatusElapsed(0);
+      statusTimerRef.current = setInterval(() => {
+        setStatusElapsed(Math.floor((Date.now() - statusStartRef.current) / 1e3));
+      }, 1e3);
+    } else {
+      setStatusElapsed(0);
+      statusTimerRef.current = null;
+    }
+    return () => {
+      if (statusTimerRef.current) clearInterval(statusTimerRef.current);
+    };
+  }, [currentStatus, isProcessing]);
+  const buildMeta = () => {
+    const parts = [];
+    if (statusElapsed > 0) parts.push(formatDuration2(statusElapsed * 1e3));
+    if (currentTokens > 0) parts.push(`\u2191 ${formatTokens(currentTokens)} tokens`);
+    return parts.length > 0 ? `(${parts.join(" \xB7 ")})` : "";
+  };
+  const meta = buildMeta();
   const isThinkingStatus = currentStatus.startsWith("Reasoning");
   const statusLines = currentStatus ? currentStatus.split("\n").filter(Boolean) : [];
   const statusMain = statusLines[0] || "Processing...";
   if (retryState.status === "retrying") {
     return /* @__PURE__ */ jsxs3(Box3, { children: [
-      /* @__PURE__ */ jsx4(Text4, { color: THEME.yellow, children: /* @__PURE__ */ jsx4(MusicSpinner, { color: THEME.yellow }) }),
-      /* @__PURE__ */ jsxs3(Text4, { color: THEME.yellow, bold: true, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: THEME.yellow, wrap: "truncate", children: /* @__PURE__ */ jsx4(MusicSpinner, { color: THEME.yellow }) }),
+      /* @__PURE__ */ jsxs3(Text4, { color: THEME.yellow, bold: true, wrap: "truncate", children: [
         " \u27F3 Retry #",
         retryState.attempt,
         "/",
         retryState.maxRetries
       ] }),
-      /* @__PURE__ */ jsxs3(Text4, { color: THEME.gray, children: [
+      /* @__PURE__ */ jsxs3(Text4, { color: THEME.gray, wrap: "truncate", children: [
         " \u2014 ",
         retryState.countdown,
         "s \xB7 ",
@@ -13815,12 +13956,12 @@ var StatusDisplay = memo3(({
   if (isProcessing) {
     const previewText = isThinkingStatus && statusLines.length > 1 ? `${statusMain} \u2014 ${statusLines[statusLines.length - 1]}` : statusMain;
     return /* @__PURE__ */ jsxs3(Box3, { children: [
-      /* @__PURE__ */ jsx4(Text4, { color: isThinkingStatus ? THEME.cyan : THEME.primary, children: /* @__PURE__ */ jsx4(MusicSpinner, { color: isThinkingStatus ? THEME.cyan : THEME.primary }) }),
-      /* @__PURE__ */ jsxs3(Text4, { color: isThinkingStatus ? THEME.cyan : THEME.primary, bold: true, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: isThinkingStatus ? THEME.cyan : THEME.primary, wrap: "truncate", children: /* @__PURE__ */ jsx4(MusicSpinner, { color: isThinkingStatus ? THEME.cyan : THEME.primary }) }),
+      /* @__PURE__ */ jsxs3(Text4, { color: isThinkingStatus ? THEME.cyan : THEME.primary, bold: true, wrap: "truncate", children: [
         " ",
         previewText
       ] }),
-      /* @__PURE__ */ jsxs3(Text4, { color: THEME.gray, children: [
+      /* @__PURE__ */ jsxs3(Text4, { color: THEME.gray, wrap: "truncate", children: [
         " ",
         meta
       ] })
@@ -13830,7 +13971,7 @@ var StatusDisplay = memo3(({
 });
 
 // src/platform/tui/components/ChatInput.tsx
-import { useMemo, useCallback as useCallback3, useRef as useRef4, memo as memo4, useState as useState4 } from "react";
+import { useMemo, useCallback as useCallback3, useRef as useRef5, memo as memo4, useState as useState5 } from "react";
 import { Box as Box4, Text as Text5, useInput } from "ink";
 import TextInput from "ink-text-input";
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
@@ -13853,17 +13994,17 @@ var ChatInput = memo4(({
     return getMatchingCommands(partialCmd).slice(0, MAX_SUGGESTIONS);
   }, [isSlashMode, partialCmd, hasArgs]);
   const showPreview = isSlashMode && !hasArgs && suggestions.length > 0;
-  const suggestionsRef = useRef4(suggestions);
+  const suggestionsRef = useRef5(suggestions);
   suggestionsRef.current = suggestions;
-  const isSlashModeRef = useRef4(isSlashMode);
+  const isSlashModeRef = useRef5(isSlashMode);
   isSlashModeRef.current = isSlashMode;
-  const hasArgsRef = useRef4(hasArgs);
+  const hasArgsRef = useRef5(hasArgs);
   hasArgsRef.current = hasArgs;
-  const inputRequestRef = useRef4(inputRequest);
+  const inputRequestRef = useRef5(inputRequest);
   inputRequestRef.current = inputRequest;
-  const onChangeRef = useRef4(onChange);
+  const onChangeRef = useRef5(onChange);
   onChangeRef.current = onChange;
-  const [inputKey, setInputKey] = useState4(0);
+  const [inputKey, setInputKey] = useState5(0);
   useInput(useCallback3((_input, key) => {
     if (inputRequestRef.current.status === "active") return;
     if (key.tab && isSlashModeRef.current && !hasArgsRef.current && suggestionsRef.current.length > 0) {
@@ -13968,6 +14109,7 @@ var Footer = memo5(({ phase, targets, findings, todo, elapsedTime, isProcessing
       paddingX: 1,
       marginTop: 0,
       justifyContent: "space-between",
+      overflow: "hidden",
       children: [
         /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
           /* @__PURE__ */ jsxs5(Text6, { color: THEME.gray, children: [
@@ -14003,9 +14145,9 @@ var App = ({ autoApprove = false, target }) => {
   const { exit } = useApp();
   const { stdout } = useStdout();
   const terminalWidth = stdout?.columns ?? 80;
-  const [input, setInput] = useState5("");
-  const [secretInput, setSecretInput] = useState5("");
-  const [autoApproveMode, setAutoApproveMode] = useState5(autoApprove);
+  const [input, setInput] = useState6("");
+  const [secretInput, setSecretInput] = useState6("");
+  const [autoApproveMode, setAutoApproveMode] = useState6(autoApprove);
   const {
     agent,
     messages,
@@ -14024,11 +14166,11 @@ var App = ({ autoApprove = false, target }) => {
     addMessage,
     refreshStats
   } = useAgent(autoApproveMode, target);
-  const isProcessingRef = useRef5(isProcessing);
+  const isProcessingRef = useRef6(isProcessing);
   isProcessingRef.current = isProcessing;
-  const autoApproveModeRef = useRef5(autoApproveMode);
+  const autoApproveModeRef = useRef6(autoApproveMode);
   autoApproveModeRef.current = autoApproveMode;
-  const inputRequestRef = useRef5(inputRequest);
+  const inputRequestRef = useRef6(inputRequest);
   inputRequestRef.current = inputRequest;
   const handleExit = useCallback4(() => {
     const ir = inputRequestRef.current;
@@ -14168,7 +14310,12 @@ ${procData.stdout || "(no output)"}
         break;
       case UI_COMMANDS.CTF:
         const ctfEnabled = agent.toggleCtfMode();
-        addMessage("system", ctfEnabled ? "[CTF] Mode ON - flag detection active" : "[CTF] Mode OFF - standard pentest");
+        addMessage("system", ctfEnabled ? "\u{1F3F4} Flag auto-detection ON" : "\u{1F3F4} Flag auto-detection OFF");
+        break;
+      case UI_COMMANDS.TOR:
+        const newTorState = !isTorEnabled();
+        setTorEnabled(newTorState);
+        addMessage("system", newTorState ? "\u{1F9C5} Tor proxy ON \u2014 target traffic routed through SOCKS5 (proxychains4 / native flags)" : "\u{1F9C5} Tor proxy OFF \u2014 direct connections");
         break;
       case UI_COMMANDS.GRAPH:
       case UI_COMMANDS.GRAPH_SHORT:
@@ -14220,8 +14367,8 @@ ${procData.stdout || "(no output)"}
     setInputRequest({ status: "inactive" });
     setSecretInput("");
   }, [addMessage, setInputRequest]);
-  const ctrlCTimerRef = useRef5(null);
-  const ctrlCPressedRef = useRef5(false);
+  const ctrlCTimerRef = useRef6(null);
+  const ctrlCPressedRef = useRef6(false);
   const handleCtrlC = useCallback4(() => {
     if (ctrlCPressedRef.current) {
       if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
@@ -14236,7 +14383,7 @@ ${procData.stdout || "(no output)"}
       ctrlCTimerRef.current = null;
     }, 3e3);
   }, [handleExit, addMessage, abort]);
-  useEffect4(() => {
+  useEffect5(() => {
     return () => {
       if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
     };
@@ -14248,7 +14395,7 @@ ${procData.stdout || "(no output)"}
     }
     if (key.ctrl && ch === "c") handleCtrlC();
   }, [cancelInputRequest, abort, handleCtrlC]));
-  useEffect4(() => {
+  useEffect5(() => {
     const onSignal = () => handleCtrlC();
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
@@ -14257,16 +14404,21 @@ ${procData.stdout || "(no output)"}
       process.off("SIGTERM", onSignal);
     };
   }, [handleCtrlC]);
+  const isSlashMode = input.startsWith("/");
+  const partialCmd = isSlashMode ? input.slice(1).split(" ")[0] : "";
+  const hasArgs = isSlashMode && input.includes(" ");
+  const suggestionCount = isSlashMode && !hasArgs && inputRequest.status !== "active" ? Math.min(getMatchingCommands(partialCmd).length, MAX_SUGGESTIONS) : 0;
+  const previewHeight = suggestionCount > 0 ? suggestionCount + 2 : 0;
+  const bottomHeight = 6 + previewHeight;
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, width: terminalWidth, children: [
     /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", children: /* @__PURE__ */ jsx7(MessageList, { messages }) }),
-    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: 6, children: [
+    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: bottomHeight, children: [
       /* @__PURE__ */ jsx7(
         StatusDisplay,
         {
           retryState,
           isProcessing,
           currentStatus,
-          elapsedTime,
           currentTokens
         }
       ),
@@ -14325,6 +14477,9 @@ var CLI_SCAN_TYPES = Object.freeze([
 import gradient from "gradient-string";
 import { jsx as jsx8 } from "react/jsx-runtime";
 initDebugLogger();
+if (process.env.PENTEST_TOR === "true") {
+  setTorEnabled(true);
+}
 var _configErrors = validateRequiredConfig();
 if (_configErrors.length > 0) {
   _configErrors.forEach((e) => console.error(chalk.hex(HEX.red)(e)));