pentesting 0.72.12 → 0.73.2

package/dist/{chunk-OUS2TZXI.js → chunk-KBJPZDIL.js}

@@ -18,7 +18,7 @@ import {
   getProcessEventLog,
   logEvent,
   setProcess
-} from "./chunk-GHJPYI4S.js";
+} from "./chunk-YFDJI3GO.js";
 
 // src/shared/constants/time/conversions.ts
 var MS_PER_MINUTE = 6e4;
@@ -235,7 +235,7 @@ var INPUT_PROMPT_PATTERNS = [
 
 // src/shared/constants/agent.ts
 var APP_NAME = "Pentest AI";
-var APP_VERSION = "0.72.12";
+var APP_VERSION = "0.73.2";
 var APP_DESCRIPTION = "Autonomous Penetration Testing AI Agent";
 var LLM_ROLES = {
   SYSTEM: "system",
@@ -304,7 +304,8 @@ var PHASE_TRANSITIONS = {
   [PHASES.FORENSICS]: [PHASES.EXPLOIT, PHASES.REPORT, PHASES.PWN, PHASES.CRYPTO]
 };
 var AGENT_ROLES = {
-  ORCHESTRATOR: "orchestrator"
+  ORCHESTRATOR: "orchestrator",
+  AGENT_TOOL: "agent_tool"
 };
 
 // src/shared/constants/protocol/services.ts
@@ -619,7 +620,10 @@ var TOOL_NAMES = {
   HARVESTER: "harvester",
   SHODAN_QUERY: "shodan_query",
   CERT_TRANSPARENCY: "cert_transparency",
-  GOOGLE_DORK: "google_dork"
+  GOOGLE_DORK: "google_dork",
+  // Task Delegation (v1)
+  RUN_TASK: "run_task",
+  TASK_COMPLETE: "task_complete"
 };
 
 // src/shared/constants/attack.ts
@@ -717,7 +721,6 @@ var UI_COMMANDS = {
   LOGS: "logs",
   LOGS_SHORT: "l",
   CTF: "ctf",
-  TOR: "tor",
   AUTO: "auto",
   LAYOUT: "layout",
   GRAPH: "graph",
@@ -1919,57 +1922,6 @@ async function installTool(toolName, eventEmitter, inputHandler) {
   });
 }
 
-// src/shared/utils/config/env.ts
-var ENV_KEYS = {
-  API_KEY: "PENTEST_API_KEY",
-  BASE_URL: "PENTEST_BASE_URL",
-  MODEL: "PENTEST_MODEL",
-  SEARCH_API_KEY: "SEARCH_API_KEY",
-  SEARCH_API_URL: "SEARCH_API_URL",
-  THINKING: "PENTEST_THINKING",
-  THINKING_BUDGET: "PENTEST_THINKING_BUDGET",
-  SCOPE_MODE: "PENTEST_SCOPE_MODE",
-  APPROVAL_MODE: "PENTEST_APPROVAL_MODE",
-  APP_VERSION: "PENTESTING_VERSION"
-};
-var DEFAULT_SEARCH_API_URL = "https://api.search.brave.com/res/v1/web/search";
-var DEFAULT_MODEL = "glm-4.7";
-function getApiKey() {
-  return process.env[ENV_KEYS.API_KEY] || "";
-}
-function getBaseUrl() {
-  return process.env[ENV_KEYS.BASE_URL] || void 0;
-}
-function getModel() {
-  return process.env[ENV_KEYS.MODEL] || "";
-}
-function getSearchApiKey() {
-  if (process.env[ENV_KEYS.SEARCH_API_KEY]) {
-    return process.env[ENV_KEYS.SEARCH_API_KEY];
-  }
-  return process.env[ENV_KEYS.API_KEY];
-}
-function getSearchApiUrl() {
-  return process.env[ENV_KEYS.SEARCH_API_URL] || DEFAULT_SEARCH_API_URL;
-}
-function isZaiProvider() {
-  const baseUrl = getBaseUrl() || "";
-  return baseUrl.includes("z.ai");
-}
-function isThinkingEnabled() {
-  return process.env[ENV_KEYS.THINKING] !== "false";
-}
-function getThinkingBudget() {
-  const val = parseInt(process.env[ENV_KEYS.THINKING_BUDGET] || "", 10);
-  return isNaN(val) ? 8e3 : Math.max(1024, val);
-}
-function getScopeMode() {
-  return process.env[ENV_KEYS.SCOPE_MODE] === "enforce" ? "enforce" : "advisory";
-}
-function getApprovalMode() {
-  return process.env[ENV_KEYS.APPROVAL_MODE] === "require_auto_approve" ? "require_auto_approve" : "advisory";
-}
-
 // src/shared/utils/config/tor/core.ts
 var TOR_PROXY = {
   /** SOCKS5 proxy host (Tor daemon listens here) */
@@ -2068,31 +2020,10 @@ function checkTorLeakRisk(command) {
   return { safe: true };
 }
 
-// src/shared/utils/config/validation.ts
-function validateRequiredConfig() {
-  const errors = [];
-  if (!getApiKey()) {
-    errors.push(
-      `[config] PENTEST_API_KEY is required.
-  Export it before running:
-    export PENTEST_API_KEY=your_api_key
-  For z.ai: get your key at https://api.z.ai`
-    );
-  }
-  const budgetRaw = process.env[ENV_KEYS.THINKING_BUDGET];
-  if (budgetRaw !== void 0 && budgetRaw !== "") {
-    const parsed = parseInt(budgetRaw, 10);
-    if (isNaN(parsed) || parsed < 1024) {
-      errors.push(
-        `[config] PENTEST_THINKING_BUDGET must be an integer \u2265 1024 (got: "${budgetRaw}")`
-      );
-    }
-  }
-  return errors;
-}
-
 // src/engine/tools-base/command-executor/internal.ts
 import { spawn as spawn3 } from "child_process";
+
+// src/engine/tools-base/command-executor/preparer.ts
 function injectCurlMaxTime(command, timeoutSec) {
   if (!/\bcurl\b/.test(command)) return command;
   if (/--max-time\b|-m\s+\d/.test(command)) return command;
@@ -2110,45 +2041,38 @@ 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);
+  return {
+    safeCommand,
+    execCommand: wrapCommandForTor(safeCommand)
+  };
 }
+
+// src/engine/tools-base/command-executor/io-handler.ts
 var ProcessIOHandler = class {
-  constructor(child, processState, eventEmitter, inputHandler) {
-    this.child = child;
-    this.processState = processState;
-    this.eventEmitter = eventEmitter;
-    this.inputHandler = inputHandler;
+  constructor(ctx) {
+    this.ctx = ctx;
   }
   stdout = "";
   stderr = "";
   inputHandled = false;
+  /**
+   * Checks if the data contains a known input prompt pattern.
+   * If found, it invokes the inputHandler and writes to stdin.
+   */
   async checkForInputPrompt(data) {
-    if (this.inputHandled || !this.inputHandler || this.processState.terminated) return;
+    if (this.inputHandled || !this.ctx.inputHandler || this.ctx.processState.terminated) return;
     for (const pattern of INPUT_PROMPT_PATTERNS) {
       if (pattern.test(data)) {
         this.inputHandled = true;
-        this.eventEmitter?.({
+        this.ctx.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");
+          const userInput = await this.ctx.inputHandler(data.trim());
+          if (userInput !== null && !this.ctx.processState.terminated && this.ctx.child.stdin?.writable) {
+            this.ctx.child.stdin.write(userInput + "\n");
           }
         } catch {
         }
@@ -2156,6 +2080,9 @@ var ProcessIOHandler = class {
       }
     }
   }
+  /**
+   * Handles a chunk of stdout data.
+   */
   handleStdout(data) {
     const text = data.toString();
     this.stdout += text;
@@ -2164,13 +2091,16 @@ var ProcessIOHandler = class {
     }
     const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
     if (lines.length > 0) {
-      this.eventEmitter?.({
+      this.ctx.eventEmitter?.({
         type: COMMAND_EVENT_TYPES.COMMAND_STDOUT,
         message: lines[lines.length - 1]
       });
     }
     this.checkForInputPrompt(text);
   }
+  /**
+   * Handles a chunk of stderr data.
+   */
   handleStderr(data) {
     const text = data.toString();
     this.stderr += text;
@@ -2180,6 +2110,23 @@ var ProcessIOHandler = class {
     this.checkForInputPrompt(text);
   }
 };
+
+// src/engine/tools-base/command-executor/internal.ts
+function setupTimeout(child, timeoutMs, onTimeout) {
+  return setTimeout(() => {
+    onTimeout();
+    try {
+      if (child.pid) {
+        process.kill(-child.pid, "SIGKILL");
+      }
+    } catch {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+  }, timeoutMs);
+}
 async function executeCommandOnce(command, options = {}) {
   return new Promise((resolve) => {
     const eventEmitter = getEventEmitter();
@@ -2202,7 +2149,12 @@ async function executeCommandOnce(command, options = {}) {
       processState.timedOut = true;
       processState.terminated = true;
     });
-    const ioHandler = new ProcessIOHandler(child, processState, eventEmitter, getInputHandler());
+    const ioHandler = new ProcessIOHandler({
+      child,
+      processState,
+      eventEmitter,
+      inputHandler: getInputHandler()
+    });
     child.stdout.on("data", (d) => ioHandler.handleStdout(d));
     child.stderr.on("data", (d) => ioHandler.handleStderr(d));
     child.on("close", (code) => {
@@ -2211,7 +2163,10 @@ async function executeCommandOnce(command, options = {}) {
       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` });
+        eventEmitter?.({
+          type: COMMAND_EVENT_TYPES.COMMAND_FAILED,
+          message: `Command timed out after ${Math.round(timeoutMs / 1e3)}s`
+        });
         return resolve({
           success: false,
           output: outTrimmed,
@@ -2223,7 +2178,11 @@ ${(ioHandler.stdout + ioHandler.stderr).trim().slice(-500)}`
         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) });
+      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) => {
@@ -2647,7 +2606,7 @@ async function cleanupAllProcesses() {
     cleanupDone = false;
     return;
   }
-  const { getBackgroundProcessesMap: getBackgroundProcessesMap2 } = await import("./process-registry-CCAQVJ4Y.js");
+  const { getBackgroundProcessesMap: getBackgroundProcessesMap2 } = await import("./process-registry-GSHEX2LT.js");
   const backgroundProcesses = getBackgroundProcessesMap2();
   terminateAllNatively(backgroundProcesses, "SIGTERM");
   await new Promise((r) => setTimeout(r, SYSTEM_LIMITS.CLEANUP_BATCH_WAIT_MS));
@@ -2830,6 +2789,799 @@ function registerExitHandlers(processMap) {
 // src/engine/process/process-manager.ts
 registerExitHandlers(getBackgroundProcessesMap());
 
+// src/shared/utils/agent-memory/types.ts
+var MEMORY_ENTRY_CATEGORIES = {
+  SUCCESS: "success",
+  FAILURE: "failure",
+  DISCOVERY: "discovery",
+  TECHNIQUE: "technique",
+  INSIGHT: "insight"
+};
+var EPISODIC_EVENT_TYPES = {
+  TOOL_SUCCESS: "tool_success",
+  TOOL_FAILURE: "tool_failure",
+  PHASE_CHANGE: "phase_change",
+  FLAG_FOUND: "flag_found",
+  ACCESS_GAINED: "access_gained",
+  VECTOR_SWITCH: "vector_switch"
+};
+
+// src/shared/utils/agent-memory/fingerprint.ts
+var WORDLIST_FLAGS = /* @__PURE__ */ new Set(["-w", "-P", "-U", "-L", "--wordlist", "--password", "--passwords", "--username", "--usernames"]);
+var PORT_FLAGS = /* @__PURE__ */ new Set(["-p", "--port"]);
+var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["python", "python3", "bash", "sh", "zsh", "node", "ruby", "perl"]);
+function stripWrappingQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function tokenizeCommand(command) {
+  const matches = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  return matches.map(stripWrappingQuotes);
+}
+function parseOptionTokens(tokens) {
+  const options = [];
+  const positionals = [];
+  for (let i = 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith("--")) {
+      const eqIndex = token.indexOf("=");
+      if (eqIndex !== -1) {
+        options.push({ flag: token.slice(0, eqIndex), value: token.slice(eqIndex + 1) });
+        continue;
+      }
+      const next = tokens[i + 1];
+      if (next && !next.startsWith("-")) {
+        options.push({ flag: token, value: next });
+        i++;
+      } else {
+        options.push({ flag: token, value: "" });
+      }
+      continue;
+    }
+    if (token.startsWith("-") && token.length > 1) {
+      const next = tokens[i + 1];
+      const expectsValue = /^-[A-Za-z]$/.test(token) || /^-[a-z]{2,}$/.test(token);
+      const canConsumeNext = expectsValue && next && !next.startsWith("-");
+      if (canConsumeNext) {
+        options.push({ flag: token, value: next });
+        i++;
+      } else {
+        options.push({ flag: token, value: "" });
+      }
+      continue;
+    }
+    positionals.push(token);
+  }
+  return { options, positionals };
+}
+function findOptionValue(options, flags) {
+  return options.find((option) => flags.has(option.flag))?.value || "";
+}
+function buildOptionSignature(options, positionals, effectiveTool) {
+  const entries = options.filter((option) => !WORDLIST_FLAGS.has(option.flag) && !PORT_FLAGS.has(option.flag)).map((option) => option.value ? `${option.flag}=${option.value}` : option.flag);
+  if (SCRIPT_RUNNERS.has(effectiveTool) && positionals.length > 0) {
+    entries.push(`script=${positionals[0]}`);
+  }
+  return Array.from(new Set(entries)).sort().join(" ");
+}
+function extractFingerprint(tool, command) {
+  const cmd = command || "";
+  const tokens = tokenizeCommand(cmd);
+  let effectiveTool = tool.toLowerCase();
+  if (effectiveTool === "run_cmd" || effectiveTool === "run_background") {
+    const firstWord = tokens[0];
+    if (firstWord && !firstWord.startsWith("-")) {
+      effectiveTool = firstWord.toLowerCase();
+    }
+  }
+  const { options, positionals } = parseOptionTokens(tokens);
+  const targetMatch = cmd.match(
+    /(?::\/\/|@)([\w.\-]+(?::\d+)?)|\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(?::\d+)?\b/
+  );
+  const target = targetMatch?.[1] || targetMatch?.[2] || "";
+  const wordlist = findOptionValue(options, WORDLIST_FLAGS);
+  const port = findOptionValue(options, PORT_FLAGS);
+  const flags = buildOptionSignature(options, positionals, effectiveTool);
+  return { tool: effectiveTool, target, wordlist, flags, port };
+}
+function fingerprintsMatch(a, b) {
+  return a.tool === b.tool && a.target === b.target && a.wordlist === b.wordlist && a.flags === b.flags && a.port === b.port;
+}
+function formatFingerprint(fp) {
+  const parts = [fp.tool];
+  if (fp.target) parts.push(`\u2192${fp.target}`);
+  if (fp.wordlist) parts.push(`[wordlist:${fp.wordlist.split("/").pop()}]`);
+  if (fp.port) parts.push(`[port:${fp.port}]`);
+  if (fp.flags) parts.push(`[${fp.flags}]`);
+  return parts.join(" ");
+}
+
+// src/shared/utils/agent-memory/working-memory.ts
+var PRUNE_IMPORTANCE_WEIGHT = 0.7;
+var PRUNE_RECENCY_WEIGHT = 0.3;
+var PRUNE_WINDOW_MS = 6e5;
+var WorkingMemory = class {
+  entries = [];
+  maxEntries = MEMORY_LIMITS.WORKING_MEMORY_MAX_ENTRIES;
+  add(category, content, importance = 0.5, context = {}) {
+    this.entries.push({
+      id: generatePrefixedId("wm"),
+      timestamp: Date.now(),
+      category,
+      content,
+      context,
+      importance
+    });
+    this.pruneIfNeeded();
+  }
+  /**
+   * Record a failed attempt with structured fingerprint.
+   *
+   * WHY: Fingerprint-based recording ensures that "hydra with rockyou.txt"
+   * and "hydra with darkweb2017.txt" are stored as distinct attempts.
+   * The LLM can see what parameter combinations have been tried and pick new ones.
+   */
+  recordFailure(tool, command, error, hypothesizedReason) {
+    const fp = extractFingerprint(tool, command);
+    fp.hypothesizedReason = hypothesizedReason;
+    const fpLabel = formatFingerprint(fp);
+    const entry = {
+      id: generatePrefixedId("wm"),
+      timestamp: Date.now(),
+      category: MEMORY_ENTRY_CATEGORIES.FAILURE,
+      content: `FAILED: ${fpLabel} \u2192 ${error.slice(0, DISPLAY_LIMITS.ERROR_PREVIEW)}`,
+      context: { tool, command },
+      importance: 0.8,
+      fingerprint: fp
+    };
+    this.entries.push(entry);
+    this.pruneIfNeeded();
+  }
+  /**
+   * Record a successful action for reference.
+   */
+  recordSuccess(tool, command, result) {
+    this.add(MEMORY_ENTRY_CATEGORIES.SUCCESS, `SUCCESS: ${tool} \u2192 ${command.slice(0, DISPLAY_LIMITS.COMMAND_PREVIEW)}`, 0.6, { tool, result: result.slice(0, DISPLAY_LIMITS.OUTPUT_SUMMARY) });
+  }
+  /**
+   * Check if the EXACT same attack attempt (all parameters identical) has failed.
+   *
+   * WHY: Only blocks truly duplicate attempts. Different wordlists, flags, or
+   * ports are treated as new attacks and allowed through.
+   */
+  hasFailedBefore(command, tool) {
+    const effectiveTool = tool || command.split(/\s+/)[0] || "";
+    const fp = extractFingerprint(effectiveTool, command);
+    return this.entries.find(
+      (e) => e.category === MEMORY_ENTRY_CATEGORIES.FAILURE && e.fingerprint != null && fingerprintsMatch(e.fingerprint, fp)
+    );
+  }
+  /**
+   * 사후 보완: Analyst가 분류한 hypothesizedReason을 기존 실패 항목에 추가한다.
+   *
+   * WHY: pipeline.ts에서 recordFailure()가 먼저 호출되고, Analyst 분석은
+   * 비동기로 나중에 완료된다. command 매칭으로 최근 실패 fingerprint를 찾아
+   * hypothesizedReason을 보완한다. 기존 reason이 있으면 덮어쓰지 않는다.
+   */
+  updateLastFailureReason(command, hypothesizedReason) {
+    const effectiveTool = command.split(/\s+/)[0] || "";
+    const fp = extractFingerprint(effectiveTool, command);
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const entry = this.entries[i];
+      if (entry.category === MEMORY_ENTRY_CATEGORIES.FAILURE && entry.fingerprint && fingerprintsMatch(entry.fingerprint, fp)) {
+        if (!entry.fingerprint.hypothesizedReason) {
+          entry.fingerprint.hypothesizedReason = hypothesizedReason;
+        }
+        break;
+      }
+    }
+  }
+  /** Internal prune helper (used by both add() and recordFailure()) */
+  pruneIfNeeded() {
+    if (this.entries.length > this.maxEntries) {
+      this.entries.sort((a, b) => {
+        const aScore = a.importance * PRUNE_IMPORTANCE_WEIGHT + (1 - (Date.now() - a.timestamp) / PRUNE_WINDOW_MS) * PRUNE_RECENCY_WEIGHT;
+        const bScore = b.importance * PRUNE_IMPORTANCE_WEIGHT + (1 - (Date.now() - b.timestamp) / PRUNE_WINDOW_MS) * PRUNE_RECENCY_WEIGHT;
+        return bScore - aScore;
+      });
+      this.entries = this.entries.slice(0, this.maxEntries);
+    }
+  }
+  /**
+   * Get count of consecutive failures on the SAME attack vector.
+   *
+   * WHY: Switching from "hydra with wordlist A" to "hydra with wordlist B"
+   * is a legitimate new approach. The consecutive-failure counter should
+   * only trigger when every recent attempt is against the same tool+target
+   * with no variation producing success. This prevents premature vector abandonment.
+   */
+  getConsecutiveFailures() {
+    let count = 0;
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      if (this.entries[i].category === MEMORY_ENTRY_CATEGORIES.FAILURE) count++;
+      else break;
+    }
+    return count;
+  }
+  /**
+   * Format for prompt injection.
+   */
+  toPrompt() {
+    if (this.entries.length === 0) return "";
+    const failures = this.entries.filter((e) => e.category === MEMORY_ENTRY_CATEGORIES.FAILURE);
+    const successes = this.entries.filter((e) => e.category === MEMORY_ENTRY_CATEGORIES.SUCCESS);
+    const insights = this.entries.filter((e) => e.category === MEMORY_ENTRY_CATEGORIES.INSIGHT || e.category === MEMORY_ENTRY_CATEGORIES.DISCOVERY);
+    const lines = ["<working-memory>"];
+    lines.push(...this.buildFailuresSection(failures));
+    lines.push(...this.buildSuccessesSection(successes));
+    lines.push(...this.buildInsightsSection(insights));
+    lines.push("</working-memory>");
+    return lines.join("\n");
+  }
+  buildFailuresSection(failures) {
+    if (failures.length === 0) return [];
+    const lines = [];
+    lines.push(`\u26A0\uFE0F FAILED ATTEMPTS (${failures.length} \u2014 DO NOT REPEAT EXACT SAME PARAMS):`);
+    for (const f of failures.slice(-DISPLAY_LIMITS.RECENT_FAILURES)) {
+      const fp = f.fingerprint;
+      if (fp) {
+        const reason = fp.hypothesizedReason ? ` [${fp.hypothesizedReason}]` : "";
+        lines.push(`  \u2717 ${formatFingerprint(fp)}${reason} \u2192 ${f.content.split("\u2192").pop()?.trim() || ""}`);
+      } else {
+        lines.push(`  \u2717 ${f.content}`);
+      }
+    }
+    lines.push(...this.buildAttackCoverageLines(failures));
+    const consecutiveFails = this.getConsecutiveFailures();
+    if (consecutiveFails >= MEMORY_LIMITS.CONSECUTIVE_FAIL_THRESHOLD) {
+      lines.push(`\u{1F534} ${consecutiveFails} CONSECUTIVE FAILURES \u2014 consider changing approach or parameters`);
+    }
+    return lines;
+  }
+  buildSuccessesSection(successes) {
+    if (successes.length === 0) return [];
+    const lines = [`\u2705 RECENT SUCCESSES (${successes.length}):`];
+    for (const s of successes.slice(-DISPLAY_LIMITS.RECENT_SUCCESSES)) {
+      lines.push(`  \u2713 ${s.content}`);
+    }
+    return lines;
+  }
+  buildInsightsSection(insights) {
+    if (insights.length === 0) return [];
+    const lines = ["\u{1F4A1} INSIGHTS:"];
+    for (const i of insights.slice(-DISPLAY_LIMITS.RECENT_INSIGHTS)) {
+      lines.push(`  \u2192 ${i.content}`);
+    }
+    return lines;
+  }
+  /**
+   * Build ATTACK COVERAGE lines grouped by tool+target.
+   * WHY: Shows the LLM which parameter combinations have been tried per vector,
+   * so it can pick genuinely untried variations instead of repeating.
+   */
+  buildAttackCoverageLines(failures) {
+    const vectorMap = /* @__PURE__ */ new Map();
+    for (const f of failures) {
+      if (f.fingerprint) {
+        const key = `${f.fingerprint.tool}\u2192${f.fingerprint.target}`;
+        const detail = f.fingerprint.wordlist ? f.fingerprint.wordlist.split("/").pop() || "" : f.fingerprint.flags || "default";
+        const existing = vectorMap.get(key) || [];
+        if (!existing.includes(detail)) existing.push(detail);
+        vectorMap.set(key, existing);
+      }
+    }
+    if (vectorMap.size === 0) return [];
+    const lines = [`  \u{1F4CA} ATTACK COVERAGE (tried variations):`];
+    for (const [vector, variations] of vectorMap) {
+      lines.push(`    ${vector}: tried [${variations.join(", ")}] \u2014 try DIFFERENT params`);
+    }
+    return lines;
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  /** Clear all working memory entries. */
+  clear() {
+    this.entries = [];
+  }
+};
+
+// src/shared/utils/agent-memory/episodic-memory.ts
+var EpisodicMemory = class {
+  events = [];
+  maxEvents = MEMORY_LIMITS.EPISODIC_MEMORY_MAX_EVENTS;
+  record(type, summary, details = {}) {
+    this.events.push({
+      timestamp: Date.now(),
+      type,
+      summary,
+      details
+    });
+    if (this.events.length > this.maxEvents) {
+      this.events = this.events.slice(-this.maxEvents);
+    }
+  }
+  /**
+   * Get timeline of key events (for strategic overview).
+   */
+  getTimeline() {
+    return [...this.events];
+  }
+  /**
+   * Get events of a specific type.
+   */
+  getByType(type) {
+    return this.events.filter((e) => e.type === type);
+  }
+  /**
+   * Count how many times a vector has been switched (indicator of difficulty).
+   */
+  getVectorSwitchCount() {
+    return this.events.filter((e) => e.type === EPISODIC_EVENT_TYPES.VECTOR_SWITCH).length;
+  }
+  /**
+   * Format for prompt (condensed timeline).
+   */
+  toPrompt() {
+    if (this.events.length === 0) return "";
+    const lines = ["<session-timeline>"];
+    const recent = this.events.slice(-DISPLAY_LIMITS.RECENT_MEMORY_EVENTS);
+    for (const e of recent) {
+      const mins = Math.floor((Date.now() - e.timestamp) / MS_PER_MINUTE);
+      const icon = {
+        tool_success: "\u2705",
+        tool_failure: "\u274C",
+        phase_change: "\u{1F504}",
+        flag_found: "\u{1F3C1}",
+        access_gained: "\u{1F513}",
+        vector_switch: "\u21AA\uFE0F"
+      }[e.type] || "\u2022";
+      lines.push(`  ${icon} [${mins}min ago] ${e.summary}`);
+    }
+    lines.push("</session-timeline>");
+    return lines.join("\n");
+  }
+  /** Clear all episodic events. */
+  clear() {
+    this.events = [];
+  }
+};
+
+// src/shared/utils/agent-memory/persistent-memory.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { join as join4 } from "path";
+
+// src/shared/utils/agent-memory/similarity.ts
+var JACCARD_MATCH_THRESHOLD = 0.15;
+var MIN_TOKEN_LENGTH = 2;
+function tokenize(s) {
+  return new Set(
+    s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= MIN_TOKEN_LENGTH)
+  );
+}
+function jaccardSimilarity(a, b) {
+  const setA = tokenize(a);
+  const setB = tokenize(b);
+  if (setA.size === 0 || setB.size === 0) return 0;
+  let intersection = 0;
+  for (const token of setA) {
+    if (setB.has(token)) intersection++;
+  }
+  const union = setA.size + setB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function matchesServiceProfile(serviceProfile, services) {
+  if (services.length === 0) return false;
+  const query = services.join(" ");
+  return jaccardSimilarity(serviceProfile, query) >= JACCARD_MATCH_THRESHOLD;
+}
+
+// src/shared/utils/agent-memory/session-snapshot.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync4 } from "fs";
+import { join as join3 } from "path";
+var SNAPSHOT_FILE = join3(WORKSPACE.MEMORY, SPECIAL_FILES.SESSION_SNAPSHOT);
+function saveSessionSnapshot(snapshot) {
+  try {
+    ensureDirExists(WORKSPACE.MEMORY);
+    writeFileSync4(SNAPSHOT_FILE, JSON.stringify(snapshot, null, 2));
+  } catch {
+  }
+}
+function loadSessionSnapshot() {
+  try {
+    if (existsSync6(SNAPSHOT_FILE)) {
+      return JSON.parse(readFileSync6(SNAPSHOT_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function snapshotToPrompt() {
+  const snap = loadSessionSnapshot();
+  if (!snap) return "";
+  const lines = [
+    "<session-snapshot>",
+    `TARGET: ${snap.target}  PHASE: ${snap.phase}  SAVED: ${new Date(snap.savedAt).toISOString()}`,
+    "",
+    "ACHIEVED:",
+    ...snap.achieved.map((a) => `  \u2705 ${a}`),
+    "",
+    "NEXT PRIORITIES (resume here):",
+    ...snap.next.map((n, i) => `  ${i + 1}. ${n}`)
+  ];
+  if (snap.credentials.length > 0) {
+    lines.push("", "USABLE CREDENTIALS:");
+    snap.credentials.forEach((c) => lines.push(`  \u{1F511} ${c}`));
+  }
+  if (snap.notes) {
+    lines.push("", `NOTES: ${snap.notes}`);
+  }
+  lines.push("</session-snapshot>");
+  return lines.join("\n");
+}
+function clearSessionSnapshot() {
+  try {
+    if (existsSync6(SNAPSHOT_FILE)) {
+      unlinkSync4(SNAPSHOT_FILE);
+    }
+  } catch {
+  }
+}
+
+// src/shared/utils/agent-memory/persistent-memory.ts
+var MEMORY_FILE = join4(WORKSPACE.MEMORY, SPECIAL_FILES.PERSISTENT_KNOWLEDGE);
+var MAX_PLAYBOOK_DISPLAY = 3;
+var MAX_SUCCESSFUL_TECHNIQUES = 100;
+var MAX_FAILURE_PATTERNS = 100;
+var MAX_TECH_FACTS = 200;
+var MAX_EXPLOIT_CHAINS = 50;
+var PersistentMemory = class {
+  knowledge;
+  constructor() {
+    this.knowledge = this.load();
+  }
+  /**
+   * Record a successful technique.
+   */
+  recordSuccess(service, version, technique) {
+    const existing = this.knowledge.successfulTechniques.find(
+      (t) => t.service === service && t.technique === technique
+    );
+    if (existing) {
+      existing.successCount++;
+      existing.lastUsed = Date.now();
+    } else {
+      this.knowledge.successfulTechniques.push({
+        service,
+        version,
+        technique,
+        successCount: 1,
+        lastUsed: Date.now()
+      });
+      if (this.knowledge.successfulTechniques.length > MAX_SUCCESSFUL_TECHNIQUES) {
+        this.knowledge.successfulTechniques.sort((a, b) => b.lastUsed - a.lastUsed);
+        this.knowledge.successfulTechniques = this.knowledge.successfulTechniques.slice(0, MAX_SUCCESSFUL_TECHNIQUES);
+      }
+    }
+    this.save();
+  }
+  /**
+   * Record a failure pattern to avoid.
+   */
+  recordFailurePattern(pattern, reason) {
+    const existing = this.knowledge.failurePatterns.find((f) => f.pattern === pattern);
+    if (existing) {
+      existing.avoidCount++;
+    } else {
+      this.knowledge.failurePatterns.push({ pattern, reason, avoidCount: 1 });
+      if (this.knowledge.failurePatterns.length > MAX_FAILURE_PATTERNS) {
+        this.knowledge.failurePatterns.sort((a, b) => b.avoidCount - a.avoidCount);
+        this.knowledge.failurePatterns = this.knowledge.failurePatterns.slice(0, MAX_FAILURE_PATTERNS);
+      }
+    }
+    this.save();
+  }
+  /**
+   * Learn a fact about a technology.
+   */
+  learnFact(technology, fact) {
+    if (!this.knowledge.techFacts.some((f) => f.technology === technology && f.fact === fact)) {
+      this.knowledge.techFacts.push({ technology, fact, learnedAt: Date.now() });
+      if (this.knowledge.techFacts.length > MAX_TECH_FACTS) {
+        this.knowledge.techFacts.sort((a, b) => b.learnedAt - a.learnedAt);
+        this.knowledge.techFacts = this.knowledge.techFacts.slice(0, MAX_TECH_FACTS);
+      }
+      this.save();
+    }
+  }
+  /**
+   * Get known successful techniques for a service.
+   */
+  getSuccessfulTechniques(service) {
+    return this.knowledge.successfulTechniques.filter((t) => t.service.toLowerCase().includes(service.toLowerCase())).sort((a, b) => b.successCount - a.successCount);
+  }
+  /**
+   * Clear all knowledge (for testing isolation).
+   */
+  clear() {
+    this.knowledge = { successfulTechniques: [], failurePatterns: [], techFacts: [], exploitChains: [] };
+    this.save();
+    clearSessionSnapshot();
+  }
+  /**
+   * Record a successful exploit chain for session-level reuse (CurriculumPT §).
+   *
+   * WHY: 단일 기법 저장(recordSuccess)과 달리, 체인 전체를 저장한다.
+   * 다음 세션에서 동일 서비스 스택 조우 시 체인 첫 단계부터 시도할 수 있다.
+   */
+  recordExploitChain(serviceProfile, chainSummary, toolsUsed) {
+    const existing = this.knowledge.exploitChains.find(
+      (c) => c.serviceProfile === serviceProfile && c.chainSummary === chainSummary
+    );
+    if (existing) {
+      existing.successCount++;
+      existing.lastSucceededAt = Date.now();
+    } else {
+      this.knowledge.exploitChains.push({
+        serviceProfile,
+        chainSummary,
+        toolsUsed,
+        successCount: 1,
+        lastSucceededAt: Date.now()
+      });
+      if (this.knowledge.exploitChains.length > MAX_EXPLOIT_CHAINS) {
+        this.knowledge.exploitChains.sort((a, b) => b.successCount - a.successCount);
+        this.knowledge.exploitChains = this.knowledge.exploitChains.slice(0, MAX_EXPLOIT_CHAINS);
+      }
+    }
+    this.save();
+  }
+  /**
+   * Format for prompt injection (most relevant persistent knowledge).
+   */
+  toPrompt(services) {
+    const relevant = [];
+    for (const svc of services) {
+      const techniques = this.getSuccessfulTechniques(svc);
+      if (techniques.length > 0) {
+        relevant.push(`${svc}: ${techniques.map((t) => `${t.technique} (${t.successCount}x)`).join(", ")}`);
+      }
+    }
+    const matchedChains = this.knowledge.exploitChains.filter(
+      (chain) => matchesServiceProfile(chain.serviceProfile, services)
+    ).sort((a, b) => b.successCount - a.successCount).slice(0, MAX_PLAYBOOK_DISPLAY);
+    if (relevant.length === 0 && matchedChains.length === 0) return "";
+    const sections = ["<persistent-memory>"];
+    if (relevant.length > 0) {
+      sections.push(
+        "PREVIOUSLY SUCCESSFUL TECHNIQUES:",
+        ...relevant.map((r) => `  \u{1F4DA} ${r}`)
+      );
+    }
+    if (matchedChains.length > 0) {
+      sections.push(
+        "EXPLOIT CHAIN PLAYBOOKS (matched to current target):",
+        ...matchedChains.map(
+          (c) => `  \u{1F517} [${c.serviceProfile}] ${c.chainSummary} (${c.successCount}x) tools:[${c.toolsUsed.join(",")}]`
+        )
+      );
+    }
+    sections.push("</persistent-memory>");
+    return sections.join("\n");
+  }
+  load() {
+    try {
+      if (existsSync7(MEMORY_FILE)) {
+        const data = JSON.parse(readFileSync7(MEMORY_FILE, "utf-8"));
+        return {
+          ...data,
+          exploitChains: data.exploitChains ?? []
+        };
+      }
+    } catch {
+    }
+    return { successfulTechniques: [], failurePatterns: [], techFacts: [], exploitChains: [] };
+  }
+  save() {
+    try {
+      ensureDirExists(WORKSPACE.MEMORY);
+      writeFileSync5(MEMORY_FILE, JSON.stringify(this.knowledge, null, 2));
+    } catch {
+    }
+  }
+};
+
+// src/shared/utils/agent-memory/dynamic/extraction.ts
+var KNOWN_TECHS = [
+  "apache",
+  "nginx",
+  "iis",
+  "tomcat",
+  "nodejs",
+  "express",
+  "flask",
+  "django",
+  "rails",
+  "php",
+  "wordpress",
+  "joomla",
+  "drupal",
+  "mysql",
+  "postgresql",
+  "mssql",
+  "mongodb",
+  "redis",
+  "memcached",
+  "ssh",
+  "ftp",
+  "smb",
+  "rdp",
+  "ldap",
+  "kerberos",
+  "dns",
+  "docker",
+  "kubernetes",
+  "jenkins",
+  "gitlab",
+  "grafana",
+  "spring",
+  "struts",
+  "log4j",
+  "jackson",
+  "fastjson"
+];
+var TECHNIQUE_PATTERNS = [
+  // "Step 1: ...", "1. Run ..."
+  /(?:step\s*\d+|^\d+\.\s)[:.]?\s*(.{20,150})/gim,
+  // "Exploit: ...", "Payload: ...", "Command: ..."
+  /(?:exploit|payload|command|technique|bypass|trick):\s*(.{10,150})/gi,
+  // Code blocks with commands
+  /(?:```|`)((?:curl|wget|python|nmap|sqlmap|nikto|gobuster|ffuf)\s+.{10,100})(?:```|`)/g
+];
+function extractTechnologies(query) {
+  const techs = [];
+  const lower = query.toLowerCase();
+  for (const tech of KNOWN_TECHS) {
+    if (lower.includes(tech)) techs.push(tech);
+  }
+  const versionMatch = query.match(/(\d+\.\d+(?:\.\d+)?)/);
+  if (versionMatch && techs.length > 0) {
+    techs[0] = `${techs[0]}/${versionMatch[1]}`;
+  }
+  return techs.length > 0 ? techs : ["general"];
+}
+function extractTechniquesFromText(resultText) {
+  if (!resultText || resultText.length < 50) return [];
+  const extracted = [];
+  for (const pattern of TECHNIQUE_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(resultText)) !== null && extracted.length < 5) {
+      const technique = (match[1] || match[0]).trim();
+      if (technique.length > 10 && technique.length < 200) {
+        extracted.push(technique);
+      }
+    }
+  }
+  return extracted;
+}
+
+// src/shared/utils/agent-memory/dynamic/formatter.ts
+function formatTechniquesForPrompt(techniques) {
+  if (techniques.length === 0) return "";
+  const confirmed = techniques.filter((t) => t.confidence >= CONFIDENCE_THRESHOLDS.CONFIRMED);
+  const discovered = techniques.filter((t) => t.confidence < CONFIDENCE_THRESHOLDS.CONFIRMED);
+  const lines = ["<learned-techniques>"];
+  if (confirmed.length > 0) {
+    lines.push("CONFIRMED (worked in this session):");
+    for (const t of confirmed) {
+      lines.push(`  \u2705 [${t.applicableTo.join(",")}] ${t.technique}`);
+    }
+  }
+  if (discovered.length > 0) {
+    lines.push(`DISCOVERED (${discovered.length} unverified):`);
+    for (const t of discovered.slice(0, MEMORY_LIMITS.PROMPT_UNVERIFIED_TECHNIQUES)) {
+      lines.push(`  \u{1F4A1} [${t.applicableTo.join(",")}] ${t.technique} (from: ${t.source})`);
+    }
+  }
+  lines.push("</learned-techniques>");
+  return lines.join("\n");
+}
+
+// src/shared/utils/agent-memory/dynamic/engine.ts
+var DynamicTechniqueLibrary = class {
+  techniques = [];
+  maxTechniques = MEMORY_LIMITS.DYNAMIC_TECHNIQUES_MAX;
+  /**
+   * Learn a new technique from a search result or successful exploit.
+   */
+  learn(technique) {
+    const exists = this.techniques.some(
+      (t) => t.technique.toLowerCase() === technique.technique.toLowerCase()
+    );
+    if (exists) return;
+    this.techniques.push({
+      ...technique,
+      learnedAt: Date.now()
+    });
+    if (this.techniques.length > this.maxTechniques) {
+      this.techniques.sort((a, b) => {
+        if (a.confidence !== b.confidence) return b.confidence - a.confidence;
+        return b.learnedAt - a.learnedAt;
+      });
+      this.techniques = this.techniques.slice(0, this.maxTechniques);
+    }
+  }
+  /**
+   * Extract and learn techniques from a web search result.
+   */
+  learnFromSearchResult(query, resultText) {
+    const extracted = extractTechniquesFromText(resultText);
+    if (extracted.length === 0) return;
+    const applicableTo = extractTechnologies(query);
+    for (const tech of extracted) {
+      this.learn({
+        source: `Web search: "${query}"`,
+        technique: tech,
+        applicableTo,
+        confidence: CONFIDENCE_THRESHOLDS.POSSIBLE,
+        fromQuery: query
+      });
+    }
+  }
+  /**
+   * Mark a technique as verified (it worked in practice).
+   */
+  verify(techniqueSubstring) {
+    for (const t of this.techniques) {
+      if (t.technique.toLowerCase().includes(techniqueSubstring.toLowerCase())) {
+        t.confidence = CONFIDENCE_THRESHOLDS.CONFIRMED;
+      }
+    }
+  }
+  /**
+   * Record that a technique failed in practice.
+   */
+  recordFailure(techniqueSubstring) {
+    if (!techniqueSubstring || techniqueSubstring.length < 3) return;
+    const lower = techniqueSubstring.toLowerCase();
+    this.techniques = this.techniques.filter((t) => {
+      if (t.technique.toLowerCase().includes(lower)) {
+        t.confidence -= MEMORY_LIMITS.TECHNIQUE_FAILURE_DECAY;
+        return t.confidence > MEMORY_LIMITS.TECHNIQUE_PRUNE_THRESHOLD;
+      }
+      return true;
+    });
+  }
+  /**
+   * Get techniques relevant to a specific service/technology.
+   */
+  getRelevant(service) {
+    const lower = service.toLowerCase();
+    return this.techniques.filter(
+      (t) => t.applicableTo.some((a) => a.toLowerCase().includes(lower) || lower.includes(a.toLowerCase()))
+    );
+  }
+  /**
+   * Get all learned techniques.
+   */
+  getAll() {
+    return [...this.techniques];
+  }
+  /** Clear all learned techniques. */
+  clear() {
+    this.techniques = [];
+  }
+  /**
+   * Format for prompt injection.
+   */
+  toPrompt() {
+    return formatTechniquesForPrompt(this.techniques);
+  }
+};
+
 // src/engine/state/persistence/serializer.ts
 var UNVERIFIED_CHAIN_DEPTH_THRESHOLD = 2;
 var ACTIONABLE_LOOT_TYPES = /* @__PURE__ */ new Set([
@@ -2857,7 +3609,7 @@ var StateSerializer = class {
     this.formatLoot(state3, lines);
     this.formatTodos(state3, lines);
     this.formatEnvironment(state3, lines);
-    const snapshot = state3.persistentMemory.snapshotToPrompt();
+    const snapshot = snapshotToPrompt();
     if (snapshot) lines.push(snapshot);
     lines.push(`Phase: ${state3.getPhase()}`);
     return lines.join("\n");
@@ -2993,8 +3745,8 @@ BLOCKED (leak real IP): ping, traceroute, dig, nslookup, nmap -sU`
 };
 
 // src/engine/state/persistence/saver.ts
-import { writeFileSync as writeFileSync4, readdirSync, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
-import { join as join3 } from "path";
+import { writeFileSync as writeFileSync6, readdirSync, statSync as statSync2, unlinkSync as unlinkSync5 } from "fs";
+import { join as join5 } from "path";
 function saveState(state3) {
   const sessionsDir = WORKSPACE.SESSIONS;
   ensureDirExists(sessionsDir);
@@ -3011,18 +3763,18 @@ function saveState(state3) {
     missionSummary: state3.getMissionSummary(),
     missionChecklist: state3.getMissionChecklist()
   };
-  const sessionFile = join3(sessionsDir, FILE_PATTERNS.session());
+  const sessionFile = join5(sessionsDir, FILE_PATTERNS.session());
   const json = JSON.stringify(snapshot, null, 2);
-  writeFileSync4(sessionFile, json, "utf-8");
-  const latestFile = join3(sessionsDir, "latest.json");
-  writeFileSync4(latestFile, json, "utf-8");
+  writeFileSync6(sessionFile, json, "utf-8");
+  const latestFile = join5(sessionsDir, "latest.json");
+  writeFileSync6(latestFile, json, "utf-8");
   pruneOldSessions(sessionsDir);
   return sessionFile;
 }
 function pruneOldSessions(sessionsDir) {
   try {
     const sessionFiles = readdirSync(sessionsDir).filter((f) => f.endsWith(FILE_EXTENSIONS.JSON) && f !== SPECIAL_FILES.LATEST_STATE).map((f) => {
-      const filePath = join3(sessionsDir, f);
+      const filePath = join5(sessionsDir, f);
       return {
         name: f,
         path: filePath,
@@ -3031,22 +3783,22 @@ function pruneOldSessions(sessionsDir) {
     }).sort((a, b) => b.mtime - a.mtime);
     const toDelete = sessionFiles.slice(AGENT_LIMITS.MAX_SESSION_FILES);
     for (const file of toDelete) {
-      unlinkSync4(file.path);
+      unlinkSync5(file.path);
     }
   } catch {
   }
 }
 
 // src/engine/state/persistence/loader.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
+import { join as join6 } from "path";
 function loadState(state3) {
-  const latestFile = join4(WORKSPACE.SESSIONS, "latest.json");
-  if (!existsSync6(latestFile)) {
+  const latestFile = join6(WORKSPACE.SESSIONS, "latest.json");
+  if (!existsSync8(latestFile)) {
     return false;
   }
   try {
-    const raw = readFileSync6(latestFile, "utf-8");
+    const raw = readFileSync8(latestFile, "utf-8");
     const snapshot = JSON.parse(raw);
     if (snapshot.version !== 1) {
       debugLog("general", `Unknown snapshot version: ${snapshot.version}`);
@@ -3088,7 +3840,7 @@ function loadState(state3) {
 }
 
 // src/engine/state/persistence/janitor.ts
-import { existsSync as existsSync7, rmSync } from "fs";
+import { existsSync as existsSync9, rmSync } from "fs";
 import path2 from "path";
 function clearWorkspace() {
   const cleared = [];
@@ -3106,7 +3858,7 @@ function clearWorkspace() {
   ];
   for (const dir2 of dirsToClean) {
     try {
-      if (existsSync7(dir2.path)) {
+      if (existsSync9(dir2.path)) {
         rmSync(dir2.path, { recursive: true, force: true });
         ensureDirExists(dir2.path);
         cleared.push(dir2.label);
@@ -3121,28 +3873,14 @@ function clearWorkspace() {
 export {
   ensureDirExists,
   FILE_EXTENSIONS,
-  SPECIAL_FILES,
   FILE_PATTERNS,
   WORK_DIR,
   WORKSPACE,
   initDebugLogger,
   debugLog,
   flowLog,
-  DEFAULT_MODEL,
-  getApiKey,
-  getBaseUrl,
-  getModel,
-  getSearchApiKey,
-  getSearchApiUrl,
-  isZaiProvider,
-  isThinkingEnabled,
-  getThinkingBudget,
-  getScopeMode,
-  getApprovalMode,
-  isTorEnabled,
   setTorEnabled,
   getTorBrowserArgs,
-  validateRequiredConfig,
   MS_PER_MINUTE,
   DISPLAY_LIMITS,
   RETRY_CONFIG,
@@ -3184,7 +3922,12 @@ export {
   COMMAND_EVENT_TYPES,
   UI_COMMANDS,
   generateId,
-  generatePrefixedId,
+  WorkingMemory,
+  EpisodicMemory,
+  saveSessionSnapshot,
+  snapshotToPrompt,
+  PersistentMemory,
+  DynamicTechniqueLibrary,
   createSessionRuntime,
   setActiveSessionRuntime,
   clearActiveSessionRuntime,