pentesting 0.73.3 → 0.73.4

package/dist/{chunk-UB7RW6LM.js → chunk-7E2VUIFU.js}

@@ -13,12 +13,13 @@ import {
   getAllProcesses,
   getBackgroundProcessesMap,
   getLimits,
-  getPipelineConfig,
   getProcess,
   getProcessEventLog,
+  getRequiredRuntimeSection,
+  getRuntimeSectionOr,
   logEvent,
   setProcess
-} from "./chunk-GLO6TOJN.js";
+} from "./chunk-I52SWXYV.js";
 
 // src/shared/constants/time/conversions.ts
 var MS_PER_MINUTE = 6e4;
@@ -138,6 +139,119 @@ var DISPLAY_LIMITS = {
   SESSION_VALUE_PREVIEW: 300
 };
 
+// src/shared/utils/file-ops/runtime-asset-resolver.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var RUNTIME_FILE_DIR = path.dirname(fileURLToPath(import.meta.url));
+var DIST_DIR = path.basename(RUNTIME_FILE_DIR) === "dist" ? RUNTIME_FILE_DIR : path.resolve(process.cwd(), "dist");
+function mapSourceAssetToDist(declaredPath) {
+  if (declaredPath.startsWith("src/agents/prompts/")) {
+    return path.join(DIST_DIR, "prompts", declaredPath.slice("src/agents/prompts/".length));
+  }
+  if (/^src\/domains\/[^/]+\/prompt\.md$/.test(declaredPath)) {
+    const [, domain] = declaredPath.split("/");
+    return path.join(DIST_DIR, domain, "prompt.md");
+  }
+  return null;
+}
+function getRuntimeAssetCandidates(declaredPath) {
+  const normalized = declaredPath.replace(/\\/g, "/").replace(/\/+$/, "");
+  const candidates = [path.resolve(process.cwd(), normalized)];
+  const distCandidate = mapSourceAssetToDist(normalized);
+  if (distCandidate) {
+    candidates.push(distCandidate);
+  }
+  return [...new Set(candidates)];
+}
+function resolveRuntimeAssetPath(declaredPath) {
+  for (const candidate of getRuntimeAssetCandidates(declaredPath)) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function readRuntimeAssetFile(declaredPath, encoding = "utf-8") {
+  const resolved = resolveRuntimeAssetPath(declaredPath);
+  if (!resolved) {
+    return null;
+  }
+  return readFileSync(resolved, encoding);
+}
+
+// src/agents/llm-node-config.ts
+var RUNTIME_CONFIG_PATH = "src/agents/runtime-config.ts";
+function buildMissingNodeError(nodeName) {
+  return new Error(
+    `[runtime-config] llm_nodes.${nodeName} is not declared. Add it to ${RUNTIME_CONFIG_PATH}.`
+  );
+}
+function buildMissingPromptError(nodeName) {
+  return new Error(
+    `[runtime-config] llm_nodes.${nodeName} must declare system_prompt_file, fallback_system_prompt_file, or system_prompt. Add one to ${RUNTIME_CONFIG_PATH}.`
+  );
+}
+function buildMissingCooldownPolicyError(nodeName) {
+  return new Error(
+    `[runtime-config] llm_nodes.${nodeName}.cooldown_policy is required but not set. Add it to ${RUNTIME_CONFIG_PATH}.`
+  );
+}
+function resolvePromptFile(declaredPath, context) {
+  const content = readRuntimeAssetFile(declaredPath, "utf-8");
+  if (content === null) {
+    throw new Error(
+      `[runtime-config] ${context} points to "${declaredPath}" but no runtime asset was found. Tried: ${getRuntimeAssetCandidates(declaredPath).join(", ")}`
+    );
+  }
+  return content.trim();
+}
+function resolveInlinePrompt(prompt2) {
+  return prompt2 ? prompt2.trim() : void 0;
+}
+function resolveConfiguredPrompt(nodeName, nodeConfig) {
+  if (nodeConfig.system_prompt_file) {
+    return resolvePromptFile(
+      nodeConfig.system_prompt_file,
+      `llm_nodes.${nodeName}.system_prompt_file`
+    );
+  }
+  if (nodeConfig.fallback_system_prompt_file) {
+    return resolvePromptFile(
+      nodeConfig.fallback_system_prompt_file,
+      `llm_nodes.${nodeName}.fallback_system_prompt_file`
+    );
+  }
+  return resolveInlinePrompt(nodeConfig.system_prompt) ?? resolveInlinePrompt(nodeConfig.fallback_system_prompt);
+}
+function getLlmNodeConfig(nodeName) {
+  const nodeConfig = getRequiredRuntimeSection("llm_nodes")[nodeName];
+  if (!nodeConfig) {
+    throw buildMissingNodeError(nodeName);
+  }
+  return nodeConfig;
+}
+function llmNodeSystemPrompt(nodeName) {
+  const prompt2 = resolveConfiguredPrompt(nodeName, getLlmNodeConfig(nodeName));
+  if (!prompt2) {
+    throw buildMissingPromptError(nodeName);
+  }
+  return prompt2;
+}
+function llmNodeOutputParsing(nodeName) {
+  return getLlmNodeConfig(nodeName).output_parsing;
+}
+function llmNodeCooldownPolicy(nodeName) {
+  const policy = getLlmNodeConfig(nodeName).cooldown_policy;
+  if (!policy) {
+    throw buildMissingCooldownPolicyError(nodeName);
+  }
+  return policy;
+}
+function llmNodeMaxTokens(nodeName, fallback) {
+  return getLlmNodeConfig(nodeName).limits?.max_tokens ?? fallback;
+}
+
 // src/shared/constants/llm/config.ts
 var RETRY_CONFIG = {
   baseDelayMs: 2e3,
@@ -150,9 +264,8 @@ var RETRY_CONFIG = {
   autoRetryDelayMs: 1e4
   // 10s fixed interval for 429/network errors
 };
-var config = getPipelineConfig();
-var mainLlmTokens = config.llm_nodes?.["main_llm"]?.limits?.max_tokens ?? 128e3;
-var strategistTokens = config.llm_nodes?.["strategist"]?.limits?.max_tokens ?? 262144;
+var mainLlmTokens = llmNodeMaxTokens("main_llm", 128e3);
+var strategistTokens = llmNodeMaxTokens("strategist", 262144);
 var LLM_LIMITS = {
   /** WHY 64K: non-streaming calls (orchestrator, summaries) benefit from
    *  generous output budgets. Don't force premature truncation. */
@@ -194,7 +307,7 @@ var AGENT_LIMITS = {
   MAX_FAILED_PATHS: state.max_failed_paths,
   MAX_ATTACK_NODES: state.max_attack_nodes,
   MAX_ATTACK_EDGES: state.max_attack_edges,
-  // ─── Fixed Infrastructure Constants (not tunable via yaml) ───
+  // ─── Fixed Infrastructure Constants (not tunable via runtime config) ───
   /** Infinite retry on LLM errors — rate limit recovery */
   MAX_CONSECUTIVE_LLM_ERRORS: agent_loop.max_consecutive_llm_errors === "infinity" || agent_loop.max_consecutive_llm_errors === Infinity ? Infinity : Number(agent_loop.max_consecutive_llm_errors ?? Infinity),
   MAX_RETRIES: agent_loop.max_retries ?? 3,
@@ -218,7 +331,7 @@ var MEMORY_LIMITS = {
   TECHNIQUE_FAILURE_DECAY: state2.technique_failure_decay,
   TECHNIQUE_PRUNE_THRESHOLD: state2.technique_prune_threshold,
   MAX_TURN_ENTRIES: archive.max_turn_entries,
-  /** Maximum unverified techniques to show in prompt (display-only, not in yaml) */
+  /** Maximum unverified techniques to show in prompt (display-only, not in runtime config) */
   PROMPT_UNVERIFIED_TECHNIQUES: 10
 };
 
@@ -235,7 +348,7 @@ var INPUT_PROMPT_PATTERNS = [
 
 // src/shared/constants/agent.ts
 var APP_NAME = "Pentest AI";
-var APP_VERSION = "0.73.3";
+var APP_VERSION = "0.73.4";
 var APP_DESCRIPTION = "Autonomous Penetration Testing AI Agent";
 var LLM_ROLES = {
   SYSTEM: "system",
@@ -518,6 +631,7 @@ var TOOL_NAMES = {
   EXPLOIT_CREDENTIAL_CHECK: "exploit_credential_check",
   EXPLOIT_ARTIFACT_CHECK: "exploit_artifact_check",
   EXPLOIT_FOOTHOLD_CHECK: "exploit_foothold_check",
+  EXPLOIT_VECTOR_CHECK: "exploit_vector_check",
   PWN_CRASH_REPRO: "pwn_crash_repro",
   PWN_OFFSET_CHECK: "pwn_offset_check",
   PWN_PAYLOAD_SMOKE: "pwn_payload_smoke",
@@ -948,7 +1062,20 @@ function getInputHandler() {
 }
 
 // src/shared/constants/paths.ts
-import path from "path";
+import path2 from "path";
+
+// src/agents/workspace-config.ts
+var DEFAULT_WORKSPACE_ROOT = ".pentesting";
+var DEFAULT_WORKSPACE_DIRECTORIES = {};
+function getWorkspaceConfig() {
+  return getRuntimeSectionOr("workspace", {});
+}
+function getWorkspaceRoot() {
+  return getWorkspaceConfig().root ?? DEFAULT_WORKSPACE_ROOT;
+}
+function getWorkspaceDirectories() {
+  return getWorkspaceConfig().directories ?? DEFAULT_WORKSPACE_DIRECTORIES;
+}
 
 // src/shared/constants/files/extensions.ts
 var FILE_EXTENSIONS = {
@@ -995,9 +1122,9 @@ var SPECIAL_FILES = {
 };
 
 // src/shared/utils/file-ops/file-utils.ts
-import { existsSync, mkdirSync } from "fs";
+import { existsSync as existsSync2, mkdirSync } from "fs";
 function ensureDirExists(dirPath) {
-  if (!existsSync(dirPath)) {
+  if (!existsSync2(dirPath)) {
     mkdirSync(dirPath, { recursive: true });
   }
 }
@@ -1025,15 +1152,13 @@ var _dirs = null;
 var _root = null;
 function getRoot() {
   if (_root === null) {
-    const ws = getPipelineConfig().workspace;
-    _root = ws?.root ?? ".pentesting";
+    _root = getWorkspaceRoot();
   }
   return _root;
 }
 function getDirs() {
   if (_dirs === null) {
-    const ws = getPipelineConfig().workspace;
-    _dirs = ws?.directories ?? {};
+    _dirs = getWorkspaceDirectories();
   }
   return _dirs;
 }
@@ -1045,39 +1170,39 @@ var WORK_DIR = dir("workspace", `${getRoot()}/workspace`);
 var MEMORY_DIR = dir("memory", `${getRoot()}/memory`);
 var WORKSPACE = {
   get ROOT() {
-    return path.resolve(getRoot());
+    return path2.resolve(getRoot());
   },
   get TMP() {
-    return path.resolve(dir("workspace", `${getRoot()}/workspace`));
+    return path2.resolve(dir("workspace", `${getRoot()}/workspace`));
   },
   get MEMORY() {
-    return path.resolve(dir("memory", `${getRoot()}/memory`));
+    return path2.resolve(dir("memory", `${getRoot()}/memory`));
   },
   get POLICY() {
-    return path.resolve(dir("memory", `${getRoot()}/memory`), SPECIAL_FILES.POLICY);
+    return path2.resolve(dir("memory", `${getRoot()}/memory`), SPECIAL_FILES.POLICY);
   },
   get REPORTS() {
-    return path.resolve(dir("reports", `${getRoot()}/reports`));
+    return path2.resolve(dir("reports", `${getRoot()}/reports`));
   },
   get SESSIONS() {
-    return path.resolve(dir("sessions", `${getRoot()}/sessions`));
+    return path2.resolve(dir("sessions", `${getRoot()}/sessions`));
   },
   get LOOT() {
-    return path.resolve(dir("loot", `${getRoot()}/loot`));
+    return path2.resolve(dir("loot", `${getRoot()}/loot`));
   },
   get DEBUG() {
-    return path.resolve(dir("debug", `${getRoot()}/debug`));
+    return path2.resolve(dir("debug", `${getRoot()}/debug`));
   },
   /** Turn insight files root: .pentesting/turns/ */
   get TURNS() {
-    return path.resolve(dir("turns", `${getRoot()}/turns`));
+    return path2.resolve(dir("turns", `${getRoot()}/turns`));
   },
   /**
    * Resolve the turn memory file for a specific turn: .pentesting/turns/{N}-memory.md
-   * Pipeline.yaml: workspace.turn_structure → single file per turn
+   * Runtime config turn storage policy → single file per turn
    */
   turnPath(turn) {
-    return path.resolve(dir("turns", `${getRoot()}/turns`), `${turn}-memory.md`);
+    return path2.resolve(dir("turns", `${getRoot()}/turns`), `${turn}-memory.md`);
   }
 };
 
@@ -1310,7 +1435,7 @@ var BLOCKED_BINARIES = /* @__PURE__ */ new Set([
 ]);
 
 // src/shared/utils/debug/debug-logger.ts
-import { appendFileSync, writeFileSync, statSync, readFileSync } from "fs";
+import { appendFileSync, writeFileSync, statSync, readFileSync as readFileSync2 } from "fs";
 import { join } from "path";
 var ROTATE_BYTES = 5 * 1024 * 1024;
 var WIPE_BYTES = 20 * 1024 * 1024;
@@ -1362,7 +1487,7 @@ var DebugLogger = class _DebugLogger {
         writeFileSync(this.logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [GENERAL] === LOG WIPED (exceeded ${Math.round(WIPE_BYTES / 1024 / 1024)}MB) ===
 `);
       } else if (size > ROTATE_BYTES) {
-        const content = readFileSync(this.logPath, "utf-8");
+        const content = readFileSync2(this.logPath, "utf-8");
         const half = content.slice(Math.floor(content.length / 2));
         const firstNewline = half.indexOf("\n");
         const trimmed = firstNewline >= 0 ? half.slice(firstNewline + 1) : half;
@@ -2344,7 +2469,7 @@ Suggestion: ${torLeak.suggestion}`
 }
 
 // src/engine/tools-base/file-operations.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
 import { join as join2 } from "path";
 import { tmpdir } from "os";
@@ -2364,14 +2489,14 @@ function getErrorMessage(error) {
 // src/engine/tools-base/file-operations.ts
 async function readFileContent(filePath) {
   try {
-    if (!existsSync2(filePath)) {
+    if (!existsSync3(filePath)) {
       return {
         success: false,
         output: "",
         error: `File not found: ${filePath}`
       };
     }
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     return {
       success: true,
       output: content
@@ -2482,7 +2607,7 @@ function startBackgroundProcess(command, options = {}) {
 }
 
 // src/engine/process/process-interaction.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, appendFileSync as appendFileSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, appendFileSync as appendFileSync2 } from "fs";
 async function sendToProcess(processId, input, waitMs = SYSTEM_LIMITS.DEFAULT_WAIT_MS_INTERACT) {
   const proc = getProcess(processId);
   if (!proc) return { success: false, output: `Process ${processId} not found`, newOutput: "" };
@@ -2490,8 +2615,8 @@ async function sendToProcess(processId, input, waitMs = SYSTEM_LIMITS.DEFAULT_WA
   if (proc.hasExited) return { success: false, output: `Process ${processId} has exited`, newOutput: "" };
   let currentLen = 0;
   try {
-    if (existsSync3(proc.stdoutFile)) {
-      currentLen = readFileSync3(proc.stdoutFile, "utf-8").length;
+    if (existsSync4(proc.stdoutFile)) {
+      currentLen = readFileSync4(proc.stdoutFile, "utf-8").length;
     }
   } catch {
   }
@@ -2504,8 +2629,8 @@ async function sendToProcess(processId, input, waitMs = SYSTEM_LIMITS.DEFAULT_WA
   await new Promise((r) => setTimeout(r, waitMs));
   let fullStdout = "";
   try {
-    if (existsSync3(proc.stdoutFile)) {
-      fullStdout = readFileSync3(proc.stdoutFile, "utf-8");
+    if (existsSync4(proc.stdoutFile)) {
+      fullStdout = readFileSync4(proc.stdoutFile, "utf-8");
     }
   } catch {
   }
@@ -2527,7 +2652,7 @@ function promoteToShell(processId, description) {
 }
 
 // src/engine/process/process-monitor.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 function isProcessRunning(processId) {
   const proc = getProcess(processId);
   if (!proc) return false;
@@ -2540,8 +2665,8 @@ function isProcessRunning(processId) {
   proc.childPids = discoverAllDescendants(proc.pid);
   if (proc.role === PROCESS_ROLES.LISTENER) {
     try {
-      if (existsSync4(proc.stdoutFile)) {
-        const stdout = readFileSync4(proc.stdoutFile, "utf-8");
+      if (existsSync5(proc.stdoutFile)) {
+        const stdout = readFileSync5(proc.stdoutFile, "utf-8");
         if (detectConnection(stdout)) {
           promoteToShell(processId, "Reverse shell connected (auto-detected)");
           logEvent(processId, PROCESS_EVENTS.CONNECTION_DETECTED, `Connection detected on port ${proc.listeningPort}`);
@@ -2559,16 +2684,16 @@ function getProcessOutput(processId) {
   let stdout = "";
   let stderr = "";
   try {
-    if (existsSync4(proc.stdoutFile)) {
-      const content = readFileSync4(proc.stdoutFile, "utf-8");
+    if (existsSync5(proc.stdoutFile)) {
+      const content = readFileSync5(proc.stdoutFile, "utf-8");
       stdout = content.length > SYSTEM_LIMITS.MAX_STDOUT_SLICE ? `... [truncated ${content.length - SYSTEM_LIMITS.MAX_STDOUT_SLICE} chars] ...
 ` + content.slice(-SYSTEM_LIMITS.MAX_STDOUT_SLICE) : content;
     }
   } catch {
   }
   try {
-    if (existsSync4(proc.stderrFile)) {
-      const content = readFileSync4(proc.stderrFile, "utf-8");
+    if (existsSync5(proc.stderrFile)) {
+      const content = readFileSync5(proc.stderrFile, "utf-8");
       stderr = content.length > SYSTEM_LIMITS.MAX_STDERR_SLICE ? `... [truncated ${content.length - SYSTEM_LIMITS.MAX_STDERR_SLICE} chars] ...
 ` + content.slice(-SYSTEM_LIMITS.MAX_STDERR_SLICE) : content;
     }
@@ -2674,7 +2799,7 @@ async function cleanupAllProcesses() {
     cleanupDone = false;
     return;
   }
-  const { getBackgroundProcessesMap: getBackgroundProcessesMap2 } = await import("./process-registry-QIW7ZIUT.js");
+  const { getBackgroundProcessesMap: getBackgroundProcessesMap2 } = await import("./process-registry-BI7BKPHN.js");
   const backgroundProcesses = getBackgroundProcessesMap2();
   terminateAllNatively(backgroundProcesses, "SIGTERM");
   await new Promise((r) => setTimeout(r, SYSTEM_LIMITS.CLEANUP_BATCH_WAIT_MS));
@@ -2741,7 +2866,7 @@ function cleanupOrphanProcesses() {
 }
 
 // src/engine/process/resource-summary.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 function formatActiveProcesses(running, lines) {
   if (running.length === 0) return;
   lines.push(`Active Assets (${running.length}):`);
@@ -2753,8 +2878,8 @@ function formatActiveProcesses(running, lines) {
     const roleIcon = PROCESS_ICONS[p.role] || PROCESS_ICONS[PROCESS_ROLES.BACKGROUND];
     let lastOutput = "";
     try {
-      if (p.stdoutFile && existsSync5(p.stdoutFile)) {
-        const content = readFileSync5(p.stdoutFile, "utf-8");
+      if (p.stdoutFile && existsSync6(p.stdoutFile)) {
+        const content = readFileSync6(p.stdoutFile, "utf-8");
         const outputLines = content.trim().split("\n");
         lastOutput = outputLines.slice(-SYSTEM_LIMITS.RECENT_OUTPUT_LINES).join(" | ").replace(/\n/g, " ");
       }
@@ -3228,7 +3353,7 @@ var EpisodicMemory = class {
 };
 
 // src/shared/utils/agent-memory/persistent-memory.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { join as join4 } from "path";
 
 // src/shared/utils/agent-memory/similarity.ts
@@ -3257,7 +3382,7 @@ function matchesServiceProfile(serviceProfile, services) {
 }
 
 // src/shared/utils/agent-memory/session-snapshot.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7, 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) {
@@ -3269,8 +3394,8 @@ function saveSessionSnapshot(snapshot) {
 }
 function loadSessionSnapshot() {
   try {
-    if (existsSync6(SNAPSHOT_FILE)) {
-      return JSON.parse(readFileSync6(SNAPSHOT_FILE, "utf-8"));
+    if (existsSync7(SNAPSHOT_FILE)) {
+      return JSON.parse(readFileSync7(SNAPSHOT_FILE, "utf-8"));
     }
   } catch {
   }
@@ -3301,7 +3426,7 @@ function snapshotToPrompt() {
 }
 function clearSessionSnapshot() {
   try {
-    if (existsSync6(SNAPSHOT_FILE)) {
+    if (existsSync7(SNAPSHOT_FILE)) {
       unlinkSync4(SNAPSHOT_FILE);
     }
   } catch {
@@ -3451,8 +3576,8 @@ var PersistentMemory = class {
   }
   load() {
     try {
-      if (existsSync7(MEMORY_FILE)) {
-        const data = JSON.parse(readFileSync7(MEMORY_FILE, "utf-8"));
+      if (existsSync8(MEMORY_FILE)) {
+        const data = JSON.parse(readFileSync8(MEMORY_FILE, "utf-8"));
         return {
           ...data,
           exploitChains: data.exploitChains ?? []
@@ -3898,15 +4023,15 @@ function pruneOldSessions(sessionsDir) {
 }
 
 // src/engine/state/persistence/loader.ts
-import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
 import { join as join6 } from "path";
 function loadState(state3) {
   const latestFile = join6(WORKSPACE.SESSIONS, "latest.json");
-  if (!existsSync8(latestFile)) {
+  if (!existsSync9(latestFile)) {
     return false;
   }
   try {
-    const raw = readFileSync8(latestFile, "utf-8");
+    const raw = readFileSync9(latestFile, "utf-8");
     const snapshot = JSON.parse(raw);
     if (snapshot.version !== 1) {
       debugLog("general", `Unknown snapshot version: ${snapshot.version}`);
@@ -3953,8 +4078,8 @@ function loadState(state3) {
 }
 
 // src/engine/state/persistence/janitor.ts
-import { existsSync as existsSync9, rmSync } from "fs";
-import path2 from "path";
+import { existsSync as existsSync10, rmSync } from "fs";
+import path3 from "path";
 function clearWorkspace() {
   const cleared = [];
   const errors = [];
@@ -3965,13 +4090,13 @@ function clearWorkspace() {
     { path: WORKSPACE.TMP, label: "workspace/temp" },
     { path: WORKSPACE.LOOT, label: "loot" },
     { path: WORKSPACE.REPORTS, label: "reports" },
-    { path: path2.join(root, "archive"), label: "archive (historical cleanup)" },
-    { path: path2.join(root, "outputs"), label: "outputs (historical cleanup)" },
-    { path: path2.join(root, "journal"), label: "journal (historical cleanup)" }
+    { path: path3.join(root, "archive"), label: "archive (historical cleanup)" },
+    { path: path3.join(root, "outputs"), label: "outputs (historical cleanup)" },
+    { path: path3.join(root, "journal"), label: "journal (historical cleanup)" }
   ];
   for (const dir2 of dirsToClean) {
     try {
-      if (existsSync9(dir2.path)) {
+      if (existsSync10(dir2.path)) {
         rmSync(dir2.path, { recursive: true, force: true });
         ensureDirExists(dir2.path);
         cleared.push(dir2.label);
@@ -3985,6 +4110,7 @@ function clearWorkspace() {
 
 export {
   ensureDirExists,
+  getWorkspaceConfig,
   FILE_EXTENSIONS,
   FILE_PATTERNS,
   WORK_DIR,
@@ -3996,6 +4122,11 @@ export {
   getTorBrowserArgs,
   MS_PER_MINUTE,
   DISPLAY_LIMITS,
+  resolveRuntimeAssetPath,
+  readRuntimeAssetFile,
+  llmNodeSystemPrompt,
+  llmNodeOutputParsing,
+  llmNodeCooldownPolicy,
   RETRY_CONFIG,
   LLM_LIMITS,
   LLM_ERROR_TYPES,