@pensar/apex 2.5.0 → 2.6.1-canary.025b1ecf

package/build/lib/chunk-8dqz8cwa.js

@@ -0,0 +1,27 @@
+import {
+  buildSystemPrompt2,
+  PATCHING_SYSTEM_PROMPT2,
+  PROJECT_INSTRUCTIONS_TAG2,
+  buildPatchingPrompt2,
+  PatchResultSchema2,
+  PATCHING_ACTIVE_TOOLS2,
+  readAgentsMd2,
+  PatchingAgent2
+} from "./chunk-a3gxgj9r.js";
+import {
+  __export
+} from "./chunk-n0ba7khr.js";
+
+// src/core/agents/specialized/patching/index.ts
+var exports_patching = {};
+__export(exports_patching, {
+  PATCHING_ACTIVE_TOOLS: () => PATCHING_ACTIVE_TOOLS2,
+  PATCHING_SYSTEM_PROMPT: () => PATCHING_SYSTEM_PROMPT2,
+  PROJECT_INSTRUCTIONS_TAG: () => PROJECT_INSTRUCTIONS_TAG2,
+  PatchResultSchema: () => PatchResultSchema2,
+  PatchingAgent: () => PatchingAgent2,
+  buildPatchingPrompt: () => buildPatchingPrompt2,
+  buildSystemPrompt: () => buildSystemPrompt2,
+  readAgentsMd: () => readAgentsMd2
+});
+export { exports_patching };

package/build/lib/chunk-8vhr65w3.js

@@ -0,0 +1,272 @@
+import {
+  __using,
+  __callDispose
+} from "./chunk-n0ba7khr.js";
+
+// src/core/storage/index.ts
+import fs, { readdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import z2 from "zod";
+
+// src/util/errors.ts
+import z from "zod";
+
+class NamedError extends Error {
+  static create(name, data) {
+    const schema = z.object({
+      name: z.literal(name),
+      data
+    });
+    const result = class extends NamedError {
+      data;
+      static Schema = schema;
+      name = name;
+      constructor(data, options) {
+        super(name, options);
+        this.data = data;
+        this.name = name;
+      }
+      static isInstance(input) {
+        return typeof input === "object" && input !== null && "name" in input && input.name === name;
+      }
+      schema() {
+        return schema;
+      }
+      toObject() {
+        return {
+          name,
+          data: this.data
+        };
+      }
+    };
+    Object.defineProperty(result, "name", { value: name });
+    return result;
+  }
+  static Unknown = NamedError.create("UnknownError", z.object({
+    message: z.string()
+  }));
+}
+
+// src/util/lock.ts
+var locks = new Map;
+function getLock(key) {
+  let lock = locks.get(key);
+  if (!lock) {
+    lock = {
+      readers: 0,
+      writer: false,
+      waitingReaders: [],
+      waitingWriters: []
+    };
+    locks.set(key, lock);
+  }
+  return lock;
+}
+function processQueue(key) {
+  const lock = locks.get(key);
+  if (!lock || lock.writer || lock.readers > 0)
+    return;
+  if (lock.waitingWriters.length > 0) {
+    const nextWriter = lock.waitingWriters.shift();
+    nextWriter?.();
+    return;
+  }
+  while (lock.waitingReaders.length > 0) {
+    const nextReader = lock.waitingReaders.shift();
+    nextReader?.();
+  }
+  if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
+    locks.delete(key);
+  }
+}
+async function read2(key) {
+  const lock = getLock(key);
+  return new Promise((resolve) => {
+    if (!lock.writer && lock.waitingWriters.length === 0) {
+      lock.readers++;
+      resolve({
+        [Symbol.dispose]: () => {
+          lock.readers--;
+          processQueue(key);
+        }
+      });
+    } else {
+      lock.waitingReaders.push(() => {
+        lock.readers++;
+        resolve({
+          [Symbol.dispose]: () => {
+            lock.readers--;
+            processQueue(key);
+          }
+        });
+      });
+    }
+  });
+}
+async function write2(key) {
+  const lock = getLock(key);
+  return new Promise((resolve) => {
+    if (!lock.writer && lock.readers === 0) {
+      lock.writer = true;
+      resolve({
+        [Symbol.dispose]: () => {
+          lock.writer = false;
+          processQueue(key);
+        }
+      });
+    } else {
+      lock.waitingWriters.push(() => {
+        lock.writer = true;
+        resolve({
+          [Symbol.dispose]: () => {
+            lock.writer = false;
+            processQueue(key);
+          }
+        });
+      });
+    }
+  });
+}
+
+// src/core/storage/index.ts
+var NotFoundError = NamedError.create("NotFoundError", z2.object({
+  message: z2.string()
+}));
+function getBaseDir() {
+  return process.env.PENSAR_DATA_DIR ?? path.join(os.homedir(), ".pensar");
+}
+async function remove(key) {
+  const dir = getBaseDir();
+  const target = `${path.join(dir, ...key)}.json`;
+  return withErrorHandling(async () => {
+    await fs.unlink(target).catch(() => {});
+  });
+}
+async function write(key, content, ext) {
+  const dir = getBaseDir();
+  const target = path.join(dir, ...key) + (ext ? ext : ".json");
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _ = __using(__stack, await write2(target), 0);
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      await fs.writeFile(target, JSON.stringify(content, null, 2), "utf-8");
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function createDir(key) {
+  const dir = getBaseDir();
+  const target = path.join(dir, ...key);
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _ = __using(__stack, await write2(target), 0);
+      await fs.mkdir(target, { recursive: true });
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function writeRaw(key, content) {
+  const dir = getBaseDir();
+  const target = path.join(dir, ...key);
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _ = __using(__stack, await write2(target), 0);
+      const parentDir = path.dirname(target);
+      await fs.mkdir(parentDir, { recursive: true });
+      await fs.writeFile(target, content, "utf-8");
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function read(key, ext) {
+  const dir = getBaseDir();
+  const target = path.join(dir, ...key) + (ext ? ext : ".json");
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _ = __using(__stack, await read2(target), 0);
+      const text = await fs.readFile(target, "utf-8");
+      const result = ext ? text : JSON.parse(text);
+      return result;
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function update(key, fn, ext) {
+  const dir = getBaseDir();
+  const target = path.join(dir, ...key) + (ext ? ext : ".json");
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _ = __using(__stack, await write2(target), 0);
+      const text = await fs.readFile(target, "utf-8");
+      const content = ext ? text : JSON.parse(text);
+      fn(content);
+      await fs.writeFile(target, JSON.stringify(content, null, 2), "utf-8");
+      return content;
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function withErrorHandling(body) {
+  return body().catch((e) => {
+    if (!(e instanceof Error))
+      throw e;
+    const errnoExcpetion = e;
+    if (errnoExcpetion.code === "ENOENT") {
+      throw new NotFoundError({
+        message: `Resource not found: ${errnoExcpetion.path}`
+      });
+    }
+    throw e;
+  });
+}
+async function listFilesRecursively(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursively(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function list3(prefix) {
+  const dir = getBaseDir();
+  const targetDir = path.join(dir, ...prefix);
+  try {
+    const files = await listFilesRecursively(targetDir);
+    const result = files.map((filePath) => {
+      const relativePath = path.relative(targetDir, filePath);
+      return [...prefix, ...relativePath.slice(0, -5).split(path.sep)];
+    });
+    result.sort();
+    return result;
+  } catch {
+    return [];
+  }
+}
+
+export { NotFoundError, remove, write, createDir, writeRaw, read, update, list3 };

package/build/lib/chunk-8xnzgfs0.js

@@ -0,0 +1,56 @@
+import {
+  TargetedPentestAgent2
+} from "./chunk-q8bk9dys.js";
+
+// src/core/runtime/agentExecution.ts
+function startAgentExecution(agent) {
+  const result = agent.consume();
+  return {
+    result,
+    abortAndDrain: () => agent.abortAndDrain(),
+    drained: agent.drained
+  };
+}
+
+// src/core/api/targetedPentest.ts
+function normalizeResult(result) {
+  const r = result;
+  if (!r || !Array.isArray(r.findings)) {
+    console.error("runTargetedPentestAgent: consume() returned unexpected shape", { keys: result ? Object.keys(result) : null });
+  }
+  const findings = Array.isArray(r?.findings) ? r.findings : [];
+  console.log(`
+Found ${findings.length} vulnerabilities`);
+  console.log(`Findings: ${r?.findingsPath}`);
+  console.log(`POCs: ${r?.pocsPath}`);
+  return {
+    findings,
+    findingsPath: r?.findingsPath,
+    pocsPath: r?.pocsPath,
+    objectiveResults: r?.objectiveResults,
+    newObjectives: r?.newObjectives
+  };
+}
+function startTargetedPentestAgent2(input) {
+  const agent = new TargetedPentestAgent2(input);
+  if (!input.eventBus) {
+    agent.eventBus.on("text-delta", (d) => process.stdout.write(d.text));
+    agent.eventBus.on("tool-call-complete", (d) => console.log(`→ calling ${d.toolName}`));
+    agent.eventBus.on("tool-result", (d) => console.log(`✓ ${d.toolName} completed`));
+    agent.eventBus.on("error", (d) => console.error("Agent error:", d.error));
+  }
+  const { result, abortAndDrain, drained } = startAgentExecution(agent);
+  return {
+    result: result.then(normalizeResult),
+    abortAndDrain,
+    drained
+  };
+}
+async function runTargetedPentestAgent2(input) {
+  const { result, drained } = startTargetedPentestAgent2(input);
+  const findings = await result;
+  await drained;
+  return findings;
+}
+
+export { startAgentExecution, startTargetedPentestAgent2, runTargetedPentestAgent2 };

package/build/lib/chunk-9nsrd4xg.js

@@ -0,0 +1,12 @@
+// src/core/agents/specialized/mobileOtpPrompt.ts
+var MOBILE_OTP_PROMPT_GUIDANCE = `## Mobile OTP credentials
+
+Read each credential's \`Authentication method\` before starting:
+- \`sms-passwordless\`: \`phoneNumber\` is the login identifier, not MFA after a password. Reserve immediately before filling that field, then request the code.
+- \`sms-mfa\`: fill username and password first. If submitting the password triggers the SMS code, reserve immediately before submitting. If it reveals a separate send-code action, reserve immediately before that action. Fill a destination phone field only if the target asks, using \`credentialId\` + \`credentialField="phoneNumber"\`.
+
+Never ask for, write, log, or pass a public phone number. Reserve with \`sms_list_messages\` and \`reserve=true\`; the Console chooses the shared number. A 429 means that number is busy: do not wait or poll inside the tool. Make at most two separate reservation attempts (with an \`execute_command\` sleep between them), then report the authentication block.
+
+At the action that sends the code, record \`Date.now()\` as \`sinceMs\`. Run \`execute_command\` \`sleep 5\`, then call \`sms_list_messages\` with \`sinceMs\` and \`claim=true\`. If no message arrives, make one delayed list retry; otherwise report the result rather than waiting indefinitely. Fill the claimed OTP and continue. Do not report \`phone_verification\` as a barrier for either Mobile OTP flow. TOTP via an environment variable is unchanged.`;
+
+export { MOBILE_OTP_PROMPT_GUIDANCE };

package/build/lib/chunk-a3gxgj9r.js

@@ -0,0 +1,317 @@
+import {
+  AgentRuntime,
+  defineAgent
+} from "./chunk-4p2n69vn.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 };