@pensar/apex 1.7.0 → 1.8.0-canary.1db2dac9

package/build/{cli-x3k26g1t.js → cli-8e3jxvsa.js}

@@ -16,7 +16,7 @@ import {
   update,
   write,
   writeRaw
-} from "./cli-nqx9y9ds.js";
+} from "./cli-zhs8z3ay.js";
 import {
   parseTargetUrl
 } from "./cli-3y0dgy56.js";
@@ -29,7 +29,7 @@ import {
   require_tslib,
   streamResponse,
   toggleTool
-} from "./cli-rc7hyq7e.js";
+} from "./cli-f55c0xh4.js";
 import {
   _enum,
   _null,
@@ -57,15 +57,15 @@ import {
 } from "./cli-0ghkg3w6.js";
 import {
   signGatewayRequest
-} from "./cli-xtqm11qt.js";
+} from "./cli-p8zdr5yc.js";
 import {
   config,
   ensureValidToken,
   getPensarApiUrl
-} from "./cli-q2dty8g4.js";
+} from "./cli-1aswmqw0.js";
 import {
   getCurrentVersion
-} from "./cli-r879p2yz.js";
+} from "./cli-mqp1725p.js";
 import {
   __commonJS,
   __require,
@@ -110688,18 +110688,23 @@ var require_mimeScore = __commonJS((exports, module) => {
 
 // src/core/eventBus.ts
 import { EventEmitter } from "events";
-var CHILD_BUS_FORWARDED_EVENTS = [
-  "text-delta",
-  "tool-call-start",
-  "tool-call-delta",
-  "tool-call-complete",
-  "tool-result",
-  "subagent-spawn",
-  "subagent-complete",
-  "command-output",
-  "error",
-  "step-finish"
-];
+var CHILD_BUS_FORWARD_POLICY = {
+  "text-delta": "forward",
+  "tool-call-start": "forward",
+  "tool-call-delta": "forward",
+  "tool-call-complete": "forward",
+  "tool-result": "forward",
+  "subagent-spawn": "forward",
+  "subagent-complete": "forward",
+  "step-finish": "forward",
+  "command-output": "forward",
+  error: "forward",
+  "trace-record": "forward",
+  "workflow-phase-start": "parent-only",
+  "workflow-phase-complete": "parent-only",
+  "app-analysis-progress": "parent-only"
+};
+var CHILD_BUS_FORWARDED_EVENTS = Object.keys(CHILD_BUS_FORWARD_POLICY).filter((key) => CHILD_BUS_FORWARD_POLICY[key] === "forward");
 
 class AgentEventBus {
   emitter = new EventEmitter;
@@ -110730,10 +110735,10 @@ class AgentEventBus {
     return this;
   }
   static attachChild(child, parent, subagentId) {
+    if (!parent)
+      return;
     for (const key of CHILD_BUS_FORWARDED_EVENTS) {
       child.on(key, (payload) => {
-        if (!parent)
-          return;
         const p = payload;
         if (!p.subagentId) {
           parent.emit(key, { ...p, subagentId });
@@ -115782,6 +115787,32 @@ OUTPUT HANDLING:
 - The tool's timeout parameter is in SECONDS, not milliseconds
 - Good timeout examples: 30, 60, 120
 - Do NOT pass millisecond values like 30000 or 120000
+- If the tool's timeout is hit, the partial stdout the command had already
+  produced is still returned (with exit code 124). It is safe to set a
+  conservative timeout: you will not lose the bytes a fuzzer printed
+  before the kill.
+
+LONG-RUNNING FUZZERS AND SCANNERS:
+
+Wordlist fuzzers (ffuf, gobuster, dirb, wfuzz, dirsearch) and large nmap
+scans against slow targets routinely take longer than a single tool call
+should. ALWAYS bound them with their OWN internal time budget, set BELOW
+the tool's timeout, so the tool exits cleanly with full output and you
+don't have to rely on signal-based truncation.
+
+General rule: set the inner tool's runtime cap at least 5s below the
+execute_command timeout, so the tool exits gracefully and flushes its
+results to disk before any signal arrives.
+
+- ffuf: pair with -maxtime <seconds> and a sane -rate.
+  Example: ffuf -u <url>/FUZZ -w <wordlist> -maxtime 55 -rate 50
+  with the tool's timeout=60.
+- gobuster: has no -maxtime flag. Wrap with the \`timeout\` coreutils
+  command and tune --timeout / --threads.
+  Example: timeout 55 gobuster dir -u <url> -w <wordlist> --timeout 5s --threads 20
+  with the tool's timeout=60.
+- nmap: prefer --host-timeout, --max-rtt-timeout, and -T4 / --min-rate
+  to bound total runtime against slow networks.
 
 IMPORTANT: Always analyze results and adjust your approach based on findings.`,
     inputSchema: executeCommandInputSchema,
@@ -119360,7 +119391,7 @@ async function generateThreatModelForEndpoint(ctx, input) {
   return threatModelLimiter(async () => {
     if (ctx.abortSignal?.aborted)
       return null;
-    const { CodeAgent } = await import("./agent-63cc9rpx.js");
+    const { CodeAgent } = await import("./agent-rsvcxej9.js");
     const subagentId = `threat-model-${sanitize(input.appName)}-${sanitize(input.routePath)}`;
     ctx.eventBus?.emit("subagent-spawn", {
       subagentId,
@@ -120049,7 +120080,7 @@ When to use delegate_to_auth_subagent vs authenticate_session:
         if (credentials) {
           ctx.session.credentialManager.addFromAuthCredentials(credentials);
         }
-        const { runAuthenticationAgent } = await import("./authentication-ec7trwb4.js");
+        const { runAuthenticationAgent } = await import("./authentication-3tstyqna.js");
         const localBus = new AgentEventBus;
         AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
         const result = await runAuthenticationAgent({
@@ -120962,7 +120993,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
       });
       if (cwd) {
         try {
-          const { WhiteboxAttackSurfaceAgent } = await import("./agent-beywhvf3.js");
+          const { WhiteboxAttackSurfaceAgent } = await import("./agent-pzymaexc.js");
           const localBus = new AgentEventBus;
           AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
           const agent = new WhiteboxAttackSurfaceAgent({
@@ -121011,7 +121042,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         }
       }
       try {
-        const { BlackboxAttackSurfaceAgent } = await import("./blackboxAgent-ng2t2p2x.js");
+        const { BlackboxAttackSurfaceAgent } = await import("./blackboxAgent-z5081b7k.js");
         const localBus = new AgentEventBus;
         AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
         const agent = new BlackboxAttackSurfaceAgent({
@@ -121087,7 +121118,7 @@ Pass every target you want tested — the swarm handles concurrency automaticall
       toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing")
     }),
     execute: async ({ targets }) => {
-      const { runPentestSwarm, DEFAULT_CONCURRENCY } = await import("./pentest-4932ke3a.js");
+      const { runPentestSwarm, DEFAULT_CONCURRENCY } = await import("./pentest-277h4psc.js");
       if (!ctx.model) {
         return {
           success: false,
@@ -121215,7 +121246,7 @@ Returns an array of results with the text output from each agent.`,
   });
 }
 async function runSingleCodingAgent(ctx, codebasePath, objective, agentIndex, name) {
-  const { CodeAgent } = await import("./agent-63cc9rpx.js");
+  const { CodeAgent } = await import("./agent-rsvcxej9.js");
   const subagentId = `coding-agent-${agentIndex}`;
   ctx.eventBus?.emit("subagent-spawn", {
     subagentId,
@@ -121276,7 +121307,7 @@ Omit \`cwd\` for blackbox mode (live target probing only).`,
       toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing")
     }),
     execute: async ({ target, cwd }) => {
-      const { runPentestWorkflow: workflow } = await import("./pentest-4932ke3a.js");
+      const { runPentestWorkflow: workflow } = await import("./pentest-277h4psc.js");
       if (!ctx.model) {
         return {
           success: false,
@@ -125938,7 +125969,48 @@ function createResponseTool(responseSchema, onResult) {
 // src/core/agents/offSecAgent/tools/persistentShell.ts
 import { spawn as spawn4, spawnSync } from "child_process";
 import { randomBytes } from "crypto";
+import {
+  closeSync,
+  mkdirSync as mkdirSync12,
+  openSync,
+  readFileSync as readFileSync4,
+  readSync,
+  statSync,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { tmpdir } from "os";
+import { join as join18 } from "path";
 var MAX_BUFFER = 5000000;
+var APEX_TMP_ROOT = join18(tmpdir(), `apex-shell-${process.pid}`);
+try {
+  mkdirSync12(APEX_TMP_ROOT, { recursive: true });
+} catch {}
+function readTempfileCapped(path) {
+  try {
+    const stat2 = statSync(path);
+    if (stat2.size === 0)
+      return "";
+    if (stat2.size <= MAX_BUFFER) {
+      return readFileSync4(path, "utf-8");
+    }
+    const fd = openSync(path, "r");
+    try {
+      const buf = Buffer.alloc(MAX_BUFFER);
+      readSync(fd, buf, 0, MAX_BUFFER, stat2.size - MAX_BUFFER);
+      return `(stdout truncated)...
+` + buf.toString("utf-8");
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return "";
+  }
+}
+function unlinkSafe(path) {
+  try {
+    unlinkSync2(path);
+  } catch {}
+}
 var stdbufAvailable = null;
 function hasStdbuf() {
   if (stdbufAvailable !== null)
@@ -125983,6 +126055,7 @@ class PersistentShell {
   extraEnv;
   current = null;
   pendingCancel = null;
+  writeChain = Promise.resolve();
   constructor(opts) {
     this.cwd = opts?.cwd;
     this.extraEnv = opts?.env;
@@ -126019,9 +126092,13 @@ class PersistentShell {
       if (cmd) {
         this.current = null;
         this.pendingCancel = null;
+        const diskStdout = readTempfileCapped(cmd.outPath);
+        const diskStderr = readTempfileCapped(cmd.errPath);
+        unlinkSafe(cmd.outPath);
+        unlinkSafe(cmd.errPath);
         cmd.resolve({
-          stdout: extractFallbackStdout(cmd),
-          stderr: cmd.stderr || "",
+          stdout: diskStdout || extractFallbackStdout(cmd) || "(no output)",
+          stderr: diskStderr || cmd.stderr || "",
           exitCode: 1
         });
       }
@@ -126080,6 +126157,8 @@ class PersistentShell {
       }
       const effectiveExit = cmd.forcedExitCode != null ? cmd.forcedExitCode : isNaN(naturalExitCode) ? 1 : naturalExitCode;
       const effectiveStderr = cmd.forcedStderrSuffix ? (cmd.stderr || "") + cmd.forcedStderrSuffix : cmd.stderr || "";
+      unlinkSafe(cmd.outPath);
+      unlinkSafe(cmd.errPath);
       const resolve5 = cmd.resolve;
       this.current = null;
       this.pendingCancel = null;
@@ -126110,129 +126189,131 @@ class PersistentShell {
       return { stdout: "", stderr: "Shell has been disposed", exitCode: 1 };
     }
     if (abortSignal?.aborted) {
-      return {
-        stdout: "",
-        stderr: "Command aborted",
-        exitCode: 130
-      };
-    }
-    this.ensureAlive();
-    const proc = this.proc;
-    if (!proc || !proc.stdin || !proc.stdout || !proc.stderr) {
-      return { stdout: "", stderr: "Failed to spawn shell", exitCode: 1 };
+      return { stdout: "", stderr: "Command aborted", exitCode: 130 };
     }
-    const marker = `__APEX_${randomBytes(8).toString("hex")}__`;
-    const exitMarkerPrefix = `${marker}_EXIT_`;
-    const cutoverMarker = `${marker}_CUTOVER`;
-    return new Promise((resolve5) => {
-      let resolved = false;
-      let timeoutTimer;
-      let killEscalationTimer;
-      const pending = {
-        streamedStdout: "",
-        authoritativeStdout: "",
-        cutoverSeen: false,
-        cutoverMarker,
-        stderr: "",
-        stdoutTruncated: false,
-        exitMarkerPrefix,
-        onData,
-        forcedExitCode: null,
-        forcedStderrSuffix: null,
-        resolve: (result) => {
-          if (resolved)
-            return;
-          resolved = true;
-          if (timeoutTimer)
-            clearTimeout(timeoutTimer);
-          if (killEscalationTimer)
-            clearTimeout(killEscalationTimer);
-          if (abortCleanup)
-            abortCleanup();
-          resolve5(result);
-        }
-      };
-      this.current = pending;
-      this.pendingCancel = pending.resolve;
-      let abortCleanup;
-      if (abortSignal) {
-        const onAbort = () => {
-          if (resolved)
-            return;
-          pending.forcedExitCode = 130;
-          pending.forcedStderrSuffix = pending.stderr ? `
-(aborted)` : "(aborted)";
-          killDescendants(proc.pid, "SIGTERM");
-          killEscalationTimer = setTimeout(() => {
+    const release = await this.acquireTurn();
+    try {
+      if (this.disposed) {
+        return { stdout: "", stderr: "Shell has been disposed", exitCode: 1 };
+      }
+      if (abortSignal?.aborted) {
+        return { stdout: "", stderr: "Command aborted", exitCode: 130 };
+      }
+      this.ensureAlive();
+      const proc = this.proc;
+      if (!proc || !proc.stdin || !proc.stdout || !proc.stderr) {
+        return { stdout: "", stderr: "Failed to spawn shell", exitCode: 1 };
+      }
+      return await new Promise((resolve5) => {
+        let resolved = false;
+        let timeoutTimer;
+        let abortCleanup;
+        const nonceHex = randomBytes(8).toString("hex");
+        const marker = `__APEX_${nonceHex}__`;
+        const exitMarkerPrefix = `${marker}_EXIT_`;
+        const cutoverMarker = `${marker}_CUTOVER`;
+        const outPath = join18(APEX_TMP_ROOT, `${nonceHex}.out`);
+        const errPath = join18(APEX_TMP_ROOT, `${nonceHex}.err`);
+        const pending = {
+          streamedStdout: "",
+          authoritativeStdout: "",
+          cutoverSeen: false,
+          cutoverMarker,
+          stderr: "",
+          stdoutTruncated: false,
+          exitMarkerPrefix,
+          onData,
+          forcedExitCode: null,
+          forcedStderrSuffix: null,
+          outPath,
+          errPath,
+          resolve: (result) => {
             if (resolved)
               return;
-            killDescendants(proc.pid, "SIGKILL");
-            setTimeout(() => {
-              if (resolved)
-                return;
-              pending.resolve({
-                stdout: extractFallbackStdout(pending),
-                stderr: (pending.stderr || "") + (pending.forcedStderrSuffix ?? ""),
-                exitCode: 130
-              });
-            }, 2000);
-          }, 500);
+            resolved = true;
+            if (timeoutTimer)
+              clearTimeout(timeoutTimer);
+            if (pending.killEscalationTimer)
+              clearTimeout(pending.killEscalationTimer);
+            pending._activeSalvageId = undefined;
+            if (abortCleanup)
+              abortCleanup();
+            resolve5(result);
+          }
         };
-        abortSignal.addEventListener("abort", onAbort, { once: true });
-        abortCleanup = () => abortSignal.removeEventListener("abort", onAbort);
-      }
-      if (timeoutSeconds != null && timeoutSeconds > 0) {
-        timeoutTimer = setTimeout(() => {
-          if (resolved)
-            return;
-          pending.forcedExitCode = 124;
-          killDescendants(proc.pid, "SIGTERM");
-          killEscalationTimer = setTimeout(() => {
+        this.current = pending;
+        this.pendingCancel = pending.resolve;
+        if (abortSignal) {
+          const onAbort = () => {
             if (resolved)
               return;
-            killDescendants(proc.pid, "SIGKILL");
-            setTimeout(() => {
-              if (resolved)
-                return;
-              pending.resolve({
-                stdout: extractFallbackStdout(pending),
-                stderr: pending.stderr || "",
-                exitCode: 124
-              });
-            }, 2000);
-          }, 500);
-        }, timeoutSeconds * 1000);
-      }
-      const tailCmd = hasStdbuf() ? `stdbuf -oL tail -n +1 -f -s 0.05 "$__APEX_OUT"` : `tail -n +1 -f -s 0.05 "$__APEX_OUT"`;
-      const wrapped = [
-        `__APEX_OUT=$(mktemp 2>/dev/null || echo /tmp/.apex_out_$$)`,
-        `__APEX_ERR=$(mktemp 2>/dev/null || echo /tmp/.apex_err_$$)`,
-        `${tailCmd} 2>/dev/null &`,
-        `__APEX_TAIL=$!`,
-        `{ ${command}
+            pending.forcedExitCode = 130;
+            pending.forcedStderrSuffix = pending.stderr ? `
+(aborted)` : "(aborted)";
+            pending.killEscalationTimer = scheduleSalvageKill(proc.pid, pending, 130);
+          };
+          abortSignal.addEventListener("abort", onAbort, { once: true });
+          abortCleanup = () => abortSignal.removeEventListener("abort", onAbort);
+        }
+        if (timeoutSeconds != null && timeoutSeconds > 0) {
+          timeoutTimer = setTimeout(() => {
+            if (resolved)
+              return;
+            pending.forcedExitCode = 124;
+            pending.killEscalationTimer = scheduleSalvageKill(proc.pid, pending, 124);
+          }, timeoutSeconds * 1000);
+        }
+        const tailCmd = hasStdbuf() ? `stdbuf -oL tail -n +1 -f -s 0.05 "$__APEX_OUT"` : `tail -n +1 -f -s 0.05 "$__APEX_OUT"`;
+        const shOutPath = `'${outPath.replace(/'/g, `'\\''`)}'`;
+        const shErrPath = `'${errPath.replace(/'/g, `'\\''`)}'`;
+        const wrapped = [
+          `__APEX_OUT=${shOutPath}`,
+          `__APEX_ERR=${shErrPath}`,
+          `: > "$__APEX_OUT"`,
+          `: > "$__APEX_ERR"`,
+          `${tailCmd} 2>/dev/null &`,
+          `__APEX_TAIL=$!`,
+          `{ ${command}
 } </dev/null >"$__APEX_OUT" 2>"$__APEX_ERR"`,
-        `__APEX_EC=$?`,
-        `sleep 0.1`,
-        `kill "$__APEX_TAIL" 2>/dev/null`,
-        `wait "$__APEX_TAIL" 2>/dev/null`,
-        `printf '%s\\n' "${cutoverMarker}"`,
-        `cat "$__APEX_OUT"`,
-        `cat "$__APEX_ERR" >&2`,
-        `rm -f "$__APEX_OUT" "$__APEX_ERR"`,
-        `echo "${exitMarkerPrefix}$__APEX_EC"`,
-        ``
-      ].join(`
+          `__APEX_EC=$?`,
+          `sleep 0.1`,
+          `kill "$__APEX_TAIL" 2>/dev/null`,
+          `wait "$__APEX_TAIL" 2>/dev/null`,
+          `printf '%s\\n' "${cutoverMarker}"`,
+          `cat "$__APEX_OUT"`,
+          `cat "$__APEX_ERR" >&2`,
+          `echo "${exitMarkerPrefix}$__APEX_EC"`,
+          ``
+        ].join(`
 `);
-      try {
-        proc.stdin.write(wrapped);
-      } catch {
-        pending.resolve({
-          stdout: "",
-          stderr: "Failed to write to shell stdin",
-          exitCode: 1
-        });
-      }
+        try {
+          proc.stdin.write(wrapped);
+        } catch {
+          pending.resolve({
+            stdout: "",
+            stderr: "Failed to write to shell stdin",
+            exitCode: 1
+          });
+        }
+      });
+    } catch (e) {
+      return {
+        stdout: "",
+        stderr: e instanceof Error ? e.message : String(e),
+        exitCode: 1
+      };
+    } finally {
+      release();
+    }
+  }
+  async acquireTurn() {
+    const myTurn = this.writeChain;
+    let release;
+    this.writeChain = new Promise((res) => {
+      release = res;
     });
+    await myTurn;
+    return release;
   }
   cancelCurrentCommand() {
     const cmd = this.current;
@@ -126242,19 +126323,10 @@ class PersistentShell {
     cmd.forcedStderrSuffix = cmd.stderr ? `
 (cancelled by user)` : "(cancelled by user)";
     if (this.proc.pid && process.platform !== "win32") {
-      killDescendants(this.proc.pid, "SIGTERM");
-      setTimeout(() => {
-        if (this.proc?.pid)
-          killDescendants(this.proc.pid, "SIGKILL");
-        setTimeout(() => {
-          cmd.resolve({
-            stdout: extractFallbackStdout(cmd),
-            stderr: (cmd.stderr || "") + (cmd.forcedStderrSuffix ?? ""),
-            exitCode: 130
-          });
-        }, 2000);
-      }, 500);
+      cmd.killEscalationTimer = scheduleSalvageKill(this.proc.pid, cmd, 130);
     } else {
+      unlinkSafe(cmd.outPath);
+      unlinkSafe(cmd.errPath);
       cmd.resolve({
         stdout: extractFallbackStdout(cmd),
         stderr: (cmd.stderr || "") + (cmd.forcedStderrSuffix ?? ""),
@@ -126267,6 +126339,13 @@ class PersistentShell {
     if (this.disposed)
       return;
     this.disposed = true;
+    if (this.current?.killEscalationTimer) {
+      clearTimeout(this.current.killEscalationTimer);
+    }
+    if (this.current) {
+      unlinkSafe(this.current.outPath);
+      unlinkSafe(this.current.errPath);
+    }
     if (this.proc) {
       try {
         this.proc.stdin?.write(`exit
@@ -126299,10 +126378,10 @@ class PersistentShell {
     this.proc = null;
   }
 }
-function killDescendants(rootPid, signal) {
+function enumerateDescendants(rootPid) {
   if (!rootPid || process.platform === "win32")
-    return;
-  const toKill = [];
+    return [];
+  const descendants = [];
   const queue = [rootPid];
   while (queue.length > 0) {
     const pid = queue.shift();
@@ -126313,25 +126392,54 @@ function killDescendants(rootPid, signal) {
 `)) {
           const child = parseInt(line, 10);
           if (Number.isFinite(child) && child > 0) {
-            toKill.push(child);
+            descendants.push(child);
             queue.push(child);
           }
         }
       }
     } catch {}
   }
-  for (let i = toKill.length - 1;i >= 0; i--) {
+  return descendants;
+}
+function signalPids(pids, signal) {
+  if (process.platform === "win32")
+    return;
+  for (let i = pids.length - 1;i >= 0; i--) {
     try {
-      process.kill(toKill[i], signal);
+      process.kill(pids[i], signal);
     } catch {}
   }
 }
+var SALVAGE_GRACE_MS = 200;
+function scheduleSalvageKill(rootPid, pending, exitCode) {
+  if (pending.killEscalationTimer) {
+    clearTimeout(pending.killEscalationTimer);
+  }
+  const pids = enumerateDescendants(rootPid);
+  signalPids(pids, "SIGTERM");
+  const salvageId = {};
+  pending._activeSalvageId = salvageId;
+  return setTimeout(() => {
+    if (pending._activeSalvageId !== salvageId)
+      return;
+    const diskStdout = readTempfileCapped(pending.outPath);
+    const diskStderr = readTempfileCapped(pending.errPath);
+    unlinkSafe(pending.outPath);
+    unlinkSafe(pending.errPath);
+    signalPids(pids, "SIGKILL");
+    pending.resolve({
+      stdout: diskStdout || extractFallbackStdout(pending) || "(no output)",
+      stderr: (diskStderr || pending.stderr || "") + (pending.forcedStderrSuffix ?? ""),
+      exitCode
+    });
+  }, SALVAGE_GRACE_MS);
+}
 
 // src/core/agents/offSecAgent/prompt.ts
-import { existsSync as existsSync12, readdirSync as readdirSync3, statSync } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join19 } from "path";
 function buildProvidedFilesSection(sessionRootPath) {
-  const providedDir = join18(sessionRootPath, "provided_files");
+  const providedDir = join19(sessionRootPath, "provided_files");
   if (!existsSync12(providedDir))
     return "";
   let entries;
@@ -126342,7 +126450,7 @@ function buildProvidedFilesSection(sessionRootPath) {
   }
   const fileEntries = entries.filter((name) => name !== "README.md").map((name) => {
     try {
-      const stat2 = statSync(join18(providedDir, name));
+      const stat2 = statSync2(join19(providedDir, name));
       if (!stat2.isFile())
         return null;
       return { name, size: stat2.size };
@@ -126612,6 +126720,7 @@ var OperatorSettingsObject = exports_external.object({
 import { EventEmitter as EventEmitter3 } from "events";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_DECISION_TIMEOUT_MS = 15 * 60 * 1000;
+var INTERNAL_ID_PATTERN = /^(apr|act|tc)_\d+_[0-9a-f]{8}$/;
 
 class ApprovalGate extends EventEmitter3 {
   config;
@@ -126670,16 +126779,18 @@ class ApprovalGate extends EventEmitter3 {
     const deferred = this.pendingApprovals.get(approvalId);
     if (!deferred)
       return;
+    const approval = deferred.approval;
     this.pendingApprovals.delete(approvalId);
-    const entry = this.recordAction(deferred.approval.toolName, deferred.approval.toolCallId, "denied");
+    const entry = this.recordAction(approval.toolName, approval.toolCallId, "denied");
     entry.resultSummary = `decision_timeout:${timeoutMs}ms`;
     this.emitEvent({
       type: "approval-resolved",
       id: approvalId,
-      decision: "denied"
+      decision: "denied",
+      approval
     });
     this.emitEvent({ type: "action-completed", entry });
-    deferred.reject(new ApprovalTimeoutError(`Operator decision timeout after ${timeoutMs}ms for ${deferred.approval.toolName} — default-safe deny`));
+    deferred.reject(new ApprovalTimeoutError(`Operator decision timeout after ${timeoutMs}ms for ${approval.toolName} — default-safe deny`));
   }
   approve(approvalId) {
     const deferred = this.pendingApprovals.get(approvalId);
@@ -126688,12 +126799,14 @@ class ApprovalGate extends EventEmitter3 {
     }
     if (deferred.timeoutHandle)
       clearTimeout(deferred.timeoutHandle);
+    const approval = deferred.approval;
     this.pendingApprovals.delete(approvalId);
-    const entry = this.recordAction(deferred.approval.toolName, deferred.approval.toolCallId, "approved");
+    const entry = this.recordAction(approval.toolName, approval.toolCallId, "approved");
     this.emitEvent({
       type: "approval-resolved",
       id: approvalId,
-      decision: "approved"
+      decision: "approved",
+      approval
     });
     this.emitEvent({ type: "action-completed", entry });
     deferred.resolve("approved");
@@ -126704,12 +126817,14 @@ class ApprovalGate extends EventEmitter3 {
       return;
     if (deferred.timeoutHandle)
       clearTimeout(deferred.timeoutHandle);
+    const approval = deferred.approval;
     this.pendingApprovals.delete(approvalId);
-    const entry = this.recordAction(deferred.approval.toolName, deferred.approval.toolCallId, "denied");
+    const entry = this.recordAction(approval.toolName, approval.toolCallId, "denied");
     this.emitEvent({
       type: "approval-resolved",
       id: approvalId,
-      decision: "denied"
+      decision: "denied",
+      approval
     });
     this.emitEvent({ type: "action-completed", entry });
     deferred.reject(new ApprovalDeniedError("Action denied by user"));
@@ -126763,7 +126878,7 @@ class ApprovalTimeoutError extends ApprovalDeniedError {
 init_zod();
 import path from "path";
 import os from "os";
-import { existsSync as existsSync13, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync5 } from "fs";
 init_toolset();
 var DEFAULT_OUTCOME_GUIDANCE = "Prove the exploit can be run but do not exfiltrate data or cause any harm to the system. " + "Create proof-of-concept exploits that demonstrate the vulnerability exists without causing damage.";
 var EXFIL_OUTCOME_GUIDANCE = "Exfiltrate data to extract the flag value. " + "Create proof-of-concept exploits that successfully extract the flag from the target system.";
@@ -127115,7 +127230,7 @@ async function loadOperatorState(sessionId) {
     const statePath = path.join(session.rootPath, "messages.json");
     if (!existsSync13(statePath))
       return null;
-    const data = readFileSync4(statePath, "utf-8");
+    const data = readFileSync5(statePath, "utf-8");
     const parsed = JSON.parse(data);
     if (Array.isArray(parsed)) {
       return {
@@ -127265,8 +127380,8 @@ var sessions = {
 };
 
 // src/core/agents/offSecAgent/offensiveSecurityAgent.ts
-import { join as join19 } from "path";
-import { mkdirSync as mkdirSync12, existsSync as existsSync14 } from "fs";
+import { join as join20 } from "path";
+import { mkdirSync as mkdirSync13, existsSync as existsSync14 } from "fs";
 import { writeFile as writeFile4 } from "fs/promises";
 class OffensiveSecurityAgent {
   streamResult;
@@ -127311,15 +127426,15 @@ class OffensiveSecurityAgent {
         input.commandCancelHandle.cancel = () => shell.cancelCurrentCommand();
       }
     }
-    const messagesDir = input.messagesDir ?? (input.subagentId ? join19(input.session.rootPath, "subagents", input.subagentId) : input.session.rootPath);
-    const tracePath = input.subagentId ? join19(input.session.rootPath, "subagents", `${input.subagentId}.trace.jsonl`) : join19(messagesDir, "trace.jsonl");
+    const messagesDir = input.messagesDir ?? (input.subagentId ? join20(input.session.rootPath, "subagents", input.subagentId) : input.session.rootPath);
+    const tracePath = input.subagentId ? join20(input.session.rootPath, "subagents", `${input.subagentId}.trace.jsonl`) : join20(messagesDir, "trace.jsonl");
     const traceWriter = new StepTraceWriter({
       tracePath,
       agentId: input.subagentId ?? null,
       eventBus: this.eventBus
     });
     const taskDriven = input.session.config?.taskDriven ?? false;
-    const tasksDir = input.tasksDir ?? (taskDriven ? input.subagentId ? join19(input.session.rootPath, "subagents", `${input.subagentId}-tasks`) : join19(input.session.rootPath, "tasks") : undefined);
+    const tasksDir = input.tasksDir ?? (taskDriven ? input.subagentId ? join20(input.session.rootPath, "subagents", `${input.subagentId}-tasks`) : join20(input.session.rootPath, "tasks") : undefined);
     const credentialManager = input.credentialManager ?? input.session.credentialManager;
     const builtinTools = createAllTools({
       session: input.session,
@@ -127390,9 +127505,9 @@ class OffensiveSecurityAgent {
       activeTools = activeTools.filter((t) => planSet.has(t));
     }
     if (!existsSync14(messagesDir)) {
-      mkdirSync12(messagesDir, { recursive: true });
+      mkdirSync13(messagesDir, { recursive: true });
     }
-    const messagesPath = join19(messagesDir, "messages.json");
+    const messagesPath = join20(messagesDir, "messages.json");
     const initialMessagesRef = {
       current: input.messages ? [...input.messages] : [
         {
@@ -127550,4 +127665,4 @@ function wrapToolsWithApprovalGate(tools, gate, exemptToolNames) {
   return wrapped;
 }
 
-export { CweEntrySchema, ValidatedCweEntrySchema, hasCanonicalName, AgentEventBus, FindingsRegistry, planFilePath, readPlan, hasPlan, ASK_USER_QUESTIONS_TOOL_NAME, createAllTools, ALL_TOOL_NAMES, PLAN_MODE_TOOL_NAMES, SKILL_TOOL_NAMES, buildBaseSystemPrompt, OPERATOR_MODES, OPERATOR_MODE_CYCLE, createInitialOperatorState, ApprovalGate, normalizeMessages, sessions, StepTraceWriter, OffensiveSecurityAgent };
+export { CweEntrySchema, ValidatedCweEntrySchema, hasCanonicalName, AgentEventBus, FindingsRegistry, planFilePath, readPlan, hasPlan, ASK_USER_QUESTIONS_TOOL_NAME, createAllTools, ALL_TOOL_NAMES, PLAN_MODE_TOOL_NAMES, SKILL_TOOL_NAMES, buildBaseSystemPrompt, OPERATOR_MODES, OPERATOR_MODE_CYCLE, createInitialOperatorState, INTERNAL_ID_PATTERN, ApprovalGate, normalizeMessages, sessions, StepTraceWriter, OffensiveSecurityAgent };