pentesting 0.55.3 → 0.55.4

package/dist/main.js

@@ -27,8 +27,8 @@ import { Command } from "commander";
 import chalk from "chalk";
 
 // src/platform/tui/app.tsx
-import { useState as useState6, useCallback as useCallback4, useEffect as useEffect5, useRef as useRef6 } from "react";
-import { Box as Box6, useInput as useInput2, useApp, useStdout } from "ink";
+import { useState as useState6, useCallback as useCallback6, useRef as useRef7 } from "react";
+import { Box as Box6, useApp, useStdout } from "ink";
 
 // src/platform/tui/hooks/useAgent.ts
 import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef3 } from "react";
@@ -1240,7 +1240,7 @@ var INPUT_PROMPT_PATTERNS = [
 
 // src/shared/constants/agent.ts
 var APP_NAME = "Pentest AI";
-var APP_VERSION = "0.55.3";
+var APP_VERSION = "0.55.4";
 var APP_DESCRIPTION = "Autonomous Penetration Testing AI Agent";
 var LLM_ROLES = {
   SYSTEM: "system",
@@ -1516,6 +1516,181 @@ var IMPACT_WEIGHT = {
   low: 1
 };
 
+// src/shared/utils/attack-graph/node.ts
+function generateNodeId(type, label) {
+  return `${type}:${label}`.toLowerCase().replace(/\s+/g, "_");
+}
+function createNode(type, label, data = {}, status = NODE_STATUS.DISCOVERED) {
+  const id = generateNodeId(type, label);
+  return {
+    id,
+    type,
+    label,
+    data,
+    status,
+    discoveredAt: Date.now()
+  };
+}
+function canMarkAttempted(node) {
+  return node.status === NODE_STATUS.DISCOVERED;
+}
+
+// src/shared/utils/attack-graph/edge.ts
+function createEdge(from, to, relation, confidence = 0.5, status = EDGE_STATUS.UNTESTED) {
+  return {
+    from,
+    to,
+    relation,
+    confidence,
+    status
+  };
+}
+function edgeExists(edges, fromId, toId, relation) {
+  return edges.some(
+    (e) => e.from === fromId && e.to === toId && e.relation === relation
+  );
+}
+function getIncomingEdges(edges, nodeId) {
+  return edges.filter((e) => e.to === nodeId);
+}
+function markEdgeSucceeded(edge) {
+  return {
+    ...edge,
+    status: EDGE_STATUS.SUCCEEDED
+  };
+}
+function markEdgeFailed(edge, reason) {
+  return {
+    ...edge,
+    status: EDGE_STATUS.FAILED,
+    failReason: reason
+  };
+}
+function isTestableEdge(edge) {
+  return edge.status === EDGE_STATUS.UNTESTED || edge.status === EDGE_STATUS.TESTING;
+}
+
+// src/shared/utils/attack-graph/utils.ts
+var AUTH_SERVICES = [
+  "ssh",
+  "ftp",
+  "rdp",
+  "smb",
+  "http",
+  "mysql",
+  "postgresql",
+  "mssql",
+  "winrm",
+  "vnc",
+  "telnet"
+];
+var HIGH_PRIVILEGE_LEVELS = ["root", "admin", "SYSTEM", "Administrator"];
+function createHostNode(ip, hostname) {
+  return createNode(NODE_TYPE.HOST, ip, { ip, hostname });
+}
+function createServiceNode(host, port, service, version) {
+  const hostId = generateNodeId(NODE_TYPE.HOST, host);
+  const node = createNode(
+    NODE_TYPE.SERVICE,
+    `${host}:${port}`,
+    { host, port, service, version }
+  );
+  const hostEdge = createEdge(hostId, node.id, "has_service", 0.95);
+  return { node, hostEdge };
+}
+function createVersionSearchNode(service, version) {
+  return createNode(
+    NODE_TYPE.VULNERABILITY,
+    `CVE search: ${service} ${version}`,
+    { service, version, status: GRAPH_STATUS.NEEDS_SEARCH }
+  );
+}
+function createCredentialNode(username, password, source) {
+  return createNode(
+    NODE_TYPE.CREDENTIAL,
+    `${username}:***`,
+    { username, password, source }
+  );
+}
+function createCredentialSprayEdges(credId, nodes) {
+  const edges = [];
+  for (const [id, node] of nodes) {
+    if (node.type === NODE_TYPE.SERVICE) {
+      const svc = String(node.data.service || "");
+      if (AUTH_SERVICES.some((s) => svc.includes(s))) {
+        edges.push(createEdge(credId, id, "can_try_on", 0.6));
+      }
+    }
+  }
+  return edges;
+}
+function createVulnerabilityNode(title, target, severity, hasExploit = false) {
+  return createNode(
+    NODE_TYPE.VULNERABILITY,
+    title,
+    { target, severity, hasExploit }
+  );
+}
+function findTargetServices(nodes, target) {
+  const results = [];
+  for (const node of nodes.values()) {
+    if (node.type === NODE_TYPE.SERVICE && node.label.includes(target)) {
+      results.push(node);
+    }
+  }
+  return results;
+}
+function createAccessNode(host, level, via) {
+  return createNode(
+    NODE_TYPE.ACCESS,
+    `${level}@${host}`,
+    { host, level, via }
+  );
+}
+function createPotentialAccessNode(exploitTitle) {
+  return createNode(
+    NODE_TYPE.ACCESS,
+    `shell via ${exploitTitle}`,
+    { via: exploitTitle, status: GRAPH_STATUS.POTENTIAL }
+  );
+}
+function createLootNode(host) {
+  return createNode(
+    NODE_TYPE.LOOT,
+    `flags on ${host}`,
+    { host, status: GRAPH_STATUS.NEEDS_SEARCH }
+  );
+}
+function createOSINTNode(category, detail, data = {}) {
+  return createNode(
+    NODE_TYPE.OSINT,
+    `${category}: ${detail}`,
+    { category, detail, ...data }
+  );
+}
+function findOSINTRelatedNodes(nodes, detail) {
+  const results = [];
+  for (const [id, node] of nodes) {
+    if (node.type === NODE_TYPE.HOST || node.type === NODE_TYPE.SERVICE) {
+      const hostIp = String(node.data.ip || node.data.host || "");
+      const hostname = String(node.data.hostname || "");
+      if (hostIp && detail.includes(hostIp) || hostname && detail.includes(hostname)) {
+        results.push({ id, node });
+      }
+    }
+  }
+  return results;
+}
+function isHighPrivilege(level) {
+  return HIGH_PRIVILEGE_LEVELS.includes(level);
+}
+function formatFailedPath(from, to, reason) {
+  return `${from} \u2192 ${to}${reason ? ` (${reason})` : ""}`;
+}
+function formatFailedNode(label, reason) {
+  return `${label}${reason ? ` (${reason})` : ""}`;
+}
+
 // src/shared/utils/attack-graph/chain-discovery.ts
 function recommendChains(nodes, edges) {
   const chains = [];
@@ -1770,7 +1945,152 @@ function getGraphStats(nodes, edges) {
   };
 }
 
-// src/shared/utils/attack-graph/attack-graph.ts
+// src/shared/utils/attack-graph/domain-operations.ts
+function registerHost(graph, ip, hostname) {
+  const node = createHostNode(ip, hostname);
+  if (!graph.nodes.has(node.id)) {
+    graph.nodes.set(node.id, node);
+  }
+  return node.id;
+}
+function registerService(graph, host, port, service, version) {
+  const hostId = registerHost(graph, host);
+  const { node, hostEdge } = createServiceNode(host, port, service, version);
+  if (!graph.nodes.has(node.id)) {
+    graph.nodes.set(node.id, node);
+  }
+  if (hostEdge && !edgeExists(graph.edges, hostEdge.from, hostEdge.to, hostEdge.relation)) {
+    graph.edges.push(hostEdge);
+  }
+  if (version) {
+    const vulnNode = createVersionSearchNode(service, version);
+    if (!graph.nodes.has(vulnNode.id)) {
+      graph.nodes.set(vulnNode.id, vulnNode);
+    }
+    graph.addEdge(node.id, vulnNode.id, "may_have", 0.3);
+  }
+  return node.id;
+}
+function registerCredential(graph, username, password, source) {
+  const node = createCredentialNode(username, password, source);
+  if (!graph.nodes.has(node.id)) {
+    graph.nodes.set(node.id, node);
+  }
+  const sprayEdges = createCredentialSprayEdges(node.id, graph.nodes);
+  for (const edge of sprayEdges) {
+    if (!edgeExists(graph.edges, edge.from, edge.to, edge.relation)) {
+      graph.edges.push(edge);
+    }
+  }
+  return node.id;
+}
+function registerVulnerability(graph, title, target, severity, hasExploit = false) {
+  const vulnNode = createVulnerabilityNode(title, target, severity, hasExploit);
+  if (!graph.nodes.has(vulnNode.id)) {
+    graph.nodes.set(vulnNode.id, vulnNode);
+  }
+  const targetServices = findTargetServices(graph.nodes, target);
+  for (const svc of targetServices) {
+    graph.addEdge(svc.id, vulnNode.id, "has_vulnerability", 0.8);
+  }
+  if (hasExploit) {
+    const accessNode = createPotentialAccessNode(title);
+    if (!graph.nodes.has(accessNode.id)) {
+      graph.nodes.set(accessNode.id, accessNode);
+    }
+    graph.addEdge(vulnNode.id, accessNode.id, "leads_to", 0.7);
+  }
+  return vulnNode.id;
+}
+function registerAccess(graph, host, level, via) {
+  const accessNode = createAccessNode(host, level, via);
+  if (!graph.nodes.has(accessNode.id)) {
+    graph.nodes.set(accessNode.id, accessNode);
+  }
+  const node = graph.nodes.get(accessNode.id);
+  if (node) {
+    node.status = NODE_STATUS.SUCCEEDED;
+    node.resolvedAt = Date.now();
+    const incomingEdges = getIncomingEdges(graph.edges, accessNode.id);
+    for (const edge of incomingEdges) {
+      Object.assign(edge, markEdgeSucceeded(edge));
+    }
+  }
+  if (isHighPrivilege(level)) {
+    const lootNode = createLootNode(host);
+    if (!graph.nodes.has(lootNode.id)) {
+      graph.nodes.set(lootNode.id, lootNode);
+    }
+    graph.addEdge(accessNode.id, lootNode.id, "can_access", 0.9);
+  }
+  return accessNode.id;
+}
+function registerOSINT(graph, category, detail, data = {}) {
+  const osintNode = createOSINTNode(category, detail, data);
+  if (!graph.nodes.has(osintNode.id)) {
+    graph.nodes.set(osintNode.id, osintNode);
+  }
+  const relatedNodes = findOSINTRelatedNodes(graph.nodes, detail);
+  for (const { id } of relatedNodes) {
+    graph.addEdge(osintNode.id, id, "relates_to", 0.5);
+  }
+  return osintNode.id;
+}
+
+// src/shared/utils/attack-graph/status-management.ts
+function markNodeAttemptedInGraph(nodes, nodeId) {
+  const node = nodes.get(nodeId);
+  if (node && canMarkAttempted(node)) {
+    node.status = NODE_STATUS.ATTEMPTED;
+    node.attemptedAt = Date.now();
+  }
+}
+function markNodeSucceededInGraph(nodes, edges, nodeId) {
+  const node = nodes.get(nodeId);
+  if (node) {
+    node.status = NODE_STATUS.SUCCEEDED;
+    node.resolvedAt = Date.now();
+    const incomingEdges = getIncomingEdges(edges, nodeId);
+    for (const edge of incomingEdges) {
+      if (edge.status === EDGE_STATUS.TESTING) {
+        Object.assign(edge, markEdgeSucceeded(edge));
+      }
+    }
+  }
+}
+function markNodeFailedInGraph(nodes, edges, nodeId, reason, callbacks) {
+  const node = nodes.get(nodeId);
+  if (node) {
+    node.status = NODE_STATUS.FAILED;
+    node.resolvedAt = Date.now();
+    node.failReason = reason;
+    callbacks.onFailedPath(formatFailedNode(node.label, reason));
+    const incomingEdges = getIncomingEdges(edges, nodeId);
+    for (const edge of incomingEdges) {
+      if (isTestableEdge(edge)) {
+        Object.assign(edge, markEdgeFailed(edge, reason));
+      }
+    }
+  }
+}
+function markEdgeTestingInList(edges, fromId, toId) {
+  for (const edge of edges) {
+    if (edge.from === fromId && edge.to === toId) {
+      edge.status = EDGE_STATUS.TESTING;
+    }
+  }
+}
+function markEdgeFailedInList(edges, fromId, toId, reason, callbacks) {
+  for (const edge of edges) {
+    if (edge.from === fromId && edge.to === toId) {
+      edge.status = EDGE_STATUS.FAILED;
+      edge.failReason = reason;
+    }
+  }
+  callbacks.onFailedPath(formatFailedPath(fromId, toId, reason));
+}
+
+// src/shared/utils/attack-graph/graph.ts
 var AttackGraph = class {
   nodes = /* @__PURE__ */ new Map();
   edges = [];
@@ -1786,26 +2106,18 @@ var AttackGraph = class {
    * Add a node to the attack graph.
    */
   addNode(type, label, data = {}) {
-    const id = `${type}:${label}`.toLowerCase().replace(/\s+/g, "_");
-    if (!this.nodes.has(id)) {
-      this.nodes.set(id, {
-        id,
-        type,
-        label,
-        data,
-        status: NODE_STATUS.DISCOVERED,
-        discoveredAt: Date.now()
-      });
+    const node = createNode(type, label, data);
+    if (!this.nodes.has(node.id)) {
+      this.nodes.set(node.id, node);
     }
-    return id;
+    return node.id;
   }
   /**
    * Add an edge (relationship) between two nodes.
    */
   addEdge(fromId, toId, relation, confidence = 0.5) {
-    const exists = this.edges.some((e) => e.from === fromId && e.to === toId && e.relation === relation);
-    if (!exists) {
-      this.edges.push({ from: fromId, to: toId, relation, confidence, status: EDGE_STATUS.UNTESTED });
+    if (!edgeExists(this.edges, fromId, toId, relation)) {
+      this.edges.push(createEdge(fromId, toId, relation, confidence));
     }
   }
   /**
@@ -1819,176 +2131,81 @@ var AttackGraph = class {
    * Mark a node as being attempted (in-progress attack).
    */
   markAttempted(nodeId) {
-    const node = this.nodes.get(nodeId);
-    if (node && node.status === NODE_STATUS.DISCOVERED) {
-      node.status = NODE_STATUS.ATTEMPTED;
-      node.attemptedAt = Date.now();
-    }
+    markNodeAttemptedInGraph(this.nodes, nodeId);
   }
   /**
    * Mark a node as successfully exploited/achieved.
    */
   markSucceeded(nodeId) {
-    const node = this.nodes.get(nodeId);
-    if (node) {
-      node.status = NODE_STATUS.SUCCEEDED;
-      node.resolvedAt = Date.now();
-    }
-    for (const edge of this.edges) {
-      if (edge.to === nodeId && edge.status === EDGE_STATUS.TESTING) {
-        edge.status = EDGE_STATUS.SUCCEEDED;
-      }
-    }
+    markNodeSucceededInGraph(this.nodes, this.edges, nodeId);
   }
   /**
    * Mark a node as failed (attack didn't work).
    */
   markFailed(nodeId, reason) {
-    const node = this.nodes.get(nodeId);
-    if (node) {
-      node.status = NODE_STATUS.FAILED;
-      node.resolvedAt = Date.now();
-      node.failReason = reason;
-      this.failedPaths.push(`${node.label}${reason ? ` (${reason})` : ""}`);
-    }
-    for (const edge of this.edges) {
-      if (edge.to === nodeId && (edge.status === EDGE_STATUS.TESTING || edge.status === EDGE_STATUS.UNTESTED)) {
-        edge.status = EDGE_STATUS.FAILED;
-        edge.failReason = reason;
-      }
-    }
+    markNodeFailedInGraph(this.nodes, this.edges, nodeId, reason, {
+      onFailedPath: (path2) => this.failedPaths.push(path2)
+    });
   }
   /**
    * Mark an edge as being tested.
    */
   markEdgeTesting(fromId, toId) {
-    for (const edge of this.edges) {
-      if (edge.from === fromId && edge.to === toId) {
-        edge.status = EDGE_STATUS.TESTING;
-      }
-    }
+    markEdgeTestingInList(this.edges, fromId, toId);
   }
   /**
    * Mark an edge as failed.
    */
   markEdgeFailed(fromId, toId, reason) {
-    for (const edge of this.edges) {
-      if (edge.from === fromId && edge.to === toId) {
-        edge.status = EDGE_STATUS.FAILED;
-        edge.failReason = reason;
-      }
-    }
-    this.failedPaths.push(`${fromId} \u2192 ${toId}${reason ? ` (${reason})` : ""}`);
+    markEdgeFailedInList(this.edges, fromId, toId, reason, {
+      onFailedPath: (path2) => this.failedPaths.push(path2)
+    });
   }
   // ─── Domain-Specific Registration ───────────────────────────
+  /** Internal graph container for domain operations */
+  get graphContainer() {
+    return {
+      nodes: this.nodes,
+      edges: this.edges,
+      addEdge: this.addEdge.bind(this),
+      markSucceeded: this.markSucceeded.bind(this)
+    };
+  }
   /**
    * Record a host discovery.
    */
   addHost(ip, hostname) {
-    return this.addNode(NODE_TYPE.HOST, ip, { ip, hostname });
+    return registerHost(this.graphContainer, ip, hostname);
   }
   /**
    * Record a service discovery and auto-create edges.
    */
   addService(host, port, service, version) {
-    const hostId = this.addHost(host);
-    const serviceId = this.addNode(NODE_TYPE.SERVICE, `${host}:${port}`, {
-      host,
-      port,
-      service,
-      version
-    });
-    this.addEdge(hostId, serviceId, "has_service", 0.95);
-    if (version) {
-      const vulnId = this.addNode(NODE_TYPE.VULNERABILITY, `CVE search: ${service} ${version}`, {
-        service,
-        version,
-        status: GRAPH_STATUS.NEEDS_SEARCH
-      });
-      this.addEdge(serviceId, vulnId, "may_have", 0.3);
-    }
-    return serviceId;
+    return registerService(this.graphContainer, host, port, service, version);
   }
   /**
    * Record a credential discovery and create spray edges.
    */
   addCredential(username, password, source) {
-    const credId = this.addNode(NODE_TYPE.CREDENTIAL, `${username}:***`, {
-      username,
-      password,
-      source
-    });
-    for (const [id, node] of this.nodes) {
-      if (node.type === NODE_TYPE.SERVICE) {
-        const svc = String(node.data.service || "");
-        if (["ssh", "ftp", "rdp", "smb", "http", "mysql", "postgresql", "mssql", "winrm", "vnc", "telnet"].some((s) => svc.includes(s))) {
-          this.addEdge(credId, id, "can_try_on", 0.6);
-        }
-      }
-    }
-    return credId;
+    return registerCredential(this.graphContainer, username, password, source);
   }
   /**
    * Record a vulnerability finding.
    */
   addVulnerability(title, target, severity, hasExploit = false) {
-    const vulnId = this.addNode(NODE_TYPE.VULNERABILITY, title, {
-      target,
-      severity,
-      hasExploit
-    });
-    for (const [id, node] of this.nodes) {
-      if (node.type === NODE_TYPE.SERVICE && node.label.includes(target)) {
-        this.addEdge(id, vulnId, "has_vulnerability", 0.8);
-      }
-    }
-    if (hasExploit) {
-      const accessId = this.addNode(NODE_TYPE.ACCESS, `shell via ${title}`, {
-        via: title,
-        status: GRAPH_STATUS.POTENTIAL
-      });
-      this.addEdge(vulnId, accessId, "leads_to", 0.7);
-    }
-    return vulnId;
+    return registerVulnerability(this.graphContainer, title, target, severity, hasExploit);
   }
   /**
    * Record gained access.
    */
   addAccess(host, level, via) {
-    const accessId = this.addNode(NODE_TYPE.ACCESS, `${level}@${host}`, {
-      host,
-      level,
-      via
-    });
-    this.markSucceeded(accessId);
-    if (["root", "admin", "SYSTEM", "Administrator"].includes(level)) {
-      const lootId = this.addNode(NODE_TYPE.LOOT, `flags on ${host}`, {
-        host,
-        status: GRAPH_STATUS.NEEDS_SEARCH
-      });
-      this.addEdge(accessId, lootId, "can_access", 0.9);
-    }
-    return accessId;
+    return registerAccess(this.graphContainer, host, level, via);
   }
   /**
    * Record OSINT discovery (Docker image, GitHub repo, company info, etc.)
    */
   addOSINT(category, detail, data = {}) {
-    const osintId = this.addNode(NODE_TYPE.OSINT, `${category}: ${detail}`, {
-      category,
-      detail,
-      ...data
-    });
-    for (const [id, node] of this.nodes) {
-      if (node.type === NODE_TYPE.HOST || node.type === NODE_TYPE.SERVICE) {
-        const hostIp = String(node.data.ip || node.data.host || "");
-        const hostname = String(node.data.hostname || "");
-        if (hostIp && detail.includes(hostIp) || hostname && detail.includes(hostname)) {
-          this.addEdge(osintId, id, "relates_to", 0.5);
-        }
-      }
-    }
-    return osintId;
+    return registerOSINT(this.graphContainer, category, detail, data);
   }
   // ─── Chain Discovery (DFS) ──────────────────────────────────
   /**
@@ -2610,11 +2827,86 @@ var DynamicTechniqueLibrary = class {
   }
 };
 
-// src/engine/state/state.ts
+// src/engine/state/target-state.ts
+var TargetState = class {
+  targets = /* @__PURE__ */ new Map();
+  attackGraph;
+  constructor(attackGraph) {
+    this.attackGraph = attackGraph;
+  }
+  /**
+   * Add a target and register it in the attack graph.
+   */
+  add(target) {
+    this.targets.set(target.ip, target);
+    this.attackGraph.addHost(target.ip, target.hostname);
+    for (const port of target.ports) {
+      this.attackGraph.addService(target.ip, port.port, port.service, port.version);
+    }
+  }
+  get(ip) {
+    return this.targets.get(ip);
+  }
+  getAll() {
+    return Array.from(this.targets.values());
+  }
+  getMap() {
+    return this.targets;
+  }
+  /**
+   * Clear all targets (for reset).
+   */
+  clear() {
+    this.targets.clear();
+  }
+};
+
+// src/engine/state/finding-state.ts
+var FindingState = class {
+  findings = [];
+  add(finding) {
+    this.findings.push(finding);
+  }
+  getAll() {
+    return this.findings;
+  }
+  getBySeverity(severity) {
+    return this.findings.filter((f) => f.severity === severity);
+  }
+  /**
+   * Clear all findings (for reset).
+   */
+  clear() {
+    this.findings = [];
+  }
+};
+
+// src/engine/state/loot-state.ts
+var LootState = class {
+  loot = [];
+  add(item) {
+    this.loot.push(item);
+  }
+  getAll() {
+    return this.loot;
+  }
+  /**
+   * Clear all loot (for reset).
+   */
+  clear() {
+    this.loot = [];
+  }
+};
+
+// src/engine/state/shared-state.ts
 var SharedState = class {
   data;
-  // ─── Improvement #6: Attack Graph ──────────────────────────────
+  // ─── Enhancement #6: Attack Graph ──────────────────────────────
   attackGraph = new AttackGraph();
+  // ─── Focused State Modules ─────────────────────────────────────
+  targetState;
+  findingState;
+  lootState;
   // ─── Improvement #12: Multi-Tier Memory ───────────────────────
   workingMemory = new WorkingMemory();
   episodicMemory = new EpisodicMemory();
@@ -2623,11 +2915,11 @@ var SharedState = class {
   dynamicTechniques = new DynamicTechniqueLibrary();
   constructor() {
     const now = Date.now();
+    this.targetState = new TargetState(this.attackGraph);
+    this.findingState = new FindingState();
+    this.lootState = new LootState();
     this.data = {
       engagement: null,
-      targets: /* @__PURE__ */ new Map(),
-      findings: [],
-      loot: [],
       todo: [],
       actionLog: [],
       currentPhase: PHASES.RECON,
@@ -2651,9 +2943,6 @@ var SharedState = class {
     const now = Date.now();
     this.data = {
       engagement: null,
-      targets: /* @__PURE__ */ new Map(),
-      findings: [],
-      loot: [],
       todo: [],
       actionLog: [],
       currentPhase: PHASES.RECON,
@@ -2665,12 +2954,17 @@ var SharedState = class {
       deadlineAt: computeDeadline(now),
       challengeAnalysis: null
     };
+    this.targetState.clear();
+    this.findingState.clear();
+    this.lootState.clear();
     this.attackGraph.reset();
     this.workingMemory.clear();
     this.episodicMemory.clear();
     this.dynamicTechniques.clear();
   }
-  // --- Mission & Persistent Context ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Mission & Persistent Context
+  // ═══════════════════════════════════════════════════════════════
   setMissionSummary(summary) {
     this.data.missionSummary = summary;
   }
@@ -2715,7 +3009,9 @@ var SharedState = class {
   restoreTodoItem(item) {
     this.data.todo.push({ ...item });
   }
-  // --- Engagement & Scope ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Engagement & Scope
+  // ═══════════════════════════════════════════════════════════════
   setEngagement(engagement) {
     this.data.engagement = engagement;
     this.data.currentPhase = engagement.phase;
@@ -2740,40 +3036,42 @@ var SharedState = class {
       };
     }
   }
-  // --- Targets ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Targets (delegated to TargetState)
+  // ═══════════════════════════════════════════════════════════════
   addTarget(target) {
-    this.data.targets.set(target.ip, target);
-    this.attackGraph.addHost(target.ip, target.hostname);
-    for (const port of target.ports) {
-      this.attackGraph.addService(target.ip, port.port, port.service, port.version);
-    }
+    this.targetState.add(target);
   }
   getTarget(ip) {
-    return this.data.targets.get(ip);
+    return this.targetState.get(ip);
   }
   getAllTargets() {
-    return Array.from(this.data.targets.values());
+    return this.targetState.getAll();
   }
   getTargets() {
-    return this.data.targets;
+    return this.targetState.getMap();
   }
-  // --- Findings & Loot ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Findings & Loot (delegated to focused modules)
+  // ═══════════════════════════════════════════════════════════════
   addFinding(finding) {
-    this.data.findings.push(finding);
+    this.findingState.add(finding);
   }
   getFindings() {
-    return this.data.findings;
+    return this.findingState.getAll();
   }
   getFindingsBySeverity(severity) {
-    return this.data.findings.filter((f) => f.severity === severity);
+    return this.findingState.getBySeverity(severity);
   }
   addLoot(loot) {
-    this.data.loot.push(loot);
+    this.lootState.add(loot);
   }
   getLoot() {
-    return this.data.loot;
+    return this.lootState.getAll();
   }
-  // --- TODO Management ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: TODO Management
+  // ═══════════════════════════════════════════════════════════════
   addTodo(content, priority = PRIORITIES.MEDIUM) {
     const id = generateId(AGENT_LIMITS.ID_RADIX, AGENT_LIMITS.ID_LENGTH);
     const item = { id, content, status: TODO_STATUSES.PENDING, priority };
@@ -2790,7 +3088,9 @@ var SharedState = class {
   completeTodo(id) {
     this.updateTodo(id, { status: TODO_STATUSES.DONE });
   }
-  // --- Logs & Phase ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Logs & Phase
+  // ═══════════════════════════════════════════════════════════════
   logAction(action) {
     this.data.actionLog.push({
       id: generateId(AGENT_LIMITS.ID_RADIX, AGENT_LIMITS.ID_LENGTH),
@@ -2810,7 +3110,9 @@ var SharedState = class {
   getPhase() {
     return this.data.currentPhase;
   }
-  // --- Flag Detection ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Flag Detection
+  // ═══════════════════════════════════════════════════════════════
   setCtfMode(shouldEnable) {
     this.data.ctfMode = shouldEnable;
   }
@@ -2826,14 +3128,18 @@ var SharedState = class {
   getFlags() {
     return this.data.flags;
   }
-  // --- Challenge Analysis (#2: Auto-Prompter) ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Challenge Analysis (#2: Auto-Prompter)
+  // ═══════════════════════════════════════════════════════════════
   setChallengeAnalysis(analysis) {
     this.data.challengeAnalysis = analysis;
   }
   getChallengeAnalysis() {
     return this.data.challengeAnalysis;
   }
-  // --- Time Management ---
+  // ═══════════════════════════════════════════════════════════════
+  // SECTION: Time Management
+  // ═══════════════════════════════════════════════════════════════
   /** Set a deadline for time-aware strategy (e.g., CTF competition end time) */
   setDeadline(deadlineMs) {
     this.data.deadlineAt = deadlineMs;
@@ -11215,6 +11521,62 @@ ${firstLine}`, phase }
   };
 }
 
+// src/agents/core-agent/step-handler.ts
+function emitIterationThink(events, iteration, phase, targetsSize, findingsLength, progress) {
+  emitThink(events, iteration, phase, targetsSize, findingsLength, progress);
+}
+function handleResponseContent(response, events, phase, hadReasoningEnd) {
+  if (response.reasoning && !hadReasoningEnd) {
+    emitReasoningStart(events, phase);
+    emitReasoningDelta(events, response.reasoning, phase);
+    emitReasoningEnd(events, phase);
+  }
+  if (response.content?.trim()) {
+    if (!response.reasoning && !hadReasoningEnd) {
+      emitReasoningStart(events, phase);
+      emitReasoningDelta(events, response.content.trim(), phase);
+      emitReasoningEnd(events, phase);
+    } else {
+      events.emit({
+        type: EVENT_TYPES.AI_RESPONSE,
+        timestamp: Date.now(),
+        data: { content: response.content.trim(), phase }
+      });
+    }
+  }
+}
+function addAssistantMessage(messages, content) {
+  messages.push({ role: LLM_ROLES.ASSISTANT, content });
+}
+function addToolResultsToMessages(messages, results) {
+  for (const res of results) {
+    messages.push({
+      role: LLM_ROLES.USER,
+      content: [{
+        type: LLM_BLOCK_TYPE.TOOL_RESULT,
+        tool_use_id: res.toolCallId,
+        content: res.output,
+        is_error: !!res.error
+      }]
+    });
+  }
+}
+async function processToolCallsInStep(toolExecutor, toolCalls, messages, progress) {
+  const results = await toolExecutor.processToolCalls(toolCalls, progress);
+  addToolResultsToMessages(messages, results);
+  return results.length;
+}
+async function getLLMStreamResponse(llm, messages, toolSchemas, systemPrompt, events, phase, abortController) {
+  const callbacks = buildStreamCallbacks(events, phase, abortController);
+  const response = await llm.generateResponseStream(
+    messages,
+    toolSchemas,
+    systemPrompt,
+    callbacks
+  );
+  return { response, hadReasoningEnd: callbacks.hadReasoningEnd() };
+}
+
 // src/agents/tool-executor/types.ts
 var PARALLEL_SAFE_TOOLS = /* @__PURE__ */ new Set([
   "get_state",
@@ -11932,6 +12294,82 @@ var ToolExecutor = class {
   }
 };
 
+// src/agents/core-agent/tool-processor.ts
+function createToolExecutor(config) {
+  return new ToolExecutor({
+    state: config.state,
+    events: config.events,
+    toolRegistry: config.toolRegistry,
+    llm: config.llm
+  });
+}
+function getTurnToolJournal(toolExecutor) {
+  return toolExecutor?.turnToolJournal ?? [];
+}
+function getTurnMemo(toolExecutor) {
+  return toolExecutor?.turnMemo ?? {
+    keyFindings: [],
+    credentials: [],
+    attackVectors: [],
+    failures: [],
+    suspicions: [],
+    attackValue: "LOW",
+    nextSteps: []
+  };
+}
+function getTurnReflections(toolExecutor) {
+  return toolExecutor?.turnReflections ?? [];
+}
+
+// src/agents/core-agent/run-loop.ts
+function createProgressTracker() {
+  return {
+    totalToolsExecuted: 0,
+    consecutiveIdleIterations: 0,
+    lastToolExecutedAt: Date.now(),
+    toolErrors: 0,
+    toolSuccesses: 0,
+    blockedCommandPatterns: /* @__PURE__ */ new Map(),
+    totalBlockedCommands: 0
+  };
+}
+function createInitialMessages(task) {
+  return [{ role: LLM_ROLES.USER, content: task }];
+}
+function checkAbort(abortController, iteration, toolsExecuted) {
+  if (abortController.signal.aborted) {
+    return buildCancelledResult(iteration, toolsExecuted);
+  }
+  return null;
+}
+function updateProgressAfterStep(progress, toolsExecuted) {
+  progress.totalToolsExecuted += toolsExecuted;
+  if (toolsExecuted > 0) {
+    progress.consecutiveIdleIterations = 0;
+    progress.lastToolExecutedAt = Date.now();
+  } else {
+    progress.consecutiveIdleIterations++;
+  }
+}
+function handleIdleIteration(progress, messages, getPhase, getTargetsSize, getFindingsLength) {
+  if (progress.consecutiveIdleIterations >= AGENT_LIMITS.MAX_CONSECUTIVE_IDLE) {
+    progress.consecutiveIdleIterations = 0;
+    const nudge = buildDeadlockNudge(getPhase(), getTargetsSize(), getFindingsLength());
+    messages.push({ role: LLM_ROLES.USER, content: nudge });
+  }
+}
+function buildSuccessResult(output, iteration, tools) {
+  return { output, iterations: iteration + 1, toolsExecuted: tools, isCompleted: true };
+}
+function buildMaxIterationsResult(maxIterations, tools) {
+  return {
+    output: `Max iterations (${maxIterations}) reached. Tools: ${tools}.`,
+    iterations: maxIterations,
+    toolsExecuted: tools,
+    isCompleted: false
+  };
+}
+
 // src/agents/core-agent/core-agent.ts
 var CoreAgent = class {
   llm;
@@ -11950,73 +12388,43 @@ var CoreAgent = class {
     this.llm = getLLMClient();
     this.maxIterations = maxIterations || AGENT_LIMITS.MAX_ITERATIONS;
   }
-  /** Set or update the tool registry (for delayed initialization) */
   setToolRegistry(registry) {
     this.toolRegistry = registry;
   }
-  /** Abort the current execution */
   abort() {
     this.abortController?.abort();
   }
-  /** Get turn tool journal (for MainAgent) */
   getTurnToolJournal() {
-    return this.toolExecutor?.turnToolJournal ?? [];
+    return getTurnToolJournal(this.toolExecutor);
   }
   getTurnMemo() {
-    return this.toolExecutor?.turnMemo ?? { keyFindings: [], credentials: [], attackVectors: [], failures: [], suspicions: [], attackValue: "LOW", nextSteps: [] };
+    return getTurnMemo(this.toolExecutor);
   }
   getTurnReflections() {
-    return this.toolExecutor?.turnReflections ?? [];
+    return getTurnReflections(this.toolExecutor);
   }
-  // ─────────────────────────────────────────────────────────────────
-  // SUBSECTION: Main Run Loop
-  // ─────────────────────────────────────────────────────────────────
   /** The core loop: Think → Act → Observe */
   async run(task, systemPrompt) {
     this.abortController = new AbortController();
-    const messages = [{ role: LLM_ROLES.USER, content: task }];
+    const messages = createInitialMessages(task);
+    const progress = createProgressTracker();
     let consecutiveLLMErrors = 0;
-    const maxConsecutiveLLMErrors = AGENT_LIMITS.MAX_CONSECUTIVE_LLM_ERRORS;
-    const progress = {
-      totalToolsExecuted: 0,
-      consecutiveIdleIterations: 0,
-      lastToolExecutedAt: Date.now(),
-      toolErrors: 0,
-      toolSuccesses: 0,
-      blockedCommandPatterns: /* @__PURE__ */ new Map(),
-      totalBlockedCommands: 0
-    };
     for (let iteration = 0; iteration < this.maxIterations; iteration++) {
-      if (this.abortController.signal.aborted) {
-        return buildCancelledResult(iteration, progress.totalToolsExecuted);
-      }
+      const cancelledResult = checkAbort(this.abortController, iteration, progress.totalToolsExecuted);
+      if (cancelledResult) return cancelledResult;
       try {
         const result2 = await this.step(iteration, messages, systemPrompt, progress);
-        progress.totalToolsExecuted += result2.toolsExecuted;
-        consecutiveLLMErrors = 0;
-        if (result2.toolsExecuted > 0) {
-          progress.consecutiveIdleIterations = 0;
-          progress.lastToolExecutedAt = Date.now();
-        } else if (!result2.isCompleted) {
-          progress.consecutiveIdleIterations++;
-        }
+        updateProgressAfterStep(progress, result2.toolsExecuted);
         if (result2.isCompleted) {
-          return {
-            output: result2.output,
-            iterations: iteration + 1,
-            toolsExecuted: progress.totalToolsExecuted,
-            isCompleted: true
-          };
-        }
-        if (progress.consecutiveIdleIterations >= AGENT_LIMITS.MAX_CONSECUTIVE_IDLE) {
-          progress.consecutiveIdleIterations = 0;
-          const nudge = buildDeadlockNudge(
-            this.state.getPhase(),
-            this.state.getTargets().size,
-            this.state.getFindings().length
-          );
-          messages.push({ role: LLM_ROLES.USER, content: nudge });
+          return buildSuccessResult(result2.output, iteration, progress.totalToolsExecuted);
         }
+        handleIdleIteration(
+          progress,
+          messages,
+          () => this.state.getPhase(),
+          () => this.state.getTargets().size,
+          () => this.state.getFindings().length
+        );
       } catch (error) {
         const action = handleLoopError(
           error,
@@ -12024,35 +12432,20 @@ var CoreAgent = class {
           progress,
           iteration,
           consecutiveLLMErrors,
-          maxConsecutiveLLMErrors,
+          AGENT_LIMITS.MAX_CONSECUTIVE_LLM_ERRORS,
           this.abortController,
           this.events,
           () => this.state.getPhase()
         );
         if (action.action === "return") return action.result;
-        if (action.action === "continue") {
-          if (error instanceof LLMError && error.errorInfo.type === "rate_limit") {
-            consecutiveLLMErrors++;
-          } else {
-            consecutiveLLMErrors = 0;
-          }
-          continue;
-        }
+        consecutiveLLMErrors = error instanceof LLMError && error.errorInfo.type === "rate_limit" ? consecutiveLLMErrors + 1 : 0;
       }
     }
-    return {
-      output: `Max iterations (${this.maxIterations}) reached. Tools: ${progress.totalToolsExecuted}.`,
-      iterations: this.maxIterations,
-      toolsExecuted: progress.totalToolsExecuted,
-      isCompleted: false
-    };
+    return buildMaxIterationsResult(this.maxIterations, progress.totalToolsExecuted);
   }
-  // ─────────────────────────────────────────────────────────────────
-  // SUBSECTION: Step Execution
-  // ─────────────────────────────────────────────────────────────────
   async step(iteration, messages, systemPrompt, progress) {
     const phase = this.state.getPhase();
-    emitThink(
+    emitIterationThink(
       this.events,
       iteration,
       phase,
@@ -12060,61 +12453,37 @@ var CoreAgent = class {
       this.state.getFindings().length,
       progress
     );
-    if (this.toolRegistry && !this.toolExecutor) {
-      this.toolExecutor = new ToolExecutor({
-        state: this.state,
-        events: this.events,
-        toolRegistry: this.toolRegistry,
-        llm: this.llm
-      });
-    }
+    this.ensureToolExecutor();
     this.toolExecutor?.clearTurnState();
-    const callbacks = buildStreamCallbacks(this.events, phase, this.abortController);
-    const response = await this.llm.generateResponseStream(
+    const { response, hadReasoningEnd } = await getLLMStreamResponse(
+      this.llm,
       messages,
       this.toolExecutor?.getToolSchemas() ?? [],
       systemPrompt,
-      callbacks
+      this.events,
+      phase,
+      this.abortController
     );
-    if (response.reasoning && !callbacks.hadReasoningEnd()) {
-      emitReasoningStart(this.events, phase);
-      emitReasoningDelta(this.events, response.reasoning, phase);
-      emitReasoningEnd(this.events, phase);
-    }
-    if (response.content?.trim()) {
-      if (!response.reasoning && !callbacks.hadReasoningEnd()) {
-        emitReasoningStart(this.events, phase);
-        emitReasoningDelta(this.events, response.content.trim(), phase);
-        emitReasoningEnd(this.events, phase);
-      } else {
-        this.events.emit({
-          type: EVENT_TYPES.AI_RESPONSE,
-          timestamp: Date.now(),
-          data: { content: response.content.trim(), phase }
-        });
-      }
-    }
-    messages.push({ role: LLM_ROLES.ASSISTANT, content: response.content });
+    handleResponseContent(response, this.events, phase, hadReasoningEnd);
+    addAssistantMessage(messages, response.content);
     if (!response.toolCalls?.length) {
       return { output: response.content, toolsExecuted: 0, isCompleted: false };
     }
-    const results = await this.toolExecutor.processToolCalls(response.toolCalls, progress);
-    this.addToolResultsToMessages(messages, results);
-    return { output: "", toolsExecuted: results.length, isCompleted: false };
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // SUBSECTION: Message Helpers
-  // ─────────────────────────────────────────────────────────────────
-  addToolResultsToMessages(messages, results) {
-    for (const res of results) {
-      messages.push({
-        role: LLM_ROLES.USER,
-        content: [{
-          type: LLM_BLOCK_TYPE.TOOL_RESULT,
-          tool_use_id: res.toolCallId,
-          content: res.output,
-          is_error: !!res.error
-        }]
+    const toolsExecuted = await processToolCallsInStep(
+      this.toolExecutor,
+      response.toolCalls,
+      messages,
+      progress
+    );
+    return { output: "", toolsExecuted, isCompleted: false };
+  }
+  ensureToolExecutor() {
+    if (this.toolRegistry && !this.toolExecutor) {
+      this.toolExecutor = createToolExecutor({
+        state: this.state,
+        events: this.events,
+        toolRegistry: this.toolRegistry,
+        llm: this.llm
       });
     }
   }
@@ -14075,6 +14444,325 @@ var useAgent = (shouldAutoApprove, target) => {
   };
 };
 
+// src/platform/tui/hooks/commands/index.ts
+import { useCallback as useCallback3 } from "react";
+
+// src/platform/tui/hooks/commands/session-commands.ts
+var createSessionCommands = (ctx) => ({
+  [UI_COMMANDS.HELP]: () => {
+    ctx.addMessage("system", HELP_TEXT);
+  },
+  [UI_COMMANDS.HELP_SHORT]: () => {
+    ctx.addMessage("system", HELP_TEXT);
+  },
+  [UI_COMMANDS.CLEAR]: async () => {
+    if (ctx.isProcessingRef.current) {
+      ctx.addMessage("error", "Cannot /clear while agent is running. Press Esc to abort first.");
+      return;
+    }
+    ctx.setMessages([]);
+    const result2 = await ctx.agent.resetSession();
+    if (result2.cleared.length > 0) {
+      ctx.addMessage("system", `[reset] Session cleared: ${result2.cleared.join(", ")}`);
+    } else {
+      ctx.addMessage("system", "[reset] Session clean");
+    }
+    if (result2.errors.length > 0) {
+      ctx.addMessage("error", `Cleanup errors: ${result2.errors.join("; ")}`);
+    }
+    ctx.refreshStats();
+  },
+  [UI_COMMANDS.CLEAR_SHORT]: async () => {
+    if (ctx.isProcessingRef.current) {
+      ctx.addMessage("error", "Cannot /clear while agent is running. Press Esc to abort first.");
+      return;
+    }
+    ctx.setMessages([]);
+    const result2 = await ctx.agent.resetSession();
+    if (result2.cleared.length > 0) {
+      ctx.addMessage("system", `[reset] Session cleared: ${result2.cleared.join(", ")}`);
+    } else {
+      ctx.addMessage("system", "[reset] Session clean");
+    }
+    if (result2.errors.length > 0) {
+      ctx.addMessage("error", `Cleanup errors: ${result2.errors.join("; ")}`);
+    }
+    ctx.refreshStats();
+  },
+  [UI_COMMANDS.EXIT]: () => {
+    ctx.handleExit();
+  },
+  [UI_COMMANDS.QUIT]: () => {
+    ctx.handleExit();
+  },
+  [UI_COMMANDS.EXIT_SHORT]: () => {
+    ctx.handleExit();
+  }
+});
+
+// src/platform/tui/hooks/commands/target-commands.ts
+var createTargetCommands = (ctx) => ({
+  [UI_COMMANDS.TARGET]: (args) => {
+    if (!args[0]) {
+      ctx.addMessage("error", "Usage: /target <ip>");
+      return;
+    }
+    ctx.agent.addTarget(args[0]);
+    ctx.agent.setScope([args[0]]);
+    ctx.addMessage("system", `Target \u2192 ${args[0]}`);
+  },
+  [UI_COMMANDS.TARGET_SHORT]: (args) => {
+    if (!args[0]) {
+      ctx.addMessage("error", "Usage: /target <ip>");
+      return;
+    }
+    ctx.agent.addTarget(args[0]);
+    ctx.agent.setScope([args[0]]);
+    ctx.addMessage("system", `Target \u2192 ${args[0]}`);
+  },
+  [UI_COMMANDS.START]: async (args) => {
+    if (!ctx.agent.getState().getTargets().size) {
+      ctx.addMessage("error", "Set target first: /target <ip>");
+      return;
+    }
+    if (!ctx.autoApproveModeRef.current) {
+      ctx.setAutoApproveMode(true);
+      ctx.agent.setAutoApprove(true);
+      ctx.addMessage("system", "[auto] Autonomous mode enabled");
+    }
+    ctx.addMessage("system", "Starting penetration test...");
+    const targets = Array.from(ctx.agent.getState().getTargets().keys());
+    const targetInfo = targets.length > 0 ? ` against ${targets.join(", ")}` : "";
+    await ctx.executeTask(args.join(" ") || `Perform comprehensive penetration testing${targetInfo}`);
+  },
+  [UI_COMMANDS.START_SHORT]: async (args) => {
+    if (!ctx.agent.getState().getTargets().size) {
+      ctx.addMessage("error", "Set target first: /target <ip>");
+      return;
+    }
+    if (!ctx.autoApproveModeRef.current) {
+      ctx.setAutoApproveMode(true);
+      ctx.agent.setAutoApprove(true);
+      ctx.addMessage("system", "[auto] Autonomous mode enabled");
+    }
+    ctx.addMessage("system", "Starting penetration test...");
+    const targets = Array.from(ctx.agent.getState().getTargets().keys());
+    const targetInfo = targets.length > 0 ? ` against ${targets.join(", ")}` : "";
+    await ctx.executeTask(args.join(" ") || `Perform comprehensive penetration testing${targetInfo}`);
+  }
+});
+
+// src/platform/tui/hooks/commands/formatters.ts
+var confIcon = (c) => {
+  if (c >= 100) return "\u{1F534}";
+  if (c >= CONFIDENCE_THRESHOLDS.CONFIRMED) return "\u{1F7E0}";
+  if (c >= CONFIDENCE_THRESHOLDS.PROBABLE) return "\u{1F7E1}";
+  if (c >= CONFIDENCE_THRESHOLDS.POSSIBLE) return "\u{1F7E2}";
+  return "\u26AA";
+};
+var confLabel = (c) => {
+  if (c >= CONFIDENCE_THRESHOLDS.CONFIRMED) return "confirmed";
+  if (c >= CONFIDENCE_THRESHOLDS.PROBABLE) return "probable";
+  if (c >= CONFIDENCE_THRESHOLDS.POSSIBLE) return "possible";
+  return "speculative";
+};
+var formatFindings = (findings) => {
+  if (!findings.length) return "No findings.";
+  const sorted = [...findings].sort((a, b) => b.confidence - a.confidence);
+  const findingLines = [];
+  const nConfirmed = sorted.filter((f) => f.confidence >= CONFIDENCE_THRESHOLDS.CONFIRMED).length;
+  const nProbable = sorted.filter((f) => f.confidence >= CONFIDENCE_THRESHOLDS.PROBABLE && f.confidence < CONFIDENCE_THRESHOLDS.CONFIRMED).length;
+  const nPossible = sorted.filter((f) => f.confidence < CONFIDENCE_THRESHOLDS.PROBABLE).length;
+  findingLines.push(`\u2500\u2500\u2500 ${findings.length} Findings \u2500\u2500 \u{1F534}\u{1F7E0} confirmed:${nConfirmed}  \u{1F7E1} probable:${nProbable}  \u{1F7E2}\u26AA possible:${nPossible} \u2500\u2500\u2500`);
+  findingLines.push("");
+  sorted.forEach((f) => {
+    const icon = confIcon(f.confidence);
+    const label = confLabel(f.confidence);
+    const scoreBar = `[${String(f.confidence).padStart(3, " ")}/100]`;
+    const atk = f.attackPattern ? ` \u2502 ATT&CK: ${f.attackPattern}` : "";
+    const cat = f.category ? ` \u2502 ${f.category}` : "";
+    findingLines.push(`  ${icon} ${scoreBar} ${f.title}`);
+    findingLines.push(`      ${label.toUpperCase()} \u2502 ${f.severity.toUpperCase()}${atk}${cat}`);
+    if (f.affected.length > 0) {
+      findingLines.push(`      Affected: ${f.affected.join(", ")}`);
+    }
+    if (f.description) {
+      findingLines.push(`      ${f.description}`);
+    }
+    if (f.evidence.length > 0) {
+      findingLines.push(`      Evidence:`);
+      f.evidence.forEach((e) => {
+        findingLines.push(`        \u25B8 ${e}`);
+      });
+    }
+    if (f.remediation) {
+      findingLines.push(`      Fix: ${f.remediation}`);
+    }
+    findingLines.push("");
+  });
+  return findingLines.join("\n");
+};
+
+// src/platform/tui/hooks/commands/display-commands.ts
+var createDisplayCommands = (ctx) => ({
+  [UI_COMMANDS.FINDINGS]: () => {
+    const findings = ctx.agent.getState().getFindings();
+    ctx.addMessage("system", formatFindings(findings));
+  },
+  [UI_COMMANDS.FINDINGS_SHORT]: () => {
+    const findings = ctx.agent.getState().getFindings();
+    ctx.addMessage("system", formatFindings(findings));
+  },
+  [UI_COMMANDS.ASSETS]: () => {
+    ctx.addMessage("status", formatInlineStatus());
+  },
+  [UI_COMMANDS.ASSETS_SHORT]: () => {
+    ctx.addMessage("status", formatInlineStatus());
+  },
+  [UI_COMMANDS.LOGS]: (args) => {
+    if (!args[0]) {
+      ctx.addMessage("error", "Usage: /logs <process_id>");
+      return;
+    }
+    const procData = getProcessOutput(args[0]);
+    if (!procData) {
+      ctx.addMessage("error", `Asset [${args[0]}] not found.`);
+      return;
+    }
+    ctx.addMessage("system", `--- Log for [${args[0]}] (${procData.role}) ---
+${procData.stdout || "(no output)"}
+--- End Log ---`);
+  },
+  [UI_COMMANDS.LOGS_SHORT]: (args) => {
+    if (!args[0]) {
+      ctx.addMessage("error", "Usage: /logs <process_id>");
+      return;
+    }
+    const procData = getProcessOutput(args[0]);
+    if (!procData) {
+      ctx.addMessage("error", `Asset [${args[0]}] not found.`);
+      return;
+    }
+    ctx.addMessage("system", `--- Log for [${args[0]}] (${procData.role}) ---
+${procData.stdout || "(no output)"}
+--- End Log ---`);
+  },
+  [UI_COMMANDS.GRAPH]: () => {
+    ctx.addMessage("system", ctx.agent.getState().attackGraph.toASCII());
+  },
+  [UI_COMMANDS.GRAPH_SHORT]: () => {
+    ctx.addMessage("system", ctx.agent.getState().attackGraph.toASCII());
+  },
+  [UI_COMMANDS.PATHS]: () => {
+    ctx.addMessage("system", ctx.agent.getState().attackGraph.toPathsList());
+  },
+  [UI_COMMANDS.PATHS_SHORT]: () => {
+    ctx.addMessage("system", ctx.agent.getState().attackGraph.toPathsList());
+  }
+});
+
+// src/platform/tui/hooks/commands/toggle-commands.ts
+var createToggleCommands = (ctx) => ({
+  [UI_COMMANDS.CTF]: () => {
+    const ctfEnabled = ctx.agent.toggleCtfMode();
+    ctx.addMessage("system", ctfEnabled ? "\u{1F3F4} Flag auto-detection ON" : "\u{1F3F4} Flag auto-detection OFF");
+  },
+  [UI_COMMANDS.TOR]: () => {
+    const newTorState = !isTorEnabled();
+    setTorEnabled(newTorState);
+    ctx.addMessage("system", newTorState ? "\u{1F9C5} Tor proxy ON \u2014 target traffic routed through SOCKS5 (proxychains4 / native flags)" : "\u{1F9C5} Tor proxy OFF \u2014 direct connections");
+  },
+  [UI_COMMANDS.AUTO]: () => {
+    ctx.setAutoApproveMode((prev) => {
+      const newVal = !prev;
+      ctx.agent.setAutoApprove(newVal);
+      ctx.addMessage("system", newVal ? "\u{1F7E2} Auto-approve ON" : "\u{1F534} Auto-approve OFF");
+      return newVal;
+    });
+  }
+});
+
+// src/platform/tui/hooks/commands/index.ts
+var useCommands = (props) => {
+  const ctx = {
+    agent: props.agent,
+    addMessage: props.addMessage,
+    setMessages: props.setMessages,
+    executeTask: props.executeTask,
+    refreshStats: props.refreshStats,
+    setAutoApproveMode: props.setAutoApproveMode,
+    handleExit: props.handleExit,
+    isProcessingRef: props.isProcessingRef,
+    autoApproveModeRef: props.autoApproveModeRef
+  };
+  const handlers = {
+    ...createSessionCommands(ctx),
+    ...createTargetCommands(ctx),
+    ...createDisplayCommands(ctx),
+    ...createToggleCommands(ctx)
+  };
+  const handleCommand = useCallback3(async (cmd, args) => {
+    const handler = handlers[cmd];
+    if (handler) {
+      await handler(args);
+    } else {
+      ctx.addMessage("error", `Unknown command: /${cmd}`);
+    }
+  }, [handlers, ctx]);
+  return { handleCommand };
+};
+
+// src/platform/tui/hooks/useKeyboardShortcuts.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef4 } from "react";
+import { useInput } from "ink";
+var useKeyboardShortcuts = ({
+  addMessage,
+  handleExit,
+  abort,
+  cancelInputRequest,
+  isProcessingRef,
+  inputRequestRef
+}) => {
+  const ctrlCTimerRef = useRef4(null);
+  const ctrlCPressedRef = useRef4(false);
+  const handleCtrlC = useCallback4(() => {
+    if (ctrlCPressedRef.current) {
+      if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
+      handleExit();
+      return;
+    }
+    ctrlCPressedRef.current = true;
+    addMessage("system", "\u26A0\uFE0F Press Ctrl+C again within 3 seconds to exit.");
+    if (isProcessingRef.current) abort();
+    ctrlCTimerRef.current = setTimeout(() => {
+      ctrlCPressedRef.current = false;
+      ctrlCTimerRef.current = null;
+    }, DISPLAY_LIMITS.EXIT_DELAY);
+  }, [handleExit, addMessage, abort, isProcessingRef]);
+  useEffect3(() => {
+    return () => {
+      if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
+    };
+  }, []);
+  useInput(useCallback4((ch, key) => {
+    if (key.escape) {
+      if (inputRequestRef.current.status === "active") cancelInputRequest();
+      else if (isProcessingRef.current) abort();
+    }
+    if (key.ctrl && ch === "c") handleCtrlC();
+  }, [cancelInputRequest, abort, handleCtrlC, isProcessingRef, inputRequestRef]));
+  useEffect3(() => {
+    const onSignal = () => handleCtrlC();
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    return () => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+    };
+  }, [handleCtrlC]);
+  return { handleCtrlC };
+};
+
 // src/platform/tui/components/MessageList.tsx
 import { memo } from "react";
 import { Box as Box2, Text as Text2, Static } from "ink";
@@ -14324,24 +15012,24 @@ var MessageList = memo(({ messages }) => {
 });
 
 // src/platform/tui/components/StatusDisplay.tsx
-import { memo as memo3, useEffect as useEffect4, useRef as useRef4, useState as useState4 } from "react";
+import { memo as memo3, useEffect as useEffect5, useRef as useRef5, useState as useState4 } from "react";
 import { Box as Box3, Text as Text4 } from "ink";
 
 // src/platform/tui/components/MusicSpinner.tsx
-import { useState as useState3, useEffect as useEffect3, memo as memo2 } from "react";
+import { useState as useState3, useEffect as useEffect4, memo as memo2 } from "react";
 import { Text as Text3 } from "ink";
 import { jsx as jsx3 } from "react/jsx-runtime";
-var FRAMES = ["\u2669", "\u266A", "\u266B", "\u266C", "\u266B", "\u266A"];
-var INTERVAL = 500;
+var FRAMES = ["\xB7", "\u2736", "\u2737", "\u2738", "\u2739", "\u273A", "\u2739", "\u2738", "\u2737", "\u2736"];
+var INTERVAL = 100;
 var MusicSpinner = memo2(({ color }) => {
   const [index, setIndex] = useState3(0);
-  useEffect3(() => {
+  useEffect4(() => {
     const timer = setInterval(() => {
       setIndex((i) => (i + 1) % FRAMES.length);
     }, INTERVAL);
     return () => clearInterval(timer);
   }, []);
-  return /* @__PURE__ */ jsx3(Text3, { color, children: FRAMES[index] });
+  return /* @__PURE__ */ jsx3(Text3, { color: color || "yellow", children: FRAMES[index] });
 });
 
 // src/platform/tui/components/StatusDisplay.tsx
@@ -14356,9 +15044,9 @@ var StatusDisplay = memo3(({
     return err.length > DISPLAY_LIMITS.RETRY_ERROR_PREVIEW ? err.substring(0, DISPLAY_LIMITS.RETRY_ERROR_TRUNCATED) + "..." : err;
   };
   const [statusElapsed, setStatusElapsed] = useState4(0);
-  const statusTimerRef = useRef4(null);
-  const statusStartRef = useRef4(Date.now());
-  useEffect4(() => {
+  const statusTimerRef = useRef5(null);
+  const statusStartRef = useRef5(Date.now());
+  useEffect5(() => {
     if (statusTimerRef.current) clearInterval(statusTimerRef.current);
     if (isProcessing && currentStatus) {
       statusStartRef.current = Date.now();
@@ -14419,8 +15107,8 @@ var StatusDisplay = memo3(({
 });
 
 // src/platform/tui/components/ChatInput.tsx
-import { useMemo, useCallback as useCallback3, useRef as useRef5, memo as memo4, useState as useState5 } from "react";
-import { Box as Box4, Text as Text5, useInput } from "ink";
+import { useMemo, useCallback as useCallback5, useRef as useRef6, memo as memo4, useState as useState5 } from "react";
+import { Box as Box4, Text as Text5, useInput as useInput2 } from "ink";
 import TextInput from "ink-text-input";
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 var MAX_SUGGESTIONS = 6;
@@ -14442,18 +15130,18 @@ var ChatInput = memo4(({
     return getMatchingCommands(partialCmd).slice(0, MAX_SUGGESTIONS);
   }, [isSlashMode, partialCmd, hasArgs]);
   const showPreview = isSlashMode && !hasArgs && suggestions.length > 0;
-  const suggestionsRef = useRef5(suggestions);
+  const suggestionsRef = useRef6(suggestions);
   suggestionsRef.current = suggestions;
-  const isSlashModeRef = useRef5(isSlashMode);
+  const isSlashModeRef = useRef6(isSlashMode);
   isSlashModeRef.current = isSlashMode;
-  const hasArgsRef = useRef5(hasArgs);
+  const hasArgsRef = useRef6(hasArgs);
   hasArgsRef.current = hasArgs;
-  const inputRequestRef = useRef5(inputRequest);
+  const inputRequestRef = useRef6(inputRequest);
   inputRequestRef.current = inputRequest;
-  const onChangeRef = useRef5(onChange);
+  const onChangeRef = useRef6(onChange);
   onChangeRef.current = onChange;
   const [inputKey, setInputKey] = useState5(0);
-  useInput(useCallback3((_input, key) => {
+  useInput2(useCallback5((_input, key) => {
     if (inputRequestRef.current.status === "active") return;
     if (key.tab && isSlashModeRef.current && !hasArgsRef.current && suggestionsRef.current.length > 0) {
       const best = suggestionsRef.current[0];
@@ -14614,13 +15302,13 @@ var App = ({ autoApprove = false, target }) => {
     addMessage,
     refreshStats
   } = useAgent(autoApproveMode, target);
-  const isProcessingRef = useRef6(isProcessing);
+  const isProcessingRef = useRef7(isProcessing);
   isProcessingRef.current = isProcessing;
-  const autoApproveModeRef = useRef6(autoApproveMode);
+  const autoApproveModeRef = useRef7(autoApproveMode);
   autoApproveModeRef.current = autoApproveMode;
-  const inputRequestRef = useRef6(inputRequest);
+  const inputRequestRef = useRef7(inputRequest);
   inputRequestRef.current = inputRequest;
-  const handleExit = useCallback4(() => {
+  const handleExit = useCallback6(() => {
     const ir = inputRequestRef.current;
     if (ir.status === "active") {
       ir.resolve(null);
@@ -14631,166 +15319,18 @@ var App = ({ autoApprove = false, target }) => {
     exit();
     setTimeout(() => process.exit(0), DISPLAY_LIMITS.EXIT_DELAY);
   }, [exit, setInputRequest]);
-  const handleCommand = useCallback4(async (cmd, args) => {
-    switch (cmd) {
-      case UI_COMMANDS.HELP:
-      case UI_COMMANDS.HELP_SHORT:
-        addMessage("system", HELP_TEXT);
-        break;
-      case UI_COMMANDS.CLEAR:
-      case UI_COMMANDS.CLEAR_SHORT: {
-        if (isProcessingRef.current) {
-          addMessage("error", "Cannot /clear while agent is running. Press Esc to abort first.");
-          break;
-        }
-        setMessages([]);
-        const result2 = await agent.resetSession();
-        if (result2.cleared.length > 0) {
-          addMessage("system", `[reset] Session cleared: ${result2.cleared.join(", ")}`);
-        } else {
-          addMessage("system", "[reset] Session clean");
-        }
-        if (result2.errors.length > 0) {
-          addMessage("error", `Cleanup errors: ${result2.errors.join("; ")}`);
-        }
-        refreshStats();
-        break;
-      }
-      case UI_COMMANDS.TARGET:
-      case UI_COMMANDS.TARGET_SHORT:
-        if (!args[0]) {
-          addMessage("error", "Usage: /target <ip>");
-          break;
-        }
-        agent.addTarget(args[0]);
-        agent.setScope([args[0]]);
-        addMessage("system", `Target \u2192 ${args[0]}`);
-        break;
-      case UI_COMMANDS.START:
-      case UI_COMMANDS.START_SHORT:
-        if (!agent.getState().getTargets().size) {
-          addMessage("error", "Set target first: /target <ip>");
-          break;
-        }
-        if (!autoApproveModeRef.current) {
-          setAutoApproveMode(true);
-          agent.setAutoApprove(true);
-          addMessage("system", "[auto] Autonomous mode enabled");
-        }
-        addMessage("system", "Starting penetration test...");
-        const targets = Array.from(agent.getState().getTargets().keys());
-        const targetInfo = targets.length > 0 ? ` against ${targets.join(", ")}` : "";
-        executeTask(args.join(" ") || `Perform comprehensive penetration testing${targetInfo}`);
-        break;
-      case UI_COMMANDS.FINDINGS:
-      case UI_COMMANDS.FINDINGS_SHORT: {
-        const findings = agent.getState().getFindings();
-        if (!findings.length) {
-          addMessage("system", "No findings.");
-          break;
-        }
-        const sorted = [...findings].sort((a, b) => b.confidence - a.confidence);
-        const confIcon = (c) => {
-          if (c >= 100) return "\u{1F534}";
-          if (c >= CONFIDENCE_THRESHOLDS.CONFIRMED) return "\u{1F7E0}";
-          if (c >= CONFIDENCE_THRESHOLDS.PROBABLE) return "\u{1F7E1}";
-          if (c >= CONFIDENCE_THRESHOLDS.POSSIBLE) return "\u{1F7E2}";
-          return "\u26AA";
-        };
-        const confLabel = (c) => {
-          if (c >= CONFIDENCE_THRESHOLDS.CONFIRMED) return "confirmed";
-          if (c >= CONFIDENCE_THRESHOLDS.PROBABLE) return "probable";
-          if (c >= CONFIDENCE_THRESHOLDS.POSSIBLE) return "possible";
-          return "speculative";
-        };
-        const findingLines = [];
-        const nConfirmed = sorted.filter((f) => f.confidence >= CONFIDENCE_THRESHOLDS.CONFIRMED).length;
-        const nProbable = sorted.filter((f) => f.confidence >= CONFIDENCE_THRESHOLDS.PROBABLE && f.confidence < CONFIDENCE_THRESHOLDS.CONFIRMED).length;
-        const nPossible = sorted.filter((f) => f.confidence < CONFIDENCE_THRESHOLDS.PROBABLE).length;
-        findingLines.push(`\u2500\u2500\u2500 ${findings.length} Findings \u2500\u2500 \u{1F534}\u{1F7E0} confirmed:${nConfirmed}  \u{1F7E1} probable:${nProbable}  \u{1F7E2}\u26AA possible:${nPossible} \u2500\u2500\u2500`);
-        findingLines.push("");
-        sorted.forEach((f, i) => {
-          const icon = confIcon(f.confidence);
-          const label = confLabel(f.confidence);
-          const scoreBar = `[${String(f.confidence).padStart(3, " ")}/100]`;
-          const atk = f.attackPattern ? ` \u2502 ATT&CK: ${f.attackPattern}` : "";
-          const cat = f.category ? ` \u2502 ${f.category}` : "";
-          findingLines.push(`  ${icon} ${scoreBar} ${f.title}`);
-          findingLines.push(`      ${label.toUpperCase()} \u2502 ${f.severity.toUpperCase()}${atk}${cat}`);
-          if (f.affected.length > 0) {
-            findingLines.push(`      Affected: ${f.affected.join(", ")}`);
-          }
-          if (f.description) {
-            findingLines.push(`      ${f.description}`);
-          }
-          if (f.evidence.length > 0) {
-            findingLines.push(`      Evidence:`);
-            f.evidence.forEach((e) => {
-              findingLines.push(`        \u25B8 ${e}`);
-            });
-          }
-          if (f.remediation) {
-            findingLines.push(`      Fix: ${f.remediation}`);
-          }
-          findingLines.push("");
-        });
-        addMessage("system", findingLines.join("\n"));
-        break;
-      }
-      case UI_COMMANDS.ASSETS:
-      case UI_COMMANDS.ASSETS_SHORT:
-        addMessage("status", formatInlineStatus());
-        break;
-      case UI_COMMANDS.LOGS:
-      case UI_COMMANDS.LOGS_SHORT:
-        if (!args[0]) {
-          addMessage("error", "Usage: /logs <process_id>");
-          break;
-        }
-        const procData = getProcessOutput(args[0]);
-        if (!procData) {
-          addMessage("error", `Asset [${args[0]}] not found.`);
-          break;
-        }
-        addMessage("system", `--- Log for [${args[0]}] (${procData.role}) ---
-${procData.stdout || "(no output)"}
---- End Log ---`);
-        break;
-      case UI_COMMANDS.CTF:
-        const ctfEnabled = agent.toggleCtfMode();
-        addMessage("system", ctfEnabled ? "\u{1F3F4} Flag auto-detection ON" : "\u{1F3F4} Flag auto-detection OFF");
-        break;
-      case UI_COMMANDS.TOR:
-        const newTorState = !isTorEnabled();
-        setTorEnabled(newTorState);
-        addMessage("system", newTorState ? "\u{1F9C5} Tor proxy ON \u2014 target traffic routed through SOCKS5 (proxychains4 / native flags)" : "\u{1F9C5} Tor proxy OFF \u2014 direct connections");
-        break;
-      case UI_COMMANDS.GRAPH:
-      case UI_COMMANDS.GRAPH_SHORT:
-        addMessage("system", agent.getState().attackGraph.toASCII());
-        break;
-      case UI_COMMANDS.PATHS:
-      case UI_COMMANDS.PATHS_SHORT:
-        addMessage("system", agent.getState().attackGraph.toPathsList());
-        break;
-      case UI_COMMANDS.AUTO:
-        setAutoApproveMode((prev) => {
-          const newVal = !prev;
-          agent.setAutoApprove(newVal);
-          addMessage("system", newVal ? "\u{1F7E2} Auto-approve ON" : "\u{1F534} Auto-approve OFF");
-          return newVal;
-        });
-        break;
-      case UI_COMMANDS.EXIT:
-      case UI_COMMANDS.QUIT:
-      case UI_COMMANDS.EXIT_SHORT:
-        handleExit();
-        break;
-      default:
-        addMessage("error", `Unknown command: /${cmd}`);
-    }
-  }, [agent, addMessage, executeTask, setMessages, handleExit, refreshStats]);
-  const handleSubmit = useCallback4(async (value) => {
+  const { handleCommand } = useCommands({
+    agent,
+    addMessage,
+    setMessages,
+    executeTask,
+    refreshStats,
+    setAutoApproveMode,
+    handleExit,
+    isProcessingRef,
+    autoApproveModeRef
+  });
+  const handleSubmit = useCallback6(async (value) => {
     const trimmed = value.trim();
     if (!trimmed) return;
     setInput("");
@@ -14805,7 +15345,7 @@ ${procData.stdout || "(no output)"}
       await executeTask(trimmed);
     }
   }, [agent, addMessage, executeTask, handleCommand]);
-  const handleSecretSubmit = useCallback4((value) => {
+  const handleSecretSubmit = useCallback6((value) => {
     const ir = inputRequestRef.current;
     if (ir.status !== "active") return;
     const displayText = ir.isPassword ? "\u2022".repeat(value.length) : value;
@@ -14815,43 +15355,14 @@ ${procData.stdout || "(no output)"}
     setInputRequest({ status: "inactive" });
     setSecretInput("");
   }, [addMessage, setInputRequest]);
-  const ctrlCTimerRef = useRef6(null);
-  const ctrlCPressedRef = useRef6(false);
-  const handleCtrlC = useCallback4(() => {
-    if (ctrlCPressedRef.current) {
-      if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
-      handleExit();
-      return;
-    }
-    ctrlCPressedRef.current = true;
-    addMessage("system", "\u26A0\uFE0F Press Ctrl+C again within 3 seconds to exit.");
-    if (isProcessingRef.current) abort();
-    ctrlCTimerRef.current = setTimeout(() => {
-      ctrlCPressedRef.current = false;
-      ctrlCTimerRef.current = null;
-    }, 3e3);
-  }, [handleExit, addMessage, abort]);
-  useEffect5(() => {
-    return () => {
-      if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
-    };
-  }, []);
-  useInput2(useCallback4((ch, key) => {
-    if (key.escape) {
-      if (inputRequestRef.current.status === "active") cancelInputRequest();
-      else if (isProcessingRef.current) abort();
-    }
-    if (key.ctrl && ch === "c") handleCtrlC();
-  }, [cancelInputRequest, abort, handleCtrlC]));
-  useEffect5(() => {
-    const onSignal = () => handleCtrlC();
-    process.on("SIGINT", onSignal);
-    process.on("SIGTERM", onSignal);
-    return () => {
-      process.off("SIGINT", onSignal);
-      process.off("SIGTERM", onSignal);
-    };
-  }, [handleCtrlC]);
+  useKeyboardShortcuts({
+    addMessage,
+    handleExit,
+    abort,
+    cancelInputRequest,
+    isProcessingRef,
+    inputRequestRef
+  });
   const isSlashMode = input.startsWith("/");
   const partialCmd = isSlashMode ? input.slice(1).split(" ")[0] : "";
   const hasArgs = isSlashMode && input.includes(" ");