pentesting 0.70.5 → 0.70.6

package/dist/main.js

@@ -762,7 +762,7 @@ var INPUT_PROMPT_PATTERNS = [
 
 // src/shared/constants/agent.ts
 var APP_NAME = "Pentest AI";
-var APP_VERSION = "0.70.5";
+var APP_VERSION = "0.70.6";
 var APP_DESCRIPTION = "Autonomous Penetration Testing AI Agent";
 var LLM_ROLES = {
   SYSTEM: "system",
@@ -817,7 +817,7 @@ import { render } from "ink";
 import chalk from "chalk";
 
 // src/platform/tui/app.tsx
-import { useState as useState7, useCallback as useCallback11, useRef as useRef10 } from "react";
+import { useState as useState6, useCallback as useCallback9, useRef as useRef8 } from "react";
 import { Box as Box19, useApp, useStdout as useStdout4 } from "ink";
 
 // src/platform/tui/hooks/useAgent.ts
@@ -1115,7 +1115,8 @@ var TOOL_NAMES = {
   MITM_PROXY: "mitm_proxy",
   PACKET_SNIFF: "packet_sniff",
   DNS_SPOOF: "dns_spoof",
-  TRAFFIC_INTERCEPT: "traffic_intercept"
+  TRAFFIC_INTERCEPT: "traffic_intercept",
+  ANALYZE_PCAP: "analyze_pcap"
 };
 
 // src/shared/constants/attack.ts
@@ -1174,7 +1175,8 @@ var EVENT_TYPES = {
   RETRY: "retry",
   USAGE_UPDATE: "usage_update",
   INPUT_REQUEST: "input_request",
-  FLAG_FOUND: "flag_found"
+  FLAG_FOUND: "flag_found",
+  NOTIFICATION: "notification"
 };
 var COMMAND_EVENT_TYPES = {
   TOOL_MISSING: "tool_missing",
@@ -1186,7 +1188,9 @@ var COMMAND_EVENT_TYPES = {
   COMMAND_SUCCESS: "command_success",
   COMMAND_FAILED: "command_failed",
   COMMAND_ERROR: "command_error",
-  INPUT_REQUIRED: "input_required"
+  INPUT_REQUIRED: "input_required",
+  COMMAND_STDOUT: "command_stdout",
+  PROCESS_NOTIFICATION: "process_notification"
 };
 
 // src/shared/constants/ui-commands.ts
@@ -1268,13 +1272,6 @@ var EDGE_STATUS = {
   SUCCEEDED: "succeeded",
   FAILED: "failed"
 };
-var SEVERITY = {
-  CRITICAL: "critical",
-  HIGH: "high",
-  MEDIUM: "medium",
-  LOW: "low",
-  INFO: "info"
-};
 var IMPACT_WEIGHT = {
   critical: 4,
   high: 3,
@@ -1523,21 +1520,21 @@ function dfsChains(nodeId, path2, pathEdges, visited, ctx) {
   visited.delete(nodeId);
 }
 function estimateImpact(node) {
-  if (node.type === NODE_TYPE.LOOT) return SEVERITY.CRITICAL;
+  if (node.type === NODE_TYPE.LOOT) return SEVERITIES.CRITICAL;
   if (node.type === NODE_TYPE.ACCESS) {
     const level = String(node.data.level || "");
-    if (["root", "SYSTEM", "Administrator", "admin"].includes(level)) return SEVERITY.CRITICAL;
-    return SEVERITY.HIGH;
+    if (["root", "SYSTEM", "Administrator", "admin"].includes(level)) return SEVERITIES.CRITICAL;
+    return SEVERITIES.HIGH;
   }
   if (node.type === NODE_TYPE.VULNERABILITY) {
     const sev = String(node.data.severity || "");
-    if (sev === SEVERITY.CRITICAL) return SEVERITY.CRITICAL;
-    if (sev === SEVERITY.HIGH) return SEVERITY.HIGH;
-    if (sev === SEVERITY.MEDIUM) return SEVERITY.MEDIUM;
+    if (sev === SEVERITIES.CRITICAL) return SEVERITIES.CRITICAL;
+    if (sev === SEVERITIES.HIGH) return SEVERITIES.HIGH;
+    if (sev === SEVERITIES.MEDIUM) return SEVERITIES.MEDIUM;
   }
-  if (node.type === NODE_TYPE.DOMAIN) return SEVERITY.CRITICAL;
-  if (node.type === NODE_TYPE.CERTIFICATE_TEMPLATE) return SEVERITY.HIGH;
-  return SEVERITY.LOW;
+  if (node.type === NODE_TYPE.DOMAIN) return SEVERITIES.CRITICAL;
+  if (node.type === NODE_TYPE.CERTIFICATE_TEMPLATE) return SEVERITIES.HIGH;
+  return SEVERITIES.LOW;
 }
 function extractSuccessfulChain(nodes, edges) {
   const MIN_CHAIN_LENGTH = 2;
@@ -1753,10 +1750,10 @@ function formatPathsList(nodes, edges, failedPaths) {
     const c = chains[i];
     const prob = (c.probability * 100).toFixed(0);
     const impactColors = {
-      [SEVERITY.CRITICAL]: "\u{1F534}",
-      [SEVERITY.HIGH]: "\u{1F7E0}",
-      [SEVERITY.MEDIUM]: "\u{1F7E1}",
-      [SEVERITY.LOW]: "\u{1F7E2}"
+      [SEVERITIES.CRITICAL]: "\u{1F534}",
+      [SEVERITIES.HIGH]: "\u{1F7E0}",
+      [SEVERITIES.MEDIUM]: "\u{1F7E1}",
+      [SEVERITIES.LOW]: "\u{1F7E2}"
     };
     const impactIcon = impactColors[c.impact] || "\u26AA";
     lines.push(`${impactIcon} PATH ${i + 1} [${c.impact.toUpperCase()} | prob: ${prob}% | steps: ${c.length}]`);
@@ -4397,133 +4394,133 @@ function injectCurlMaxTime(command, timeoutSec) {
   if (/--max-time\b|-m\s+\d/.test(command)) return command;
   return command.replace(/\bcurl\b/, `curl --max-time ${timeoutSec}`);
 }
-async function executeCommandOnce(command, options = {}) {
-  return new Promise((resolve) => {
-    const eventEmitter = getEventEmitter();
-    const inputHandler = getInputHandler();
-    const timeout = options.timeout ?? TOOL_TIMEOUTS.DEFAULT_COMMAND;
-    const safeCommand = injectCurlMaxTime(command, CURL_MAX_TIME_SEC);
-    const torLeak = checkTorLeakRisk(safeCommand);
-    if (!torLeak.safe) {
-      resolve({
-        success: false,
-        output: "",
-        error: `\u{1F6D1} TOR IP LEAK BLOCKED
+function prepareCommand(command) {
+  const safeCommand = injectCurlMaxTime(command, CURL_MAX_TIME_SEC);
+  const torLeak = checkTorLeakRisk(safeCommand);
+  if (!torLeak.safe) {
+    return {
+      safeCommand,
+      execCommand: "",
+      error: `\u{1F6D1} TOR IP LEAK BLOCKED
 Reason: ${torLeak.reason}
 Suggestion: ${torLeak.suggestion}`
+    };
+  }
+  return { safeCommand, execCommand: wrapCommandForTor(safeCommand) };
+}
+function setupTimeout(child, timeoutMs, onTimeout) {
+  return setTimeout(() => {
+    onTimeout();
+    try {
+      process.kill(-child.pid, "SIGKILL");
+    } catch {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+  }, timeoutMs);
+}
+var ProcessIOHandler = class {
+  constructor(child, processState, eventEmitter, inputHandler) {
+    this.child = child;
+    this.processState = processState;
+    this.eventEmitter = eventEmitter;
+    this.inputHandler = inputHandler;
+  }
+  stdout = "";
+  stderr = "";
+  inputHandled = false;
+  async checkForInputPrompt(data) {
+    if (this.inputHandled || !this.inputHandler || this.processState.terminated) return;
+    for (const pattern of INPUT_PROMPT_PATTERNS) {
+      if (pattern.test(data)) {
+        this.inputHandled = true;
+        this.eventEmitter?.({
+          type: COMMAND_EVENT_TYPES.INPUT_REQUIRED,
+          message: `Input required: ${data.trim().slice(0, SYSTEM_LIMITS.MAX_PROMPT_PREVIEW)}`,
+          detail: "Waiting for user input..."
+        });
+        try {
+          const userInput = await this.inputHandler(data.trim());
+          if (userInput !== null && !this.processState.terminated && this.child.stdin?.writable) {
+            this.child.stdin.write(userInput + "\n");
+          }
+        } catch {
+        }
+        return;
+      }
+    }
+  }
+  handleStdout(data) {
+    const text = data.toString();
+    this.stdout += text;
+    const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length > 0) {
+      this.eventEmitter?.({
+        type: COMMAND_EVENT_TYPES.COMMAND_STDOUT,
+        message: lines[lines.length - 1]
       });
-      return;
+    }
+    this.checkForInputPrompt(text);
+  }
+  handleStderr(data) {
+    const text = data.toString();
+    this.stderr += text;
+    this.checkForInputPrompt(text);
+  }
+};
+async function executeCommandOnce(command, options = {}) {
+  return new Promise((resolve) => {
+    const eventEmitter = getEventEmitter();
+    const { safeCommand, execCommand, error } = prepareCommand(command);
+    if (error) {
+      return resolve({ success: false, output: "", error });
     }
     eventEmitter?.({
       type: COMMAND_EVENT_TYPES.COMMAND_START,
       message: `Executing: ${safeCommand.slice(0, DISPLAY_LIMITS.COMMAND_PREVIEW)}${safeCommand.length > DISPLAY_LIMITS.COMMAND_PREVIEW ? "..." : ""}`
     });
-    const execCommand = wrapCommandForTor(safeCommand);
     const child = spawn3("sh", ["-c", execCommand], {
       detached: true,
       env: { ...process.env, ...options.env },
       cwd: options.cwd
     });
-    let stdout = "";
-    let stderr = "";
-    let inputHandled = false;
-    let processTerminated = false;
-    let timedOut = false;
-    const killTimer = setTimeout(() => {
-      if (processTerminated) return;
-      timedOut = true;
-      processTerminated = true;
-      try {
-        process.kill(-child.pid, "SIGKILL");
-      } catch {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-      }
-    }, timeout);
-    const checkForInputPrompt = async (data) => {
-      if (inputHandled || !inputHandler || processTerminated) return;
-      for (const pattern of INPUT_PROMPT_PATTERNS) {
-        if (pattern.test(data)) {
-          inputHandled = true;
-          eventEmitter?.({
-            type: COMMAND_EVENT_TYPES.INPUT_REQUIRED,
-            message: `Input required: ${data.trim().slice(0, SYSTEM_LIMITS.MAX_PROMPT_PREVIEW)}`,
-            detail: "Waiting for user input..."
-          });
-          const promptText = data.trim();
-          try {
-            const userInput = await inputHandler(promptText);
-            if (userInput !== null && !processTerminated && child.stdin?.writable) {
-              child.stdin.write(userInput + "\n");
-            }
-          } catch {
-          }
-          return;
-        }
-      }
-    };
-    child.stdout.on("data", (data) => {
-      const text = data.toString();
-      stdout += text;
-      checkForInputPrompt(text);
-    });
-    child.stderr.on("data", (data) => {
-      const text = data.toString();
-      stderr += text;
-      checkForInputPrompt(text);
+    const processState = { terminated: false, timedOut: false };
+    const timeoutMs = options.timeout ?? TOOL_TIMEOUTS.DEFAULT_COMMAND;
+    const killTimer = setupTimeout(child, timeoutMs, () => {
+      processState.timedOut = true;
+      processState.terminated = true;
     });
+    const ioHandler = new ProcessIOHandler(child, processState, eventEmitter, getInputHandler());
+    child.stdout.on("data", (d) => ioHandler.handleStdout(d));
+    child.stderr.on("data", (d) => ioHandler.handleStderr(d));
     child.on("close", (code) => {
       clearTimeout(killTimer);
-      processTerminated = true;
-      if (timedOut) {
-        eventEmitter?.({
-          type: COMMAND_EVENT_TYPES.COMMAND_FAILED,
-          message: `Command timed out after ${Math.round(timeout / 1e3)}s`
-        });
-        resolve({
+      processState.terminated = true;
+      const outTrimmed = ioHandler.stdout.trim();
+      const errTrimmed = ioHandler.stderr.trim();
+      if (processState.timedOut) {
+        eventEmitter?.({ type: COMMAND_EVENT_TYPES.COMMAND_FAILED, message: `Command timed out after ${Math.round(timeoutMs / 1e3)}s` });
+        return resolve({
           success: false,
-          output: stdout.trim(),
-          error: `Command timed out after ${Math.round(timeout / 1e3)}s. Output so far:
-${(stdout + stderr).trim().slice(-500)}`
+          output: outTrimmed,
+          error: `Command timed out after ${Math.round(timeoutMs / 1e3)}s. Output so far:
+${(ioHandler.stdout + ioHandler.stderr).trim().slice(-500)}`
         });
-        return;
       }
       if (code === 0) {
-        eventEmitter?.({
-          type: COMMAND_EVENT_TYPES.COMMAND_SUCCESS,
-          message: `Command completed`
-        });
-        resolve({
-          success: true,
-          output: stdout.trim() || stderr.trim()
-        });
-      } else {
-        eventEmitter?.({
-          type: COMMAND_EVENT_TYPES.COMMAND_FAILED,
-          message: `Command failed (exit ${code})`,
-          detail: stderr.slice(0, SYSTEM_LIMITS.MAX_INPUT_SLICE)
-        });
-        resolve({
-          success: false,
-          output: stdout.trim(),
-          error: stderr.trim() || `Process exited with code ${code}`
-        });
+        eventEmitter?.({ type: COMMAND_EVENT_TYPES.COMMAND_SUCCESS, message: `Command completed` });
+        return resolve({ success: true, output: outTrimmed || errTrimmed });
       }
+      eventEmitter?.({ type: COMMAND_EVENT_TYPES.COMMAND_FAILED, message: `Command failed (exit ${code})`, detail: errTrimmed.slice(0, SYSTEM_LIMITS.MAX_INPUT_SLICE) });
+      return resolve({ success: false, output: outTrimmed, error: errTrimmed || `Process exited with code ${code}` });
     });
     child.on("error", (err) => {
       clearTimeout(killTimer);
-      processTerminated = true;
-      eventEmitter?.({
-        type: COMMAND_EVENT_TYPES.COMMAND_ERROR,
-        message: `Command error: ${err.message}`
-      });
-      resolve({
-        success: false,
-        output: "",
-        error: err.message || String(err)
-      });
+      processState.terminated = true;
+      eventEmitter?.({ type: COMMAND_EVENT_TYPES.COMMAND_ERROR, message: `Command error: ${err.message}` });
+      resolve({ success: false, output: "", error: err.message || String(err) });
     });
   });
 }
@@ -4702,6 +4699,13 @@ function startBackgroundProcess(command, options = {}) {
     bgProcess.hasExited = true;
     bgProcess.exitCode = code;
     logEvent(processId, PROCESS_EVENTS.DIED, `Process exited with code ${code}`);
+    const emitter = getEventEmitter();
+    if (emitter) {
+      emitter({
+        type: COMMAND_EVENT_TYPES.PROCESS_NOTIFICATION,
+        message: `Process finished: ${bgProcess.description} (exit ${code}). Ready for analysis.`
+      });
+    }
   });
   setProcess(processId, bgProcess);
   logEvent(processId, PROCESS_EVENTS.STARTED, `${role} started: ${command.slice(0, SYSTEM_LIMITS.MAX_DESCRIPTION_LENGTH)} (PID:${child.pid})`);
@@ -6363,10 +6367,6 @@ Returns recommendations on process status, port conflicts, long-running tasks, e
   }
 ];
 
-// src/domains/registry.ts
-import { join as join11, dirname as dirname3 } from "path";
-import { fileURLToPath } from "url";
-
 // src/shared/constants/service-ports.ts
 var SERVICE_PORTS = {
   SSH: 22,
@@ -6779,7 +6779,8 @@ Requires root/sudo privileges.`,
     duration: { type: "number", description: "Capture duration in seconds. Default: 30" },
     output_file: { type: "string", description: "Path to save pcap file. Auto-generated if not specified." },
     count: { type: "number", description: "Number of packets to capture. Default: 1000" },
-    extract_creds: { type: "boolean", description: "Try to extract credentials from captured traffic. Default: true" }
+    extract_creds: { type: "boolean", description: "Try to extract credentials from captured traffic. Default: true" },
+    background: { type: "boolean", description: "Run the capture in the background and return immediately. Default: false" }
   },
   execute: async (p) => {
     const iface = p.interface || "any";
@@ -6788,11 +6789,23 @@ Requires root/sudo privileges.`,
     const outputFile = p.output_file || createTempFile(FILE_EXTENSIONS.PCAP);
     const count = p.count || NETWORK_CONFIG.DEFAULT_PACKET_COUNT;
     const extractCreds = p.extract_creds !== false;
+    const isBackground = p.background === true;
     const filterFlag = filter ? `"${filter}"` : "";
     const captureCmd = NETWORK_COMMANDS.TCPDUMP_CAPTURE.replace("${duration}", duration.toString()).replace("${iface}", iface).replace("${count}", count.toString()).replace("${outputFile}", outputFile).replace("${filterFlag}", filterFlag);
     const proc = startBackgroundProcess(captureCmd, {
       description: `Packet capture on ${iface}`
     });
+    if (isBackground) {
+      return {
+        success: true,
+        output: `Packet capture started in background.
+Process ID: ${proc.id}
+Duration: ${duration}s
+Output File: ${outputFile}
+
+You can continue with other tasks. To analyze the capture later, use run_cmd with tshark or tcpdump against the output file.`
+      };
+    }
     await new Promise((r) => setTimeout(r, (duration + NETWORK_CONFIG.WAIT_BUFFER_SECONDS) * 1e3));
     const captureOutput = getProcessOutput(proc.id);
     await stopBackgroundProcess(proc.id);
@@ -6958,6 +6971,56 @@ ${dnsQueries.output}
   }
 });
 
+// src/domains/network/analyze-pcap.ts
+var createAnalyzePcapTool = () => ({
+  name: TOOL_NAMES.ANALYZE_PCAP,
+  description: `Perform deep microscopic analysis of a PCAP file using tshark filters.
+Use this to:
+- Extract credentials from specific protocols
+- Reconstruct TCP streams
+- Analyze specific communication patterns (e.g. HTTP, SMB, DNS)
+- Identify potential attack vectors from intercepted traffic`,
+  parameters: {
+    file_path: { type: "string", description: "Path to the PCAP file to analyze." },
+    filter: { type: "string", description: 'tshark display filter (e.g., "http.request.method == POST", "tcp.port == 445")' },
+    fields: { type: "string", description: 'Comma-separated list of fields to extract (e.g., "http.host,http.user_agent,http.auth_basic")' },
+    limit: { type: "number", description: "Maximum number of packets to process. Default: 100" }
+  },
+  required: ["file_path"],
+  execute: async (p) => {
+    const filePath = p.file_path;
+    const filter = p.filter || "";
+    const fields = p.fields || "";
+    const limit = p.limit || 100;
+    let cmd = `tshark -r ${filePath}`;
+    if (filter) {
+      cmd += ` -Y "${filter}"`;
+    }
+    if (fields) {
+      const fieldArgs = fields.split(",").map((f) => `-e ${f.trim()}`).join(" ");
+      cmd += ` -T fields ${fieldArgs} -E header=y -E separator=/t`;
+    } else {
+      cmd += ` -c ${limit}`;
+    }
+    const result = await runCommand(cmd);
+    if (!result.success) {
+      return {
+        success: false,
+        output: `Failed to analyze PCAP: ${result.error}`
+      };
+    }
+    let output = `PCAP Analysis Results for ${filePath}:
+`;
+    if (filter) output += `Filter: ${filter}
+`;
+    if (fields) output += `Fields: ${fields}
+`;
+    output += `
+${result.output}`;
+    return { success: true, output };
+  }
+});
+
 // src/engine/tools/intel-utils/types.ts
 var PORT_STATE = {
   OPEN: "open",
@@ -8057,13 +8120,12 @@ var RETRY_CONFIG = {
   baseDelayMs: 2e3,
   maxDelayMs: 6e4,
   jitterMs: 1e3,
-  // Auto-retry only for transient errors (rate limits)
-  // Other errors are returned to agent for autonomous decision
-  // Set high to handle extended rate limiting during peak usage
-  autoRetryMaxAttempts: 10,
-  // Auto-retry for rate limits
-  autoRetryDelayMs: 5e3
-  // Initial delay for rate limit retry (exponential backoff)
+  /** WHY Infinity: Rate limit (429) errors are transient infrastructure delays. 
+   *  Infinite fixed-interval retries allow the agent to eventually recover 
+   *  without failing the entire engagement. */
+  autoRetryMaxAttempts: Infinity,
+  autoRetryDelayMs: 1e4
+  // 10s fixed interval for 429/network errors
 };
 var LLM_LIMITS = {
   /** WHY 64K: non-streaming calls (orchestrator, summaries) benefit from
@@ -8320,7 +8382,8 @@ var NETWORK_TOOLS = [
   createDnsSpoofTool(),
   createMitmProxyTool(),
   createPacketSniffTool(),
-  createTrafficInterceptTool()
+  createTrafficInterceptTool(),
+  createAnalyzePcapTool()
 ];
 
 // src/domains/web/intel.ts
@@ -10739,98 +10802,82 @@ var INTEL_TOOLS = [
 ];
 
 // src/domains/registry.ts
-var __dirname = dirname3(fileURLToPath(import.meta.url));
 var DOMAINS = {
   [SERVICE_CATEGORIES.NETWORK]: {
     id: SERVICE_CATEGORIES.NETWORK,
     name: "Network Infrastructure",
-    description: "Vulnerability scanning, port mapping, and network service exploitation.",
-    promptPath: join11(__dirname, "network/prompt.md")
+    description: "Vulnerability scanning, port mapping, and network service exploitation."
   },
   [SERVICE_CATEGORIES.WEB]: {
     id: SERVICE_CATEGORIES.WEB,
     name: "Web Application",
-    description: "Web app security testing, injection attacks, and auth bypass.",
-    promptPath: join11(__dirname, "web/prompt.md")
+    description: "Web app security testing, injection attacks, and auth bypass."
   },
   // Phase 2 domains (using internal categories for now)
   "engagement": {
     id: "engagement",
     name: "Engagement Management",
-    description: "Mission planning, state tracking, and finding management.",
-    promptPath: join11(__dirname, "engagement/prompt.md")
+    description: "Mission planning, state tracking, and finding management."
   },
   "exploit": {
     id: "exploit",
     name: "Exploitation Utilities",
-    description: "Payload mutation, hash cracking, and wordlists.",
-    promptPath: join11(__dirname, "exploit/prompt.md")
+    description: "Payload mutation, hash cracking, and wordlists."
   },
   "intel": {
     id: "intel",
     name: "Vulnerability Intelligence",
-    description: "OWASP knowledge, CVE research, and web attack surface.",
-    promptPath: join11(__dirname, "intel/prompt.md")
+    description: "OWASP knowledge, CVE research, and web attack surface."
   },
   [SERVICE_CATEGORIES.DATABASE]: {
     id: SERVICE_CATEGORIES.DATABASE,
     name: "Database Security",
-    description: "SQL injection, database enumeration, and data extraction.",
-    promptPath: join11(__dirname, "database/prompt.md")
+    description: "SQL injection, database enumeration, and data extraction."
   },
   [SERVICE_CATEGORIES.AD]: {
     id: SERVICE_CATEGORIES.AD,
     name: "Active Directory",
-    description: "Kerberos, LDAP, and Windows domain privilege escalation.",
-    promptPath: join11(__dirname, "ad/prompt.md")
+    description: "Kerberos, LDAP, and Windows domain privilege escalation."
   },
   [SERVICE_CATEGORIES.EMAIL]: {
     id: SERVICE_CATEGORIES.EMAIL,
     name: "Email Services",
-    description: "SMTP, IMAP, POP3 security and user enumeration.",
-    promptPath: join11(__dirname, "email/prompt.md")
+    description: "SMTP, IMAP, POP3 security and user enumeration."
   },
   [SERVICE_CATEGORIES.REMOTE_ACCESS]: {
     id: SERVICE_CATEGORIES.REMOTE_ACCESS,
     name: "Remote Access",
-    description: "SSH, RDP, VNC and other remote control protocols.",
-    promptPath: join11(__dirname, "remote-access/prompt.md")
+    description: "SSH, RDP, VNC and other remote control protocols."
   },
   [SERVICE_CATEGORIES.FILE_SHARING]: {
     id: SERVICE_CATEGORIES.FILE_SHARING,
     name: "File Sharing",
-    description: "SMB, NFS, FTP and shared resource security.",
-    promptPath: join11(__dirname, "file-sharing/prompt.md")
+    description: "SMB, NFS, FTP and shared resource security."
   },
   [SERVICE_CATEGORIES.CLOUD]: {
     id: SERVICE_CATEGORIES.CLOUD,
     name: "Cloud Infrastructure",
-    description: "AWS, Azure, and GCP security and misconfiguration.",
-    promptPath: join11(__dirname, "cloud/prompt.md")
+    description: "AWS, Azure, and GCP security and misconfiguration."
   },
   [SERVICE_CATEGORIES.CONTAINER]: {
     id: SERVICE_CATEGORIES.CONTAINER,
     name: "Container Systems",
-    description: "Docker and Kubernetes security testing.",
-    promptPath: join11(__dirname, "container/prompt.md")
+    description: "Docker and Kubernetes security testing."
   },
   [SERVICE_CATEGORIES.API]: {
     id: SERVICE_CATEGORIES.API,
     name: "API Security",
-    description: "REST, GraphQL, and SOAP API security testing.",
-    promptPath: join11(__dirname, "api/prompt.md")
+    description: "REST, GraphQL, and SOAP API security testing."
   },
   [SERVICE_CATEGORIES.WIRELESS]: {
     id: SERVICE_CATEGORIES.WIRELESS,
     name: "Wireless Networks",
-    description: "WiFi and Bluetooth security testing.",
-    promptPath: join11(__dirname, "wireless/prompt.md")
+    description: "WiFi and Bluetooth security testing."
   },
   [SERVICE_CATEGORIES.ICS]: {
     id: SERVICE_CATEGORIES.ICS,
     name: "Industrial Systems",
-    description: "Critical infrastructure - Modbus, DNP3, ENIP.",
-    promptPath: join11(__dirname, "ics/prompt.md")
+    description: "Critical infrastructure - Modbus, DNP3, ENIP."
   }
 };
 function loadAllDomainTools(state, events) {
@@ -11503,20 +11550,38 @@ function classifyError(error) {
 }
 
 // src/engine/llm-client/retry-handler.ts
+var retryUtils = {
+  sleep: (ms, signal) => {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      }, { once: true });
+    });
+  }
+};
 async function executeWithRetry(operation, callbacks) {
   const signal = callbacks?.abortSignal;
   const maxAttempts = RETRY_CONFIG.autoRetryMaxAttempts;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+  const delayMs = RETRY_CONFIG.autoRetryDelayMs;
+  let attempt = 0;
+  while (attempt < maxAttempts) {
     if (signal?.aborted) throwAbort();
     try {
       return await operation();
     } catch (error) {
       if (isAbortError(error, signal)) throwAbort();
       const errorInfo = classifyError(error);
-      if (errorInfo.type === LLM_ERROR_TYPES.RATE_LIMIT && attempt < maxAttempts - 1) {
-        const delayMs = RETRY_CONFIG.autoRetryDelayMs * Math.pow(2, attempt);
-        callbacks?.onRetry?.(attempt + 1, maxAttempts, delayMs, errorInfo.message);
-        await sleep(delayMs, signal);
+      const isRetryableType = errorInfo.type === LLM_ERROR_TYPES.RATE_LIMIT || errorInfo.type === LLM_ERROR_TYPES.NETWORK_ERROR || errorInfo.type === LLM_ERROR_TYPES.TIMEOUT;
+      if (isRetryableType) {
+        attempt++;
+        callbacks?.onRetry?.(attempt, maxAttempts, delayMs, errorInfo.message);
+        await retryUtils.sleep(delayMs, signal);
         continue;
       }
       throw new LLMError(errorInfo);
@@ -11524,19 +11589,6 @@ async function executeWithRetry(operation, callbacks) {
   }
   throw new LLMError({ type: LLM_ERROR_TYPES.UNKNOWN, message: "Max retry exceeded", isRetryable: false });
 }
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new DOMException("Aborted", "AbortError"));
-      return;
-    }
-    const timer = setTimeout(resolve, ms);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(timer);
-      reject(new DOMException("Aborted", "AbortError"));
-    }, { once: true });
-  });
-}
 function isAbortError(error, signal) {
   return error?.name === "AbortError" || !!signal?.aborted;
 }
@@ -12518,6 +12570,18 @@ function extractHypothesizedReason(failureLine) {
 }
 
 // src/shared/utils/context-digest/formatters.ts
+function formatContextForLLM(memo14) {
+  const compact = {};
+  if (memo14.keyFindings.length > 0) compact.findings = memo14.keyFindings;
+  if (memo14.credentials.length > 0) compact.credentials = memo14.credentials;
+  if (memo14.attackVectors.length > 0) compact.attackVectors = memo14.attackVectors;
+  if (memo14.failures.length > 0) compact.failures = memo14.failures;
+  if (memo14.suspicions.length > 0) compact.suspicions = memo14.suspicions;
+  if (memo14.nextSteps.length > 0) compact.nextSteps = memo14.nextSteps;
+  compact.attackValue = memo14.attackValue;
+  if (memo14.reflection) compact.reflection = memo14.reflection;
+  return JSON.stringify(compact);
+}
 function formatAnalystDigest(digest, filePath, originalChars) {
   return [
     digest,
@@ -12555,6 +12619,7 @@ async function digestToolOutput(output, toolName, toolInput, analystFn) {
   if (originalLength < PASSTHROUGH_THRESHOLD) {
     return {
       digestedOutput: output,
+      contextForLLM: output,
       fullOutputPath: null,
       analystUsed: false,
       memo: null,
@@ -12574,8 +12639,10 @@ async function digestToolOutput(output, toolName, toolInput, analystFn) {
       const rawAnalystResponse = await analystFn(preprocessed, context);
       const memo14 = parseAnalystMemo(rawAnalystResponse);
       const formatted = formatAnalystDigest(rawAnalystResponse, savedOutputPath, originalLength);
+      const contextForLLM = formatContextForLLM(memo14);
       return {
         digestedOutput: formatted,
+        contextForLLM,
         fullOutputPath: savedOutputPath,
         analystUsed: true,
         memo: memo14,
@@ -12593,6 +12660,7 @@ async function digestToolOutput(output, toolName, toolInput, analystFn) {
   const fallback = formatFallbackDigest(preprocessed, savedOutputPath, originalLength);
   return {
     digestedOutput: fallback,
+    contextForLLM: fallback,
     fullOutputPath: savedOutputPath,
     analystUsed: false,
     memo: null,
@@ -12696,7 +12764,7 @@ ${text}
 
 // src/agents/tool-executor/result-handler/digest.ts
 async function digestAndEmit(call, outputText, result, toolStartTime, llm, events) {
-  let digestedOutputForLLM = outputText;
+  let contextOutputForLLM = outputText;
   let digestResult = null;
   try {
     const llmDigestFn = createLLMDigestFn(llm);
@@ -12706,12 +12774,12 @@ async function digestAndEmit(call, outputText, result, toolStartTime, llm, event
       JSON.stringify(call.input).slice(0, DISPLAY_LIMITS.OUTPUT_SUMMARY),
       llmDigestFn
     );
-    digestedOutputForLLM = digestResult.digestedOutput;
+    contextOutputForLLM = digestResult.contextForLLM;
   } catch {
-    if (digestedOutputForLLM.length > AGENT_LIMITS.MAX_TOOL_OUTPUT_LENGTH) {
-      const truncated = digestedOutputForLLM.slice(0, AGENT_LIMITS.MAX_TOOL_OUTPUT_LENGTH);
-      const remaining = digestedOutputForLLM.length - AGENT_LIMITS.MAX_TOOL_OUTPUT_LENGTH;
-      digestedOutputForLLM = `${truncated}
+    if (contextOutputForLLM.length > AGENT_LIMITS.MAX_TOOL_OUTPUT_LENGTH) {
+      const truncated = contextOutputForLLM.slice(0, AGENT_LIMITS.MAX_TOOL_OUTPUT_LENGTH);
+      const remaining = contextOutputForLLM.length - AGENT_LIMITS.MAX_TOOL_OUTPUT_LENGTH;
+      contextOutputForLLM = `${truncated}
 
 ... [TRUNCATED ${remaining} chars] ...`;
     }
@@ -12720,16 +12788,16 @@ async function digestAndEmit(call, outputText, result, toolStartTime, llm, event
   const tuiOutput = digestResult?.digestedOutput ? `${digestResult.digestedOutput}${outputFilePath ? `
 \u{1F4C4} Full output: ${outputFilePath}` : ""}` : outputText.slice(0, DISPLAY_LIMITS.OUTPUT_SUMMARY);
   emitToolResult(events, call.name, result.success, tuiOutput, result.error, Date.now() - toolStartTime);
-  return { digestedOutputForLLM, digestResult };
+  return { contextOutputForLLM, digestResult };
 }
 
 // src/agents/tool-executor/result-handler/journal.ts
-function recordJournalMemo(call, result, digestedOutputForLLM, digestResult, turnState, state) {
+function recordJournalMemo(call, result, contextOutputForLLM, digestResult, turnState, state) {
   turnState.toolJournal.push({
     name: call.name,
     inputSummary: JSON.stringify(call.input),
     success: result.success,
-    analystSummary: digestResult?.memo ? digestResult.memo.keyFindings.join("; ") || "No key findings" : digestedOutputForLLM,
+    analystSummary: digestResult?.memo ? digestResult.memo.keyFindings.join("; ") || "No key findings" : contextOutputForLLM,
     outputFile: digestResult?.fullOutputPath ?? null
   });
   if (digestResult?.memo) {
@@ -12843,7 +12911,7 @@ async function executeSingle(call, deps, progress) {
     let outputText = result.output ?? "";
     scanForFlags(outputText, deps.state, deps.events);
     outputText = handleToolResult(result, call, outputText, progress);
-    const { digestedOutputForLLM, digestResult } = await digestAndEmit(
+    const { contextOutputForLLM, digestResult } = await digestAndEmit(
       call,
       outputText,
       result,
@@ -12851,8 +12919,8 @@ async function executeSingle(call, deps, progress) {
       deps.llm,
       deps.events
     );
-    recordJournalMemo(call, result, digestedOutputForLLM, digestResult, deps.turnState, deps.state);
-    return { toolCallId: call.id, output: digestedOutputForLLM, error: result.error };
+    recordJournalMemo(call, result, contextOutputForLLM, digestResult, deps.turnState, deps.state);
+    return { toolCallId: call.id, output: contextOutputForLLM, error: result.error };
   } catch (error) {
     const errorMsg = String(error);
     const enrichedError = enrichToolErrorContext({
@@ -13171,17 +13239,17 @@ var PHASE_TECHNIQUE_MAP = {
 
 // src/agents/prompt-builder/prompt-loader.ts
 import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
-import { join as join12, dirname as dirname4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
-var PROMPTS_DIR = join12(__dirname2, "../prompts");
-var TECHNIQUES_DIR = join12(PROMPTS_DIR, PROMPT_PATHS.TECHNIQUES_DIR);
+import { join as join11, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var PROMPTS_DIR = join11(__dirname, "../prompts");
+var TECHNIQUES_DIR = join11(PROMPTS_DIR, PROMPT_PATHS.TECHNIQUES_DIR);
 function loadPromptFile(filename) {
-  const path2 = join12(PROMPTS_DIR, filename);
+  const path2 = join11(PROMPTS_DIR, filename);
   return existsSync11(path2) ? readFileSync8(path2, PROMPT_CONFIG.ENCODING) : "";
 }
 function loadTechniqueFile(techniqueName) {
-  const filePath = join12(TECHNIQUES_DIR, `${techniqueName}.md`);
+  const filePath = join11(TECHNIQUES_DIR, `${techniqueName}.md`);
   try {
     if (!existsSync11(filePath)) return "";
     return readFileSync8(filePath, PROMPT_CONFIG.ENCODING);
@@ -13330,11 +13398,11 @@ ${lines.join("\n")}
 
 // src/shared/utils/journal/reader.ts
 import { readFileSync as readFileSync9, existsSync as existsSync13 } from "fs";
-import { join as join14 } from "path";
+import { join as join13 } from "path";
 
 // src/shared/utils/journal/rotation.ts
 import { existsSync as existsSync12, readdirSync as readdirSync3, statSync as statSync4, rmSync as rmSync2 } from "fs";
-import { join as join13 } from "path";
+import { join as join12 } from "path";
 function parseTurnNumbers(turnsDir) {
   if (!existsSync12(turnsDir)) return [];
   return readdirSync3(turnsDir).filter((e) => e.startsWith(TURN_FOLDER_PREFIX) && /^\d+$/.test(e.slice(TURN_FOLDER_PREFIX.length))).map((e) => Number(e.slice(TURN_FOLDER_PREFIX.length)));
@@ -13343,12 +13411,12 @@ function rotateTurnRecords() {
   try {
     const turnsDir = WORKSPACE.TURNS;
     if (!existsSync12(turnsDir)) return;
-    const turnDirs = parseTurnNumbers(turnsDir).map((n) => `${TURN_FOLDER_PREFIX}${n}`).filter((e) => statSync4(join13(turnsDir, e)).isDirectory()).sort((a, b) => Number(a.slice(TURN_FOLDER_PREFIX.length)) - Number(b.slice(TURN_FOLDER_PREFIX.length)));
+    const turnDirs = parseTurnNumbers(turnsDir).map((n) => `${TURN_FOLDER_PREFIX}${n}`).filter((e) => statSync4(join12(turnsDir, e)).isDirectory()).sort((a, b) => Number(a.slice(TURN_FOLDER_PREFIX.length)) - Number(b.slice(TURN_FOLDER_PREFIX.length)));
     if (turnDirs.length > MEMORY_LIMITS.MAX_TURN_ENTRIES) {
       const dirsToDel = turnDirs.slice(0, turnDirs.length - MEMORY_LIMITS.MAX_TURN_ENTRIES);
       for (const dir of dirsToDel) {
         try {
-          rmSync2(join13(turnsDir, dir), { recursive: true, force: true });
+          rmSync2(join12(turnsDir, dir), { recursive: true, force: true });
         } catch {
         }
       }
@@ -13367,7 +13435,7 @@ function readJournalSummary() {
     const turnsDir = WORKSPACE.TURNS;
     const turnDirs = parseTurnNumbers(turnsDir).sort((a, b) => b - a);
     for (const turn of turnDirs) {
-      const summaryPath = join14(WORKSPACE.turnPath(turn), TURN_FILES.SUMMARY);
+      const summaryPath = join13(WORKSPACE.turnPath(turn), TURN_FILES.SUMMARY);
       if (existsSync13(summaryPath)) {
         return readFileSync9(summaryPath, "utf-8");
       }
@@ -13384,7 +13452,7 @@ function getRecentEntries(count = MEMORY_LIMITS.MAX_TURN_ENTRIES) {
     const entries = [];
     for (const turn of turnDirs) {
       try {
-        const filePath = join14(WORKSPACE.turnPath(turn), TURN_FILES.STRUCTURED);
+        const filePath = join13(WORKSPACE.turnPath(turn), TURN_FILES.STRUCTURED);
         if (existsSync13(filePath)) {
           const raw = readFileSync9(filePath, "utf-8");
           entries.push(JSON.parse(raw));
@@ -13410,7 +13478,7 @@ function getNextTurnNumber() {
 
 // src/shared/utils/journal/summary.ts
 import { writeFileSync as writeFileSync9 } from "fs";
-import { join as join15 } from "path";
+import { join as join14 } from "path";
 
 // src/shared/utils/journal/summary-collector.ts
 function collectSummaryBuckets(entries) {
@@ -13515,7 +13583,7 @@ function regenerateJournalSummary() {
     const turnDir = WORKSPACE.turnPath(latestTurn);
     ensureDirExists(turnDir);
     const summary = buildSummaryFromEntries(entries);
-    const summaryPath = join15(turnDir, TURN_FILES.SUMMARY);
+    const summaryPath = join14(turnDir, TURN_FILES.SUMMARY);
     writeFileSync9(summaryPath, summary, "utf-8");
     debugLog("general", "Journal summary regenerated", {
       entries: entries.length,
@@ -14109,10 +14177,10 @@ function formatForPrompt(directive, isStale = false) {
 
 // src/agents/strategist/prompt-loader.ts
 import { readFileSync as readFileSync10, existsSync as existsSync14 } from "fs";
-import { join as join16, dirname as dirname5 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname3 = dirname5(fileURLToPath3(import.meta.url));
-var STRATEGIST_PROMPT_PATH = join16(__dirname3, "../prompts", "strategist-system.md");
+import { join as join15, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
+var STRATEGIST_PROMPT_PATH = join15(__dirname2, "../prompts", "strategist-system.md");
 function loadSystemPrompt() {
   try {
     if (existsSync14(STRATEGIST_PROMPT_PATH)) {
@@ -14513,7 +14581,7 @@ async function processReflection(toolJournal, memo14, phase, reflector) {
 
 // src/agents/main-agent/turn-recorder.ts
 import { writeFileSync as writeFileSync10, existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
-import { join as join17 } from "path";
+import { join as join16 } from "path";
 async function recordTurn(context) {
   const { turnCounter, phase, toolJournal, memo: memo14, reflections, summaryRegenerator } = context;
   if (toolJournal.length === 0) {
@@ -14551,8 +14619,8 @@ async function createTurnArchive(turnCounter, ctx) {
       memo: memo14,
       reflection: entry.reflection
     });
-    writeFileSync10(join17(turnDir, TURN_FILES.RECORD), turnContent, "utf-8");
-    writeFileSync10(join17(turnDir, TURN_FILES.STRUCTURED), JSON.stringify(entry, null, 2), "utf-8");
+    writeFileSync10(join16(turnDir, TURN_FILES.RECORD), turnContent, "utf-8");
+    writeFileSync10(join16(turnDir, TURN_FILES.STRUCTURED), JSON.stringify(entry, null, 2), "utf-8");
     writeAnalystFile(turnDir, memo14);
   } catch {
   }
@@ -14566,7 +14634,7 @@ function writeAnalystFile(turnDir, memo14) {
   if (memo14.suspicions.length > 0) memoLines.push("## Suspicious", ...memo14.suspicions.map((s) => `- ${s}`), "");
   if (memo14.nextSteps.length > 0) memoLines.push("## Next Steps", ...memo14.nextSteps.map((n) => `- ${n}`), "");
   if (memoLines.length > 0) {
-    writeFileSync10(join17(turnDir, TURN_FILES.ANALYST), memoLines.join("\n"), "utf-8");
+    writeFileSync10(join16(turnDir, TURN_FILES.ANALYST), memoLines.join("\n"), "utf-8");
     flowLog(
       "\u2462Analyst",
       "\u2192",
@@ -14579,11 +14647,11 @@ async function regenerateSummary(turnCounter, summaryRegenerator, ctx) {
   const { entry, journalTools, memo: memo14, phase } = ctx;
   try {
     const turnDir = WORKSPACE.turnPath(turnCounter);
-    const summaryPath = join17(turnDir, TURN_FILES.SUMMARY);
+    const summaryPath = join16(turnDir, TURN_FILES.SUMMARY);
     const prevTurn = turnCounter - 1;
     let existingSummary = null;
     if (prevTurn >= 1) {
-      const prevSummaryPath = join17(WORKSPACE.turnPath(prevTurn), TURN_FILES.SUMMARY);
+      const prevSummaryPath = join16(WORKSPACE.turnPath(prevTurn), TURN_FILES.SUMMARY);
       if (existsSync15(prevSummaryPath)) {
         existingSummary = readFileSync11(prevSummaryPath, "utf-8");
       }
@@ -15198,6 +15266,10 @@ function createLifecycleHandlers(agent, state, _reasoningBufferRef) {
       todo: s.getTodo().length
     });
   };
+  const onNotification = (e) => {
+    const prefix = e.data.level === "error" ? "\u274C" : e.data.level === "warning" ? "\u26A0\uFE0F" : e.data.level === "success" ? "\u2705" : "\u{1F514}";
+    addMessage("system", `${prefix} [${e.data.title}] ${e.data.message}`);
+  };
   return {
     onComplete,
     onRetry,
@@ -15206,7 +15278,8 @@ function createLifecycleHandlers(agent, state, _reasoningBufferRef) {
     onAIResponse,
     onUsageUpdate,
     onFlagFound,
-    onPhaseChange
+    onPhaseChange,
+    onNotification
   };
 }
 
@@ -15276,9 +15349,26 @@ function setupInputHandlers(setInputRequest, addMessage) {
 }
 
 // src/platform/tui/hooks/useAgentEvents/handlers/command.ts
-function setupCommandHandlers(addMessage) {
+function setupCommandHandlers(addMessage, setCurrentStatus) {
+  let lastStatusBase = "";
   setCommandEventEmitter((event) => {
-    if (event.type === COMMAND_EVENT_TYPES.COMMAND_START || event.type === COMMAND_EVENT_TYPES.COMMAND_SUCCESS) {
+    if (event.type === COMMAND_EVENT_TYPES.COMMAND_START) {
+      lastStatusBase = event.message;
+      return;
+    }
+    if (event.type === COMMAND_EVENT_TYPES.COMMAND_SUCCESS) {
+      return;
+    }
+    if (event.type === COMMAND_EVENT_TYPES.COMMAND_STDOUT) {
+      if (lastStatusBase) {
+        const cleanLine = event.message.replace(/\s+/g, " ").slice(0, 100);
+        setCurrentStatus(`${lastStatusBase}
+[live] ${cleanLine}`);
+      }
+      return;
+    }
+    if (event.type === COMMAND_EVENT_TYPES.PROCESS_NOTIFICATION) {
+      addMessage("system", `\u{1F514} [Background Alert] ${event.message}`);
       return;
     }
     const icon = getCommandEventIcon(event.type);
@@ -15325,7 +15415,7 @@ var useAgentEvents = (agent, eventsRef, state) => {
     }, reasoningBufferRef);
     const reasoningHandlers = createReasoningHandlers({ addMessage, setCurrentStatus }, reasoningBufferRef);
     const cleanupInput = setupInputHandlers(setInputRequest, addMessage);
-    const cleanupCommand = setupCommandHandlers(addMessage);
+    const cleanupCommand = setupCommandHandlers(addMessage, setCurrentStatus);
     const updateStats = () => {
       const s = agent.getState();
       setStats({
@@ -15344,6 +15434,7 @@ var useAgentEvents = (agent, eventsRef, state) => {
     events.on(EVENT_TYPES.USAGE_UPDATE, lifecycleHandlers.onUsageUpdate);
     events.on(EVENT_TYPES.FLAG_FOUND, lifecycleHandlers.onFlagFound);
     events.on(EVENT_TYPES.PHASE_CHANGE, lifecycleHandlers.onPhaseChange);
+    events.on(EVENT_TYPES.NOTIFICATION, lifecycleHandlers.onNotification);
     events.on(EVENT_TYPES.STATE_CHANGE, updateStats);
     events.on(EVENT_TYPES.START, updateStats);
     events.on(EVENT_TYPES.REASONING_START, reasoningHandlers.onStart);
@@ -16003,7 +16094,7 @@ var useCommands = (props) => {
 };
 
 // src/platform/tui/hooks/useKeyboardShortcuts.ts
-import { useCallback as useCallback7, useEffect as useEffect4 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect4 } from "react";
 import { useInput } from "ink";
 
 // src/platform/tui/hooks/keyboard/useDoubleTap.ts
@@ -16093,17 +16184,6 @@ var useEscHandler = ({
   return { handleEsc };
 };
 
-// src/platform/tui/hooks/keyboard/useScrollHandler.ts
-import { useRef as useRef5, useCallback as useCallback6 } from "react";
-var useScrollHandler = ({ onScroll }) => {
-  const onScrollRef = useRef5(onScroll);
-  onScrollRef.current = onScroll;
-  const handleScroll = useCallback6((delta) => {
-    onScrollRef.current?.(delta);
-  }, []);
-  return { handleScroll };
-};
-
 // src/platform/tui/hooks/useKeyboardShortcuts.ts
 var DOUBLE_TAP_WINDOW = 3e3;
 var useKeyboardShortcuts = ({
@@ -16115,8 +16195,7 @@ var useKeyboardShortcuts = ({
   inputRequestRef,
   isModalOpenRef,
   inputRef,
-  clearInput,
-  onScroll
+  clearInput
 }) => {
   const { handleCtrlC } = useExitHandler({
     handleExit,
@@ -16135,18 +16214,11 @@ var useKeyboardShortcuts = ({
     inputRef,
     windowMs: DOUBLE_TAP_WINDOW
   });
-  const { handleScroll } = useScrollHandler({ onScroll });
-  useInput(useCallback7((ch, key) => {
+  useInput(useCallback6((ch, key) => {
     if (isModalOpenRef.current) return;
     if (key.escape) handleEsc();
     if (key.ctrl && ch === "c") handleCtrlC();
-    if (key.pageUp) {
-      handleScroll(-10);
-    }
-    if (key.pageDown) {
-      handleScroll(10);
-    }
-  }, [handleEsc, handleCtrlC, handleScroll, isModalOpenRef]));
+  }, [handleEsc, handleCtrlC, isModalOpenRef]));
   useEffect4(() => {
     const onSignal = () => handleCtrlC();
     process.on("SIGINT", onSignal);
@@ -16177,33 +16249,32 @@ var AnimationProvider = ({ children }) => {
 var useAnimationTick = () => useContext(AnimationContext);
 
 // src/platform/tui/components/MessageList.tsx
-import { memo as memo7, useState as useState4, useCallback as useCallback8, useRef as useRef6 } from "react";
-import { Box as Box8, Text as Text8, useInput as useInput2 } from "ink";
+import { memo as memo7 } from "react";
+import { Box as Box8, Static } from "ink";
 
 // src/platform/tui/components/messages/ThinkingBlock.tsx
 import { memo } from "react";
 import { Box, Text } from "ink";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 var THINKING_PREVIEW_LINES = 3;
-var ThinkingBlock = memo(({ msg, isExpanded }) => {
+var ThinkingBlock = memo(({ msg }) => {
   const lines = msg.content.split("\n");
   const charCount = msg.content.length;
   const estTokens = Math.round(charCount / LLM_LIMITS.charsPerTokenEstimate);
   const hiddenCount = lines.length - THINKING_PREVIEW_LINES;
-  const visibleLines = isExpanded ? lines : lines.slice(0, THINKING_PREVIEW_LINES);
+  const visibleLines = lines.slice(0, THINKING_PREVIEW_LINES);
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [
     /* @__PURE__ */ jsxs(Box, { children: [
       /* @__PURE__ */ jsx2(Text, { color: THEME.dimGray, children: "  \u25C6 " }),
       /* @__PURE__ */ jsx2(Text, { color: THEME.gray, children: "Reasoning" }),
       /* @__PURE__ */ jsx2(Text, { color: THEME.dimGray, children: ` (~${estTokens} tokens)` }),
-      !isExpanded && hiddenCount > 0 && /* @__PURE__ */ jsx2(Text, { color: THEME.dimGray, children: ` [+${hiddenCount} lines \xB7 R]` }),
-      isExpanded && /* @__PURE__ */ jsx2(Text, { color: THEME.dimGray, children: " [R to collapse]" })
+      hiddenCount > 0 && /* @__PURE__ */ jsx2(Text, { color: THEME.dimGray, children: ` [+${hiddenCount} lines]` })
     ] }),
     visibleLines.map((line, i) => /* @__PURE__ */ jsxs(Box, { children: [
       /* @__PURE__ */ jsx2(Text, { dimColor: true, children: "  \u2502 " }),
       /* @__PURE__ */ jsx2(Text, { dimColor: true, children: line })
     ] }, i)),
-    !isExpanded && hiddenCount > 0 && /* @__PURE__ */ jsxs(Box, { children: [
+    hiddenCount > 0 && /* @__PURE__ */ jsxs(Box, { children: [
       /* @__PURE__ */ jsx2(Text, { dimColor: true, children: "  \u2502 " }),
       /* @__PURE__ */ jsx2(Text, { dimColor: true, children: "..." })
     ] })
@@ -16611,23 +16682,22 @@ function classifyResult(content) {
   if (content.startsWith("\u26A0") || content.startsWith("!")) return RESULT_KINDS.WARNING;
   return RESULT_KINDS.NEUTRAL;
 }
-function computeResultDisplay(content, isExpanded) {
+function computeResultDisplay(content) {
   const kind = classifyResult(content);
   const isFailure = kind === RESULT_KINDS.FAILURE;
   const lines = content.split("\n");
   const firstLine = lines[0] || "";
   const restLines = lines.slice(1);
   const hiddenCount = restLines.length;
-  const effectiveExpanded = isFailure ? true : isExpanded;
-  const showCount = effectiveExpanded ? hiddenCount : Math.min(hiddenCount, RESULT_PREVIEW_LINES);
-  const visibleRest = restLines.slice(0, showCount);
-  const hasMore = !effectiveExpanded && hiddenCount > RESULT_PREVIEW_LINES;
-  return { firstLine, visibleRest, hasMore, effectiveExpanded };
+  const previewLines = isFailure ? RESULT_PREVIEW_LINES * 2 : RESULT_PREVIEW_LINES;
+  const visibleRest = restLines.slice(0, previewLines);
+  const hasMore = hiddenCount > previewLines;
+  return { firstLine, visibleRest, hasMore };
 }
 
 // src/platform/tui/components/messages/MessageRow.tsx
 import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
-var MessageRow = memo4(({ msg, isExpanded }) => {
+var MessageRow = memo4(({ msg }) => {
   if (msg.type === "status") {
     const statusData = parseStatusContent(msg.content);
     if (statusData) {
@@ -16646,7 +16716,7 @@ var MessageRow = memo4(({ msg, isExpanded }) => {
     ] }, msg.id);
   }
   if (msg.type === "thinking") {
-    return /* @__PURE__ */ jsx6(ThinkingBlock, { msg, isExpanded });
+    return /* @__PURE__ */ jsx6(ThinkingBlock, { msg });
   }
   if (msg.type === "tool") {
     return /* @__PURE__ */ jsx6(Box5, { children: /* @__PURE__ */ jsx6(ToolCard, { content: msg.content }) }, msg.id);
@@ -16654,15 +16724,13 @@ var MessageRow = memo4(({ msg, isExpanded }) => {
   if (msg.type === "result") {
     const kind = classifyResult(msg.content);
     const color = kind === "success" ? THEME.primary : kind === "failure" ? THEME.red : kind === "warning" ? THEME.yellow : THEME.gray;
-    const { firstLine, visibleRest, hasMore, effectiveExpanded } = computeResultDisplay(msg.content, isExpanded);
+    const { firstLine, visibleRest, hasMore } = computeResultDisplay(msg.content);
     const hiddenCount = msg.content.split("\n").length - 1;
-    const isFailure = kind === "failure";
     return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
       /* @__PURE__ */ jsxs5(Box5, { children: [
         /* @__PURE__ */ jsx6(Text5, { color: THEME.dimGray, children: "  \u2514 " }),
         /* @__PURE__ */ jsx6(Text5, { color, children: firstLine }),
-        hasMore && /* @__PURE__ */ jsx6(Text5, { dimColor: true, color: THEME.dimGray, children: ` [+${hiddenCount - RESULT_PREVIEW_LINES} \xB7 T]` }),
-        effectiveExpanded && hiddenCount > RESULT_PREVIEW_LINES && !isFailure && /* @__PURE__ */ jsx6(Text5, { dimColor: true, color: THEME.dimGray, children: " [T \u2193]" })
+        hasMore && /* @__PURE__ */ jsx6(Text5, { dimColor: true, color: THEME.dimGray, children: ` [+${hiddenCount - RESULT_PREVIEW_LINES}]` })
       ] }),
       visibleRest.map((line, i) => /* @__PURE__ */ jsxs5(Box5, { children: [
         /* @__PURE__ */ jsx6(Text5, { color: THEME.dimGray, children: "    " }),
@@ -16677,18 +16745,11 @@ var MessageRow = memo4(({ msg, isExpanded }) => {
     const eLines = msg.content.split("\n");
     const eFirst = eLines[0] || msg.content;
     const eHidden = eLines.length - 1;
-    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs5(Box5, { children: [
-        /* @__PURE__ */ jsx6(Text5, { color: THEME.red, children: "  \u2717 " }),
-        /* @__PURE__ */ jsx6(Text5, { color: THEME.red, children: eFirst }),
-        !isExpanded && eHidden > 0 && /* @__PURE__ */ jsx6(Text5, { dimColor: true, color: THEME.dimGray, children: ` [+${eHidden} \xB7 E]` }),
-        isExpanded && eHidden > 0 && /* @__PURE__ */ jsx6(Text5, { dimColor: true, color: THEME.dimGray, children: " [E \u2191]" })
-      ] }),
-      isExpanded && eLines.slice(1).map((line, i) => /* @__PURE__ */ jsxs5(Box5, { children: [
-        /* @__PURE__ */ jsx6(Text5, { color: THEME.dimGray, children: "    " }),
-        /* @__PURE__ */ jsx6(Text5, { dimColor: true, color: THEME.red, children: line })
-      ] }, i))
-    ] }, msg.id);
+    return /* @__PURE__ */ jsx6(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx6(Text5, { color: THEME.red, children: "  \u2717 " }),
+      /* @__PURE__ */ jsx6(Text5, { color: THEME.red, children: eFirst }),
+      eHidden > 0 && /* @__PURE__ */ jsx6(Text5, { dimColor: true, color: THEME.dimGray, children: ` [+${eHidden}]` })
+    ] }) }, msg.id);
   }
   if (msg.type === "user") {
     return /* @__PURE__ */ jsxs5(Box5, { children: [
@@ -16771,72 +16832,9 @@ var EmptyState = memo6(({ modelName, autoApproveMode, version }) => {
   ] });
 });
 
-// src/platform/tui/components/messages/sliding-window.ts
-var MAX_VISIBLE_MESSAGES = 200;
-function computeSlidingWindow(messages, scrollOffset) {
-  const allVisible = messages.length > MAX_VISIBLE_MESSAGES ? messages.slice(-MAX_VISIBLE_MESSAGES) : messages;
-  const clampedOffset = Math.min(scrollOffset, Math.max(0, allVisible.length - 1));
-  const visibleMessages = clampedOffset === 0 ? allVisible : allVisible.slice(0, allVisible.length - clampedOffset);
-  const hiddenAbove = allVisible.length - visibleMessages.length;
-  return { visibleMessages, hiddenAbove, clampedOffset };
-}
-
 // src/platform/tui/components/MessageList.tsx
-import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
-var MessageList = memo7(({ messages, isModalOpen, modelName, autoApproveMode, version, scrollOffset = 0 }) => {
-  const [expandedIds, setExpandedIds] = useState4(/* @__PURE__ */ new Set());
-  const messagesRef = useRef6(messages);
-  messagesRef.current = messages;
-  const isModalOpenRef = useRef6(isModalOpen);
-  isModalOpenRef.current = isModalOpen;
-  useInput2(useCallback8((_ch, key) => {
-    if (isModalOpenRef.current || key.ctrl) return;
-    if (_ch === "r") {
-      const msgs = messagesRef.current;
-      for (let i = msgs.length - 1; i >= 0; i--) {
-        if (msgs[i].type === "thinking") {
-          const id = msgs[i].id;
-          setExpandedIds((prev) => {
-            const next = new Set(prev);
-            if (next.has(id)) next.delete(id);
-            else next.add(id);
-            return next;
-          });
-          break;
-        }
-      }
-    }
-    if (_ch === "e") {
-      const msgs = messagesRef.current;
-      for (let i = msgs.length - 1; i >= 0; i--) {
-        if (msgs[i].type === "error") {
-          const id = msgs[i].id;
-          setExpandedIds((prev) => {
-            const next = new Set(prev);
-            if (next.has(id)) next.delete(id);
-            else next.add(id);
-            return next;
-          });
-          break;
-        }
-      }
-    }
-    if (_ch === "t") {
-      const msgs = messagesRef.current;
-      for (let i = msgs.length - 1; i >= 0; i--) {
-        if (msgs[i].type === "result") {
-          const id = msgs[i].id;
-          setExpandedIds((prev) => {
-            const next = new Set(prev);
-            if (next.has(id)) next.delete(id);
-            else next.add(id);
-            return next;
-          });
-          break;
-        }
-      }
-    }
-  }, []));
+import { jsx as jsx9 } from "react/jsx-runtime";
+var MessageList = memo7(({ messages, modelName, autoApproveMode, version }) => {
   if (messages.length === 0) {
     return /* @__PURE__ */ jsx9(
       EmptyState,
@@ -16847,30 +16845,19 @@ var MessageList = memo7(({ messages, isModalOpen, modelName, autoApproveMode, ve
       }
     );
   }
-  const { visibleMessages, hiddenAbove, clampedOffset } = computeSlidingWindow(messages, scrollOffset);
-  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", children: [
-    clampedOffset > 0 && /* @__PURE__ */ jsx9(Box8, { paddingX: 1, children: /* @__PURE__ */ jsx9(Text8, { dimColor: true, color: THEME.dimGray, children: `\u2191 ${hiddenAbove} message${hiddenAbove !== 1 ? "s" : ""} above \xB7 PgDn to scroll down` }) }),
-    visibleMessages.map((msg) => /* @__PURE__ */ jsx9(
-      MessageRow,
-      {
-        msg,
-        isExpanded: expandedIds.has(msg.id)
-      },
-      msg.id
-    ))
-  ] });
+  return /* @__PURE__ */ jsx9(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsx9(Static, { items: messages, children: (msg) => /* @__PURE__ */ jsx9(MessageRow, { msg }, msg.id) }) });
 });
 
 // src/platform/tui/components/StatusDisplay.tsx
 import { memo as memo10 } from "react";
-import { Box as Box11, Text as Text13 } from "ink";
+import { Box as Box11, Text as Text12 } from "ink";
 
 // src/platform/tui/hooks/useStatusTimer.ts
-import { useState as useState5, useEffect as useEffect6, useRef as useRef7 } from "react";
+import { useState as useState4, useEffect as useEffect6, useRef as useRef5 } from "react";
 var useStatusTimer = (currentStatus, isProcessing) => {
-  const [statusElapsed, setStatusElapsed] = useState5(0);
-  const statusTimerRef = useRef7(null);
-  const statusStartRef = useRef7(Date.now());
+  const [statusElapsed, setStatusElapsed] = useState4(0);
+  const statusTimerRef = useRef5(null);
+  const statusStartRef = useRef5(Date.now());
   useEffect6(() => {
     if (statusTimerRef.current) clearInterval(statusTimerRef.current);
     if (isProcessing && currentStatus) {
@@ -16891,11 +16878,11 @@ var useStatusTimer = (currentStatus, isProcessing) => {
 };
 
 // src/platform/tui/components/status/RetryView.tsx
-import { Box as Box9, Text as Text10 } from "ink";
+import { Box as Box9, Text as Text9 } from "ink";
 
 // src/platform/tui/components/StarSpinner.tsx
 import { memo as memo8 } from "react";
-import { Text as Text9 } from "ink";
+import { Text as Text8 } from "ink";
 import { jsx as jsx10 } from "react/jsx-runtime";
 var FRAMES = [
   "\xB7",
@@ -16916,31 +16903,31 @@ var FRAMES = [
 var StarSpinner = memo8(({ color }) => {
   const tick = useAnimationTick();
   const index = tick % FRAMES.length;
-  return /* @__PURE__ */ jsx10(Text9, { color: color || "yellow", children: FRAMES[index] });
+  return /* @__PURE__ */ jsx10(Text8, { color: color || "yellow", children: FRAMES[index] });
 });
 
 // src/platform/tui/components/status/RetryView.tsx
-import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
 var RetryView = ({ retryState }) => {
   const truncateError = (err) => {
     return err.length > DISPLAY_LIMITS.RETRY_ERROR_PREVIEW ? err.substring(0, DISPLAY_LIMITS.RETRY_ERROR_TRUNCATED) + "..." : err;
   };
-  return /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", height: 2, children: [
-    /* @__PURE__ */ jsxs8(Box9, { children: [
-      /* @__PURE__ */ jsx11(Text10, { color: THEME.yellow, wrap: "truncate", children: /* @__PURE__ */ jsx11(StarSpinner, { color: THEME.yellow }) }),
-      /* @__PURE__ */ jsxs8(Text10, { color: THEME.yellow, bold: true, wrap: "truncate", children: [
+  return /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", height: 2, children: [
+    /* @__PURE__ */ jsxs7(Box9, { children: [
+      /* @__PURE__ */ jsx11(Text9, { color: THEME.yellow, wrap: "truncate", children: /* @__PURE__ */ jsx11(StarSpinner, { color: THEME.yellow }) }),
+      /* @__PURE__ */ jsxs7(Text9, { color: THEME.yellow, bold: true, wrap: "truncate", children: [
         " \u29F3 Retry #",
         retryState.attempt,
         "/",
         retryState.maxRetries
       ] }),
-      /* @__PURE__ */ jsxs8(Text10, { color: THEME.gray, wrap: "truncate", children: [
+      /* @__PURE__ */ jsxs7(Text9, { color: THEME.gray, wrap: "truncate", children: [
         " \u2014 ",
         retryState.countdown,
         "s"
       ] })
     ] }),
-    /* @__PURE__ */ jsx11(Box9, { children: /* @__PURE__ */ jsxs8(Text10, { color: THEME.gray, wrap: "truncate", children: [
+    /* @__PURE__ */ jsx11(Box9, { children: /* @__PURE__ */ jsxs7(Text9, { color: THEME.gray, wrap: "truncate", children: [
       "  ",
       truncateError(retryState.error)
     ] }) })
@@ -16948,11 +16935,11 @@ var RetryView = ({ retryState }) => {
 };
 
 // src/platform/tui/components/status/ProcessingView.tsx
-import { Box as Box10, Text as Text12 } from "ink";
+import { Box as Box10, Text as Text11 } from "ink";
 
 // src/platform/tui/components/ShimmerText.tsx
 import { memo as memo9 } from "react";
-import { Text as Text11 } from "ink";
+import { Text as Text10 } from "ink";
 import { jsx as jsx12 } from "react/jsx-runtime";
 var WAVE_SPEED = 0.25 * (120 / ANIM_TICK_MS);
 var CHAR_PHASE_GAP = 0.55;
@@ -16965,16 +16952,16 @@ function sinToColor(sin) {
 var ShimmerText = memo9(({ children, bold, phase = 0 }) => {
   const tick = useAnimationTick();
   const globalPhase = tick * WAVE_SPEED + phase;
-  return /* @__PURE__ */ jsx12(Text11, { bold, children: Array.from(children).map((char, i) => {
+  return /* @__PURE__ */ jsx12(Text10, { bold, children: Array.from(children).map((char, i) => {
     const charPhase = globalPhase - i * CHAR_PHASE_GAP;
     const sin = Math.sin(charPhase);
     const color = sinToColor(sin);
-    return /* @__PURE__ */ jsx12(Text11, { color, children: char }, i);
+    return /* @__PURE__ */ jsx12(Text10, { color, children: char }, i);
   }) });
 });
 
 // src/platform/tui/components/status/ProcessingView.tsx
-import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
 var ProcessingView = ({
   statusMain,
   detailText,
@@ -16993,26 +16980,26 @@ var ProcessingView = ({
   const parenIdx = statusMain.indexOf("(");
   const shimmerPart = parenIdx > -1 ? statusMain.slice(0, parenIdx).trimEnd() : statusMain;
   const staticSuffix = parenIdx > -1 ? " " + statusMain.slice(parenIdx) : "";
-  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", height: 2, children: [
-    /* @__PURE__ */ jsxs9(Box10, { children: [
-      /* @__PURE__ */ jsx13(Text12, { color, wrap: "truncate", children: /* @__PURE__ */ jsx13(StarSpinner, { color }) }),
-      /* @__PURE__ */ jsx13(Text12, { children: " " }),
+  return /* @__PURE__ */ jsxs8(Box10, { flexDirection: "column", height: 2, children: [
+    /* @__PURE__ */ jsxs8(Box10, { children: [
+      /* @__PURE__ */ jsx13(Text11, { color, wrap: "truncate", children: /* @__PURE__ */ jsx13(StarSpinner, { color }) }),
+      /* @__PURE__ */ jsx13(Text11, { children: " " }),
       /* @__PURE__ */ jsx13(ShimmerText, { bold: true, phase: 0, children: shimmerPart }),
-      staticSuffix ? /* @__PURE__ */ jsx13(Text12, { color: THEME.dimGray, wrap: "truncate", children: staticSuffix }) : null,
-      /* @__PURE__ */ jsxs9(Text12, { color: THEME.dimGray, wrap: "truncate", children: [
+      staticSuffix ? /* @__PURE__ */ jsx13(Text11, { color: THEME.dimGray, wrap: "truncate", children: staticSuffix }) : null,
+      /* @__PURE__ */ jsxs8(Text11, { color: THEME.dimGray, wrap: "truncate", children: [
         " ",
         meta
       ] })
     ] }),
-    /* @__PURE__ */ jsx13(Box10, { children: detailText ? /* @__PURE__ */ jsxs9(Text12, { color: THEME.dimGray, wrap: "truncate", children: [
+    /* @__PURE__ */ jsx13(Box10, { children: detailText ? /* @__PURE__ */ jsxs8(Text11, { color: THEME.dimGray, wrap: "truncate", children: [
       "  ",
       detailText
-    ] }) : /* @__PURE__ */ jsx13(Text12, { children: " " }) })
+    ] }) : /* @__PURE__ */ jsx13(Text11, { children: " " }) })
   ] });
 };
 
 // src/platform/tui/components/StatusDisplay.tsx
-import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
 var StatusDisplay = memo10(({
   retryState,
   isProcessing,
@@ -17026,9 +17013,9 @@ var StatusDisplay = memo10(({
     return /* @__PURE__ */ jsx14(RetryView, { retryState });
   }
   if (isProcessing && isWaitingForInput) {
-    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", height: 2, children: [
-      /* @__PURE__ */ jsx14(Text13, { children: " " }),
-      /* @__PURE__ */ jsx14(Text13, { children: " " })
+    return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: 2, children: [
+      /* @__PURE__ */ jsx14(Text12, { children: " " }),
+      /* @__PURE__ */ jsx14(Text12, { children: " " })
     ] });
   }
   if (isProcessing) {
@@ -17047,19 +17034,19 @@ var StatusDisplay = memo10(({
       }
     );
   }
-  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", height: 2, children: [
-    /* @__PURE__ */ jsx14(Text13, { children: " " }),
-    /* @__PURE__ */ jsx14(Text13, { children: " " })
+  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: 2, children: [
+    /* @__PURE__ */ jsx14(Text12, { children: " " }),
+    /* @__PURE__ */ jsx14(Text12, { children: " " })
   ] });
 });
 
 // src/platform/tui/components/ChatInput.tsx
-import { useMemo, useCallback as useCallback9, useRef as useRef8, memo as memo11, useState as useState6, useEffect as useEffect7 } from "react";
-import { Box as Box15, Text as Text17, useInput as useInput3 } from "ink";
+import { useMemo, useCallback as useCallback7, useRef as useRef6, memo as memo11, useState as useState5, useEffect as useEffect7 } from "react";
+import { Box as Box15, Text as Text16, useInput as useInput2 } from "ink";
 
 // src/platform/tui/components/input/AutocompletePreview.tsx
-import { Box as Box12, Text as Text14 } from "ink";
-import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Box as Box12, Text as Text13 } from "ink";
+import { jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
 var AutocompletePreview = ({
   suggestions,
   clampedIdx
@@ -17067,26 +17054,26 @@ var AutocompletePreview = ({
   return /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", paddingX: 1, children: suggestions.map((cmd, i) => {
     const isSelected = i === clampedIdx;
     const argsText = cmd.args ? ` ${cmd.args}` : "";
-    return /* @__PURE__ */ jsxs11(Box12, { children: [
-      /* @__PURE__ */ jsx15(Text14, { color: isSelected ? THEME.primary : THEME.dimGray, children: isSelected ? "  \u276F " : "    " }),
-      /* @__PURE__ */ jsxs11(Text14, { color: isSelected ? THEME.white : THEME.gray, bold: isSelected, children: [
+    return /* @__PURE__ */ jsxs10(Box12, { children: [
+      /* @__PURE__ */ jsx15(Text13, { color: isSelected ? THEME.primary : THEME.dimGray, children: isSelected ? "  \u276F " : "    " }),
+      /* @__PURE__ */ jsxs10(Text13, { color: isSelected ? THEME.white : THEME.gray, bold: isSelected, children: [
         "/",
         cmd.name
       ] }),
-      /* @__PURE__ */ jsx15(Text14, { dimColor: true, color: THEME.gray, children: argsText }),
-      /* @__PURE__ */ jsxs11(Text14, { dimColor: true, color: THEME.dimGray, children: [
+      /* @__PURE__ */ jsx15(Text13, { dimColor: true, color: THEME.gray, children: argsText }),
+      /* @__PURE__ */ jsxs10(Text13, { dimColor: true, color: THEME.dimGray, children: [
         " \u2014 ",
         cmd.description
       ] }),
-      isSelected && cmd.alias && /* @__PURE__ */ jsx15(Text14, { dimColor: true, color: THEME.dimGray, children: ` (/${cmd.alias})` })
+      isSelected && cmd.alias && /* @__PURE__ */ jsx15(Text13, { dimColor: true, color: THEME.dimGray, children: ` (/${cmd.alias})` })
     ] }, cmd.name);
   }) });
 };
 
 // src/platform/tui/components/input/SecretInputArea.tsx
-import { Box as Box13, Text as Text15, useStdout } from "ink";
+import { Box as Box13, Text as Text14, useStdout } from "ink";
 import TextInput from "ink-text-input";
-import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx16, jsxs as jsxs11 } from "react/jsx-runtime";
 var OUTER_PADDING = 2;
 var SecretInputArea = ({
   inputRequest,
@@ -17097,10 +17084,10 @@ var SecretInputArea = ({
   const { stdout } = useStdout();
   const borderWidth = Math.max(10, (stdout?.columns ?? 80) - OUTER_PADDING);
   const borderLine = "\u2501".repeat(borderWidth);
-  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx16(Box13, { children: /* @__PURE__ */ jsx16(Text15, { color: THEME.yellow, children: borderLine }) }),
-    /* @__PURE__ */ jsxs12(Box13, { paddingX: 1, children: [
-      /* @__PURE__ */ jsx16(Text15, { color: THEME.yellow, bold: true, children: "\u25B8 " }),
+  return /* @__PURE__ */ jsxs11(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx16(Box13, { children: /* @__PURE__ */ jsx16(Text14, { color: THEME.yellow, children: borderLine }) }),
+    /* @__PURE__ */ jsxs11(Box13, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx16(Text14, { color: THEME.yellow, bold: true, children: "\u25B8 " }),
       /* @__PURE__ */ jsx16(
         TextInput,
         {
@@ -17112,14 +17099,14 @@ var SecretInputArea = ({
         }
       )
     ] }),
-    /* @__PURE__ */ jsx16(Box13, { children: /* @__PURE__ */ jsx16(Text15, { color: THEME.yellow, children: borderLine }) })
+    /* @__PURE__ */ jsx16(Box13, { children: /* @__PURE__ */ jsx16(Text14, { color: THEME.yellow, children: borderLine }) })
   ] });
 };
 
 // src/platform/tui/components/input/NormalInputArea.tsx
-import { Box as Box14, Text as Text16, useStdout as useStdout2 } from "ink";
+import { Box as Box14, Text as Text15, useStdout as useStdout2 } from "ink";
 import TextInput2 from "ink-text-input";
-import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+import { jsx as jsx17, jsxs as jsxs12 } from "react/jsx-runtime";
 var OUTER_PADDING2 = 2;
 var NormalInputArea = ({
   inputKey,
@@ -17131,10 +17118,10 @@ var NormalInputArea = ({
   const { stdout } = useStdout2();
   const borderWidth = Math.max(10, (stdout?.columns ?? 80) - OUTER_PADDING2);
   const borderLine = "\u2500".repeat(borderWidth);
-  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx17(Box14, { children: /* @__PURE__ */ jsx17(Text16, { dimColor: true, color: THEME.dimGray, children: borderLine }) }),
-    /* @__PURE__ */ jsxs13(Box14, { paddingX: 1, children: [
-      /* @__PURE__ */ jsx17(Text16, { color: THEME.primary, children: "\u276F " }),
+  return /* @__PURE__ */ jsxs12(Box14, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx17(Box14, { children: /* @__PURE__ */ jsx17(Text15, { dimColor: true, color: THEME.dimGray, children: borderLine }) }),
+    /* @__PURE__ */ jsxs12(Box14, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx17(Text15, { color: THEME.primary, children: "\u276F " }),
       /* @__PURE__ */ jsx17(
         TextInput2,
         {
@@ -17146,12 +17133,12 @@ var NormalInputArea = ({
         inputKey
       )
     ] }),
-    /* @__PURE__ */ jsx17(Box14, { children: /* @__PURE__ */ jsx17(Text16, { dimColor: true, color: THEME.dimGray, children: borderLine }) })
+    /* @__PURE__ */ jsx17(Box14, { children: /* @__PURE__ */ jsx17(Text15, { dimColor: true, color: THEME.dimGray, children: borderLine }) })
   ] });
 };
 
 // src/platform/tui/components/ChatInput.tsx
-import { jsx as jsx18, jsxs as jsxs14 } from "react/jsx-runtime";
+import { jsx as jsx18, jsxs as jsxs13 } from "react/jsx-runtime";
 var MAX_SUGGESTIONS = 6;
 var ChatInput = memo11(({
   value,
@@ -17171,25 +17158,25 @@ var ChatInput = memo11(({
     return getMatchingCommands(partialCmd).slice(0, MAX_SUGGESTIONS);
   }, [isSlashMode, partialCmd, hasArgs]);
   const showPreview = isSlashMode && !hasArgs && suggestions.length > 0;
-  const [selectedIdx, setSelectedIdx] = useState6(0);
+  const [selectedIdx, setSelectedIdx] = useState5(0);
   const clampedIdx = Math.min(selectedIdx, Math.max(0, suggestions.length - 1));
-  const selectedIdxRef = useRef8(clampedIdx);
+  const selectedIdxRef = useRef6(clampedIdx);
   selectedIdxRef.current = clampedIdx;
-  const suggestionsRef = useRef8(suggestions);
+  const suggestionsRef = useRef6(suggestions);
   suggestionsRef.current = suggestions;
-  const isSlashModeRef = useRef8(isSlashMode);
+  const isSlashModeRef = useRef6(isSlashMode);
   isSlashModeRef.current = isSlashMode;
-  const hasArgsRef = useRef8(hasArgs);
+  const hasArgsRef = useRef6(hasArgs);
   hasArgsRef.current = hasArgs;
-  const showPreviewRef = useRef8(showPreview);
+  const showPreviewRef = useRef6(showPreview);
   showPreviewRef.current = showPreview;
-  const inputRequestRef = useRef8(inputRequest);
+  const inputRequestRef = useRef6(inputRequest);
   inputRequestRef.current = inputRequest;
-  const onChangeRef = useRef8(onChange);
+  const onChangeRef = useRef6(onChange);
   onChangeRef.current = onChange;
-  const [pastedHint, setPastedHint] = useState6(null);
-  const prevValueRef = useRef8(value);
-  const pasteTimerRef = useRef8(null);
+  const [pastedHint, setPastedHint] = useState5(null);
+  const prevValueRef = useRef6(value);
+  const pasteTimerRef = useRef6(null);
   useEffect7(() => {
     const diff = value.length - prevValueRef.current.length;
     if (diff > 20) {
@@ -17202,8 +17189,8 @@ var ChatInput = memo11(({
       if (pasteTimerRef.current) clearTimeout(pasteTimerRef.current);
     };
   }, [value]);
-  const [inputKey, setInputKey] = useState6(0);
-  const completeCommand = useCallback9((idx) => {
+  const [inputKey, setInputKey] = useState5(0);
+  const completeCommand = useCallback7((idx) => {
     const sug = suggestionsRef.current;
     if (!sug.length) return;
     const best = sug[Math.min(idx, sug.length - 1)];
@@ -17213,9 +17200,9 @@ var ChatInput = memo11(({
     setSelectedIdx(0);
     setInputKey((k) => k + 1);
   }, []);
-  const onSubmitRef = useRef8(onSubmit);
+  const onSubmitRef = useRef6(onSubmit);
   onSubmitRef.current = onSubmit;
-  const wrappedOnSubmit = useCallback9((val) => {
+  const wrappedOnSubmit = useCallback7((val) => {
     if (showPreviewRef.current) {
       const sug = suggestionsRef.current;
       if (!sug.length) {
@@ -17234,7 +17221,7 @@ var ChatInput = memo11(({
     }
     onSubmitRef.current(val);
   }, [completeCommand]);
-  useInput3(useCallback9((_input, key) => {
+  useInput2(useCallback7((_input, key) => {
     if (inputRequestRef.current.status === "active") return;
     const sug = suggestionsRef.current;
     const visible = showPreviewRef.current;
@@ -17250,7 +17237,7 @@ var ChatInput = memo11(({
       completeCommand(selectedIdxRef.current);
     }
   }, [completeCommand]));
-  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs13(Box15, { flexDirection: "column", children: [
     showPreview && /* @__PURE__ */ jsx18(
       AutocompletePreview,
       {
@@ -17282,14 +17269,14 @@ var ChatInput = memo11(({
         }
       )
     ),
-    pastedHint && /* @__PURE__ */ jsx18(Box15, { paddingX: 2, children: /* @__PURE__ */ jsx18(Text17, { dimColor: true, color: THEME.dimGray, children: pastedHint }) })
+    pastedHint && /* @__PURE__ */ jsx18(Box15, { paddingX: 2, children: /* @__PURE__ */ jsx18(Text16, { dimColor: true, color: THEME.dimGray, children: pastedHint }) })
   ] });
 });
 
 // src/platform/tui/components/footer.tsx
 import { memo as memo12 } from "react";
-import { Box as Box16, Text as Text18 } from "ink";
-import { jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
+import { Box as Box16, Text as Text17 } from "ink";
+import { jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
 var CTX_WARN_THRESHOLD = 0.8;
 var MAX_CONTEXT_TOKENS = LLM_LIMITS.streamMaxTokens;
 var formatElapsed = (totalSeconds) => {
@@ -17305,7 +17292,7 @@ var formatElapsed = (totalSeconds) => {
 var Footer = memo12(({ phase, targets, findings, todo, elapsedTime, isProcessing, totalTokens, turnCount }) => {
   const ctxPct = totalTokens > 0 ? Math.round(totalTokens / MAX_CONTEXT_TOKENS * 100) : 0;
   const ctxColor = ctxPct >= CTX_WARN_THRESHOLD * 100 ? THEME.yellow : THEME.dimGray;
-  return /* @__PURE__ */ jsxs15(
+  return /* @__PURE__ */ jsxs14(
     Box16,
     {
       width: "100%",
@@ -17313,44 +17300,44 @@ var Footer = memo12(({ phase, targets, findings, todo, elapsedTime, isProcessing
       justifyContent: "space-between",
       overflow: "hidden",
       children: [
-        /* @__PURE__ */ jsxs15(Box16, { gap: 2, children: [
-          /* @__PURE__ */ jsxs15(Text18, { color: THEME.gray, children: [
+        /* @__PURE__ */ jsxs14(Box16, { gap: 2, children: [
+          /* @__PURE__ */ jsxs14(Text17, { color: THEME.gray, children: [
             "Phase: ",
-            /* @__PURE__ */ jsx19(Text18, { color: THEME.white, children: phase })
+            /* @__PURE__ */ jsx19(Text17, { color: THEME.white, children: phase })
           ] }),
-          /* @__PURE__ */ jsxs15(Text18, { color: THEME.gray, children: [
+          /* @__PURE__ */ jsxs14(Text17, { color: THEME.gray, children: [
             "Targets: ",
-            /* @__PURE__ */ jsx19(Text18, { color: THEME.white, children: targets })
+            /* @__PURE__ */ jsx19(Text17, { color: THEME.white, children: targets })
           ] }),
-          /* @__PURE__ */ jsxs15(Text18, { color: THEME.gray, children: [
+          /* @__PURE__ */ jsxs14(Text17, { color: THEME.gray, children: [
             "Findings: ",
-            /* @__PURE__ */ jsx19(Text18, { color: THEME.white, children: findings })
+            /* @__PURE__ */ jsx19(Text17, { color: THEME.white, children: findings })
           ] }),
-          /* @__PURE__ */ jsxs15(Text18, { color: THEME.gray, children: [
+          /* @__PURE__ */ jsxs14(Text17, { color: THEME.gray, children: [
             "Tasks: ",
-            /* @__PURE__ */ jsx19(Text18, { color: THEME.white, children: todo })
+            /* @__PURE__ */ jsx19(Text17, { color: THEME.white, children: todo })
           ] })
         ] }),
-        /* @__PURE__ */ jsxs15(Box16, { gap: 2, children: [
-          isProcessing ? /* @__PURE__ */ jsxs15(Box16, { gap: 1, children: [
-            /* @__PURE__ */ jsx19(Text18, { dimColor: true, color: THEME.dimGray, children: "[ESC] abort" }),
-            /* @__PURE__ */ jsx19(Text18, { dimColor: true, color: THEME.dimGray, children: "[^C\xD72] exit" })
-          ] }) : /* @__PURE__ */ jsx19(Text18, { dimColor: true, color: THEME.dimGray, children: "[/help] commands" }),
-          turnCount > 0 && /* @__PURE__ */ jsxs15(Text18, { dimColor: true, color: THEME.dimGray, children: [
+        /* @__PURE__ */ jsxs14(Box16, { gap: 2, children: [
+          isProcessing ? /* @__PURE__ */ jsxs14(Box16, { gap: 1, children: [
+            /* @__PURE__ */ jsx19(Text17, { dimColor: true, color: THEME.dimGray, children: "[ESC] abort" }),
+            /* @__PURE__ */ jsx19(Text17, { dimColor: true, color: THEME.dimGray, children: "[^C\xD72] exit" })
+          ] }) : /* @__PURE__ */ jsx19(Text17, { dimColor: true, color: THEME.dimGray, children: "[/help] commands" }),
+          turnCount > 0 && /* @__PURE__ */ jsxs14(Text17, { dimColor: true, color: THEME.dimGray, children: [
             "turn:",
             turnCount
           ] }),
-          totalTokens > 0 && /* @__PURE__ */ jsxs15(Text18, { dimColor: true, color: ctxColor, children: [
+          totalTokens > 0 && /* @__PURE__ */ jsxs14(Text17, { dimColor: true, color: ctxColor, children: [
             "ctx:",
             ctxPct,
             "%"
           ] }),
-          totalTokens > 0 && /* @__PURE__ */ jsxs15(Text18, { dimColor: true, color: THEME.dimGray, children: [
+          totalTokens > 0 && /* @__PURE__ */ jsxs14(Text17, { dimColor: true, color: THEME.dimGray, children: [
             "\u2191",
             formatTokens(totalTokens)
           ] }),
-          /* @__PURE__ */ jsx19(Text18, { color: isProcessing ? THEME.primary : THEME.gray, children: isProcessing ? "Running " : "Idle " }),
-          /* @__PURE__ */ jsx19(Text18, { color: THEME.white, children: formatElapsed(elapsedTime) })
+          /* @__PURE__ */ jsx19(Text17, { color: isProcessing ? THEME.primary : THEME.gray, children: isProcessing ? "Running " : "Idle " }),
+          /* @__PURE__ */ jsx19(Text17, { color: THEME.white, children: formatElapsed(elapsedTime) })
         ] })
       ]
     }
@@ -17359,9 +17346,9 @@ var Footer = memo12(({ phase, targets, findings, todo, elapsedTime, isProcessing
 var footer_default = Footer;
 
 // src/platform/tui/components/Modal.tsx
-import { useMemo as useMemo2, memo as memo13, useCallback as useCallback10, useRef as useRef9 } from "react";
-import { Box as Box17, Text as Text19, useStdout as useStdout3, useInput as useInput4 } from "ink";
-import { jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
+import { useMemo as useMemo2, memo as memo13, useCallback as useCallback8, useRef as useRef7 } from "react";
+import { Box as Box17, Text as Text18, useStdout as useStdout3, useInput as useInput3 } from "ink";
+import { jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
 var MODAL_TITLES = {
   findings: "\u25C8 FINDINGS \u25C8",
   graph: "\u25C8 ATTACK GRAPH \u25C8",
@@ -17374,9 +17361,9 @@ var Modal = memo13(({
   onScroll,
   onClose
 }) => {
-  const onScrollRef = useRef9(onScroll);
+  const onScrollRef = useRef7(onScroll);
   onScrollRef.current = onScroll;
-  const onCloseRef = useRef9(onClose);
+  const onCloseRef = useRef7(onClose);
   onCloseRef.current = onClose;
   const { stdout } = useStdout3();
   const terminalHeight = stdout?.rows ?? 24;
@@ -17388,7 +17375,7 @@ var Modal = memo13(({
     () => lines.slice(scrollOffset, scrollOffset + maxHeight),
     [lines, scrollOffset, maxHeight]
   );
-  useInput4(useCallback10((input, key) => {
+  useInput3(useCallback8((input, key) => {
     if (key.escape || input === "q") {
       onCloseRef.current();
     } else if (key.upArrow || input === "k") {
@@ -17405,14 +17392,14 @@ var Modal = memo13(({
   const endLine = Math.min(scrollOffset + maxHeight, totalLines);
   const scrollbarHeight = Math.max(1, Math.floor(maxHeight * (maxHeight / Math.max(totalLines, 1))));
   const scrollbarPosition = totalLines > maxHeight ? Math.floor(scrollOffset / (totalLines - maxHeight) * (maxHeight - scrollbarHeight)) : 0;
-  return /* @__PURE__ */ jsxs16(
+  return /* @__PURE__ */ jsxs15(
     Box17,
     {
       flexDirection: "column",
       width: terminalWidth,
       height: terminalHeight,
       children: [
-        /* @__PURE__ */ jsx20(Box17, { justifyContent: "center", marginBottom: 0, children: /* @__PURE__ */ jsx20(Text19, { color: THEME.cyan, bold: true, children: (() => {
+        /* @__PURE__ */ jsx20(Box17, { justifyContent: "center", marginBottom: 0, children: /* @__PURE__ */ jsx20(Text18, { color: THEME.cyan, bold: true, children: (() => {
           const title = MODAL_TITLES[type];
           const sideWidth = Math.max(3, Math.floor((terminalWidth - title.length - 2) / 2));
           return `${"\u2500".repeat(sideWidth)} ${title} ${"\u2500".repeat(sideWidth)}`;
@@ -17427,17 +17414,17 @@ var Modal = memo13(({
             flexGrow: 1,
             children: visibleLines.map((line, i) => {
               const showScrollbar = totalLines > maxHeight && i >= scrollbarPosition && i < scrollbarPosition + scrollbarHeight;
-              return /* @__PURE__ */ jsxs16(Box17, { children: [
-                /* @__PURE__ */ jsx20(Text19, { color: THEME.white, wrap: "truncate", children: line }),
+              return /* @__PURE__ */ jsxs15(Box17, { children: [
+                /* @__PURE__ */ jsx20(Text18, { color: THEME.white, wrap: "truncate", children: line }),
                 /* @__PURE__ */ jsx20(Box17, { flexGrow: 1 }),
-                totalLines > maxHeight && /* @__PURE__ */ jsx20(Text19, { color: showScrollbar ? THEME.cyan : THEME.dimGray, children: showScrollbar ? "\u2588" : "\u2502" })
+                totalLines > maxHeight && /* @__PURE__ */ jsx20(Text18, { color: showScrollbar ? THEME.cyan : THEME.dimGray, children: showScrollbar ? "\u2588" : "\u2502" })
               ] }, i);
             })
           }
         ),
-        /* @__PURE__ */ jsxs16(Box17, { justifyContent: "space-between", paddingX: 1, children: [
-          /* @__PURE__ */ jsx20(Text19, { dimColor: true, color: THEME.gray, children: "\u2191\u2193/jk: scroll | g/G: top/bottom | ESC/q: close" }),
-          /* @__PURE__ */ jsxs16(Text19, { dimColor: true, color: THEME.cyan, children: [
+        /* @__PURE__ */ jsxs15(Box17, { justifyContent: "space-between", paddingX: 1, children: [
+          /* @__PURE__ */ jsx20(Text18, { dimColor: true, color: THEME.gray, children: "\u2191\u2193/jk: scroll | g/G: top/bottom | ESC/q: close" }),
+          /* @__PURE__ */ jsxs15(Text18, { dimColor: true, color: THEME.cyan, children: [
             startLine,
             "-",
             endLine,
@@ -17452,7 +17439,7 @@ var Modal = memo13(({
 
 // src/platform/tui/components/app/bottom-region.tsx
 import { Box as Box18 } from "ink";
-import { jsx as jsx21, jsxs as jsxs17 } from "react/jsx-runtime";
+import { jsx as jsx21, jsxs as jsxs16 } from "react/jsx-runtime";
 var BottomRegion = ({
   input,
   setInput,
@@ -17476,7 +17463,7 @@ var BottomRegion = ({
   const suggestionCount = isSlashMode && !hasArgs && inputRequest.status !== "active" ? Math.min(getMatchingCommands(partialCmd).length, MAX_SUGGESTIONS) : 0;
   const previewHeight = suggestionCount;
   const bottomMinHeight = 7;
-  return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", minHeight: bottomMinHeight, children: [
+  return /* @__PURE__ */ jsxs16(Box18, { flexDirection: "column", minHeight: bottomMinHeight, children: [
     /* @__PURE__ */ jsx21(
       StatusDisplay,
       {
@@ -17517,16 +17504,16 @@ var BottomRegion = ({
 };
 
 // src/platform/tui/app.tsx
-import { jsx as jsx22, jsxs as jsxs18 } from "react/jsx-runtime";
+import { jsx as jsx22, jsxs as jsxs17 } from "react/jsx-runtime";
 var MODEL_NAME = getModel() || DEFAULT_MODEL;
 var App = ({ autoApprove = false, target }) => {
   const { exit } = useApp();
   const { stdout } = useStdout4();
   const terminalWidth = stdout?.columns ?? 80;
-  const [input, setInput] = useState7("");
-  const [secretInput, setSecretInput] = useState7("");
-  const [autoApproveMode, setAutoApproveMode] = useState7(autoApprove);
-  const [modal, setModal] = useState7({ type: null, content: "", scrollOffset: 0 });
+  const [input, setInput] = useState6("");
+  const [secretInput, setSecretInput] = useState6("");
+  const [autoApproveMode, setAutoApproveMode] = useState6(autoApprove);
+  const [modal, setModal] = useState6({ type: null, content: "", scrollOffset: 0 });
   const {
     agent,
     messages,
@@ -17546,37 +17533,26 @@ var App = ({ autoApprove = false, target }) => {
     addMessage,
     refreshStats
   } = useAgent(autoApproveMode, target);
-  const isProcessingRef = useRef10(isProcessing);
+  const isProcessingRef = useRef8(isProcessing);
   isProcessingRef.current = isProcessing;
-  const autoApproveModeRef = useRef10(autoApproveMode);
+  const autoApproveModeRef = useRef8(autoApproveMode);
   autoApproveModeRef.current = autoApproveMode;
-  const inputRequestRef = useRef10(inputRequest);
+  const inputRequestRef = useRef8(inputRequest);
   inputRequestRef.current = inputRequest;
-  const isModalOpenRef = useRef10(!!modal.type);
+  const isModalOpenRef = useRef8(!!modal.type);
   isModalOpenRef.current = !!modal.type;
-  const inputRef = useRef10(input);
+  const inputRef = useRef8(input);
   inputRef.current = input;
-  const clearInput = useCallback11(() => {
+  const clearInput = useCallback9(() => {
     setInput("");
   }, []);
-  const [historyScrollOffset, setHistoryScrollOffset] = useState7(0);
-  const handleScroll = useCallback11((delta) => {
-    setHistoryScrollOffset((prev) => Math.max(0, prev - delta));
-  }, []);
-  const messageCountRef = useRef10(messages.length);
-  if (messages.length !== messageCountRef.current) {
-    messageCountRef.current = messages.length;
-    if (historyScrollOffset > 0) {
-      setHistoryScrollOffset(0);
-    }
-  }
-  const showModal = useCallback11((type, content) => {
+  const showModal = useCallback9((type, content) => {
     setModal({ type, content, scrollOffset: 0 });
   }, []);
-  const closeModal = useCallback11(() => {
+  const closeModal = useCallback9(() => {
     setModal({ type: null, content: "", scrollOffset: 0 });
   }, []);
-  const handleModalScroll = useCallback11((delta) => {
+  const handleModalScroll = useCallback9((delta) => {
     setModal((prev) => {
       const lines = prev.content.split("\n");
       const maxHeight = (stdout?.rows ?? 24) - 6;
@@ -17585,7 +17561,7 @@ var App = ({ autoApprove = false, target }) => {
       return { ...prev, scrollOffset: newOffset };
     });
   }, [stdout?.rows]);
-  const handleExit = useCallback11(() => {
+  const handleExit = useCallback9(() => {
     const ir = inputRequestRef.current;
     if (ir.status === "active") {
       ir.resolve(null);
@@ -17608,7 +17584,7 @@ var App = ({ autoApprove = false, target }) => {
     isProcessingRef,
     autoApproveModeRef
   });
-  const handleSubmit = useCallback11(async (value) => {
+  const handleSubmit = useCallback9(async (value) => {
     const trimmed = value.trim();
     if (!trimmed) return;
     setInput("");
@@ -17623,7 +17599,7 @@ var App = ({ autoApprove = false, target }) => {
       await executeTask(trimmed);
     }
   }, [agent, addMessage, executeTask, handleCommand]);
-  const handleSecretSubmit = useCallback11((value) => {
+  const handleSecretSubmit = useCallback9((value) => {
     const ir = inputRequestRef.current;
     if (ir.status !== "active") return;
     const displayText = ir.isPassword ? "\u2022".repeat(Math.min(value.length, 20)) : value;
@@ -17641,8 +17617,7 @@ var App = ({ autoApprove = false, target }) => {
     inputRequestRef,
     isModalOpenRef,
     inputRef,
-    clearInput,
-    onScroll: handleScroll
+    clearInput
   });
   if (modal.type) {
     return /* @__PURE__ */ jsx22(Box19, { flexDirection: "column", paddingX: 1, width: terminalWidth, children: /* @__PURE__ */ jsx22(
@@ -17656,16 +17631,14 @@ var App = ({ autoApprove = false, target }) => {
       }
     ) });
   }
-  return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", paddingX: 1, width: terminalWidth, children: [
+  return /* @__PURE__ */ jsxs17(Box19, { flexDirection: "column", paddingX: 1, width: terminalWidth, children: [
     /* @__PURE__ */ jsx22(Box19, { flexDirection: "column", children: /* @__PURE__ */ jsx22(
       MessageList,
       {
         messages,
-        isModalOpen: !!modal.type,
         modelName: MODEL_NAME,
         autoApproveMode,
-        version: APP_VERSION,
-        scrollOffset: historyScrollOffset
+        version: APP_VERSION
       }
     ) }),
     /* @__PURE__ */ jsx22(