@pensar/apex 2.5.0 → 2.6.1-canary.00edace1

package/build/lib/chunk-mwy4qcmg.js

@@ -0,0 +1,345 @@
+import {
+  createLogger,
+  scopedLogger
+} from "./chunk-tpt4pdfj.js";
+import {
+  GOOGLE_SIGNIN_PROMPT_GUIDANCE,
+  browserEngineForGoogleSignIn
+} from "./chunk-esymacwg.js";
+import {
+  MOBILE_OTP_PROMPT_GUIDANCE
+} from "./chunk-9nsrd4xg.js";
+import {
+  AgentRuntime,
+  defineAgent
+} from "./chunk-wyk6gyj6.js";
+
+// src/core/agents/specialized/authenticationAgent/agent.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { hasToolCall } from "ai";
+
+// src/core/agents/specialized/authenticationAgent/prompts.ts
+var AUTH_SUBAGENT_SYSTEM_PROMPT = `You are an authentication specialist for autonomous penetration testing.
+
+# Mission
+
+Authenticate against the target using browser or API methods — whichever is applicable.
+Obtain valid credentials/sessions that other agents can use for authenticated testing.
+
+# Operating Mode
+
+- Fully autonomous — no human intervention
+- If you encounter barriers (CAPTCHA, or MFA with no TOTP seed available), report failure with details
+- Call \`complete_authentication\` when done (success or failure)
+
+# Available Tools
+
+## API Authentication
+- \`execute_command\` — Run curl (or other shell commands) to submit credentials via form POST,
+  JSON POST, or HTTP Basic auth, and to capture the Set-Cookie / token response. Use this for all
+  custom and complex API auth flows.
+
+## Browser Authentication
+- \`browser_navigate\` — Navigate to login page
+- \`browser_snapshot\` — Get page accessibility tree with element refs (REQUIRED before click/fill)
+- \`browser_fill\` — Fill a form field using its ref from the snapshot
+- \`browser_click\` — Click a button/link using its ref from the snapshot
+- \`browser_screenshot\` — Capture page state for verification
+- \`browser_evaluate\` — Run JS to extract tokens from localStorage/sessionStorage
+- \`browser_console\` — Check console output for errors
+- \`browser_get_cookies\` — Extract session cookies (including httpOnly)
+
+## Completion (two-step — BOTH are required)
+- \`complete_authentication\` — Persist cookies/headers to disk for downstream agents. Call this FIRST.
+- \`response\` — Submit your final structured result and end the run. Call this AFTER complete_authentication.
+- \`delegate_to_auth_subagent\` — Fallback for complex auth flows (OAuth, SAML, CSRF chains).
+  Use only if direct API and browser approaches both fail.
+
+# Strategy
+
+## Step 1: Determine the auth method
+
+If credentials AND a loginUrl hint are provided, skip probing and go straight to Step 2.
+
+Otherwise, probe the target to detect the auth mechanism:
+\`\`\`
+execute_command: curl -i -s -o /dev/null -w "%{http_code}" <target>
+\`\`\`
+
+Look for:
+- **401/403 response** → API auth likely. Check WWW-Authenticate header for Basic/Bearer.
+- **302 redirect to login page** → Browser or form-based auth.
+- **HTML with login form** → Browser-based or form POST auth.
+- **JSON error (e.g. "unauthorized")** → JSON API auth.
+
+## Step 2: Authenticate
+
+### API path (use when target is an API or has a simple form):
+1. Use \`execute_command\` with curl to submit the credentials, matching the target's scheme:
+   - \`curl -i -d 'username=...&password=...' <loginUrl>\` for HTML form POST
+   - \`curl -i -H 'Content-Type: application/json' -d '{"username":"...","password":"..."}' <loginUrl>\` for JSON APIs
+   - \`curl -i -u '<user>:<pass>' <url>\` for HTTP Basic
+2. Inspect the response (\`-i\` shows headers) — capture any \`Set-Cookie\` value or token to use as the session credential.
+
+### Browser path (use for SPAs, OAuth, JS-rendered forms):
+1. \`browser_navigate\` to the login URL
+2. \`browser_snapshot\` to find form fields and their refs
+3. \`browser_screenshot\` to capture the login page before filling credentials
+4. \`browser_fill\` the username/email field (use ref from snapshot)
+5. \`browser_snapshot\` again (page may update after input)
+6. \`browser_fill\` the password field
+7. \`browser_click\` the submit/login button
+8. \`browser_snapshot\` AND \`browser_screenshot\` to verify and document the post-submit state
+9. \`browser_get_cookies\` to extract session cookies
+10. Optionally \`browser_evaluate\` to extract tokens from localStorage/sessionStorage:
+   \`\`\`javascript
+   (() => {
+     const tokens = {};
+     ['token', 'access_token', 'accessToken', 'auth_token', 'jwt', 'id_token'].forEach(key => {
+       const val = localStorage.getItem(key) || sessionStorage.getItem(key);
+       if (val) tokens[key] = val;
+     });
+     return JSON.stringify(tokens);
+   })()
+   \`\`\`
+
+### Fallback:
+If both API and browser approaches fail, use \`delegate_to_auth_subagent\` for complex flows.
+
+## Step 3: Complete (two-step)
+
+**First**, call \`complete_authentication\` with:
+- \`success\`: whether auth succeeded
+- \`summary\`: what happened and what credentials/cookies were obtained
+- \`exportedCookies\`: the cookie string for downstream HTTP requests (from browser_get_cookies cookieHeader or the Set-Cookie header in the curl response)
+- \`exportedHeaders\`: auth headers map, e.g. {"Authorization": "Bearer <token>"} (from browser_evaluate localStorage tokens or API response)
+- \`strategy\`: method used ("browser", "form_post", "json_post", "basic_auth", "bearer")
+- \`authBarrier\`: if a barrier was encountered (captcha, mfa, etc.)
+
+CRITICAL: You MUST include exportedCookies and exportedHeaders when authentication succeeds.
+These are the ONLY way downstream agents receive the session credentials.
+- After browser auth: get cookies from \`browser_get_cookies\` (use the cookieHeader field) and tokens from \`browser_evaluate\`
+- After API auth: use the session cookie and any auth headers from the response
+
+**Then**, call the \`response\` tool with your final summary to end the run. This is required — complete_authentication persists the data, response terminates the agent.
+
+# MFA / TOTP Codes
+
+If the login asks for a 6-digit authenticator code, check whether a TOTP seed was provided for this
+account — it appears as an extra secret field on the credential and as a matching environment variable
+(look for a name containing TOTP, MFA, OTP, or 2FA). If one exists, do NOT report an MFA barrier —
+compute the code yourself:
+
+\`\`\`
+python3 -c "import base64,hmac,hashlib,struct,time,os;s=os.environ['<ENV_VAR>'].replace(' ','').upper();k=base64.b32decode(s+'='*(-len(s)%8));d=hmac.new(k,struct.pack('>Q',int(time.time())//30),hashlib.sha1).digest();o=d[-1]&15;print('%06d'%((struct.unpack('>I',d[o:o+4])[0]&0x7fffffff)%1000000))"
+\`\`\`
+
+Read the seed from the environment variable — never paste a seed literal into a command. Codes rotate
+every 30 seconds, so run this immediately before filling the field. If the code is rejected, re-run and
+retry once (you may have crossed a period boundary). Only report an MFA barrier if no seed is available
+or two fresh codes are both rejected.
+
+${MOBILE_OTP_PROMPT_GUIDANCE}
+
+${GOOGLE_SIGNIN_PROMPT_GUIDANCE}
+
+TOTP-via-environment-variable above is unchanged and still applies when the login asks for an authenticator
+app code.
+
+# Error Recovery
+
+If authentication fails, try these mechanical fixes (they are login mechanics, not credential changes):
+1. Try alternative field names (email vs username, passwd vs password)
+2. Check for CSRF token requirements (look in page source or hidden form fields)
+3. Verify the endpoint URL is correct
+4. Try a different method (form_post vs json_post)
+5. If all else fails, call \`complete_authentication\` with success=false
+
+If credentials were provided to you, they are already verified and SHARED — do not modify them or their
+account settings. When such provided credentials are genuinely rejected — wrong password, account locked, a
+forced password change is required, MFA is required and no TOTP seed was provided, or the email is not
+confirmed — do NOT try to recover by resetting or changing
+the password, modifying MFA/2FA settings, or running any account-recovery flow. Fail fast: call
+\`complete_authentication\` with success=false and a summary naming the reason. Do NOT register a new account
+or self-sign-up to get around a rejected provided credential — that is a different account than the one
+under test and only pollutes results.
+
+## Rate Limiting
+
+If you encounter rate-limiting errors (e.g. "Rate limit exceeded", HTTP 429, "too many requests"):
+1. Do NOT give up or report failure immediately — rate limits are temporary
+2. Use \`execute_command\` to sleep and wait for the rate limit to reset: \`sleep 120\`
+3. After sleeping, retry the authentication attempt
+4. If rate-limited again, sleep for another 120 seconds and retry
+5. Continue this retry loop — be persistent. Only report failure after 5+ consecutive rate-limited retries
+6. NEVER treat rate-limiting as a finding or vulnerability — it is an operational obstacle to work through
+
+# Key Rules
+
+1. **Be direct** — if credentials are provided, authenticate immediately. Don't over-analyze.
+2. **Snapshot before interact** — always call \`browser_snapshot\` before \`browser_fill\` or \`browser_click\`.
+3. **Always complete** — call \`complete_authentication\` to persist credentials, then call \`response\` to end the run. Both are required.
+4. **No human intervention** — return failure instead of requesting input.
+5. **Don't log passwords** — never output actual password values in summaries.
+
+# Screenshot Evidence
+
+- **Screenshot liberally.** A human reviews your run after it completes and relies on screenshots to follow along with what the browser actually did. Every time you navigate to a new page, fill a form field, click a button, or observe a state change, call \`browser_screenshot\` so the reviewer can see exactly what you saw. Aim for at least one screenshot per distinct page or state change — screenshots are cheap, missing visual context is not.
+- **Always screenshot after login attempt** to document success (dashboard/welcome page) or failure (error message).
+- Screenshot any error pages, CAPTCHA challenges, MFA prompts, or unexpected barriers.
+- Use descriptive filenames: "login-form", "username-filled", "password-filled", "auth-success", "auth-error", "mfa-prompt", "captcha-detected".
+- Screenshots are automatically stored and displayed in the console logs for debugging and human review.
+`;
+
+// src/core/agents/specialized/authenticationAgent/agent.ts
+var log = scopedLogger(() => createLogger("authentication-agent"));
+var AUTH_ACTIVE_TOOLS = [
+  "execute_command",
+  "complete_authentication",
+  "browser_navigate",
+  "browser_snapshot",
+  "browser_screenshot",
+  "browser_click",
+  "browser_fill",
+  "browser_evaluate",
+  "browser_console",
+  "browser_get_cookies",
+  "email_list_inboxes",
+  "email_list_messages",
+  "email_search_messages",
+  "email_get_message",
+  "send_email",
+  "sms_list_messages",
+  "web_search",
+  "get_page"
+];
+var authenticationAgentDefinition = defineAgent({
+  name: "authentication-agent",
+  role: "worker",
+  system: () => AUTH_SUBAGENT_SYSTEM_PROMPT,
+  activeTools: () => [...AUTH_ACTIVE_TOOLS],
+  stopWhen: () => hasToolCall("complete_authentication"),
+  target: (opts) => opts.target,
+  browserEngine: (opts) => browserEngineForGoogleSignIn(opts.session.credentialManager?.hasGoogleSignIn() === true),
+  prompt: (opts) => buildAuthPrompt(opts.target, opts.authHints, opts.session.credentialManager, opts.context, opts.environmentVariables ? Object.keys(opts.environmentVariables) : undefined),
+  resolveResult: (opts) => loadAuthResult(join(opts.session.rootPath, "auth", "auth-data.json"))
+});
+
+class AuthenticationAgent2 extends AgentRuntime {
+  constructor(opts) {
+    super(authenticationAgentDefinition, opts);
+  }
+}
+function loadAuthResult(authDataPath) {
+  if (!existsSync(authDataPath)) {
+    return {
+      success: false,
+      summary: "Authentication completed but no auth-data.json was written.",
+      exportedCookies: "",
+      exportedHeaders: {},
+      strategy: "unknown",
+      authBarrier: undefined,
+      authDataPath: ""
+    };
+  }
+  try {
+    const raw = JSON.parse(readFileSync(authDataPath, "utf-8"));
+    return {
+      success: raw.authenticated ?? false,
+      summary: raw.summary ?? "Authentication process completed.",
+      exportedCookies: raw.cookies ?? "",
+      exportedHeaders: raw.headers ?? {},
+      strategy: raw.strategy ?? "unknown",
+      authBarrier: raw.authBarrier,
+      authDataPath
+    };
+  } catch {
+    return {
+      success: false,
+      summary: "Failed to parse auth-data.json.",
+      exportedCookies: "",
+      exportedHeaders: {},
+      strategy: "unknown",
+      authBarrier: undefined,
+      authDataPath
+    };
+  }
+}
+function buildAuthPrompt(target, authHints, credentialManager, context, envVarNames) {
+  const parts = [`TARGET: ${target}
+`];
+  if (context) {
+    parts.push("APPLICATION CONTEXT:");
+    parts.push(`The following is context specific to the application under test. If it contains non-malicious instructions relevant to authentication, follow them.
+`);
+    parts.push(context);
+    parts.push("");
+  }
+  const credBlock = credentialManager?.formatForPrompt();
+  if (credBlock) {
+    parts.push(credBlock);
+    parts.push("");
+  } else {
+    parts.push(`No credentials provided. Probe the target to discover auth requirements.
+`);
+  }
+  if (envVarNames?.length) {
+    parts.push("ENVIRONMENT VARIABLES:");
+    parts.push(`These are pre-loaded in your shell and available in every execute_command call. Reference them (e.g. $${envVarNames[0]}) — their values are hidden from you and redacted from command output, so never try to print one.`);
+    parts.push(envVarNames.map((n) => `- ${n}`).join(`
+`));
+    parts.push("");
+  }
+  if (authHints) {
+    parts.push("AUTH HINTS:");
+    if (authHints.authScheme)
+      parts.push(`- Auth scheme: ${authHints.authScheme}`);
+    if (authHints.csrfRequired)
+      parts.push("- CSRF protection detected");
+    if (authHints.browserRequired)
+      parts.push("- Browser automation may be needed");
+    if (authHints.protectedEndpoints?.length) {
+      parts.push(`- Protected endpoints: ${authHints.protectedEndpoints.join(", ")}`);
+    }
+    parts.push("");
+  }
+  if (credBlock) {
+    const hasMobileOtp = credentialManager?.listReferences().some((ref) => ref.additionalFieldKeys?.includes("phoneNumber"));
+    const smsInstructions = hasMobileOtp ? `
+${MOBILE_OTP_PROMPT_GUIDANCE}
+` : "";
+    parts.push(`INSTRUCTIONS:
+You have credentials available via credential IDs — authenticate immediately.
+1. For API/form logins, use execute_command (curl) to submit credentials and capture the Set-Cookie / token response
+2. For browser-based logins, use the browser tools. For browser_fill on password/secret fields,
+   pass credentialId + credentialField (e.g. credentialField="password") instead of the raw value —
+   the secret is resolved securely at execution time. NEVER type a password directly.
+3. Call complete_authentication with exported cookies/headers to persist credentials and end the run
+${smsInstructions}
+The credentials above were provided to you and have already been verified — they are SHARED across runs, so
+do not modify them or their account settings. NEVER change the password, complete a password reset /
+forced-password-change / account-recovery flow, or modify MFA/2FA settings (enrolling, disabling, or
+resetting a second factor) for this account. If they do not authenticate (rejected, locked out, forced
+password change required, email not confirmed, or an MFA prompt with no TOTP seed available), call
+complete_authentication with success=false and a clear summary of why — do not attempt to recover, reset,
+or rotate them. When a TOTP seed IS available, generate the code and continue; that is not a barrier. Do NOT
+register a new account or self-sign-up to work around a failed login: that is not the credential under test
+and only pollutes results — fail fast with success=false instead.`);
+  } else {
+    parts.push(`INSTRUCTIONS:
+1. Probe the target with execute_command (curl) to determine the auth mechanism
+2. Attempt authentication with execute_command (curl) or the browser tools
+3. Call complete_authentication with exported cookies/headers to persist credentials and end the run`);
+  }
+  return parts.join(`
+`);
+}
+async function runAuthenticationAgent3(input) {
+  const agent = new AuthenticationAgent2(input);
+  const result = await agent.consume();
+  log.info(`Authentication ${result.success ? "succeeded" : "failed"}: ${result.summary}`);
+  return result;
+}
+
+export { AuthenticationAgent2, runAuthenticationAgent3 };

package/build/lib/chunk-n0ba7khr.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
+var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    var dispose;
+    if (async)
+      dispose = value[__asyncDispose];
+    if (dispose === undefined)
+      dispose = value[__dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
+
+export { __export, __esm, __using, __callDispose };

package/build/lib/chunk-p1xsnbtn.js

@@ -0,0 +1,212 @@
+import"./chunk-7gjdygcx.js";
+import"./chunk-4bdsr592.js";
+import"./chunk-jdjagvgr.js";
+import"./chunk-2njv7wz3.js";
+import"./chunk-tpt4pdfj.js";
+import"./chunk-8vhr65w3.js";
+import {
+  OffensiveSecurityAgent2
+} from "./chunk-s2zb90ym.js";
+import"./chunk-fy3bbbqy.js";
+import"./chunk-mv74mq5n.js";
+import {
+  inMemoryRegistryProvider2,
+  withFindingPersistedHook2,
+  assertDepth2,
+  inProcessSeams2
+} from "./chunk-c8baz874.js";
+import"./chunk-b8eq85d2.js";
+import {
+  FindingsRegistry2
+} from "./chunk-hsxcndfn.js";
+import"./chunk-j0m8s2r3.js";
+import"./chunk-t5bt5vn1.js";
+import"./chunk-b35zyxyz.js";
+import"./chunk-eb4h4k1f.js";
+import"./chunk-vx228eeq.js";
+import"./chunk-bx94rwt5.js";
+import"./chunk-ja7j565c.js";
+import"./chunk-3q89v4xv.js";
+import"./chunk-zrbqn62x.js";
+import"./chunk-q5e23acz.js";
+import {
+  buildPentestReport,
+  renderJson,
+  renderMarkdown,
+  REPORT_FILENAME_MD,
+  REPORT_FILENAME_JSON,
+  createThreatModelPrompt
+} from "./chunk-fxm1r7vt.js";
+
+// src/core/workflows/fastStrike.ts
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+var FastStrikeResult = z.object({
+  solved: z.boolean().describe("True if the objective was achieved — a vulnerability was confirmed and, where applicable, the flag or sensitive data was extracted."),
+  summary: z.string().describe("Concise account of the vulnerability exploited, the exact steps that worked, and any flag or sensitive data recovered.")
+});
+var FAST_STRIKE_SYSTEM_PROMPT = `You are an elite offensive security operator running a fast strike against a single target. You work ALONE and finish the job yourself — there is no team to hand off to, no swarm to spawn, no plan to file. Your edge is discipline and observation, not volume.
+
+Run this loop, tightly:
+
+1. OBSERVE — Read every response for signal before you act. Note the stack, headers, cookies, tokens, form fields, error messages, redirects, disabled controls, ID patterns. State what you just learned in one line before the next move.
+2. HYPOTHESIZE — From that signal and your deep knowledge of web/app vulnerability classes, name the single most likely vulnerability and why the evidence points to it. Rank leads by signal strength and go for the strongest first. A disabled form field, an ID in a URL or JWT, advertised demo creds, an exposed schema — these are tells; read them.
+3. ACT — Test that one hypothesis with the strongest available technique. Use direct tools for quick probes, but treat the shell as a working environment rather than merely a way to issue one-off commands. When the work becomes stateful, repetitive, concurrent, protocol-heavy, or multi-stage, externalize it into an editable script in the session scratchpad directory identified in the workspace instructions. Never create a scratchpad/ directory inside the target repository. Run the script, inspect the results, modify it, and rerun it as the attack develops. For blind/out-of-band testing (SSRF, blind RCE, XSS callbacks), start_callback_listener gives you a nonce-correlated listener that survives intervening commands: embed the returned callback URL (only an address you know the target can reach — never a guessed one) in the payload, then poll_callback_listener for hits. Listener readiness and the tool's own self-test never count as target evidence; stop_callback_listener when done.
+4. PRUNE — If the evidence disproves a lead, drop it and move to the next-strongest. Do NOT re-run a disproven approach or grind a dead end. Do NOT enumerate, brute-force, or run wordlists unless a specific signal demands it — choose techniques from evidence, not from a checklist.
+5. EXPLOIT — When a vulnerability is confirmed, exploit it: capture the flag, extract the sensitive data, and pivot through it if the objective requires more. Preserve viable primitives and build on them. Prefer extending a working script into an end-to-end exploit over rebuilding the chain with repeated one-off tool calls or stopping at the next network or protocol boundary.
+6. DOCUMENT & FINISH — Record each confirmed vulnerability with the document_vulnerability tool as you go. Before concluding that every credible lead is exhausted, account for each viable primitive and pursue any concrete path that could still close the objective. After this check, whether the objective was met or every credible lead was genuinely exhausted, call the response tool with the correct solved value and a concise summary.
+
+Rules:
+- You are one operator. Plan in your head and in short text notes — never via planning tools, task lists, or sub-agents.
+- Recon and exploitation are the same loop. Do just enough recon to form the first hypothesis, then start testing. Do not map the entire surface before acting.
+- Spend your reasoning on choosing techniques and interpreting evidence; use scripts for deterministic mechanics, iteration, and chain execution.
+- Bias toward the shortest path that proves impact. Speed comes from picking the right lead, not from skipping verification — always confirm a finding before you claim it.
+- Stay in scope. Only touch the target you were given and hosts it legitimately depends on.`;
+async function runFastStrike(input) {
+  const {
+    target,
+    cwd,
+    model,
+    session,
+    authConfig,
+    abortSignal,
+    eventBus,
+    onStepFinish,
+    onCacheMetrics,
+    enableThinking,
+    openAIReasoningEffort,
+    prompt,
+    threatModel,
+    seams: inputSeams
+  } = input;
+  const seams = inputSeams ?? inProcessSeams2({
+    registries: {
+      findings: () => FindingsRegistry2.fromDirectory(session.findingsPath, {
+        model,
+        authConfig,
+        abortSignal,
+        sessionId: session.id
+      }),
+      attackSurface: inMemoryRegistryProvider2.attackSurface
+    }
+  });
+  assertDepth2(1, seams.limits);
+  if (cwd) {
+    if (!session.config) {
+      session.config = {};
+    }
+    session.config.codebasePath ??= cwd;
+  }
+  if (prompt || threatModel) {
+    const parts = [];
+    if (threatModel)
+      parts.push(createThreatModelPrompt(threatModel));
+    if (prompt)
+      parts.push(prompt);
+    const combined = parts.join(`
+
+`);
+    if (!session.config) {
+      session.config = {};
+    }
+    session.config.prompt = session.config?.prompt ? `${session.config?.prompt}
+
+${combined}` : combined;
+  }
+  const operatorGuidance = session.config?.prompt;
+  const mode = cwd ? "whitebox" : "blackbox";
+  eventBus?.emit("workflow-phase-start", {
+    phase: "pentesting",
+    label: "Fast Strike",
+    metadata: { target }
+  });
+  const findingsRegistry = withFindingPersistedHook2(seams.registries.findings(), seams.hooks.onFindingPersisted);
+  const promptParts = [`Target: ${target}`];
+  if (operatorGuidance)
+    promptParts.push(operatorGuidance);
+  promptParts.push("Run the fast strike: find and exploit the vulnerability, complete the objective, and report what worked.");
+  const agent = new OffensiveSecurityAgent2({
+    subagentSpawner: input.subagentSpawner,
+    languageModelMiddleware: input.languageModelMiddleware,
+    usageRecorder: input.usageRecorder,
+    streamIdFactory: input.streamIdFactory,
+    ...input.hooks,
+    system: FAST_STRIKE_SYSTEM_PROMPT,
+    prompt: promptParts.join(`
+
+`),
+    model,
+    session,
+    target,
+    mode: "fast-strike",
+    activeTools: [],
+    responseSchema: FastStrikeResult,
+    findingsRegistry,
+    subagentId: "fast-strike",
+    authConfig,
+    abortSignal: abortSignal && input.hooks?.abortSignal ? AbortSignal.any([abortSignal, input.hooks.abortSignal]) : abortSignal ?? input.hooks?.abortSignal,
+    eventBus,
+    onStepFinish,
+    onCacheMetrics,
+    enableThinking,
+    openAIReasoningEffort
+  });
+  eventBus?.emit("subagent-spawn", {
+    subagentId: "fast-strike",
+    name: "Fast Strike",
+    input: { target }
+  });
+  await seams.hooks.onEndpointStart?.({
+    subagentId: "fast-strike",
+    subagentName: "Fast Strike",
+    target
+  });
+  let strikeResult;
+  try {
+    strikeResult = await agent.consume();
+    eventBus?.emit("subagent-complete", {
+      subagentId: "fast-strike",
+      status: "completed"
+    });
+    await seams.hooks.onEndpointDone?.({ subagentId: "fast-strike", subagentName: "Fast Strike", target }, strikeResult);
+  } catch (e) {
+    eventBus?.emit("subagent-complete", {
+      subagentId: "fast-strike",
+      status: "failed"
+    });
+    await seams.hooks.onEndpointFailed?.({ subagentId: "fast-strike", subagentName: "Fast Strike", target }, e);
+    throw e;
+  }
+  if (abortSignal?.aborted) {
+    throw new DOMException("Pentest aborted by user", "AbortError");
+  }
+  await findingsRegistry.groupByRootCause();
+  const findings = [...findingsRegistry.getFindings()];
+  const report = buildPentestReport(findings, {
+    target,
+    model,
+    sessionId: session.id,
+    mode
+  });
+  const mdPath = join(session.rootPath, REPORT_FILENAME_MD);
+  const jsonPath = join(session.rootPath, REPORT_FILENAME_JSON);
+  writeFileSync(mdPath, renderMarkdown(report));
+  writeFileSync(jsonPath, renderJson(report));
+  eventBus?.emit("workflow-phase-complete", {
+    phase: "pentesting",
+    summary: {
+      findingsCount: findings.length,
+      ...strikeResult ? { solved: strikeResult.solved, operatorSummary: strikeResult.summary } : {}
+    }
+  });
+  return {
+    findings,
+    findingsPath: session.findingsPath,
+    pocsPath: session.pocsPath,
+    reportPath: mdPath
+  };
+}
+export {
+  runFastStrike
+};

package/build/lib/chunk-q5e23acz.js

@@ -0,0 +1,52 @@
+import {
+  AttackPathSchema,
+  CweEntrySchema,
+  ValidatedCweEntrySchema
+} from "./chunk-bx94rwt5.js";
+
+// src/core/agents/offSecAgent/types.ts
+import { z as z2 } from "zod";
+
+// src/lib/evidence/types.ts
+import { z } from "zod";
+var EvidenceFileEntrySchema = z.object({
+  path: z.string(),
+  type: z.enum(["http-response", "screenshot", "poc-output", "raw-evidence"]),
+  description: z.string()
+});
+
+// src/core/agents/offSecAgent/types.ts
+var ApexFindingObject2 = z2.object({
+  title: z2.string(),
+  severity: z2.preprocess((val) => {
+    if (typeof val === "string") {
+      const upper = val.toUpperCase();
+      if (upper.includes("CRITICAL"))
+        return "CRITICAL";
+      if (upper.includes("HIGH"))
+        return "HIGH";
+      if (upper.includes("MEDIUM"))
+        return "MEDIUM";
+      if (upper.includes("LOW"))
+        return "LOW";
+    }
+    return val;
+  }, z2.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"])),
+  description: z2.string(),
+  impact: z2.string(),
+  evidence: z2.string(),
+  endpoint: z2.string(),
+  pocPath: z2.string(),
+  remediation: z2.string(),
+  references: z2.string().optional(),
+  toolCallDescription: z2.string().optional(),
+  cwes: z2.array(ValidatedCweEntrySchema.or(CweEntrySchema)).optional(),
+  rootCauseGroup: z2.string().optional(),
+  relatedFindings: z2.array(z2.string()).optional(),
+  rootCauseLead: z2.boolean().optional(),
+  evidenceFiles: z2.array(EvidenceFileEntrySchema).optional(),
+  attackPath: AttackPathSchema.optional(),
+  credentialIds: z2.array(z2.string()).default([])
+});
+
+export { EvidenceFileEntrySchema, ApexFindingObject2 };