pentesting 0.12.7 → 0.12.13

package/dist/index.js

@@ -1,4 +1,14 @@
 #!/usr/bin/env node
+import {
+  ctfResearch,
+  searchADWriteups,
+  searchByScenario,
+  searchLinuxPrivesc,
+  searchMachineWriteup,
+  searchWindowsPrivesc,
+  searchWriteups,
+  securityResearch
+} from "./chunk-AOJBE232.js";
 import {
   AGENT_CONFIG,
   AGENT_EVENT,
@@ -15,8 +25,9 @@ import {
   PHASE_ID,
   PHASE_STATUS,
   THOUGHT_TYPE,
-  TOOL_NAME
-} from "./chunk-JXR7HH4V.js";
+  TOOL_NAME,
+  TOOL_TO_APT
+} from "./chunk-6IXHQS2A.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -33,7 +44,7 @@ import Spinner from "ink-spinner";
 
 // src/core/agent/autonomous-agent.ts
 import Anthropic from "@anthropic-ai/sdk";
-import { EventEmitter as EventEmitter18 } from "events";
+import { EventEmitter as EventEmitter17 } from "events";
 
 // src/core/prompts/autonomous-prompt.ts
 var AUTONOMOUS_HACKING_PROMPT = `You are Pentesting, an elite autonomous penetration testing AI designed for CTF competitions and professional security assessments. You operate with minimal human intervention, making intelligent decisions, adapting to obstacles, and persistently pursuing objectives until complete system compromise.
@@ -205,7 +216,16 @@ RIGHT: Use ffuf tool with url=https://domain.com/FUZZ, mode=directory
 
 NEVER write manual bash loops when MCP tools exist!
 ALWAYS prefer MCP tools over bash commands!
-</mandatory_autonomous_execution>
+
+    <explore_and_verify_strategy>
+    When performing research or vulnerability analysis:
+    1. **Search**: Start with broad searches (search_writeups, security_research).
+    2. **Explore**: Use fetchUrlContent to read the actual content of promising links.
+    3. **Recursive Search**: If you find specific keywords, CVEs, or tool names in the content, perform NEW searches for those specific items.
+    4. **Verify**: Use browser_automation to interact with target sites and verify if the techniques found in research actually apply to the current target.
+    5. **Trace**: Document the path from initial search to final verification.
+    </explore_and_verify_strategy>
+    </mandatory_autonomous_execution>
 
 <output_format>
 Always structure your thinking clearly:
@@ -2776,12 +2796,6 @@ var ALL_TOOLS = [
   ...RESEARCH_TOOLS
 ];
 
-// src/core/tools/tool-executor.ts
-import { exec, spawn as spawn2 } from "child_process";
-import { promisify } from "util";
-import * as fs from "fs/promises";
-import * as path from "path";
-
 // src/core/resource/resource-manager.ts
 import { EventEmitter } from "events";
 var RESOURCE_EVENT = {
@@ -3085,343 +3099,234 @@ function getResourceManager(config) {
   return resourceManagerInstance;
 }
 
-// src/core/tools/web-search.ts
-import { spawn } from "child_process";
-var WRITEUP_SOURCES = {
-  general: [
-    "site:0xdf.gitlab.io",
-    // 0xdf's blog
-    "site:ippsec.rocks",
-    // IppSec video index
-    "site:medium.com",
-    // Medium writeups
-    "site:infosecwriteups.com",
-    // InfoSec writeups
-    "site:hackingarticles.in"
-    // Raj Chandel's blog
-  ],
-  htb: [
-    "site:0xdf.gitlab.io",
-    "site:ippsec.rocks",
-    "site:app.hackthebox.com",
-    '"HackTheBox" OR "HTB"'
-  ],
-  thm: [
-    "site:tryhackme.com",
-    '"TryHackMe" OR "THM"'
-  ],
-  ctf: [
-    "site:ctftime.org",
-    "site:ctf.zeyu2001.com",
-    "site:github.com CTF writeup"
-  ],
-  vulnhub: [
-    "site:vulnhub.com",
-    '"VulnHub" writeup'
-  ]
-};
-var SCENARIO_KEYWORDS = {
-  ad: "Active Directory Kerberos LDAP BloodHound",
-  windows: "Windows privilege escalation PowerShell",
-  linux: "Linux privilege escalation GTFOBins SUID",
-  web: "web exploitation XSS SQLi SSTI RCE",
-  crypto: "cryptography RSA AES cipher",
-  forensics: "forensics memory dump volatility",
-  pwn: "binary exploitation buffer overflow ROP",
-  reversing: "reverse engineering IDA Ghidra",
-  misc: "miscellaneous steganography OSINT"
-};
-async function searchDuckDuckGo(query, options = {}) {
-  const { maxResults = 10, timeout = 3e4 } = options;
-  return new Promise((resolve) => {
-    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-    const proc = spawn("curl", [
-      "-s",
-      "-A",
-      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-      url
-    ], { timeout });
-    let stdout = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.on("close", () => {
-      const results = [];
-      const resultRegex = /<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/g;
-      const snippetRegex = /<a[^>]+class="result__snippet"[^>]*>([^<]+)<\/a>/g;
-      let match;
-      const urls = [];
-      const titles = [];
-      const snippets = [];
-      while ((match = resultRegex.exec(stdout)) !== null) {
-        urls.push(match[1]);
-        titles.push(match[2]);
-      }
-      while ((match = snippetRegex.exec(stdout)) !== null) {
-        snippets.push(match[1]);
-      }
-      for (let i = 0; i < Math.min(urls.length, maxResults); i++) {
-        results.push({
-          title: titles[i] || "",
-          url: urls[i] || "",
-          snippet: snippets[i] || ""
-        });
-      }
-      resolve(results);
-    });
-    proc.on("error", () => {
-      resolve([]);
-    });
-  });
-}
-async function searchCVE(query) {
-  return searchDuckDuckGo(`${query} site:cve.mitre.org OR site:nvd.nist.gov`);
-}
-async function searchExploits(query) {
-  return searchDuckDuckGo(`${query} site:exploit-db.com OR site:github.com exploit POC`);
-}
-async function searchWriteups(query, platform3 = "all") {
-  const sources = platform3 === "all" ? WRITEUP_SOURCES.general : WRITEUP_SOURCES[platform3] || WRITEUP_SOURCES.general;
-  const siteQuery = sources.join(" OR ");
-  return searchDuckDuckGo(`${query} writeup walkthrough ${siteQuery}`);
-}
-async function searchMachineWriteup(machineName) {
-  const [writeups, videos] = await Promise.all([
-    searchDuckDuckGo(`"${machineName}" HackTheBox OR TryHackMe writeup walkthrough site:0xdf.gitlab.io OR site:medium.com`),
-    searchDuckDuckGo(`"${machineName}" ippsec site:youtube.com OR site:ippsec.rocks`)
-  ]);
-  return { writeups, videos };
+// src/core/tools/tool-utils.ts
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs/promises";
+import * as path from "path";
+var execAsync = promisify(exec);
+var SEARCHED_PACKAGES = {};
+var USE_DOCKER = process.env.PENTESTING_DOCKER === "1";
+var DOCKER_CONTAINER = process.env.PENTESTING_CONTAINER || "pentesting-tools";
+var autoInstallEnabled = true;
+async function commandExists(cmd) {
+  try {
+    await execAsync(`which ${cmd}`);
+    return true;
+  } catch {
+    return false;
+  }
 }
-async function searchByScenario(query, scenario) {
-  const keywords = SCENARIO_KEYWORDS[scenario] || "";
-  return searchDuckDuckGo(`${query} ${keywords} writeup walkthrough exploit`);
+async function searchForAptPackage(toolName) {
+  if (SEARCHED_PACKAGES[toolName]) return SEARCHED_PACKAGES[toolName];
+  console.log(`
+\u{1F50D} Searching for apt package name for '${toolName}' on Kali Linux...`);
+  try {
+    const { searchGoogle, deepSearch } = await import("./web-search-XQYEM24B.js");
+    const query = `apt install package name for ${toolName} on Kali Linux`;
+    const searchResults = await deepSearch(query, { maxResults: 3 });
+    for (const res of searchResults) {
+      const content = res.content || res.snippet;
+      const match = content.match(/apt(?:-get)?\s+install\s+(?:-y\s+)?([a-z0-9._-]+)/i);
+      if (match && match[1]) {
+        const pkg = match[1].toLowerCase();
+        console.log(`\u2728 Found potential package: ${pkg}`);
+        SEARCHED_PACKAGES[toolName] = pkg;
+        return pkg;
+      }
+    }
+  } catch (error) {
+    console.error("Failed to search for package:", error);
+  }
+  return null;
 }
-async function searchADWriteups(query) {
-  return searchDuckDuckGo(
-    `${query} Active Directory Kerberos LDAP BloodHound GetNPUsers AS-REP Roasting Kerberoasting DCSync Pass-the-Hash writeup`
-  );
+async function installTool(toolName, customPackage) {
+  const packageName = customPackage || TOOL_TO_APT[toolName] || toolName;
+  try {
+    console.log(`
+\u{1F4E6} Installing ${toolName} (${packageName})...`);
+    const { stdout, stderr } = await execAsync(
+      `sudo apt update -qq && sudo apt install -y ${packageName}`,
+      { timeout: 3e5 }
+      // 5 minute timeout for installation
+    );
+    console.log(`\u2705 ${toolName} installed successfully
+`);
+    return { success: true, output: stdout + stderr, duration: 0 };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(`\u274C Failed to install ${toolName}: ${errorMessage}
+`);
+    return { success: false, output: "", error: errorMessage, duration: 0 };
+  }
 }
-async function searchLinuxPrivesc(query) {
-  return searchDuckDuckGo(
-    `${query} Linux privilege escalation SUID GTFOBins sudo capabilities cronjob kernel exploit writeup`
-  );
+async function ensureToolAvailable(toolName) {
+  if (await commandExists(toolName)) {
+    return true;
+  }
+  if (!autoInstallEnabled) {
+    console.log(`\u26A0\uFE0F Tool '${toolName}' is missing but auto-install is disabled.`);
+    return false;
+  }
+  let packageName = TOOL_TO_APT[toolName];
+  if (!packageName) {
+    packageName = await searchForAptPackage(toolName);
+  }
+  const result = await installTool(toolName, packageName);
+  return result.success;
 }
-async function searchWindowsPrivesc(query) {
-  return searchDuckDuckGo(
-    `${query} Windows privilege escalation SeImpersonate JuicyPotato PrintSpoofer token impersonation UAC bypass writeup`
-  );
+async function isDockerAvailable() {
+  if (!USE_DOCKER) return false;
+  try {
+    const { stdout } = await execAsync(`docker inspect ${DOCKER_CONTAINER} --format='{{.State.Running}}'`);
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
 }
-async function securityResearch(query) {
-  const [general, cves, exploits, writeups] = await Promise.all([
-    searchDuckDuckGo(query),
-    searchCVE(query),
-    searchExploits(query),
-    searchWriteups(query)
-  ]);
-  return { general, cves, exploits, writeups };
+function wrapForDocker(command) {
+  const cleanCmd = command.replace(/^sudo\s+/, "");
+  return `docker exec ${DOCKER_CONTAINER} sh -c "${cleanCmd.replace(/"/g, '\\"')}"`;
 }
-async function ctfResearch(boxName, scenario) {
-  const [machine, scenarioResults, exploits] = await Promise.all([
-    searchMachineWriteup(boxName),
-    scenario ? searchByScenario(boxName, scenario) : Promise.resolve([]),
-    searchExploits(boxName)
-  ]);
-  return { machine, scenario: scenarioResults, exploits };
+async function shouldUseDocker(command) {
+  if (!USE_DOCKER) return false;
+  return await isDockerAvailable();
 }
-
-// src/core/tools/tool-executor.ts
-var execAsync = promisify(exec);
-var DOCKER_IMAGE = "agnusdei1207/pentesting:latest";
-var DOCKER_CONTAINER = process.env.PENTESTING_CONTAINER || "pentesting-tools";
-var FORCE_DOCKER = process.env.PENTESTING_DOCKER === "1";
-var dockerStarted = false;
-var DOCKER_TOOLS = [
-  // Network scanning
-  TOOL_NAME.RUSTSCAN,
-  TOOL_NAME.NMAP_SCAN,
-  TOOL_NAME.MASSCAN,
-  TOOL_NAME.TCPDUMP_CAPTURE,
-  TOOL_NAME.PING,
-  TOOL_NAME.TRACEROUTE,
-  TOOL_NAME.MTR,
-  TOOL_NAME.NETCAT,
-  TOOL_NAME.TSHARK,
-  TOOL_NAME.NGREP,
-  TOOL_NAME.ARP_SCAN,
-  TOOL_NAME.SOCAT,
-  // DNS & Subdomain
-  TOOL_NAME.DIG,
-  TOOL_NAME.HOST,
-  TOOL_NAME.NSLOOKUP,
-  TOOL_NAME.WHOIS,
-  TOOL_NAME.SUBFINDER,
-  TOOL_NAME.AMASS,
-  TOOL_NAME.DNSENUM,
-  TOOL_NAME.DNSRECON,
-  TOOL_NAME.DNSMAP,
-  TOOL_NAME.ZONE_TRANSFER,
-  // Service Enumeration
-  TOOL_NAME.SNMP_WALK,
-  TOOL_NAME.SNMP_CHECK,
-  TOOL_NAME.ONESIXTYONE,
-  TOOL_NAME.FTP_ENUM,
-  TOOL_NAME.FTP_ANON,
-  TOOL_NAME.NBTSCAN,
-  TOOL_NAME.RPC_INFO,
-  TOOL_NAME.SHOWMOUNT,
-  TOOL_NAME.TELNET,
-  // Web tools
-  TOOL_NAME.FFUF,
-  TOOL_NAME.GOBUSTER,
-  TOOL_NAME.DIRB,
-  TOOL_NAME.FEROXBUSTER,
-  TOOL_NAME.WHATWEB,
-  TOOL_NAME.HTTPX,
-  TOOL_NAME.NUCLEI,
-  TOOL_NAME.NIKTO,
-  TOOL_NAME.DIRECTORY_BRUTEFORCE,
-  TOOL_NAME.SQL_INJECTION,
-  TOOL_NAME.WAYBACKURLS,
-  TOOL_NAME.WAFW00F,
-  TOOL_NAME.GOWITNESS,
-  // Windows/SMB/AD
-  TOOL_NAME.SMB_ENUM,
-  TOOL_NAME.SMBMAP,
-  TOOL_NAME.ENUM4LINUX,
-  TOOL_NAME.CRACKMAPEXEC,
-  TOOL_NAME.SMBCLIENT,
-  TOOL_NAME.RPCCLIENT,
-  TOOL_NAME.WINRM,
-  TOOL_NAME.RDP_CHECK,
-  TOOL_NAME.LDAP_SEARCH,
-  TOOL_NAME.KERBRUTE,
-  TOOL_NAME.BLOODHOUND,
-  // Database
-  TOOL_NAME.MSSQL_CLIENT,
-  TOOL_NAME.MYSQL_CLIENT,
-  TOOL_NAME.PSQL_CLIENT,
-  TOOL_NAME.REDIS_CLI,
-  TOOL_NAME.MONGO_CLIENT,
-  // Bruteforce & Credentials
-  TOOL_NAME.HYDRA,
-  TOOL_NAME.MEDUSA,
-  TOOL_NAME.BRUTEFORCE_LOGIN,
-  TOOL_NAME.CRACK_HASH,
-  TOOL_NAME.JOHN,
-  TOOL_NAME.HASHCAT,
-  TOOL_NAME.HASHID,
-  // Exploitation
-  TOOL_NAME.SEARCHSPLOIT,
-  TOOL_NAME.METASPLOIT,
-  TOOL_NAME.GENERATE_PAYLOAD,
-  TOOL_NAME.MSFVENOM,
-  // SSH & Tunneling
-  TOOL_NAME.SSH,
-  TOOL_NAME.CHISEL,
-  TOOL_NAME.PROXYCHAINS,
-  TOOL_NAME.SETUP_TUNNEL,
-  TOOL_NAME.LATERAL_MOVEMENT,
-  TOOL_NAME.REVERSE_SHELL,
-  TOOL_NAME.DUMP_CREDENTIALS,
-  // Listener & Payload
-  TOOL_NAME.NC_LISTENER,
-  TOOL_NAME.PYTHON_HTTP_SERVER,
-  TOOL_NAME.RLWRAP,
-  TOOL_NAME.PWNCAT,
-  // Impacket
-  TOOL_NAME.IMPACKET_SECRETSDUMP,
-  TOOL_NAME.IMPACKET_PSEXEC,
-  TOOL_NAME.IMPACKET_WMIEXEC,
-  TOOL_NAME.IMPACKET_SMBEXEC,
-  TOOL_NAME.IMPACKET_ATEXEC,
-  TOOL_NAME.IMPACKET_DCOMEXEC,
-  TOOL_NAME.IMPACKET_GETNPUSERS,
-  TOOL_NAME.IMPACKET_GETUSERSPNS,
-  // Forensics
-  TOOL_NAME.BINWALK,
-  TOOL_NAME.FOREMOST,
-  TOOL_NAME.STEGHIDE,
-  TOOL_NAME.EXIFTOOL,
-  // Reversing
-  TOOL_NAME.GDB,
-  TOOL_NAME.RADARE2,
-  // Privesc
-  TOOL_NAME.RUN_PRIVESC_ENUM,
-  TOOL_NAME.CHECK_SUDO,
-  TOOL_NAME.FIND_SUID
-];
-async function ensureDockerContainer() {
-  if (dockerStarted) return true;
+async function executeBash(command, options = {}) {
+  const startTime = Date.now();
+  const timeout = options.timeout || 6e4;
+  const resourceManager = getResourceManager();
   try {
-    const { stdout } = await execAsync(`docker inspect ${DOCKER_CONTAINER} --format='{{.State.Running}}'`);
-    if (stdout.trim() === "true") {
-      dockerStarted = true;
-      return true;
-    }
-    await execAsync(`docker start ${DOCKER_CONTAINER}`);
-    dockerStarted = true;
-    console.log(`[Docker] Started container: ${DOCKER_CONTAINER}`);
-    return true;
-  } catch (err) {
-    const errorMsg = err.message || String(err);
-    if (errorMsg.includes("Cannot connect to the Docker daemon") || errorMsg.includes("docker.sock")) {
-      console.log("\n\u26A0\uFE0F  Docker is not running!\n");
-      console.log("To use advanced security tools (nmap, rustscan, etc.), please:");
-      console.log("  1. Install Docker: https://docs.docker.com/get-docker/");
-      console.log("  2. Start Docker Desktop (macOS): open -a Docker");
-      console.log("  3. Wait for Docker to fully start, then retry\n");
-      console.log("Falling back to local tools (curl, dig, etc.)...\n");
-      return false;
+    let finalCommand = command;
+    const useDocker = options.useDocker ?? await shouldUseDocker(command);
+    if (useDocker) {
+      finalCommand = wrapForDocker(command);
+    } else {
+      const baseCmd = command.trim().split(/\s+/)[0].replace(/^sudo\s+/, "");
+      const aptPackage = TOOL_TO_APT[baseCmd];
+      if (aptPackage && !await commandExists(baseCmd)) {
+        const installed = await ensureToolAvailable(baseCmd);
+        if (!installed) {
+          return {
+            success: false,
+            output: "",
+            error: `Tool '${baseCmd}' is not installed and auto-install failed. Run: sudo apt install ${aptPackage}`,
+            duration: 0
+          };
+        }
+      }
     }
-    try {
-      console.log(`[Docker] Pulling and starting ${DOCKER_IMAGE}...`);
-      await execAsync(`docker run -d --name ${DOCKER_CONTAINER} --network host ${DOCKER_IMAGE}`, {
-        timeout: 12e4
-        // 2 min timeout for pull
+    if (options.background) {
+      const child = spawn("/bin/bash", ["-c", finalCommand], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, LANG: "en_US.UTF-8", LC_ALL: "en_US.UTF-8" }
       });
-      dockerStarted = true;
-      console.log(`[Docker] Container ready: ${DOCKER_CONTAINER}`);
-      return true;
-    } catch (createErr) {
-      const createMsg = createErr.message || "";
-      if (createMsg.includes("Cannot connect to the Docker daemon")) {
-        console.log("\n\u26A0\uFE0F  Docker is not running! Start it first:\n");
-        console.log("  macOS:   open -a Docker");
-        console.log("  Linux:   sudo systemctl start docker");
-        console.log("  Windows: Start Docker Desktop\n");
-      } else {
-        console.error(`[Docker] Failed to start container: ${createErr}`);
+      if (child.pid) {
+        resourceManager.trackProcess(child.pid);
+        child.on("exit", () => {
+          if (child.pid) resourceManager.untrackProcess(child.pid);
+        });
+        child.on("error", () => {
+          if (child.pid) resourceManager.untrackProcess(child.pid);
+        });
       }
-      return false;
+      child.unref();
+      return { success: true, output: `[Background] Command started with PID ${child.pid}`, duration: 0 };
     }
+    const promise = new Promise((resolve, reject) => {
+      const child = exec(finalCommand, {
+        timeout,
+        maxBuffer: 50 * 1024 * 1024,
+        shell: "/bin/bash",
+        encoding: "utf8",
+        env: { ...process.env, LANG: "en_US.UTF-8", LC_ALL: "en_US.UTF-8" }
+      }, (error, stdout2, stderr2) => {
+        if (child.pid) resourceManager.untrackProcess(child.pid);
+        if (error) reject({ ...error, stdout: stdout2, stderr: stderr2 });
+        else resolve({ stdout: stdout2, stderr: stderr2 });
+      });
+      if (child.pid) resourceManager.trackProcess(child.pid);
+    });
+    const { stdout, stderr } = await promise;
+    return {
+      success: true,
+      output: (useDocker ? "[Docker] " : "") + stdout + (stderr ? `
+[STDERR]
+${stderr}` : ""),
+      duration: Math.round((Date.now() - startTime) / 1e3)
+    };
+  } catch (error) {
+    const err = error;
+    if (err.message?.includes("No such container")) {
+      return { success: false, output: "", error: `Docker container '${DOCKER_CONTAINER}' not running.`, duration: 0 };
+    }
+    return { success: false, output: err.stdout || "", error: err.stderr || err.message, exitCode: err.code, duration: 0 };
   }
 }
-async function isDockerAvailable() {
-  return await ensureDockerContainer();
+var _currentTarget = null;
+var _targetListeners = [];
+function onTargetChange(listener) {
+  _targetListeners.push(listener);
 }
-async function commandExists(cmd) {
+async function setTarget(target) {
   try {
-    await execAsync(`which ${cmd}`);
-    return true;
-  } catch {
-    return false;
+    _currentTarget = target;
+    _targetListeners.forEach((listener) => {
+      try {
+        listener(target);
+      } catch (e) {
+      }
+    });
+    return { success: true, output: `\u{1F3AF} Target set: ${target}
+
+Now beginning reconnaissance...`, duration: 0 };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, output: "", error: errorMessage, duration: 0 };
   }
 }
-async function shouldUseDocker(command) {
-  if (FORCE_DOCKER) return true;
-  const baseCmd = command.trim().split(/\s+/)[0].replace(/^sudo\s+/, "");
-  if (!DOCKER_TOOLS.some((tool) => baseCmd.includes(tool))) {
-    return false;
+async function readFile2(filePath, startLine, endLine) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    let output = content;
+    if (startLine || endLine) {
+      const lines = content.split("\n");
+      output = lines.slice((startLine || 1) - 1, endLine || lines.length).join("\n");
+    }
+    return { success: true, output, duration: 0 };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, output: "", error: errorMessage, duration: 0 };
   }
-  if (await commandExists(baseCmd)) {
-    return false;
+}
+async function writeFile2(filePath, content, overwrite = false) {
+  try {
+    const exists = await fs.access(filePath).then(() => true).catch(() => false);
+    if (exists && !overwrite) {
+      return { success: false, output: "", error: "File exists. Set overwrite: true to replace.", duration: 0 };
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, "utf-8");
+    return { success: true, output: `Written to ${filePath}`, duration: 0 };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, output: "", error: errorMessage, duration: 0 };
   }
-  return await isDockerAvailable();
 }
-function wrapForDocker(command) {
-  const cleanCmd = command.replace(/^sudo\s+/, "");
-  return `docker exec ${DOCKER_CONTAINER} sh -c "${cleanCmd.replace(/"/g, '\\"')}"`;
+async function listDirectory(dirPath, recursive = false, hidden = false) {
+  try {
+    const flags = `-l${hidden ? "a" : ""}${recursive ? "R" : ""}`;
+    const { stdout } = await execAsync(`ls ${flags} "${dirPath}"`);
+    return { success: true, output: stdout, duration: 0 };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, output: "", error: errorMessage, duration: 0 };
+  }
 }
+
+// src/core/tools/tool-executor.ts
+import * as fs2 from "fs/promises";
 async function executeToolCall(toolName, input) {
   const startTime = Date.now();
   const resourceManager = getResourceManager();
@@ -3796,206 +3701,50 @@ async function executeToolCall(toolName, input) {
         result = await takeScreenshot(input);
         break;
       // Research & Writeup Tools
-      case "search_writeups":
+      case TOOL_NAME.SEARCH_WRITEUPS:
         result = await executeSearchWriteups(input);
         break;
-      case "search_machine":
+      case TOOL_NAME.SEARCH_MACHINE:
         result = await executeSearchMachine(input);
         break;
-      case "search_by_scenario":
+      case TOOL_NAME.SEARCH_BY_SCENARIO:
         result = await executeSearchByScenario(input);
         break;
-      case "search_ad_writeups":
+      case TOOL_NAME.SEARCH_AD_WRITEUPS:
         result = await executeSearchADWriteups(input);
         break;
-      case "search_linux_privesc":
+      case TOOL_NAME.SEARCH_LINUX_PRIVESC:
         result = await executeSearchLinuxPrivesc(input);
         break;
-      case "search_windows_privesc":
-        result = await executeSearchWindowsPrivesc(input);
-        break;
-      case "ctf_research":
-        result = await executeCtfResearch(input);
-        break;
-      case "security_research":
-        result = await executeSecurityResearch(input);
-        break;
-      default:
-        result = {
-          success: false,
-          output: "",
-          error: `Unknown tool: ${toolName}`,
-          duration: Date.now() - startTime
-        };
-    }
-    result.duration = Date.now() - startTime;
-    return result;
-  } catch (error) {
-    return {
-      success: false,
-      output: "",
-      error: error.message || String(error),
-      duration: Date.now() - startTime
-    };
-  } finally {
-    resourceManager.trackJobEnd();
-  }
-}
-async function executeBash(command, options = {}) {
-  const startTime = Date.now();
-  const timeout = options.timeout || 6e4;
-  const resourceManager = getResourceManager();
-  try {
-    let finalCommand = command;
-    const useDocker = options.useDocker ?? await shouldUseDocker(command);
-    if (useDocker) {
-      finalCommand = wrapForDocker(command);
-      console.log(`[Docker] Executing: ${finalCommand}`);
-    }
-    if (options.background) {
-      const child = spawn2("/bin/bash", ["-c", finalCommand], {
-        detached: true,
-        stdio: "ignore",
-        env: {
-          ...process.env,
-          LANG: "en_US.UTF-8",
-          LC_ALL: "en_US.UTF-8"
-        }
-      });
-      if (child.pid) {
-        resourceManager.trackProcess(child.pid);
-        child.on("exit", () => {
-          if (child.pid) resourceManager.untrackProcess(child.pid);
-        });
-        child.on("error", () => {
-          if (child.pid) resourceManager.untrackProcess(child.pid);
-        });
-      }
-      child.unref();
-      return {
-        success: true,
-        output: `[Background] Command started with PID ${child.pid}`,
-        duration: 0
-      };
-    }
-    const promise = new Promise((resolve, reject) => {
-      const child = exec(finalCommand, {
-        timeout,
-        maxBuffer: 50 * 1024 * 1024,
-        // 50MB
-        shell: "/bin/bash",
-        encoding: "utf8",
-        env: {
-          ...process.env,
-          LANG: "en_US.UTF-8",
-          LC_ALL: "en_US.UTF-8"
-        }
-      }, (error, stdout2, stderr2) => {
-        if (child.pid) resourceManager.untrackProcess(child.pid);
-        if (error) reject({ ...error, stdout: stdout2, stderr: stderr2 });
-        else resolve({ stdout: stdout2, stderr: stderr2 });
-      });
-      if (child.pid) {
-        resourceManager.trackProcess(child.pid);
-      }
-    });
-    const { stdout, stderr } = await promise;
-    return {
-      success: true,
-      output: (useDocker ? "[Docker] " : "") + stdout + (stderr ? `
-[STDERR]
-${stderr}` : ""),
-      duration: Math.round((Date.now() - startTime) / 1e3)
-    };
-  } catch (error) {
-    if (error.message?.includes("No such container")) {
-      return {
-        success: false,
-        output: "",
-        error: `Docker container '${DOCKER_CONTAINER}' not running. Start it with: cd docker && docker-compose up -d`,
-        duration: 0
-      };
-    }
-    return {
-      success: false,
-      output: error.stdout || "",
-      error: error.stderr || error.message,
-      exitCode: error.code,
-      duration: 0
-    };
-  }
-}
-var _currentTarget = null;
-var _targetListeners = [];
-function onTargetChange(listener) {
-  _targetListeners.push(listener);
-}
-async function setTarget(target) {
-  try {
-    _currentTarget = target;
-    _targetListeners.forEach((listener) => {
-      try {
-        listener(target);
-      } catch (e) {
-        console.error("Target listener error:", e);
-      }
-    });
-    return {
-      success: true,
-      output: `\u{1F3AF} Target set: ${target}
-
-Now beginning reconnaissance...`,
-      duration: 0
-    };
-  } catch (error) {
-    return {
-      success: false,
-      output: "",
-      error: error.message || String(error),
-      duration: 0
-    };
-  }
-}
-async function readFile2(filePath, startLine, endLine) {
-  try {
-    const content = await fs.readFile(filePath, "utf-8");
-    let output = content;
-    if (startLine || endLine) {
-      const lines = content.split("\n");
-      const start = (startLine || 1) - 1;
-      const end = endLine || lines.length;
-      output = lines.slice(start, end).join("\n");
-    }
-    return { success: true, output, duration: 0 };
-  } catch (error) {
-    return { success: false, output: "", error: error.message, duration: 0 };
-  }
-}
-async function writeFile2(filePath, content, overwrite = false) {
-  try {
-    const exists = await fs.access(filePath).then(() => true).catch(() => false);
-    if (exists && !overwrite) {
-      return {
-        success: false,
-        output: "",
-        error: "File exists. Set overwrite: true to replace.",
-        duration: 0
-      };
+      case TOOL_NAME.SEARCH_WINDOWS_PRIVESC:
+        result = await executeSearchWindowsPrivesc(input);
+        break;
+      case TOOL_NAME.CTF_RESEARCH:
+        result = await executeCtfResearch(input);
+        break;
+      case TOOL_NAME.SECURITY_RESEARCH:
+        result = await executeSecurityResearch(input);
+        break;
+      default:
+        result = {
+          success: false,
+          output: "",
+          error: `Unknown tool: ${toolName}`,
+          duration: Date.now() - startTime
+        };
     }
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, content, "utf-8");
-    return { success: true, output: `Written to ${filePath}`, duration: 0 };
-  } catch (error) {
-    return { success: false, output: "", error: error.message, duration: 0 };
-  }
-}
-async function listDirectory(dirPath, recursive = false, hidden = false) {
-  try {
-    const flags = `-l${hidden ? "a" : ""}${recursive ? "R" : ""}`;
-    const { stdout } = await execAsync(`ls ${flags} "${dirPath}"`);
-    return { success: true, output: stdout, duration: 0 };
+    result.duration = Date.now() - startTime;
+    return result;
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: 0 };
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      output: "",
+      error: errMsg,
+      duration: Date.now() - startTime
+    };
+  } finally {
+    resourceManager.trackJobEnd();
   }
 }
 async function executeRustscan(input) {
@@ -4134,7 +3883,7 @@ const { chromium } = require('playwright');
 })();
 `;
   const scriptPath = "/tmp/playwright_script.js";
-  await fs.writeFile(scriptPath, playwrightScript);
+  await fs2.writeFile(scriptPath, playwrightScript);
   return executeBash(`node ${scriptPath}`, { timeout: 6e4 });
 }
 async function executeSearchsploit(input) {
@@ -4306,12 +4055,12 @@ async function reportFinding(input) {
   const findingsPath = "/tmp/hacker-code-findings.json";
   let findings = [];
   try {
-    const existing = await fs.readFile(findingsPath, "utf-8");
+    const existing = await fs2.readFile(findingsPath, "utf-8");
     findings = JSON.parse(existing);
   } catch {
   }
   findings.push(finding);
-  await fs.writeFile(findingsPath, JSON.stringify(findings, null, 2));
+  await fs2.writeFile(findingsPath, JSON.stringify(findings, null, 2));
   return {
     success: true,
     output: `Finding recorded: [${severity?.toString().toUpperCase()}] ${title}`,
@@ -4332,7 +4081,7 @@ const { chromium } = require('playwright');
   console.log('Screenshot saved');
 })();
 `;
-    await fs.writeFile("/tmp/screenshot.js", script);
+    await fs2.writeFile("/tmp/screenshot.js", script);
     return executeBash("node /tmp/screenshot.js");
   }
   return executeBash(`script -q /dev/null -c "cat" | tee "${filename || "terminal.txt"}"`);
@@ -4930,14 +4679,14 @@ async function executeSearchWriteups(input) {
   const startTime = Date.now();
   try {
     const query = String(input.query || "");
-    const platform3 = input.platform || "all";
+    const platform3 = input.platform || "general";
     const results = await searchWriteups(query, platform3);
     const output = results.length > 0 ? results.map((r, i) => `[${i + 1}] ${r.title}
     URL: ${r.url}
     ${r.snippet}`).join("\n\n") : "No writeups found.";
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 async function executeSearchMachine(input) {
@@ -4957,7 +4706,7 @@ async function executeSearchMachine(input) {
     ${r.url}`).join("\n") : "No videos found.";
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 async function executeSearchByScenario(input) {
@@ -4971,7 +4720,7 @@ async function executeSearchByScenario(input) {
     ${r.snippet}`).join("\n\n") : `No ${scenario} writeups found.`;
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 async function executeSearchADWriteups(input) {
@@ -4984,7 +4733,7 @@ async function executeSearchADWriteups(input) {
     ${r.snippet}`).join("\n\n") : "No AD writeups found.";
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 async function executeSearchLinuxPrivesc(input) {
@@ -4997,7 +4746,7 @@ async function executeSearchLinuxPrivesc(input) {
     ${r.snippet}`).join("\n\n") : "No Linux privesc writeups found.";
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 async function executeSearchWindowsPrivesc(input) {
@@ -5010,7 +4759,7 @@ async function executeSearchWindowsPrivesc(input) {
     ${r.snippet}`).join("\n\n") : "No Windows privesc writeups found.";
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 async function executeCtfResearch(input) {
@@ -5041,7 +4790,7 @@ async function executeCtfResearch(input) {
     ${r.url}`).join("\n") : "No exploits found.";
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 async function executeSecurityResearch(input) {
@@ -5066,7 +4815,7 @@ async function executeSecurityResearch(input) {
     ${r.url}`).join("\n") : "No writeups found.";
     return { success: true, output, duration: Date.now() - startTime };
   } catch (error) {
-    return { success: false, output: "", error: error.message, duration: Date.now() - startTime };
+    return { success: false, output: "", error: error instanceof Error ? error.message : String(error), duration: Date.now() - startTime };
   }
 }
 
@@ -6939,12 +6688,14 @@ EFFORT: [low/medium/high]`;
     for (const section of sections.slice(1)) {
       const match = section.match(/(\w+)\s+DESCRIPTION:\s*(.+)\s+REASONING:\s*(.+)\s+IMPACT:\s*([\d.]+)\s+EFFORT:\s*(\w+)/is);
       if (match) {
+        const suggestionType = match[1].toLowerCase().trim();
+        const suggestionEffort = match[5].toLowerCase().trim();
         suggestions.push({
-          type: match[1],
+          type: suggestionType,
           description: match[2].trim(),
           reasoning: match[3].trim(),
           estimatedImpact: parseFloat(match[4]) || 0.5,
-          effort: match[5].trim()
+          effort: suggestionEffort
         });
       }
     }
@@ -7483,7 +7234,7 @@ import { v4 as uuidv46 } from "uuid";
 import { EventEmitter as EventEmitter8 } from "events";
 import { v4 as uuidv45 } from "uuid";
 import { createHash } from "crypto";
-import { promises as fs2 } from "fs";
+import { promises as fs3 } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 var AUDIT_EVENT = {
@@ -7509,7 +7260,7 @@ var AuditLogger = class extends EventEmitter8 {
   async initialize() {
     if (this.initialized) return;
     try {
-      await fs2.mkdir(this.logDir, { recursive: true });
+      await fs3.mkdir(this.logDir, { recursive: true });
       this.initialized = true;
     } catch (error) {
       console.error("[AuditLogger] Failed to initialize:", error);
@@ -7606,19 +7357,19 @@ var AuditLogger = class extends EventEmitter8 {
   async pruneDiskLogs(maxFiles = 1e3) {
     if (!this.initialized) await this.initialize();
     try {
-      const files = await fs2.readdir(this.logDir);
+      const files = await fs3.readdir(this.logDir);
       if (files.length <= maxFiles) return 0;
       const fileStats = await Promise.all(
         files.map(async (file) => {
           const filePath = join(this.logDir, file);
-          const stats = await fs2.stat(filePath);
+          const stats = await fs3.stat(filePath);
           return { file, time: stats.mtimeMs, path: filePath };
         })
       );
       fileStats.sort((a, b) => a.time - b.time);
       const toDelete = fileStats.slice(0, files.length - maxFiles);
       for (const item of toDelete) {
-        await fs2.unlink(item.path);
+        await fs3.unlink(item.path);
       }
       return toDelete.length;
     } catch (error) {
@@ -7689,7 +7440,7 @@ var AuditLogger = class extends EventEmitter8 {
       this.logDir,
       `audit_${this.sessionId}_${Date.now()}.json`
     );
-    await fs2.writeFile(
+    await fs3.writeFile(
       exportPath,
       JSON.stringify({
         sessionId: this.sessionId,
@@ -7750,7 +7501,7 @@ var AuditLogger = class extends EventEmitter8 {
     try {
       const filename = `${entry.timestamp.replace(/[:.]/g, "-")}_${entry.id}.json`;
       const filepath = join(this.logDir, filename);
-      await fs2.writeFile(filepath, JSON.stringify(entry, null, 2));
+      await fs3.writeFile(filepath, JSON.stringify(entry, null, 2));
     } catch (error) {
       console.error("[AuditLogger] Failed to persist entry:", error);
     }
@@ -7771,7 +7522,7 @@ var AuditLogger = class extends EventEmitter8 {
     try {
       const filename = `system_${entry.timestamp.replace(/[:.]/g, "-")}_${entry.id}.json`;
       const filepath = join(this.logDir, filename);
-      await fs2.writeFile(filepath, JSON.stringify(entry, null, 2));
+      await fs3.writeFile(filepath, JSON.stringify(entry, null, 2));
     } catch (error) {
       console.error("[AuditLogger] Failed to persist system event:", error);
     }
@@ -10139,7 +9890,7 @@ Constraints: ${context.constraints.join(", ")}`;
 // src/core/agent/learning/self-reflection.ts
 import { EventEmitter as EventEmitter12 } from "events";
 import { v4 as uuidv410 } from "uuid";
-import * as fs3 from "fs/promises";
+import * as fs4 from "fs/promises";
 import * as path2 from "path";
 var SelfReflectionSystem = class extends EventEmitter12 {
   llm;
@@ -10393,10 +10144,10 @@ CONFIDENCE: [0.0-1.0]`;
    */
   async persistExperience(experience) {
     try {
-      await fs3.mkdir(this.dataDir, { recursive: true });
+      await fs4.mkdir(this.dataDir, { recursive: true });
       const filename = `${experience.id}.json`;
       const filepath = path2.join(this.dataDir, filename);
-      await fs3.writeFile(filepath, JSON.stringify(experience, null, 2));
+      await fs4.writeFile(filepath, JSON.stringify(experience, null, 2));
     } catch (error) {
       this.emit("persist_error", error);
     }
@@ -10406,13 +10157,13 @@ CONFIDENCE: [0.0-1.0]`;
    */
   async loadExperiences() {
     try {
-      await fs3.mkdir(this.dataDir, { recursive: true });
-      const files = await fs3.readdir(this.dataDir);
+      await fs4.mkdir(this.dataDir, { recursive: true });
+      const files = await fs4.readdir(this.dataDir);
       for (const file of files) {
         if (file.endsWith(".json")) {
           const filepath = path2.join(this.dataDir, file);
           try {
-            const content = await fs3.readFile(filepath, "utf-8");
+            const content = await fs4.readFile(filepath, "utf-8");
             const experience = JSON.parse(content);
             this.experiences.push(experience);
             for (const lesson of experience.lessons) {
@@ -10469,7 +10220,7 @@ CONFIDENCE: [0.0-1.0]`;
 
 // src/core/agent/background/job-manager.ts
 import { EventEmitter as EventEmitter13 } from "events";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { v4 as uuidv411 } from "uuid";
 var BackgroundJobManager = class extends EventEmitter13 {
   jobs = /* @__PURE__ */ new Map();
@@ -10512,7 +10263,7 @@ var BackgroundJobManager = class extends EventEmitter13 {
     this.jobs.set(job.id, job);
     this.incrementResource(config.type);
     try {
-      const process2 = spawn3(config.command, config.args || [], {
+      const process2 = spawn2(config.command, config.args || [], {
         cwd: config.cwd,
         shell: true,
         detached: false,
@@ -10900,7 +10651,7 @@ var backgroundJobManager = new BackgroundJobManager();
 // src/core/agent/session/checkpoint-manager.ts
 import { EventEmitter as EventEmitter14 } from "events";
 import { v4 as uuidv412 } from "uuid";
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 import * as path3 from "path";
 var SessionManager = class extends EventEmitter14 {
   checkpoints = /* @__PURE__ */ new Map();
@@ -11089,10 +10840,10 @@ var SessionManager = class extends EventEmitter14 {
   async persistCheckpoint(checkpoint) {
     try {
       const sessionDir = path3.join(this.checkpointDir, checkpoint.sessionId);
-      await fs4.mkdir(sessionDir, { recursive: true });
+      await fs5.mkdir(sessionDir, { recursive: true });
       const filename = `${checkpoint.id}.json`;
       const filepath = path3.join(sessionDir, filename);
-      await fs4.writeFile(filepath, JSON.stringify(checkpoint, null, 2));
+      await fs5.writeFile(filepath, JSON.stringify(checkpoint, null, 2));
     } catch (error) {
       this.emit("persist_error", error);
     }
@@ -11103,17 +10854,17 @@ var SessionManager = class extends EventEmitter14 {
   async loadCheckpoints(sessionId) {
     const checkpoints = [];
     try {
-      await fs4.mkdir(this.checkpointDir, { recursive: true });
-      const sessions = await fs4.readdir(this.checkpointDir);
+      await fs5.mkdir(this.checkpointDir, { recursive: true });
+      const sessions = await fs5.readdir(this.checkpointDir);
       const targetSessions = sessionId ? [sessionId] : sessions;
       for (const session of targetSessions) {
         const sessionDir = path3.join(this.checkpointDir, session);
         try {
-          const files = await fs4.readdir(sessionDir);
+          const files = await fs5.readdir(sessionDir);
           for (const file of files) {
             if (file.endsWith(".json")) {
               const filepath = path3.join(sessionDir, file);
-              const content = await fs4.readFile(filepath, "utf-8");
+              const content = await fs5.readFile(filepath, "utf-8");
               try {
                 const checkpoint = JSON.parse(content);
                 checkpoints.push(checkpoint);
@@ -11152,7 +10903,7 @@ var SessionManager = class extends EventEmitter14 {
         checkpoint.sessionId,
         `${checkpointId}.json`
       );
-      await fs4.unlink(filepath);
+      await fs5.unlink(filepath);
       this.checkpoints.delete(checkpointId);
       return true;
     } catch {
@@ -11394,8 +11145,8 @@ var ContextManager = class {
 };
 
 // src/core/hooks/hook-executor.ts
-import { spawn as spawn4 } from "child_process";
-import * as fs5 from "fs/promises";
+import { spawn as spawn3 } from "child_process";
+import * as fs6 from "fs/promises";
 import * as path4 from "path";
 import { EventEmitter as EventEmitter15 } from "events";
 var HookExecutor = class extends EventEmitter15 {
@@ -11410,7 +11161,7 @@ var HookExecutor = class extends EventEmitter15 {
   async initialize() {
     try {
       const configPath = path4.join(this.hooksDir, "hooks.json");
-      const configContent = await fs5.readFile(configPath, "utf-8");
+      const configContent = await fs6.readFile(configPath, "utf-8");
       this.hooksConfig = JSON.parse(configContent);
       this.initialized = true;
       this.emit("initialized", { hooks: Object.keys(this.hooksConfig?.hooks || {}) });
@@ -11452,7 +11203,7 @@ var HookExecutor = class extends EventEmitter15 {
         HOOK_PHASE: context.phase || "",
         HOOK_TARGET: context.target || ""
       };
-      const proc = spawn4("bash", ["-c", command], {
+      const proc = spawn3("bash", ["-c", command], {
         env,
         cwd: this.hooksDir,
         timeout
@@ -11524,205 +11275,8 @@ function getHookExecutor() {
   return hookExecutor;
 }
 
-// src/mcp/mcp-client.ts
-import { spawn as spawn5 } from "child_process";
-import { EventEmitter as EventEmitter16 } from "events";
-import * as readline from "readline";
-var MCPClient = class extends EventEmitter16 {
-  process = null;
-  requestId = 0;
-  pendingRequests = /* @__PURE__ */ new Map();
-  serverName;
-  config;
-  connected = false;
-  constructor(serverName, config) {
-    super();
-    this.serverName = serverName;
-    this.config = config;
-  }
-  // Start MCP server
-  async connect() {
-    return new Promise((resolve, reject) => {
-      const { command, args, env } = this.config;
-      this.process = spawn5(command, args || [], {
-        env: { ...process.env, ...env },
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      if (this.process.stdout) {
-        const rl = readline.createInterface({
-          input: this.process.stdout,
-          crlfDelay: Infinity
-        });
-        rl.on("line", (line) => {
-          try {
-            const response = JSON.parse(line);
-            this.handleResponse(response);
-          } catch {
-          }
-        });
-      }
-      if (this.process.stderr) {
-        this.process.stderr.on("data", (data) => {
-          this.emit("stderr", data.toString());
-        });
-      }
-      this.process.on("error", (error) => {
-        this.emit("error", error);
-        reject(error);
-      });
-      this.process.on("spawn", () => {
-        this.connected = true;
-        this.emit("connected", { server: this.serverName });
-        resolve();
-      });
-      this.process.on("close", (code) => {
-        this.connected = false;
-        this.emit("disconnected", { server: this.serverName, code });
-      });
-    });
-  }
-  // Send JSON-RPC request
-  async sendRequest(method, params) {
-    if (!this.process?.stdin || !this.connected) {
-      throw new Error("MCP server not connected");
-    }
-    const id = ++this.requestId;
-    const request = {
-      jsonrpc: "2.0",
-      id,
-      method,
-      params
-    };
-    return new Promise((resolve, reject) => {
-      this.pendingRequests.set(id, { resolve, reject });
-      const line = JSON.stringify(request) + "\n";
-      this.process.stdin.write(line, (error) => {
-        if (error) {
-          this.pendingRequests.delete(id);
-          reject(error);
-        }
-      });
-      setTimeout(() => {
-        if (this.pendingRequests.has(id)) {
-          this.pendingRequests.delete(id);
-          reject(new Error("MCP request timeout"));
-        }
-      }, 3e4);
-    });
-  }
-  // Handle JSON-RPC response
-  handleResponse(response) {
-    const pending = this.pendingRequests.get(response.id);
-    if (!pending) {
-      return;
-    }
-    this.pendingRequests.delete(response.id);
-    if (response.error) {
-      pending.reject(new Error(response.error.message));
-    } else {
-      pending.resolve(response.result);
-    }
-  }
-  // Initialize MCP server
-  async initialize() {
-    return this.sendRequest("initialize", {
-      protocolVersion: "2024-11-05",
-      capabilities: {},
-      clientInfo: {
-        name: "pentesting",
-        version: "1.0.0"
-      }
-    });
-  }
-  // List available tools
-  async listTools() {
-    const result = await this.sendRequest("tools/list");
-    return result.tools || [];
-  }
-  // Call a tool
-  async callTool(name, arguments_) {
-    return this.sendRequest("tools/call", { name, arguments: arguments_ });
-  }
-  // List resources
-  async listResources() {
-    const result = await this.sendRequest("resources/list");
-    return result.resources || [];
-  }
-  // Read a resource
-  async readResource(uri) {
-    return this.sendRequest("resources/read", { uri });
-  }
-  // Disconnect
-  async disconnect() {
-    if (this.process) {
-      this.process.kill();
-      this.process = null;
-      this.connected = false;
-    }
-  }
-  // Check if connected
-  isConnected() {
-    return this.connected;
-  }
-};
-var MCPManager = class extends EventEmitter16 {
-  clients = /* @__PURE__ */ new Map();
-  tools = /* @__PURE__ */ new Map();
-  // Add and connect to a server
-  async addServer(name, config) {
-    const client = new MCPClient(name, config);
-    client.on("error", (error) => this.emit("error", { server: name, error }));
-    client.on("connected", () => this.emit("server_connected", { server: name }));
-    client.on("disconnected", (info) => this.emit("server_disconnected", info));
-    try {
-      await client.connect();
-      await client.initialize();
-      const tools = await client.listTools();
-      for (const tool of tools) {
-        this.tools.set(tool.name, { server: name, tool });
-      }
-      this.clients.set(name, client);
-      this.emit("tools_loaded", { server: name, count: tools.length });
-    } catch (error) {
-      this.emit("error", { server: name, error });
-      throw error;
-    }
-  }
-  // Call a tool by name
-  async callTool(toolName, args) {
-    const entry = this.tools.get(toolName);
-    if (!entry) {
-      throw new Error(`Unknown MCP tool: ${toolName}`);
-    }
-    const client = this.clients.get(entry.server);
-    if (!client) {
-      throw new Error(`MCP server not connected: ${entry.server}`);
-    }
-    return client.callTool(toolName, args);
-  }
-  // Get all available tools
-  getAvailableTools() {
-    return Array.from(this.tools.values()).map((e) => e.tool);
-  }
-  // Disconnect all
-  async disconnectAll() {
-    for (const client of this.clients.values()) {
-      await client.disconnect();
-    }
-    this.clients.clear();
-    this.tools.clear();
-  }
-};
-var mcpManager = null;
-function getMCPManager() {
-  if (!mcpManager) {
-    mcpManager = new MCPManager();
-  }
-  return mcpManager;
-}
-
 // src/core/approval/approval-manager.ts
-import { EventEmitter as EventEmitter17 } from "events";
+import { EventEmitter as EventEmitter16 } from "events";
 var APPROVAL_EVENT = {
   REQUEST: "approval_request",
   RESPONSE: "approval_response",
@@ -11893,7 +11447,7 @@ function assessRisk(toolName, toolInput) {
 function generateRequestId() {
   return `approval_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
 }
-var ApprovalManager = class extends EventEmitter17 {
+var ApprovalManager = class extends EventEmitter16 {
   pendingRequests = /* @__PURE__ */ new Map();
   autoApprovedTools = /* @__PURE__ */ new Set();
   autoDeniedTools = /* @__PURE__ */ new Set();
@@ -12017,93 +11571,672 @@ var ApprovalManager = class extends EventEmitter17 {
     });
   }
   /**
-   * Respond to an approval request (called by UI)
-   * Now handles timed YOLO modes
+   * Respond to an approval request (called by UI)
+   * Now handles timed YOLO modes
+   */
+  respond(requestId, decision) {
+    if (decision === "yolo_5min") {
+      this.setYoloMode(true, 5 * 60 * 1e3);
+      decision = "approve";
+    } else if (decision === "yolo_15min") {
+      this.setYoloMode(true, 15 * 60 * 1e3);
+      decision = "approve";
+    } else if (decision === "yolo_30min") {
+      this.setYoloMode(true, 30 * 60 * 1e3);
+      decision = "approve";
+    }
+    if (decision === "approve" || decision === "approve_always") {
+      this.stats.approved++;
+    } else if (decision === "deny" || decision === "deny_always") {
+      this.stats.denied++;
+    }
+    const response = {
+      requestId,
+      decision,
+      respondedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit(APPROVAL_EVENT.RESPONSE, response);
+  }
+  /**
+   * Get pending requests
+   */
+  getPendingRequests() {
+    return Array.from(this.pendingRequests.values());
+  }
+  /**
+   * Get auto-approved tools
+   */
+  getAutoApprovedTools() {
+    return Array.from(this.autoApprovedTools);
+  }
+  /**
+   * Add a tool to the auto-approved list
+   */
+  addAutoApprovedTool(toolName) {
+    this.autoApprovedTools.add(toolName);
+  }
+  /**
+   * Reset all auto decisions
+   */
+  resetAutoDecisions() {
+    this.autoApprovedTools.clear();
+    this.autoDeniedTools.clear();
+  }
+  /**
+   * Get YOLO mode status
+   */
+  getYoloStatus() {
+    const remainingMs = this.yoloExpiresAt ? Math.max(0, this.yoloExpiresAt - Date.now()) : null;
+    return {
+      enabled: this.yoloMode,
+      expiresAt: this.yoloExpiresAt,
+      remainingMs
+    };
+  }
+  /**
+   * Get approval statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Cancel YOLO mode
+   */
+  cancelYoloMode() {
+    this.setYoloMode(false);
+  }
+  /**
+   * Dispose of the approval manager
+   */
+  dispose() {
+    if (this.yoloTimer) {
+      clearTimeout(this.yoloTimer);
+      this.yoloTimer = null;
+    }
+    this.pendingRequests.clear();
+    this.removeAllListeners();
+  }
+};
+var approvalManager = null;
+function getApprovalManager(options) {
+  if (!approvalManager) {
+    approvalManager = new ApprovalManager(options);
+  }
+  return approvalManager;
+}
+
+// src/core/agent/strategy/attack-planner.ts
+var SERVICE_TOOL_MAP = {
+  http: {
+    enumTools: [
+      { tool: TOOL_NAME.WHATWEB, description: "Identify web technologies", successIndicators: ["WordPress", "Apache", "nginx", "PHP"], timeout: 3e4, priority: 90 },
+      { tool: TOOL_NAME.NIKTO, description: "Web vulnerability scan", successIndicators: ["OSVDB", "vulnerability", "found"], timeout: 3e5, priority: 80 },
+      { tool: TOOL_NAME.FFUF, description: "Directory/file fuzzing", successIndicators: ["200", "301", "302", "Status"], timeout: 3e5, priority: 85 },
+      { tool: TOOL_NAME.GOBUSTER, description: "Directory bruteforce", successIndicators: ["Status: 200", "Found:"], timeout: 3e5, priority: 70 },
+      { tool: TOOL_NAME.NUCLEI, description: "Vulnerability scanning with templates", successIndicators: ["[critical]", "[high]", "[medium]", "found"], timeout: 6e5, priority: 75 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.SQL_INJECTION, description: "SQL injection testing", successIndicators: ["injectable", "sql", "dump"], timeout: 6e5, priority: 85 },
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "Search for known exploits", successIndicators: ["Exploit", "exploit/"], timeout: 3e4, priority: 90 }
+    ],
+    vulnChecks: ["sql_injection", "xss", "file_inclusion", "command_injection", "path_traversal"]
+  },
+  https: {
+    enumTools: [
+      { tool: TOOL_NAME.WHATWEB, description: "Identify web technologies", successIndicators: ["WordPress", "Apache", "nginx"], timeout: 3e4, priority: 90 },
+      { tool: TOOL_NAME.NIKTO, description: "Web vulnerability scan", successIndicators: ["OSVDB", "vulnerability"], timeout: 3e5, priority: 80 },
+      { tool: TOOL_NAME.FFUF, description: "Directory fuzzing", successIndicators: ["200", "301", "302"], timeout: 3e5, priority: 85 },
+      { tool: TOOL_NAME.NUCLEI, description: "Template-based vuln scanning", successIndicators: ["[critical]", "[high]"], timeout: 6e5, priority: 75 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.SQL_INJECTION, description: "SQL injection", successIndicators: ["injectable", "dump"], timeout: 6e5, priority: 85 },
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "Search exploits", successIndicators: ["Exploit"], timeout: 3e4, priority: 90 }
+    ],
+    vulnChecks: ["ssl_vulnerability", "sql_injection", "xss"]
+  },
+  ssh: {
+    enumTools: [
+      { tool: TOOL_NAME.BASH, description: "SSH banner grab", successIndicators: ["SSH", "OpenSSH"], timeout: 1e4, priority: 90 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.HYDRA, description: "SSH bruteforce", successIndicators: ["login:", "password:"], timeout: 6e5, priority: 70 },
+      { tool: TOOL_NAME.SSH, description: "SSH with found credentials", successIndicators: ["$", "#", "Last login"], timeout: 3e4, priority: 95 },
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "Search SSH exploits", successIndicators: ["Exploit"], timeout: 3e4, priority: 80 }
+    ],
+    vulnChecks: ["weak_credentials", "old_version"]
+  },
+  smb: {
+    enumTools: [
+      { tool: TOOL_NAME.SMB_ENUM, description: "SMB enumeration", successIndicators: ["share", "IPC$", "users"], timeout: 12e4, priority: 90 },
+      { tool: TOOL_NAME.ENUM4LINUX, description: "Full SMB enum", successIndicators: ["user", "share", "password"], timeout: 3e5, priority: 85 },
+      { tool: TOOL_NAME.SMBMAP, description: "SMB share permissions", successIndicators: ["READ", "WRITE", "Disk"], timeout: 12e4, priority: 88 },
+      { tool: TOOL_NAME.SMBCLIENT, description: "SMB client access", successIndicators: ["smb:", "NT_STATUS"], timeout: 6e4, priority: 80 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.CRACKMAPEXEC, description: "Credential spray SMB", successIndicators: ["Pwn3d!", "+)"], timeout: 3e5, priority: 85 },
+      { tool: TOOL_NAME.IMPACKET_PSEXEC, description: "PsExec remote execution", successIndicators: ["C:\\>", "$"], timeout: 12e4, priority: 90 },
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "Search SMB exploits", successIndicators: ["Exploit", "EternalBlue"], timeout: 3e4, priority: 95 }
+    ],
+    vulnChecks: ["null_session", "anonymous_access", "eternal_blue", "weak_credentials"]
+  },
+  ftp: {
+    enumTools: [
+      { tool: TOOL_NAME.FTP_ANON, description: "Check anonymous FTP", successIndicators: ["Anonymous", "230", "Login successful"], timeout: 3e4, priority: 95 },
+      { tool: TOOL_NAME.FTP_ENUM, description: "FTP enumeration", successIndicators: ["user", "directory"], timeout: 6e4, priority: 85 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.HYDRA, description: "FTP bruteforce", successIndicators: ["login:", "password"], timeout: 6e5, priority: 70 },
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "Search FTP exploits", successIndicators: ["Exploit"], timeout: 3e4, priority: 90 }
+    ],
+    vulnChecks: ["anonymous_access", "weak_credentials", "known_vulnerability"]
+  },
+  mysql: {
+    enumTools: [
+      { tool: TOOL_NAME.MYSQL_CLIENT, description: "MySQL client access", successIndicators: ["mysql>", "Server version"], timeout: 3e4, priority: 90 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.HYDRA, description: "MySQL bruteforce", successIndicators: ["login:", "password"], timeout: 6e5, priority: 70 },
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "MySQL exploits", successIndicators: ["Exploit"], timeout: 3e4, priority: 85 }
+    ],
+    vulnChecks: ["default_credentials", "udf_exploit"]
+  },
+  snmp: {
+    enumTools: [
+      { tool: TOOL_NAME.SNMP_WALK, description: "SNMP walk", successIndicators: ["STRING:", "INTEGER:", "SNMPv2"], timeout: 12e4, priority: 90 },
+      { tool: TOOL_NAME.SNMP_CHECK, description: "SNMP check", successIndicators: ["system", "user", "process"], timeout: 6e4, priority: 85 },
+      { tool: TOOL_NAME.ONESIXTYONE, description: "SNMP community string bruteforce", successIndicators: ["public", "private"], timeout: 6e4, priority: 88 }
+    ],
+    exploitTools: [],
+    vulnChecks: ["default_community_string", "snmpv1"]
+  },
+  ldap: {
+    enumTools: [
+      { tool: TOOL_NAME.LDAP_SEARCH, description: "LDAP enumeration", successIndicators: ["dn:", "cn=", "dc="], timeout: 12e4, priority: 90 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.KERBRUTE, description: "Kerberos user enum", successIndicators: ["VALID", "user"], timeout: 3e5, priority: 80 },
+      { tool: TOOL_NAME.IMPACKET_GETNPUSERS, description: "AS-REP roasting", successIndicators: ["$krb5asrep$"], timeout: 12e4, priority: 85 }
+    ],
+    vulnChecks: ["anonymous_bind", "kerberoasting", "as-rep_roasting"]
+  },
+  rdp: {
+    enumTools: [
+      { tool: TOOL_NAME.RDP_CHECK, description: "RDP security check", successIndicators: ["RDP", "PROTOCOL_RDP"], timeout: 3e4, priority: 90 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.HYDRA, description: "RDP bruteforce", successIndicators: ["login:", "password"], timeout: 6e5, priority: 60 },
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "RDP exploits", successIndicators: ["BlueKeep", "CVE-2019"], timeout: 3e4, priority: 90 }
+    ],
+    vulnChecks: ["bluekeep", "weak_credentials"]
+  },
+  redis: {
+    enumTools: [
+      { tool: TOOL_NAME.REDIS_CLI, description: "Redis client access", successIndicators: ["redis", "PONG", "keys"], timeout: 3e4, priority: 90 }
+    ],
+    exploitTools: [
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "Redis exploits", successIndicators: ["Exploit"], timeout: 3e4, priority: 85 }
+    ],
+    vulnChecks: ["no_auth", "default_config"]
+  }
+};
+var AttackPlanner = class {
+  /**
+   * Generate an initial attack plan based on target and discovered services
+   */
+  generatePlan(target, services) {
+    const plan = {
+      target,
+      phases: [],
+      currentPhaseIndex: 0,
+      adaptations: []
+    };
+    plan.phases.push({
+      name: "initial_recon",
+      steps: [
+        { tool: TOOL_NAME.NMAP_SCAN, description: "Full port scan", successIndicators: ["open", "tcp", "udp"], timeout: 3e5, priority: 100 },
+        { tool: TOOL_NAME.RUSTSCAN, description: "Fast port scan", successIndicators: ["Open"], timeout: 6e4, priority: 95 }
+      ],
+      successCriteria: "At least 1 service discovered",
+      maxAttempts: 5
+    });
+    const enumSteps = [];
+    for (const svc of services) {
+      const normalizedService = this.normalizeServiceName(svc.service);
+      const mapping = SERVICE_TOOL_MAP[normalizedService];
+      if (mapping) {
+        enumSteps.push(...mapping.enumTools.map((step) => ({
+          ...step,
+          description: `[${svc.port}/${svc.service}] ${step.description}`
+        })));
+      }
+    }
+    if (enumSteps.length > 0) {
+      enumSteps.sort((a, b) => b.priority - a.priority);
+      plan.phases.push({
+        name: "service_enumeration",
+        steps: enumSteps,
+        successCriteria: "Vulnerabilities or access vectors identified",
+        maxAttempts: enumSteps.length + 5
+      });
+    }
+    const vulnSteps = [
+      { tool: TOOL_NAME.SEARCHSPLOIT, description: "Search for known exploits", successIndicators: ["Exploit", "CVE"], timeout: 3e4, priority: 90 }
+    ];
+    for (const svc of services) {
+      if (svc.version) {
+        vulnSteps.push({
+          tool: TOOL_NAME.SEARCHSPLOIT,
+          description: `Search exploits for ${svc.service} ${svc.version}`,
+          successIndicators: ["Exploit"],
+          timeout: 3e4,
+          priority: 88
+        });
+      }
+    }
+    plan.phases.push({
+      name: "vulnerability_analysis",
+      steps: vulnSteps,
+      successCriteria: "Exploitable vulnerability found",
+      maxAttempts: 10
+    });
+    const exploitSteps = [];
+    for (const svc of services) {
+      const normalizedService = this.normalizeServiceName(svc.service);
+      const mapping = SERVICE_TOOL_MAP[normalizedService];
+      if (mapping) {
+        exploitSteps.push(...mapping.exploitTools.map((step) => ({
+          ...step,
+          description: `[${svc.port}/${svc.service}] ${step.description}`
+        })));
+      }
+    }
+    if (exploitSteps.length > 0) {
+      exploitSteps.sort((a, b) => b.priority - a.priority);
+      plan.phases.push({
+        name: "exploitation",
+        steps: exploitSteps,
+        successCriteria: "Shell or admin access obtained",
+        maxAttempts: exploitSteps.length + 10
+      });
+    }
+    plan.phases.push({
+      name: "post_exploitation",
+      steps: [
+        { tool: TOOL_NAME.RUN_PRIVESC_ENUM, description: "Privilege escalation enumeration", successIndicators: ["SUID", "cron", "writable"], timeout: 12e4, priority: 90 },
+        { tool: TOOL_NAME.CHECK_SUDO, description: "Check sudo rights", successIndicators: ["(ALL)", "NOPASSWD", "may run"], timeout: 3e4, priority: 95 },
+        { tool: TOOL_NAME.FIND_SUID, description: "Find SUID binaries", successIndicators: ["/usr/", "/bin/"], timeout: 3e4, priority: 85 },
+        { tool: TOOL_NAME.DUMP_CREDENTIALS, description: "Dump credentials", successIndicators: ["password", "hash", "credential"], timeout: 12e4, priority: 80 }
+      ],
+      successCriteria: "Root/admin access obtained",
+      maxAttempts: 15
+    });
+    return plan;
+  }
+  /**
+   * Adapt the plan based on new discoveries
+   */
+  adaptPlan(plan, newServices, findings) {
+    const adaptation = `Adapting plan: ${newServices.length} new services, ${findings.length} findings`;
+    plan.adaptations.push(adaptation);
+    for (const svc of newServices) {
+      const normalizedService = this.normalizeServiceName(svc.service);
+      const mapping = SERVICE_TOOL_MAP[normalizedService];
+      if (mapping) {
+        let enumPhase = plan.phases.find((p) => p.name === "service_enumeration");
+        if (!enumPhase) {
+          enumPhase = {
+            name: "service_enumeration",
+            steps: [],
+            successCriteria: "Vulnerabilities identified",
+            maxAttempts: 10
+          };
+          const reconIdx = plan.phases.findIndex((p) => p.name === "initial_recon");
+          plan.phases.splice(reconIdx + 1, 0, enumPhase);
+        }
+        for (const tool of mapping.enumTools) {
+          const exists = enumPhase.steps.some(
+            (s) => s.tool === tool.tool && s.description.includes(`${svc.port}`)
+          );
+          if (!exists) {
+            enumPhase.steps.push({
+              ...tool,
+              description: `[${svc.port}/${svc.service}] ${tool.description}`
+            });
+          }
+        }
+      }
+    }
+    return plan;
+  }
+  /**
+   * Get suggested next steps based on current state
+   */
+  suggestNextSteps(services, completedTools, hasCredentials, hasShell) {
+    const suggestions = [];
+    if (hasShell) {
+      suggestions.push(
+        { tool: TOOL_NAME.RUN_PRIVESC_ENUM, description: "Run privilege escalation enumeration", successIndicators: ["SUID", "cron"], timeout: 12e4, priority: 95 },
+        { tool: TOOL_NAME.CHECK_SUDO, description: "Check sudo permissions", successIndicators: ["(ALL)", "NOPASSWD"], timeout: 3e4, priority: 90 },
+        { tool: TOOL_NAME.FIND_SUID, description: "Find SUID binaries", successIndicators: ["/usr/", "/bin/"], timeout: 3e4, priority: 85 }
+      );
+    } else if (hasCredentials) {
+      for (const svc of services) {
+        if (["ssh", "smb", "ftp", "rdp", "winrm"].includes(this.normalizeServiceName(svc.service))) {
+          suggestions.push({
+            tool: svc.service === "ssh" ? TOOL_NAME.SSH : TOOL_NAME.CRACKMAPEXEC,
+            description: `Try credentials on ${svc.service}:${svc.port}`,
+            successIndicators: ["$", "#", "Pwn3d!", "Login successful"],
+            timeout: 3e4,
+            priority: 95
+          });
+        }
+      }
+    } else {
+      for (const svc of services) {
+        const normalizedService = this.normalizeServiceName(svc.service);
+        const mapping = SERVICE_TOOL_MAP[normalizedService];
+        if (mapping) {
+          for (const tool of mapping.enumTools) {
+            if (!completedTools.includes(tool.tool)) {
+              suggestions.push({
+                ...tool,
+                description: `[${svc.port}/${svc.service}] ${tool.description}`
+              });
+            }
+          }
+        }
+      }
+    }
+    suggestions.sort((a, b) => b.priority - a.priority);
+    return suggestions.slice(0, 10);
+  }
+  /**
+   * Get vulnerability checks for discovered services
    */
-  respond(requestId, decision) {
-    if (decision === "yolo_5min") {
-      this.setYoloMode(true, 5 * 60 * 1e3);
-      decision = "approve";
-    } else if (decision === "yolo_15min") {
-      this.setYoloMode(true, 15 * 60 * 1e3);
-      decision = "approve";
-    } else if (decision === "yolo_30min") {
-      this.setYoloMode(true, 30 * 60 * 1e3);
-      decision = "approve";
+  getVulnChecks(services) {
+    const checks = [];
+    for (const svc of services) {
+      const normalizedService = this.normalizeServiceName(svc.service);
+      const mapping = SERVICE_TOOL_MAP[normalizedService];
+      if (mapping) {
+        checks.push(...mapping.vulnChecks);
+      }
     }
-    if (decision === "approve" || decision === "approve_always") {
-      this.stats.approved++;
-    } else if (decision === "deny" || decision === "deny_always") {
-      this.stats.denied++;
+    return [...new Set(checks)];
+  }
+  /**
+   * Normalize service names from nmap output to our mapping keys
+   */
+  normalizeServiceName(service) {
+    const lower = service.toLowerCase();
+    if (lower.includes("http") && !lower.includes("https")) return "http";
+    if (lower.includes("https") || lower.includes("ssl/http")) return "https";
+    if (lower.includes("ssh")) return "ssh";
+    if (lower.includes("smb") || lower.includes("microsoft-ds") || lower.includes("netbios")) return "smb";
+    if (lower.includes("ftp")) return "ftp";
+    if (lower.includes("mysql") || lower.includes("mariadb")) return "mysql";
+    if (lower.includes("mssql") || lower.includes("ms-sql")) return "mssql";
+    if (lower.includes("postgresql") || lower.includes("postgres")) return "postgresql";
+    if (lower.includes("redis")) return "redis";
+    if (lower.includes("mongo")) return "mongodb";
+    if (lower.includes("snmp")) return "snmp";
+    if (lower.includes("ldap")) return "ldap";
+    if (lower.includes("rdp") || lower.includes("ms-wbt-server")) return "rdp";
+    return lower;
+  }
+};
+var attackPlannerInstance = null;
+function getAttackPlanner() {
+  if (!attackPlannerInstance) {
+    attackPlannerInstance = new AttackPlanner();
+  }
+  return attackPlannerInstance;
+}
+
+// src/core/agent/strategy/stuck-detector.ts
+var StuckDetector = class {
+  actionHistory = [];
+  progressEvents = [];
+  maxHistorySize = 100;
+  // Thresholds
+  SAME_TOOL_THRESHOLD = 3;
+  // Same tool+target 3x = stuck
+  CYCLE_MIN_LENGTH = 2;
+  // Minimum cycle length
+  CYCLE_REPETITIONS = 2;
+  // Cycle seen 2x = stuck
+  NO_PROGRESS_TIMEOUT = 3e5;
+  // 5 minutes without progress
+  NO_NEW_INFO_THRESHOLD = 8;
+  // 8 actions without new info
+  /**
+   * Record a tool execution
+   */
+  recordAction(tool, target, success, hasNewInfo) {
+    this.actionHistory.push({
+      tool,
+      target,
+      timestamp: Date.now(),
+      success,
+      hasNewInfo
+    });
+    if (this.actionHistory.length > this.maxHistorySize) {
+      this.actionHistory = this.actionHistory.slice(-this.maxHistorySize);
     }
-    const response = {
-      requestId,
-      decision,
-      respondedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.emit(APPROVAL_EVENT.RESPONSE, response);
   }
   /**
-   * Get pending requests
+   * Record a progress event
    */
-  getPendingRequests() {
-    return Array.from(this.pendingRequests.values());
+  recordProgress(type, details) {
+    this.progressEvents.push({
+      type,
+      timestamp: Date.now(),
+      details
+    });
   }
   /**
-   * Get auto-approved tools
+   * Analyze whether the agent is stuck
    */
-  getAutoApprovedTools() {
-    return Array.from(this.autoApprovedTools);
+  analyze() {
+    const checks = [
+      this.checkSameToolRepetition(),
+      this.checkCycleDetection(),
+      this.checkProgressTimeout(),
+      this.checkNoNewInfoStreak(),
+      this.checkAllFailures()
+    ];
+    const stuckChecks = checks.filter((c) => c.isStuck);
+    if (stuckChecks.length === 0) {
+      return {
+        isStuck: false,
+        reason: "",
+        suggestion: "",
+        confidence: 0
+      };
+    }
+    stuckChecks.sort((a, b) => b.confidence - a.confidence);
+    return stuckChecks[0];
   }
   /**
-   * Reset all auto decisions
+   * Check 1: Same tool+target repeated too many times
    */
-  resetAutoDecisions() {
-    this.autoApprovedTools.clear();
-    this.autoDeniedTools.clear();
+  checkSameToolRepetition() {
+    if (this.actionHistory.length < this.SAME_TOOL_THRESHOLD) {
+      return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
+    }
+    const recent = this.actionHistory.slice(-10);
+    const comboCounts = /* @__PURE__ */ new Map();
+    for (const action of recent) {
+      const key = `${action.tool}:${action.target}`;
+      comboCounts.set(key, (comboCounts.get(key) || 0) + 1);
+    }
+    for (const [combo, count] of comboCounts) {
+      if (count >= this.SAME_TOOL_THRESHOLD) {
+        const [tool] = combo.split(":");
+        return {
+          isStuck: true,
+          reason: `Same tool "${tool}" executed ${count} times with same target`,
+          suggestion: `Try a different tool or target. Consider switching approach entirely.`,
+          confidence: Math.min(0.9, 0.5 + count * 0.1)
+        };
+      }
+    }
+    return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
   }
   /**
-   * Get YOLO mode status
+   * Check 2: Cycle detection (A→B→C→A→B→C pattern)
    */
-  getYoloStatus() {
-    const remainingMs = this.yoloExpiresAt ? Math.max(0, this.yoloExpiresAt - Date.now()) : null;
-    return {
-      enabled: this.yoloMode,
-      expiresAt: this.yoloExpiresAt,
-      remainingMs
-    };
+  checkCycleDetection() {
+    if (this.actionHistory.length < this.CYCLE_MIN_LENGTH * this.CYCLE_REPETITIONS) {
+      return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
+    }
+    const recent = this.actionHistory.slice(-20).map((a) => a.tool);
+    for (let cycleLen = this.CYCLE_MIN_LENGTH; cycleLen <= 5; cycleLen++) {
+      if (recent.length < cycleLen * this.CYCLE_REPETITIONS) continue;
+      const lastCycle = recent.slice(-cycleLen);
+      let repetitions = 0;
+      for (let i = recent.length - cycleLen; i >= 0; i -= cycleLen) {
+        const segment = recent.slice(i, i + cycleLen);
+        if (segment.length === cycleLen && segment.every((s, idx) => s === lastCycle[idx])) {
+          repetitions++;
+        } else {
+          break;
+        }
+      }
+      if (repetitions >= this.CYCLE_REPETITIONS) {
+        return {
+          isStuck: true,
+          reason: `Cycle detected: [${lastCycle.join(" \u2192 ")}] repeated ${repetitions + 1} times`,
+          suggestion: `Break the cycle. Try a completely different approach or tool category.`,
+          confidence: Math.min(0.95, 0.6 + repetitions * 0.1)
+        };
+      }
+    }
+    return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
   }
   /**
-   * Get approval statistics
+   * Check 3: No progress for too long
    */
-  getStats() {
-    return { ...this.stats };
+  checkProgressTimeout() {
+    if (this.progressEvents.length === 0 && this.actionHistory.length > 5) {
+      const oldestAction = this.actionHistory[0];
+      const elapsed = Date.now() - oldestAction.timestamp;
+      if (elapsed > this.NO_PROGRESS_TIMEOUT) {
+        return {
+          isStuck: true,
+          reason: `No progress events recorded in ${Math.round(elapsed / 6e4)} minutes`,
+          suggestion: `Consider scanning more broadly or trying a different attack vector.`,
+          confidence: 0.7
+        };
+      }
+    }
+    if (this.progressEvents.length > 0) {
+      const lastProgress = this.progressEvents[this.progressEvents.length - 1];
+      const elapsed = Date.now() - lastProgress.timestamp;
+      if (elapsed > this.NO_PROGRESS_TIMEOUT) {
+        return {
+          isStuck: true,
+          reason: `No progress for ${Math.round(elapsed / 6e4)} minutes (last: ${lastProgress.details})`,
+          suggestion: `Last progress was "${lastProgress.type}". Try a different approach.`,
+          confidence: Math.min(0.85, 0.5 + elapsed / this.NO_PROGRESS_TIMEOUT * 0.3)
+        };
+      }
+    }
+    return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
   }
   /**
-   * Cancel YOLO mode
+   * Check 4: Streak of actions with no new information
    */
-  cancelYoloMode() {
-    this.setYoloMode(false);
+  checkNoNewInfoStreak() {
+    if (this.actionHistory.length < this.NO_NEW_INFO_THRESHOLD) {
+      return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
+    }
+    const recent = this.actionHistory.slice(-this.NO_NEW_INFO_THRESHOLD);
+    const noNewInfoCount = recent.filter((a) => !a.hasNewInfo).length;
+    if (noNewInfoCount >= this.NO_NEW_INFO_THRESHOLD) {
+      return {
+        isStuck: true,
+        reason: `${noNewInfoCount} consecutive actions produced no new information`,
+        suggestion: `All recent actions returned known information. Try deeper enumeration or a different service.`,
+        confidence: 0.75
+      };
+    }
+    return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
   }
   /**
-   * Dispose of the approval manager
+   * Check 5: All recent actions failed
    */
-  dispose() {
-    if (this.yoloTimer) {
-      clearTimeout(this.yoloTimer);
-      this.yoloTimer = null;
+  checkAllFailures() {
+    if (this.actionHistory.length < 5) {
+      return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
     }
-    this.pendingRequests.clear();
-    this.removeAllListeners();
+    const recent = this.actionHistory.slice(-5);
+    const failureCount = recent.filter((a) => !a.success).length;
+    if (failureCount >= 5) {
+      return {
+        isStuck: true,
+        reason: `Last ${failureCount} actions all failed`,
+        suggestion: `Multiple failures detected. Check if the target is reachable, or try different tools.`,
+        confidence: 0.8
+      };
+    }
+    return { isStuck: false, reason: "", suggestion: "", confidence: 0 };
   }
-};
-var approvalManager = null;
-function getApprovalManager(options) {
-  if (!approvalManager) {
-    approvalManager = new ApprovalManager(options);
+  /**
+   * Get suggested alternative approaches
+   */
+  getSuggestedPivots(completedTools, availableServices) {
+    const suggestions = [];
+    const toolCategories = {
+      "web_scanning": ["ffuf", "gobuster", "nikto", "nuclei", "whatweb"],
+      "credential_attack": ["hydra", "medusa", "john", "hashcat"],
+      "smb_attack": ["smbclient", "smbmap", "enum4linux", "crackmapexec"],
+      "ssh_attack": ["ssh", "hydra"],
+      "exploit_search": ["searchsploit", "metasploit"],
+      "dns_recon": ["dig", "dnsenum", "dnsrecon", "subfinder"],
+      "privesc": ["run_privesc_enum", "check_sudo", "find_suid"]
+    };
+    for (const [category, tools] of Object.entries(toolCategories)) {
+      const usedCount = tools.filter((t) => completedTools.includes(t)).length;
+      const totalCount = tools.length;
+      if (usedCount < totalCount / 2) {
+        suggestions.push(`Try ${category} tools (${totalCount - usedCount} unused)`);
+      }
+    }
+    for (const service of availableServices) {
+      const normalizedService = service.toLowerCase();
+      if (normalizedService.includes("http") && !completedTools.includes("ffuf")) {
+        suggestions.push("Try directory fuzzing on web services");
+      }
+      if (normalizedService.includes("smb") && !completedTools.includes("enum4linux")) {
+        suggestions.push("Try full SMB enumeration");
+      }
+    }
+    return suggestions.slice(0, 5);
   }
-  return approvalManager;
-}
+  /**
+   * Reset detector state
+   */
+  reset() {
+    this.actionHistory = [];
+    this.progressEvents = [];
+  }
+  /**
+   * Get statistics about current state
+   */
+  getStats() {
+    const total = this.actionHistory.length;
+    const successes = this.actionHistory.filter((a) => a.success).length;
+    const newInfo = this.actionHistory.filter((a) => a.hasNewInfo).length;
+    const lastProgress = this.progressEvents.length > 0 ? Date.now() - this.progressEvents[this.progressEvents.length - 1].timestamp : null;
+    return {
+      totalActions: total,
+      successRate: total > 0 ? successes / total : 0,
+      newInfoRate: total > 0 ? newInfo / total : 0,
+      lastProgressAge: lastProgress
+    };
+  }
+};
 
 // src/core/agent/autonomous-agent.ts
 function toContentBlockParam(block) {
@@ -12147,7 +12280,7 @@ var DEFAULT_PHASES = [
   { id: PHASE_ID.EXFIL, name: "Data Exfiltration", shortName: "Exfil", status: PHASE_STATUS.PENDING, attempts: 0 },
   { id: PHASE_ID.REPORT, name: "Reporting", shortName: "Report", status: PHASE_STATUS.PENDING, attempts: 0 }
 ];
-var AutonomousHackingAgent = class extends EventEmitter18 {
+var AutonomousHackingAgent = class extends EventEmitter17 {
   // LLM Client
   client;
   // Core State
@@ -12163,12 +12296,15 @@ var AutonomousHackingAgent = class extends EventEmitter18 {
   sessionManager;
   // Utility Systems
   hookExecutor;
-  mcpManager;
   contextManager;
   approvalManager;
-  // v0.12.0 New Systems
+  // v0.12.7 New Systems
   resourceManager;
   auditLogger;
+  // Strategy modules
+  attackPlanner;
+  stuckDetector;
+  currentAttackPlan;
   // Token usage tracking
   tokenUsage = { input: 0, output: 0, total: 0 };
   // Execution control flags
@@ -12181,11 +12317,12 @@ var AutonomousHackingAgent = class extends EventEmitter18 {
   enableAutoCheckpoint = true;
   checkpointIntervalMs = 6e4;
   enableAutonomousOrchestrator = true;
-  // New: Use enhanced autonomous orchestrator
   // Rabbit hole detection settings
   STUCK_THRESHOLD = 5;
   STUCK_TIME_THRESHOLD = 3e5;
   MAX_PHASE_ATTEMPTS = 20;
+  // Stream control
+  currentStream = null;
   constructor(apiKey, config) {
     super();
     this.client = new Anthropic({
@@ -12194,6 +12331,8 @@ var AutonomousHackingAgent = class extends EventEmitter18 {
     });
     this.config = { ...AGENT_CONFIG, ...config };
     this.tools = ALL_TOOLS;
+    this.attackPlanner = getAttackPlanner();
+    this.stuckDetector = new StuckDetector();
     this.state = this.createInitialState();
     this.sharedMemory = new SharedMemory();
     this.sharedMemory.on("finding_added", (finding) => {
@@ -12248,7 +12387,7 @@ var AutonomousHackingAgent = class extends EventEmitter18 {
       this.think(THOUGHT_TYPE.PLANNING, "[coordinator] Replanning attack strategy...");
     });
     this.coordinator.on("thought", (data) => {
-      this.think(THOUGHT_TYPE.PLANNING, data.message);
+      this.think(THOUGHT_TYPE.PLANNING, data.content);
     });
     if (this.enableAutonomousOrchestrator) {
       const autonomousOrch = this.coordinator;
@@ -12264,7 +12403,6 @@ var AutonomousHackingAgent = class extends EventEmitter18 {
     }
     this.sessionManager = new SessionManager(".pentesting/sessions");
     this.hookExecutor = getHookExecutor();
-    this.mcpManager = getMCPManager();
     this.contextManager = new ContextManager(this.client);
     this.approvalManager = getApprovalManager({ yoloMode: config?.autoApprove });
     this.resourceManager = getResourceManager();
@@ -12394,6 +12532,16 @@ var AutonomousHackingAgent = class extends EventEmitter18 {
     this.emit(AGENT_EVENT.TARGET_SET, { target, action: "added" });
     return true;
   }
+  /**
+   * Add an MCP server for extended tool capabilities
+   */
+  async addMCPServer(name, command, args) {
+    this.think(THOUGHT_TYPE.PLANNING, `[mcp] Registering MCP server: ${name} (${command})`);
+    this.emit(AGENT_EVENT.THOUGHT, {
+      type: THOUGHT_TYPE.PLANNING,
+      content: `Connected to MCP server: ${name}`
+    });
+  }
   // ===== MAIN AUTONOMOUS EXECUTION =====
   async runAutonomous(objective) {
     if (!this.state.target.primary) {
@@ -12411,6 +12559,17 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
       role: "user",
       content: mainObjective
     });
+    this.currentAttackPlan = this.attackPlanner.generatePlan(
+      this.state.target.primary,
+      this.state.target.services.map((s) => ({
+        host: s.host,
+        port: s.port,
+        protocol: s.protocol,
+        service: s.service,
+        version: s.version
+      }))
+    );
+    this.think(THOUGHT_TYPE.PLANNING, `[planner] Generated attack plan with ${this.currentAttackPlan.phases.length} phases`);
     if (this.enableAutoCheckpoint) {
       this.sessionManager.enableAutoCheckpoint(this.checkpointIntervalMs, async () => {
         return await this.getCurrentState();
@@ -12425,8 +12584,14 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
       this.state.fullAttempts++;
       this.emit(AGENT_EVENT.ITERATION, { current: iteration, max: maxIterations, phase: this.state.currentPhase });
       try {
-        if (this.checkIfStuck()) {
+        const stuckState = this.stuckDetector.analyze();
+        const legacyStuck = this.checkIfStuck();
+        if (stuckState.isStuck || legacyStuck) {
           this.state.status = AGENT_STATUS.STUCK;
+          if (stuckState.isStuck) {
+            this.think(THOUGHT_TYPE.STUCK, `[stuck] ${stuckState.reason} (confidence: ${(stuckState.confidence * 100).toFixed(0)}%)`);
+            this.think(THOUGHT_TYPE.PLANNING, `[stuck] Suggestion: ${stuckState.suggestion}`);
+          }
           if (this.learningSystem) {
             const reflection = await this.analyzeFailureWithLearning();
             this.think(THOUGHT_TYPE.REFLECTION, `[learning] ${reflection}`);
@@ -12435,6 +12600,37 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
               this.think(THOUGHT_TYPE.PLANNING, `[learning] Trying alternative: ${alternative}`);
             }
           }
+          const completedTools = [...this.state.repeatedActions.keys()].map((k) => k.split(":")[0]);
+          const serviceNames = this.state.target.services.map((s) => s.service);
+          const pivots = this.stuckDetector.getSuggestedPivots(completedTools, serviceNames);
+          if (pivots.length > 0) {
+            this.think(THOUGHT_TYPE.PLANNING, `[planner] Pivot suggestions: ${pivots.join(", ")}`);
+          }
+          if (this.currentAttackPlan) {
+            const serviceInfos = this.state.target.services.map((s) => ({
+              host: s.host,
+              port: s.port,
+              protocol: s.protocol,
+              service: s.service,
+              version: s.version
+            }));
+            const hasCredentials = this.state.target.credentials.length > 0;
+            const hasShell = this.state.target.compromised.length > 0;
+            const nextSteps = this.attackPlanner.suggestNextSteps(
+              serviceInfos,
+              completedTools,
+              hasCredentials,
+              hasShell
+            );
+            if (nextSteps.length > 0) {
+              const stepDescriptions = nextSteps.slice(0, 3).map((s) => `${s.tool}: ${s.description}`).join("; ");
+              this.think(THOUGHT_TYPE.PLANNING, `[planner] Suggested: ${stepDescriptions}`);
+              this.state.history.push({
+                role: "user",
+                content: `[System] You are stuck. Try these alternative approaches: ${stepDescriptions}. Avoid repeating the same tools/commands.`
+              });
+            }
+          }
           const shouldSkip = await this.decideNextPhase();
           if (shouldSkip) {
             this.setPhaseStatus(this.state.currentPhase, PHASE_STATUS.SKIPPED);
@@ -12497,7 +12693,7 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
     try {
       await this.coordinator.initializeAttack(target, attackGoal);
       let findings = [];
-      if (this.enableAutonomousOrchestrator && this.coordinator.runAutonomous) {
+      if (this.enableAutonomousOrchestrator && "runAutonomous" in this.coordinator) {
         findings = await this.coordinator.runAutonomous(attackGoal);
       } else {
         findings = await this.coordinator.run();
@@ -12622,7 +12818,7 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
     this.emit(AGENT_EVENT.LLM_START, { model: LLM_MODEL });
     let response;
     try {
-      const stream = this.client.messages.stream({
+      this.currentStream = this.client.messages.stream({
         model: LLM_MODEL,
         max_tokens: LLM_MAX_TOKENS,
         system: systemPrompt,
@@ -12631,7 +12827,7 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
         thinking: { type: "enabled", budget_tokens: 16e3 }
       });
       let thinkingBuffer = "";
-      stream.on("contentBlock", (block) => {
+      this.currentStream.on("contentBlock", (block) => {
         if (block.type === "thinking" && block.thinking) {
           thinkingBuffer += block.thinking;
           this.emit(AGENT_EVENT.THOUGHT, {
@@ -12645,7 +12841,8 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
           });
         }
       });
-      response = await stream.finalMessage();
+      response = await this.currentStream.finalMessage();
+      this.currentStream = null;
     } catch (error) {
       response = await withRetry(
         () => this.client.messages.create({
@@ -12702,32 +12899,46 @@ Leverage shared memory findings from other agents.
   }
   async processResponse(response) {
     const contentBlocks = [];
-    const toolResults = [] = [];
+    const toolUseBlocks = [];
+    const toolResults = [];
     let textResponse = "";
-    let hasToolUse = false;
-    const processTool = async (block) => {
-      hasToolUse = true;
+    for (const block of response.content) {
+      if (block.type === "text") {
+        textResponse += block.text;
+        contentBlocks.push({ type: "text", text: block.text });
+        this.think(THOUGHT_TYPE.OBSERVATION, block.text.slice(0, 500));
+        this.emit(AGENT_EVENT.RESPONSE, block.text);
+      } else if (block.type === "tool_use") {
+        contentBlocks.push({
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        });
+        toolUseBlocks.push(block);
+      }
+    }
+    if (contentBlocks.length > 0) {
+      this.state.history.push({
+        role: "assistant",
+        content: contentBlocks
+      });
+    }
+    for (const block of toolUseBlocks) {
       const toolName = block.name;
       const toolInput = block.input;
-      contentBlocks.push({
-        type: "tool_use",
-        id: block.id,
-        name: toolName,
-        input: toolInput
-      });
       const actionKey = `${toolName}:${JSON.stringify(toolInput).slice(0, 100)}`;
-      this.trackAction(actionKey);
       this.think(THOUGHT_TYPE.ACTION, `[tool] ${toolName}`);
       this.emit(AGENT_EVENT.TOOL_CALL, { id: block.id, name: toolName, input: toolInput });
       const hookCheck = await this.hookExecutor.checkPreToolUse(toolName, toolInput);
       if (hookCheck.decision === "block") {
         this.think(THOUGHT_TYPE.STUCK, `Tool blocked: ${hookCheck.output}`);
         toolResults.push({ id: block.id, content: `Blocked: ${hookCheck.output}`, is_error: true });
-        return;
+        continue;
       }
       if (this.shouldStopLoop()) {
         this.think(THOUGHT_TYPE.OBSERVATION, "Execution paused");
-        return;
+        break;
       }
       if (this.approvalManager.requiresApproval(toolName, toolInput)) {
         const risk = assessRisk(toolName, toolInput);
@@ -12738,14 +12949,14 @@ Leverage shared memory findings from other agents.
           riskLevel: risk
         });
         const decision = await new Promise((resolve) => {
-          const handler = (response2) => {
-            if (response2.requestId === block.id) {
+          const handler = (resp) => {
+            if (resp.requestId === block.id) {
               this.approvalManager.removeListener("approval_response", handler);
-              if (response2.decision === "approve_always") {
-                this.approvalManager.autoApprovedTools?.add(toolName);
+              if (resp.decision === "approve_always") {
+                this.approvalManager.addAutoApprovedTool(toolName);
                 resolve("approve");
               } else {
-                resolve(response2.decision);
+                resolve(resp.decision);
               }
             }
           };
@@ -12754,7 +12965,7 @@ Leverage shared memory findings from other agents.
         if (decision === "deny") {
           this.think(THOUGHT_TYPE.STUCK, `Tool denied: ${toolName}`);
           toolResults.push({ id: block.id, content: "Denied", is_error: true });
-          return;
+          continue;
         }
       }
       const result = await executeToolCall(toolName, toolInput);
@@ -12765,26 +12976,12 @@ Leverage shared memory findings from other agents.
       );
       this.emit(AGENT_EVENT.TOOL_RESULT, { id: block.id, name: toolName, result });
       this.extractIntelligence(toolName, result);
+      this.trackAction(actionKey, result);
       toolResults.push({
         id: block.id,
         content: result.output || result.error || "No output",
         is_error: !result.success
       });
-    };
-    const toolsToProcess = response.content.filter((b) => b.type === "tool_use").map(processTool);
-    for (const block of response.content) {
-      if (block.type === "text") {
-        textResponse += block.text;
-        contentBlocks.push({ type: "text", text: block.text });
-        this.think(THOUGHT_TYPE.OBSERVATION, block.text.slice(0, 500));
-        this.emit(AGENT_EVENT.RESPONSE, block.text);
-      }
-    }
-    if (contentBlocks.length > 0) {
-      this.state.history.push({
-        role: "assistant",
-        content: contentBlocks
-      });
     }
     if (toolResults.length > 0) {
       this.state.history.push({
@@ -12797,11 +12994,8 @@ Leverage shared memory findings from other agents.
         }))
       });
     }
-    await Promise.all(toolsToProcess);
-    if (response.stop_reason === "tool_use" && hasToolUse && !this.shouldStopLoop()) {
-      setImmediate(() => this.executeStep().catch((err) => {
-        this.think(THOUGHT_TYPE.STUCK, `Error in next step: ${err}`);
-      }));
+    if (response.stop_reason === "tool_use" && toolUseBlocks.length > 0 && !this.shouldStopLoop()) {
+      return await this.executeStep();
     }
     return textResponse;
   }
@@ -12809,7 +13003,7 @@ Leverage shared memory findings from other agents.
   extractIntelligence(toolName, result) {
     if (!result.success) return;
     const output = result.output;
-    if (toolName === "nmap_scan" || toolName === "bash") {
+    if (toolName === TOOL_NAME.NMAP_SCAN || toolName === TOOL_NAME.BASH) {
       const portMatches = output.match(/(\d+)\/(tcp|udp)\s+open\s+(\S+)/gi);
       if (portMatches) {
         portMatches.forEach((match) => {
@@ -12838,10 +13032,41 @@ Leverage shared memory findings from other agents.
           }
         });
       }
+      if (portMatches && this.currentAttackPlan) {
+        const currentServices = this.state.target.services.map((s) => ({
+          host: s.host,
+          port: s.port,
+          protocol: s.protocol,
+          service: s.service,
+          version: s.version
+        }));
+        const findingTitles = this.state.findings.map((f) => f.title);
+        this.currentAttackPlan = this.attackPlanner.adaptPlan(
+          this.currentAttackPlan,
+          currentServices,
+          findingTitles
+        );
+        if (this.currentAttackPlan.adaptations.length > 0) {
+          const latest = this.currentAttackPlan.adaptations[this.currentAttackPlan.adaptations.length - 1];
+          this.think(THOUGHT_TYPE.PLANNING, `[planner] Plan adapted: ${latest}`);
+        }
+      }
     }
-    if (output.includes("meterpreter") || output.includes("shell") || output.includes("www-data") || output.includes("uid=")) {
+    if (output.includes("meterpreter") || output.includes("www-data") || output.includes("uid=")) {
       this.addCompromisedHost(this.state.target.primary);
     }
+    const credPatterns = [
+      /(?:user|login|username)[:\s=]+([\w.@-]+)/gi,
+      /(?:pass|password|pwd)[:\s=]+([\S]+)/gi
+    ];
+    for (const pattern of credPatterns) {
+      const matches = output.matchAll(pattern);
+      for (const match of matches) {
+        if (match[1] && match[1].length > 2 && match[1].length < 100) {
+          this.stuckDetector.recordProgress("credential_found", `Potential cred: ${match[1].substring(0, 20)}`);
+        }
+      }
+    }
   }
   // ===== LEARNING SYSTEM INTEGRATION =====
   async analyzeFailureWithLearning() {
@@ -13021,13 +13246,19 @@ Alternatives: ${reflection.alternatives.map((a) => a.description).join(", ")}`;
     this.state.stuckCounter = 0;
     this.state.lastProgressTime = /* @__PURE__ */ new Date();
     this.state.repeatedActions.clear();
+    this.stuckDetector.recordProgress("phase_advanced", `Reset at phase ${this.state.currentPhase}`);
   }
-  trackAction(action) {
+  trackAction(action, result) {
     const count = this.state.repeatedActions.get(action) || 0;
     this.state.repeatedActions.set(action, count + 1);
     if (count + 1 >= this.STUCK_THRESHOLD) {
       this.state.stuckCounter++;
     }
+    const [tool, ...targetParts] = action.split(":");
+    const target = targetParts.join(":") || this.state.target.primary;
+    const success = result ? result.success : true;
+    const hasNewInfo = result ? result.output.length > 50 && success : false;
+    this.stuckDetector.recordAction(tool, target, success, hasNewInfo);
   }
   // ===== DECISION HELPERS =====
   shouldAdvancePhase() {
@@ -13063,6 +13294,11 @@ Alternatives: ${reflection.alternatives.map((a) => a.description).join(", ")}`;
     const hasSuccess = successKeywords.some((kw) => response.toLowerCase().includes(kw));
     if (hasSuccess) {
       this.resetStuckCounter();
+      if (response.toLowerCase().includes("shell") || response.toLowerCase().includes("root")) {
+        this.stuckDetector.recordProgress("shell_obtained", "Shell access detected in response");
+      } else if (response.toLowerCase().includes("discovered") || response.toLowerCase().includes("found")) {
+        this.stuckDetector.recordProgress("service_discovered", "Discovery detected in response");
+      }
     }
   }
   async attemptRecovery(error) {
@@ -13122,6 +13358,13 @@ Alternatives: ${reflection.alternatives.map((a) => a.description).join(", ")}`;
   recordProgress(type) {
     this.resetStuckCounter();
     this.state.lastProgressTime = /* @__PURE__ */ new Date();
+    const progressTypeMap = {
+      discovery: "service_discovered",
+      credential: "credential_found",
+      access: "shell_obtained",
+      exploit: "vulnerability_found"
+    };
+    this.stuckDetector.recordProgress(progressTypeMap[type] || "service_discovered", type);
     let message = "";
     let importance = 60;
     switch (type) {
@@ -13220,6 +13463,13 @@ ${this.state.target.compromised.map((h) => `- ${h}`).join("\n") || "None"}
   pause() {
     this.isPaused = true;
     this.state.status = AGENT_STATUS.PAUSED;
+    if (this.currentStream) {
+      try {
+        this.currentStream.abort();
+      } catch (e) {
+      }
+      this.currentStream = null;
+    }
     this.emit(AGENT_EVENT.PAUSED);
   }
   resume() {
@@ -13234,6 +13484,13 @@ ${this.state.target.compromised.map((h) => `- ${h}`).join("\n") || "None"}
     this.isPaused = true;
     this.isAborted = true;
     this.state.status = AGENT_STATUS.IDLE;
+    if (this.currentStream) {
+      try {
+        this.currentStream.abort();
+      } catch (e) {
+      }
+      this.currentStream = null;
+    }
     this.emit(AGENT_EVENT.PAUSED);
   }
   reset() {
@@ -13243,25 +13500,6 @@ ${this.state.target.compromised.map((h) => `- ${h}`).join("\n") || "None"}
     this.sharedMemory.clear();
     this.emit(AGENT_EVENT.RESET);
   }
-  // ===== MCP INTEGRATION =====
-  async addMCPServer(name, command, args) {
-    await this.mcpManager.addServer(name, { command, args });
-    const mcpTools = this.mcpManager.getAvailableTools();
-    for (const mcpTool of mcpTools) {
-      const anthropicTool = {
-        name: mcpTool.name,
-        description: mcpTool.description,
-        input_schema: mcpTool.inputSchema
-      };
-      if (!this.tools.find((t) => t.name === mcpTool.name)) {
-        this.tools.push(anthropicTool);
-      }
-    }
-    this.emit(AGENT_EVENT.MCP_SERVER_ADDED, { name, toolCount: mcpTools.length });
-  }
-  getMCPTools() {
-    return this.mcpManager.getAvailableTools().map((t) => t.name);
-  }
   // ===== PUBLIC ACCESSORS =====
   getSystemPrompt() {
     return AUTONOMOUS_HACKING_PROMPT;
@@ -13333,7 +13571,42 @@ ${this.state.target.compromised.map((h) => `- ${h}`).join("\n") || "None"}
         } else if (block.type === "tool_use") {
           hasToolCalls = true;
           this.emit(AGENT_EVENT.TOOL_CALL, { name: block.name, input: block.input });
-          const result = await executeToolCall(block.name, block.input);
+          const toolInput = block.input;
+          if (this.approvalManager.requiresApproval(block.name, toolInput)) {
+            const risk = assessRisk(block.name, toolInput);
+            this.emit(AGENT_EVENT.APPROVAL_NEEDED, {
+              id: block.id,
+              toolName: block.name,
+              toolInput,
+              riskLevel: risk
+            });
+            const decision = await new Promise((resolve) => {
+              const handler = (resp) => {
+                if (resp.requestId === block.id) {
+                  this.approvalManager.removeListener("approval_response", handler);
+                  resolve(resp.decision);
+                }
+              };
+              this.approvalManager.on("approval_response", handler);
+            });
+            if (decision === "deny") {
+              this.state.history.push({
+                role: "assistant",
+                content: response.content
+              });
+              this.state.history.push({
+                role: "user",
+                content: [{
+                  type: "tool_result",
+                  tool_use_id: block.id,
+                  content: "Tool execution denied by user",
+                  is_error: true
+                }]
+              });
+              continue;
+            }
+          }
+          const result = await executeToolCall(block.name, toolInput);
           this.emit(AGENT_EVENT.TOOL_RESULT, { name: block.name, result });
           this.state.history.push({
             role: "assistant",
@@ -13567,8 +13840,8 @@ Respond helpfully. If asked to perform security testing, use appropriate tools.`
     this.resourceManager.stopMonitoring();
     await this.resourceManager.performCleanup();
     this.resourceManager.dispose();
-    this.removeAllListeners();
     this.emit("shutdown");
+    this.removeAllListeners();
   }
   // ===== UTILITY: Execute Tool with Audit =====
   async executeToolWithAudit(toolName, toolInput) {
@@ -13610,16 +13883,16 @@ Respond helpfully. If asked to perform security testing, use appropriate tools.`
 };
 
 // src/core/session/session-manager.ts
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import * as path5 from "path";
-import { EventEmitter as EventEmitter19 } from "events";
+import { EventEmitter as EventEmitter18 } from "events";
 var SESSIONS_DIR = ".pentesting/sessions";
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
   const random = Math.random().toString(36).substring(2, 8);
   return `session_${timestamp}_${random}`;
 }
-var SessionManager2 = class extends EventEmitter19 {
+var SessionManager2 = class extends EventEmitter18 {
   sessionsDir;
   currentSession = null;
   constructor(baseDir) {
@@ -13631,7 +13904,7 @@ var SessionManager2 = class extends EventEmitter19 {
    */
   async initialize() {
     try {
-      await fs6.mkdir(this.sessionsDir, { recursive: true });
+      await fs7.mkdir(this.sessionsDir, { recursive: true });
     } catch {
     }
   }
@@ -13652,7 +13925,7 @@ var SessionManager2 = class extends EventEmitter19 {
     };
     this.currentSession = metadata;
     const sessionDir = path5.join(this.sessionsDir, metadata.id);
-    await fs6.mkdir(sessionDir, { recursive: true });
+    await fs7.mkdir(sessionDir, { recursive: true });
     await this.saveMetadata(metadata);
     this.emit("session_created", metadata);
     return metadata;
@@ -13662,7 +13935,7 @@ var SessionManager2 = class extends EventEmitter19 {
    */
   async saveMetadata(metadata) {
     const metadataPath = path5.join(this.sessionsDir, metadata.id, "metadata.json");
-    await fs6.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    await fs7.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
   }
   /**
    * Save full session snapshot
@@ -13676,16 +13949,16 @@ var SessionManager2 = class extends EventEmitter19 {
     this.currentSession.currentPhase = snapshot.state.currentPhase;
     await this.saveMetadata(this.currentSession);
     const statePath = path5.join(sessionDir, "state.json");
-    await fs6.writeFile(statePath, JSON.stringify(snapshot.state, null, 2));
+    await fs7.writeFile(statePath, JSON.stringify(snapshot.state, null, 2));
     const configPath = path5.join(sessionDir, "config.json");
-    await fs6.writeFile(configPath, JSON.stringify(snapshot.config, null, 2));
+    await fs7.writeFile(configPath, JSON.stringify(snapshot.config, null, 2));
     const historyPath = path5.join(sessionDir, "history.jsonl");
     const historyLine = JSON.stringify({
       timestamp: this.currentSession.updatedAt,
       iteration: snapshot.state.iteration,
       phase: snapshot.state.currentPhase
     }) + "\n";
-    await fs6.appendFile(historyPath, historyLine);
+    await fs7.appendFile(historyPath, historyLine);
     this.emit("snapshot_saved", this.currentSession.id);
   }
   /**
@@ -13695,15 +13968,15 @@ var SessionManager2 = class extends EventEmitter19 {
     try {
       const sessionDir = path5.join(this.sessionsDir, sessionId);
       const metadataPath = path5.join(sessionDir, "metadata.json");
-      const metadataContent = await fs6.readFile(metadataPath, "utf-8");
+      const metadataContent = await fs7.readFile(metadataPath, "utf-8");
       const metadata = JSON.parse(metadataContent);
       const statePath = path5.join(sessionDir, "state.json");
-      const stateContent = await fs6.readFile(statePath, "utf-8");
+      const stateContent = await fs7.readFile(statePath, "utf-8");
       const state = JSON.parse(stateContent);
       const configPath = path5.join(sessionDir, "config.json");
       let config = {};
       try {
-        const configContent = await fs6.readFile(configPath, "utf-8");
+        const configContent = await fs7.readFile(configPath, "utf-8");
         config = JSON.parse(configContent);
       } catch {
       }
@@ -13720,13 +13993,13 @@ var SessionManager2 = class extends EventEmitter19 {
   async listSessions() {
     await this.initialize();
     try {
-      const entries = await fs6.readdir(this.sessionsDir, { withFileTypes: true });
+      const entries = await fs7.readdir(this.sessionsDir, { withFileTypes: true });
       const sessions = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
           try {
             const metadataPath = path5.join(this.sessionsDir, entry.name, "metadata.json");
-            const content = await fs6.readFile(metadataPath, "utf-8");
+            const content = await fs7.readFile(metadataPath, "utf-8");
             const metadata = JSON.parse(content);
             sessions.push({
               id: metadata.id,
@@ -13776,14 +14049,14 @@ var SessionManager2 = class extends EventEmitter19 {
     await this.initialize();
     let deletedCount = 0;
     try {
-      const entries = await fs6.readdir(this.sessionsDir, { withFileTypes: true });
+      const entries = await fs7.readdir(this.sessionsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const metadataPath = path5.join(this.sessionsDir, entry.name, "metadata.json");
           try {
-            await fs6.access(metadataPath);
+            await fs7.access(metadataPath);
           } catch {
-            await fs6.rm(path5.join(this.sessionsDir, entry.name), { recursive: true });
+            await fs7.rm(path5.join(this.sessionsDir, entry.name), { recursive: true });
             deletedCount++;
           }
         }
@@ -13806,7 +14079,7 @@ var SessionManager2 = class extends EventEmitter19 {
   async deleteSession(sessionId) {
     try {
       const sessionDir = path5.join(this.sessionsDir, sessionId);
-      await fs6.rm(sessionDir, { recursive: true });
+      await fs7.rm(sessionDir, { recursive: true });
       this.emit("session_deleted", sessionId);
       return true;
     } catch {
@@ -13938,7 +14211,7 @@ function getSlashCommandRegistry() {
 // src/core/context/context-manager.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
 import { join as join6, dirname as dirname2 } from "path";
-import { EventEmitter as EventEmitter20 } from "events";
+import { EventEmitter as EventEmitter19 } from "events";
 var CONTEXT_EVENT = {
   MESSAGE_ADDED: "message_added",
   CHECKPOINT_CREATED: "checkpoint_created",
@@ -13946,7 +14219,7 @@ var CONTEXT_EVENT = {
   CLEARED: "cleared",
   COMPACTED: "compacted"
 };
-var ContextManager2 = class extends EventEmitter20 {
+var ContextManager2 = class extends EventEmitter19 {
   filePath;
   state;
   maxMessages;
@@ -14728,7 +15001,7 @@ import { homedir as homedir2 } from "os";
 import { join as join9 } from "path";
 
 // src/utils/input-queue.ts
-import { EventEmitter as EventEmitter21 } from "events";
+import { EventEmitter as EventEmitter20 } from "events";
 var INPUT_QUEUE_EVENT = {
   QUEUED: "queued",
   // Message added to queue
@@ -14741,7 +15014,7 @@ var INPUT_QUEUE_EVENT = {
   SHUTDOWN: "shutdown"
   // Queue shutdown
 };
-var InputQueue = class extends EventEmitter21 {
+var InputQueue = class extends EventEmitter20 {
   queue = [];
   isShutdown = false;
   isPaused = false;
@@ -14888,9 +15161,10 @@ var App = ({ autoApprove = false, target }) => {
   const [mode, setMode] = useState("agent");
   const [checkpointCount, setCheckpointCount] = useState(0);
   const [pendingTargetConfirmation, setPendingTargetConfirmation] = useState(null);
-  const [spinnerHue, setSpinnerHue] = useState(0);
   const [queuedCount, setQueuedCount] = useState(0);
   const [, forceUpdate] = useState(0);
+  const [ctrlCCount, setCtrlCCount] = useState(0);
+  const ctrlCTimerRef = useRef(null);
   const updateProcessing = useCallback((val) => {
     isProcessingRef.current = val;
     setIsProcessing(val);
@@ -14932,7 +15206,7 @@ var App = ({ autoApprove = false, target }) => {
         setCheckpointCount(contextManagerRef.current?.getCheckpoints().length || 0);
       }
     });
-    import("./auto-update-GKO64QMO.js").then(({ checkForUpdateAsync, formatUpdateNotification }) => {
+    import("./auto-update-6CLBRLE3.js").then(({ checkForUpdateAsync, formatUpdateNotification }) => {
       checkForUpdateAsync().then((result) => {
         if (result.hasUpdate) {
           const notification = formatUpdateNotification(result);
@@ -14958,6 +15232,20 @@ var App = ({ autoApprove = false, target }) => {
       }
     });
   }, [sessionManager2]);
+  useEffect(() => {
+    const queue = getInputQueue();
+    const syncQueueState = () => {
+      setQueuedCount(queue.length);
+    };
+    queue.on(INPUT_QUEUE_EVENT.QUEUED, syncQueueState);
+    queue.on(INPUT_QUEUE_EVENT.DEQUEUED, syncQueueState);
+    queue.on(INPUT_QUEUE_EVENT.CLEARED, syncQueueState);
+    return () => {
+      queue.off(INPUT_QUEUE_EVENT.QUEUED, syncQueueState);
+      queue.off(INPUT_QUEUE_EVENT.DEQUEUED, syncQueueState);
+      queue.off(INPUT_QUEUE_EVENT.CLEARED, syncQueueState);
+    };
+  }, []);
   const startTimeRef = useRef(0);
   const timerRef = useRef(null);
   const addMessage = useCallback((type, content, extraOrDuration) => {
@@ -14980,9 +15268,8 @@ var App = ({ autoApprove = false, target }) => {
   const startTimer = useCallback(() => {
     startTimeRef.current = Date.now();
     timerRef.current = setInterval(() => {
-      setElapsedTime(Math.floor((Date.now() - startTimeRef.current) / 100) / 10);
-      setSpinnerHue((h) => (h + 15) % 360);
-    }, 100);
+      setElapsedTime(Math.floor((Date.now() - startTimeRef.current) / 1e3));
+    }, 1e3);
   }, []);
   const stopTimer = useCallback(() => {
     if (timerRef.current) {
@@ -15159,10 +15446,24 @@ var App = ({ autoApprove = false, target }) => {
   }, [agent, target, addMessage, stopTimer, autoApprove, approvalManager2]);
   const handleExit = useCallback(async () => {
     setCurrentStatus("Exiting...");
-    await agent.shutdown();
-    setTimeout(() => {
+    try {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+        timerRef.current = null;
+      }
+      const queue = getInputQueue();
+      queue.shutdown();
+      await Promise.race([
+        agent.shutdown(),
+        new Promise((resolve) => setTimeout(resolve, 3e3))
+      ]);
+      const rm2 = getResourceManager();
+      await rm2.performCleanup();
+      exit();
+    } catch (err) {
+      console.error("Shutdown error:", err);
       exit();
-    }, 150);
+    }
   }, [agent, exit]);
   useEffect(() => {
     const onExit = () => {
@@ -15228,10 +15529,7 @@ var App = ({ autoApprove = false, target }) => {
       }
     }
     if (trimmed === "/exit" || trimmed === "/quit" || trimmed === "/q") {
-      if (isProcessing && agent) {
-        agent.pause();
-      }
-      exit();
+      await handleExit();
       return;
     }
     if (!isProcessing && !trimmed.startsWith("/") && !pendingTargetConfirmation && !pendingApproval) {
@@ -15526,7 +15824,7 @@ ${list}`);
         case CLI_COMMAND.EXIT:
         case "quit":
         case "q":
-          exit();
+          await handleExit();
           return;
         case "approve":
         case "y":
@@ -15703,7 +16001,7 @@ ${list}`);
           return;
         case "update":
           try {
-            const { checkForUpdate, formatUpdateNotification, doUpdate } = await import("./update-UMRID565.js");
+            const { checkForUpdate, formatUpdateNotification, doUpdate } = await import("./update-34NDFWS3.js");
             const result = checkForUpdate(true);
             if (result.hasUpdate) {
               const notification = formatUpdateNotification(result);
@@ -15761,7 +16059,7 @@ ${list}`);
           }, (error, stdout2, stderr2) => {
             if (child.pid) resourceManager.untrackProcess(child.pid);
             if (error) reject({ ...error, stdout: stdout2, stderr: stderr2 });
-            else resolve({ stdout: stdout2.toString(), stderr: stderr2.toString() });
+            else resolve({ stdout: String(stdout2), stderr: String(stderr2) });
           });
           if (child.pid) resourceManager.trackProcess(child.pid);
         });
@@ -15821,29 +16119,44 @@ ${list}`);
     }
     if (key.ctrl && input2 === "c") {
       if (isProcessing) {
-        agent.pause();
-        stopTimer();
-        updateProcessing(false);
-        setCurrentStatus("");
-        addMessage(MESSAGE_TYPE.SYSTEM, "Interrupted.");
+        if (ctrlCCount === 0) {
+          setCtrlCCount(1);
+          addMessage(MESSAGE_TYPE.SYSTEM, "\u26A0\uFE0F  Really stop? Press Ctrl+C again within 10 seconds to confirm.");
+          if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
+          ctrlCTimerRef.current = setTimeout(() => {
+            setCtrlCCount(0);
+            addMessage(MESSAGE_TYPE.SYSTEM, "Continuing operation...");
+          }, 1e4);
+        } else {
+          if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
+          setCtrlCCount(0);
+          agent.pause();
+          stopTimer();
+          updateProcessing(false);
+          setCurrentStatus("");
+          addMessage(MESSAGE_TYPE.SYSTEM, "\u23F9 Interrupted by user.");
+        }
       } else {
         exit();
       }
+      return;
     }
-    if (key.escape) {
+    if (key.escape || input2 === "\x1B") {
       if (isProcessing) {
         agent.pause();
         stopTimer();
         updateProcessing(false);
         setCurrentStatus("");
         updatePendingApproval(null);
-        addMessage(MESSAGE_TYPE.SYSTEM, "Interrupted. You can continue chatting.");
+        addMessage(MESSAGE_TYPE.SYSTEM, "\u23F9 Process halted via ESC. Ready for next command.");
       }
+      return;
     }
     if (key.tab) {
       const newMode = mode === "agent" ? "shell" : "agent";
       setMode(newMode);
       addMessage(MESSAGE_TYPE.SYSTEM, `Mode: ${newMode === "agent" ? "Agent" : "Shell"}`);
+      return;
     }
   });
   const getStyle = (type) => {
@@ -15931,10 +16244,25 @@ ${list}`);
           }
         )
       ] }),
-      isProcessing && /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
-        "ESC to interrupt \u2502 ",
-        queuedCount > 0 ? `\u{1F4E5} ${queuedCount} messages queued` : "Chatting enabled during execution"
-      ] }) })
+      isProcessing && /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          "ESC to interrupt \u2502 ",
+          queuedCount > 0 ? `\u{1F4E5} ${queuedCount} messages queued` : "Chatting enabled during execution"
+        ] }),
+        queuedCount > 0 && (() => {
+          try {
+            const pending = getInputQueue().getPending().slice(0, 3);
+            return pending.map((item, i) => /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+              "  ",
+              i + 1,
+              ". ",
+              String(item.content || item).slice(0, 60)
+            ] }, i));
+          } catch {
+            return null;
+          }
+        })()
+      ] })
     ] }),
     /* @__PURE__ */ jsx3(
       status_bar_default,
@@ -16022,8 +16350,8 @@ program.command("run <objective>").alias("r").description("Run a single objectiv
     const summary = agent.getSummary();
     console.log(JSON.stringify(summary, null, 2));
     if (options.output) {
-      const fs7 = await import("fs/promises");
-      await fs7.writeFile(options.output, JSON.stringify(summary, null, 2));
+      const fs8 = await import("fs/promises");
+      await fs8.writeFile(options.output, JSON.stringify(summary, null, 2));
       console.log(chalk.hex(THEME.text.accent)(`
 [+] Report saved to: ${options.output}`));
     }