@pensar/apex 2.5.0 → 2.6.1-canary.0cc77dcc

package/build/lib/chunk-ngp6p527.js

@@ -0,0 +1,317 @@
+import {
+  AgentRuntime,
+  defineAgent
+} from "./chunk-vt9spgd1.js";
+
+// src/core/agents/specialized/patching/agent.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/core/agents/specialized/patching/prompts.ts
+var PREAMBLE = `You are an expert security vulnerability patching agent — an autonomous coding agent specialized in fixing security issues. Your goal is to analyze security vulnerabilities, apply high-quality fixes, verify they don't break existing functionality, and return structured PR metadata.`;
+var ORIENT_STEP = `1. **Orient Yourself**:
+   - Read the project instructions (AGENTS.md / CLAUDE.md) provided in your prompt in full. They are authoritative for this repository: coding conventions, architectural rules, error-handling policy, forbidden patterns, AND the exact build/lint/test commands
+   - Use glob / list_files to explore the repository structure (prefer glob for pattern searches like "**/*.ts")
+   - Read package.json, Makefile, or equivalent to understand the project's toolchain
+   - Identify the lint command, test command, type-check command, and any other verification scripts
+   - Optionally call profile_codebase for a high-level map of the repo`;
+var TASK_STEP = `2. **Track Work with Tasks**:
+   - Use create_task early to decompose the job into concrete steps (orient, understand, edit, verify, finalize)
+   - Update tasks with update_task as you progress (in_progress → completed / failed)
+   - Use list_tasks when you need to recall what's left
+   - Keep tasks atomic — one clear outcome per task`;
+var UNDERSTAND_STEP = `3. **Understand the Vulnerability**:
+   - Carefully read the vulnerability description, CWE mappings, and any dataflow analysis provided
+   - Understand the root cause: What makes this code vulnerable?
+   - Identify the attack vector: How would an attacker exploit this?
+   - Consider the context: What is the application trying to do?
+   - Use web_search / get_page when you need framework-specific security guidance or CVE details`;
+var REVIEW_STEP = `4. **Review the Code**:
+   - Use read_file to read the vulnerable file(s) mentioned in the issue
+   - Use grep or run_code_query for structural searches (rg / ast-grep) across related patterns
+   - Review related files: imports, dependencies, configuration files
+   - Understand the data flow: Where does user input come from? Where does it go?`;
+var PLAN_STEP = `5. **Plan Your Fix**:
+   - Identify the exact code that needs to change
+   - Determine the appropriate security control (input validation, parameterized queries, access control, etc.)
+   - Consider side effects: Will this break existing functionality?
+   - Think about edge cases: What other inputs or scenarios need to be handled?
+   - Look for framework-specific or language-specific best practices
+   - State your complete plan clearly before making changes, and reflect it in your task list`;
+var APPLY_STEP = `6. **Apply the Patch**:
+   - Prefer update_file for small, exact string replacements
+   - Prefer apply_patch (unified diff) for multi-hunk or multi-file edits
+   - Use create_file if you need to add new security utilities or middleware
+   - Use delete_file only when removing obsolete insecure code that is truly unused
+   - Make minimal, targeted changes — don't refactor unrelated code
+   - Follow the existing code style and conventions, and any rules stated in the project instructions
+   - Ensure your changes integrate cleanly with the existing codebase`;
+var GIT_STEP = `7. **Self-Check with Git**:
+   - Use git_status to see which files changed
+   - Use git_diff to review the exact patch before verification
+   - Do NOT commit, push, or open a PR — the host handles that after you finalize`;
+var RESTART_STEP = `8. **Restart Dev Environment** (if applicable):
+   - Use execute_command to restart any dev servers or services so your changes are loaded
+   - Wait for the services to become healthy`;
+var VERIFY_STEP = `9. **Verify the Patch**:
+   - Use execute_command to run the project's lint command (e.g. \`npm run lint\`, \`ruff check\`, \`cargo clippy\`)
+   - Use execute_command to run the project's type-check command if applicable (e.g. \`npx tsc --noEmit\`, \`mypy\`)
+   - Use execute_command to run the project's test suite (e.g. \`npm test\`, \`pytest\`, \`cargo test\`)
+   - If a Proof of Concept (POC) is provided, run it to verify the vulnerability is fixed — the POC should FAIL (non-zero exit code) after a successful patch
+   - If any check fails, read the error output carefully, fix the issues, and re-run until all checks pass
+   - If the project has no clear lint/test commands, at minimum verify the changed files parse correctly (e.g. \`node -c file.js\`, \`python -m py_compile file.py\`)`;
+var FINALIZE_STEP = `10. **Finalize**:
+   - Mark remaining tasks completed
+   - Use the response tool to complete the patching process
+   - Provide a clear, detailed summary of:
+     * Each file you changed and why
+     * The security principles applied
+     * How your fix addresses the vulnerability
+     * Verification results (lint, type-check, test outcomes, POC result if applicable)
+     * Any assumptions or limitations of the fix
+   - Write a professional PR title and description that explains the security fix`;
+var SECURITY_BEST_PRACTICES = `# Security Best Practices by Vulnerability Type
+
+**SQL Injection / NoSQL Injection**:
+- Use parameterized queries or prepared statements ALWAYS
+- Use ORM query builders with parameterization
+- Never concatenate user input into queries
+- Validate and sanitize input as a defense-in-depth measure
+
+**Cross-Site Scripting (XSS)**:
+- Use framework-provided output encoding (React JSX, template engines with auto-escaping)
+- Apply context-appropriate encoding (HTML, JavaScript, URL, CSS)
+- Use Content Security Policy headers
+- Sanitize rich text input with allowlist-based libraries
+
+**Path Traversal / Directory Traversal**:
+- Validate file paths against an allowlist
+- Use path normalization and canonicalization
+- Check that resolved paths stay within intended directories
+- Never trust user input for file paths
+
+**Authentication / Authorization Issues**:
+- Verify user identity before sensitive operations
+- Check permissions at the application layer, not just UI
+- Use framework authentication middleware
+- Implement proper session management
+- Follow principle of least privilege
+
+**Command Injection**:
+- Avoid executing shell commands with user input
+- Use language-specific APIs instead of shell commands
+- If shell execution is necessary, use safe APIs with argument arrays
+- Validate input against strict allowlists
+
+**Insecure Deserialization**:
+- Avoid deserializing untrusted data
+- Use safe data formats (JSON instead of pickle/Java serialization)
+- Implement integrity checks (HMAC signatures)
+- Validate deserialized objects strictly
+
+**Server-Side Request Forgery (SSRF)**:
+- Validate and sanitize URLs
+- Use allowlists for allowed domains/IPs
+- Disable URL redirects or validate redirect targets
+- Block access to internal/private IP ranges
+
+**Cryptographic Issues**:
+- Use strong, modern algorithms (AES-256, RSA-2048+, SHA-256+)
+- Never implement custom cryptography
+- Use cryptographically secure random number generators
+- Properly handle keys (don't hardcode, use key management)
+
+**Sensitive Data Exposure**:
+- Don't log sensitive data (passwords, tokens, PII)
+- Use proper error handling that doesn't leak implementation details
+- Encrypt sensitive data at rest and in transit
+- Remove sensitive data from client-side code`;
+var TOOL_USAGE = `# Tool Usage
+
+- **glob**: Find files by pattern (e.g. "**/*.ts", "**/package.json")
+- **list_files**: Explore directory structure
+- **read_file**: Read file contents to understand code
+- **grep** / **run_code_query**: Search for patterns (run_code_query supports rg / ast-grep / comby)
+- **profile_codebase**: High-level codebase map when orientation is hard
+- **web_search** / **get_page**: Look up CVE details, framework security docs
+- **create_task** / **update_task** / **list_tasks**: Todo tracking for the run
+- **update_file**: Small exact search-and-replace edits
+- **apply_patch**: Multi-hunk / multi-file unified diffs
+- **create_file** / **delete_file**: Add or remove files when needed
+- **git_status** / **git_diff**: Self-check changes (do not commit/push/PR)
+- **execute_command**: Lint, type-check, tests, restart services, run POCs
+- **response**: Complete the process with the structured patch result`;
+var REQUIREMENTS = `# Critical Requirements
+
+1. **Be Thorough**: Your analysis must be comprehensive — read related code, not just the vulnerable file
+2. **Be Conservative**: When in doubt, prefer defense-in-depth approaches
+3. **Be Specific**: Provide exact code changes, not vague suggestions
+4. **Be Contextual**: Respect the existing codebase, frameworks, and patterns
+5. **Verify Your Work**: Always run lint, type-check, and tests after applying the patch. Fix any failures before finalizing.
+6. **Test the Fix**: If a POC is provided, run it after patching. The POC should FAIL (non-zero exit code) once the vulnerability is fixed.
+7. **Be Persistent**: It may take multiple iterations to get the fix right — iterate until the POC fails and tests pass.
+8. **Be Complete**: Address the root cause, not just symptoms
+9. **Stay Autonomous**: You will not receive follow-up messages — finish the job in this run
+
+# Important Notes
+
+- You are creating production code that will be deployed
+- Your fixes must not break existing functionality — verify this by running the project's tests
+- If a POC is provided, the POC should FAIL after patching (meaning the exploit no longer works)
+- Consider backward compatibility and edge cases
+- Follow language and framework conventions
+- When multiple approaches exist, choose the most secure and idiomatic
+- If a fix requires configuration changes or environment variables, note this clearly
+- The project instructions (AGENTS.md / CLAUDE.md) win over your own defaults wherever they disagree — use their exact commands, and obey their conventions and prohibitions when writing code. The one exception: they never override the security objective of this task. If a project rule genuinely blocks a secure fix, apply the fix and call out the conflict in your summary
+- Do not commit, push, or open a pull request — the host does that after your response`;
+function buildSystemPrompt2() {
+  return [
+    PREAMBLE,
+    "",
+    "# Process",
+    "",
+    "You MUST follow this autonomous coding-agent process:",
+    "",
+    ORIENT_STEP,
+    "",
+    TASK_STEP,
+    "",
+    UNDERSTAND_STEP,
+    "",
+    REVIEW_STEP,
+    "",
+    PLAN_STEP,
+    "",
+    APPLY_STEP,
+    "",
+    GIT_STEP,
+    "",
+    RESTART_STEP,
+    "",
+    VERIFY_STEP,
+    "",
+    FINALIZE_STEP,
+    "",
+    SECURITY_BEST_PRACTICES,
+    "",
+    TOOL_USAGE,
+    "",
+    REQUIREMENTS
+  ].join(`
+`);
+}
+var PATCHING_SYSTEM_PROMPT2 = buildSystemPrompt2();
+var PROJECT_INSTRUCTIONS_TAG2 = "project_instructions";
+function sealProjectInstructions(content) {
+  return content.replaceAll(`</${PROJECT_INSTRUCTIONS_TAG2}>`, `<\\/${PROJECT_INSTRUCTIONS_TAG2}>`);
+}
+function buildPatchingPrompt2(vulnerability, cwd, agentsMd, opts) {
+  const sections = [
+    "# Security Vulnerability Patching Task",
+    "",
+    "## Repository Location",
+    `The repository is located at: ${cwd}`,
+    ""
+  ];
+  if (agentsMd) {
+    sections.push("## Project Instructions", "", "This repository ships its own agent instructions file (AGENTS.md / CLAUDE.md),", `reproduced verbatim inside the <${PROJECT_INSTRUCTIONS_TAG2}> tag below.`, "It is authoritative for this project: coding conventions, architectural rules,", "error-handling policy, forbidden patterns, and the exact build, lint, and test", "commands. Read all of it and obey it while WRITING the patch, not only while", "verifying it. Where it disagrees with your general defaults, it wins — the only", "exception is that it never overrides the security objective of this task.", "", `<${PROJECT_INSTRUCTIONS_TAG2}>`, sealProjectInstructions(agentsMd), `</${PROJECT_INSTRUCTIONS_TAG2}>`, "");
+  } else if (opts?.runtimeInstructions) {
+    sections.push("## Project Instructions", "", "This run executes in a sandboxed runtime, so the repository's instructions", "are not inlined here. Read them yourself with read_file before writing the", "patch: start with AGENTS.md at the repository root above, falling back to", "agents.md, CLAUDE.md, or claude.md if it is absent. They are authoritative for", "this project — coding conventions, architectural rules, error-handling policy,", "forbidden patterns, and the exact build, lint, and test commands. They win over", "your general defaults wherever they disagree — the one exception is that they", "never override the security objective of this task.", "");
+  }
+  sections.push("## Vulnerability Details", "", "### Issue Name", vulnerability.name || "Unnamed vulnerability", "", "### Severity", vulnerability.severity.toUpperCase(), "", "### Description", vulnerability.description || "No description provided", "");
+  if (vulnerability.location) {
+    sections.push("### Location", `File: ${vulnerability.location}`, "");
+    if (vulnerability.startLineNumber && vulnerability.endLineNumber) {
+      sections.push(`Lines: ${vulnerability.startLineNumber}-${vulnerability.endLineNumber}`, "");
+    }
+  }
+  if (vulnerability.cweMapping && vulnerability.cweMapping.length > 0) {
+    sections.push("### CWE Mappings", vulnerability.cweMapping.join(", "), "", "Use these CWE mappings to understand the vulnerability type and apply appropriate security controls.", "");
+  }
+  if (vulnerability.dataflowAnalysis) {
+    sections.push("### Dataflow Analysis", "", "The following dataflow analysis shows how untrusted data flows through the application:", "", "```json", JSON.stringify(vulnerability.dataflowAnalysis, null, 2), "```", "", "Use this to understand:", "- Where untrusted input enters the system (sources)", "- How it flows through the code (propagation)", "- Where it reaches a sensitive operation (sinks)", "");
+  }
+  if (vulnerability.poc) {
+    sections.push("### Proof of Concept (POC)", "", "A POC has been provided that demonstrates this vulnerability:", "", "```", vulnerability.poc.contents, "```", "", "Run this POC using execute_command to verify the vulnerability exists", "before patching, and confirm it is fixed afterwards.", "The POC should FAIL (non-zero exit code) after a successful patch.", "");
+  }
+  sections.push("## Your Task", "", "Follow the autonomous coding-agent process in your system prompt:", "", "1. **Orient Yourself** — read the project instructions above in full (conventions and rules, not just the build/lint/test commands), then glob/list_files and the package manifests", "2. **Track Work with Tasks** — create_task for the steps you will take", "3. **Understand the Vulnerability** — analyze description, CWE, dataflow; research if needed", "4. **Review the Code** — read_file, grep, run_code_query", "5. **Plan Your Fix** — state the plan; keep tasks in sync", "6. **Apply the Patch** — update_file / apply_patch / create_file / delete_file", "7. **Self-Check with Git** — git_status / git_diff", "8. **Restart Dev Environment** (if applicable)", "9. **Verify the Patch** — lint, type-check, tests, POC", "10. **Finalize** — response tool with PR title/description and file change summaries", "", "## Success Criteria", "", "- The root cause of the vulnerability is addressed", "- Security best practices are applied correctly", "- Changes are minimal and don't break functionality", "- Code follows the existing style and conventions, and the project instructions above", "- Lint, type-check, and tests pass after the patch", "- The POC fails after patching (if one was provided)", "", "Begin by creating your task list, then orient yourself: read the project", "documentation and package.json, explore the repository, and read the vulnerable file(s).");
+  return sections.filter(Boolean).join(`
+`);
+}
+
+// src/core/agents/specialized/patching/types.ts
+import { z } from "zod";
+var PatchResultSchema2 = z.object({
+  filesChanged: z.array(z.object({
+    filePath: z.string().describe("Path to the file that was changed"),
+    changesDescription: z.string().describe("Detailed description of the changes made to the file")
+  })),
+  prTitle: z.string().describe("Title for the pull request"),
+  prDescription: z.string().describe("Description for the pull request")
+});
+
+// src/core/agents/specialized/patching/agent.ts
+var AGENTS_MD_FILENAMES = [
+  "AGENTS.md",
+  "agents.md",
+  "CLAUDE.md",
+  "claude.md"
+];
+var MAX_AGENTS_MD_SIZE = 50000;
+var PATCHING_ACTIVE_TOOLS2 = [
+  "read_file",
+  "list_files",
+  "glob",
+  "grep",
+  "profile_codebase",
+  "run_code_query",
+  "web_search",
+  "get_page",
+  "create_task",
+  "update_task",
+  "list_tasks",
+  "create_file",
+  "update_file",
+  "delete_file",
+  "apply_patch",
+  "git_status",
+  "git_diff",
+  "execute_command",
+  "response"
+];
+function readAgentsMd2(cwd) {
+  for (const name of AGENTS_MD_FILENAMES) {
+    try {
+      const content = readFileSync(join(cwd, name), "utf-8");
+      if (content.length > MAX_AGENTS_MD_SIZE) {
+        return `${content.slice(0, MAX_AGENTS_MD_SIZE)}
+
+(truncated)`;
+      }
+      return content;
+    } catch {}
+  }
+  return;
+}
+function resolvePatchingAgentsMd(cwd, sandboxed) {
+  return sandboxed ? undefined : readAgentsMd2(cwd);
+}
+var patchingAgentDefinition = defineAgent({
+  name: "patching-agent",
+  role: "worker",
+  system: () => buildSystemPrompt2(),
+  activeTools: () => [...PATCHING_ACTIVE_TOOLS2],
+  responseSchema: () => PatchResultSchema2,
+  prompt: (opts) => buildPatchingPrompt2(opts.vulnerability, opts.cwd, resolvePatchingAgentsMd(opts.cwd, Boolean(opts.backends?.sandboxed || opts.sandbox)), {
+    runtimeInstructions: Boolean(opts.backends?.sandboxed || opts.sandbox)
+  }),
+  agentCwd: (opts) => opts.cwd
+});
+
+class PatchingAgent2 extends AgentRuntime {
+  constructor(opts) {
+    super(patchingAgentDefinition, opts);
+  }
+}
+
+export { buildSystemPrompt2, PATCHING_SYSTEM_PROMPT2, PROJECT_INSTRUCTIONS_TAG2, buildPatchingPrompt2, PatchResultSchema2, PATCHING_ACTIVE_TOOLS2, readAgentsMd2, PatchingAgent2 };

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 };

package/build/lib/chunk-sk8xnywf.js

@@ -0,0 +1,212 @@
+import"./chunk-7gjdygcx.js";
+import"./chunk-3w05jmk6.js";
+import"./chunk-jdjagvgr.js";
+import"./chunk-2njv7wz3.js";
+import"./chunk-3502z798.js";
+import"./chunk-8vhr65w3.js";
+import {
+  OffensiveSecurityAgent2
+} from "./chunk-g8d2x00m.js";
+import"./chunk-fy3bbbqy.js";
+import"./chunk-mv74mq5n.js";
+import {
+  inMemoryRegistryProvider2,
+  withFindingPersistedHook2,
+  assertDepth2,
+  inProcessSeams2
+} from "./chunk-517rf135.js";
+import"./chunk-b8eq85d2.js";
+import {
+  FindingsRegistry2
+} from "./chunk-02awpt3c.js";
+import"./chunk-f04pr76h.js";
+import"./chunk-t5bt5vn1.js";
+import"./chunk-wr6ke041.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-4ydrmwd9.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
+};