sentinelayer-cli 0.6.2 → 0.8.0

package/src/swarm/pentest.js

@@ -1,934 +1,934 @@
-import { createHash, createHmac, randomUUID } from "node:crypto";
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { getTargetById } from "../ai/domain-target-store.js";
-import { resolveOutputRoot } from "../config/service.js";
-
-const PENTEST_SCHEMA_VERSION = 1;
-
-const BUILTIN_PENTEST_SCENARIOS = Object.freeze([
-  {
-    id: "auth-bypass",
-    title: "Auth Bypass",
-    description:
-      "Probe authentication and session controls using expired tokens, missing headers, and CSRF token omission.",
-    owaspCategories: ["A07:2021-Identification and Authentication Failures", "A01:2021-Broken Access Control"],
-  },
-  {
-    id: "rate-limit-probe",
-    title: "Rate Limit Probe",
-    description: "Probe API threshold behavior to verify rate-limit enforcement at configured policy ceilings.",
-    owaspCategories: ["A04:2021-Insecure Design"],
-  },
-  {
-    id: "input-validation",
-    title: "Input Validation",
-    description: "Inject XSS and SQL-like payloads to detect reflection and server-side validation failures.",
-    owaspCategories: ["A03:2021-Injection"],
-  },
-  {
-    id: "privilege-escalation",
-    title: "Privilege Escalation",
-    description: "Attempt privileged endpoints with standard-user context to detect broken access boundaries.",
-    owaspCategories: ["A01:2021-Broken Access Control"],
-  },
-]);
-
-const SUPPORTED_SCENARIOS = new Set(["pen-test", ...BUILTIN_PENTEST_SCENARIOS.map((scenario) => scenario.id)]);
-
-function normalizeString(value) {
-  return String(value || "").trim();
-}
-
-function normalizeLower(value) {
-  return normalizeString(value).toLowerCase();
-}
-
-function normalizeUpper(value) {
-  return normalizeString(value).toUpperCase();
-}
-
-function formatTimestampToken() {
-  const now = new Date();
-  const pad = (value) => String(value).padStart(2, "0");
-  return `${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}-${pad(
-    now.getUTCHours()
-  )}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`;
-}
-
-function createPentestRunId() {
-  return `swarm-pentest-${formatTimestampToken()}-${randomUUID().slice(0, 8)}`;
-}
-
-function sha256Hex(value) {
-  return createHash("sha256").update(String(value || ""), "utf-8").digest("hex");
-}
-
-function hmacSha256Hex(key, value) {
-  return createHmac("sha256", String(key || "")).update(String(value || ""), "utf-8").digest("hex");
-}
-
-function toPosixPath(value) {
-  return String(value || "").replace(/\\/g, "/");
-}
-
-function normalizePathPattern(value) {
-  const raw = normalizeString(value);
-  if (!raw) {
-    return "/";
-  }
-  if (raw === "*" || raw === "/*") {
-    return "/*";
-  }
-  return raw.startsWith("/") ? raw : `/${raw}`;
-}
-
-function escapeRegex(value) {
-  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function compilePathPattern(pattern) {
-  const normalized = normalizePathPattern(pattern);
-  if (normalized === "/" || normalized === "/*") {
-    return /^\/.*/;
-  }
-  const source = `^${normalized.split("*").map(escapeRegex).join(".*")}$`;
-  return new RegExp(source);
-}
-
-function isPathAllowed(pathname, allowedPaths = []) {
-  const targetPath = normalizePathPattern(pathname);
-  if (!Array.isArray(allowedPaths) || allowedPaths.length === 0) {
-    return false;
-  }
-  return allowedPaths.some((pattern) => compilePathPattern(pattern).test(targetPath));
-}
-
-function materializeAllowedPath(pattern) {
-  const normalized = normalizePathPattern(pattern);
-  if (normalized === "/" || normalized === "/*") {
-    return "/";
-  }
-  const withoutWildcard = normalized.replace(/\*/g, "probe");
-  return withoutWildcard || "/";
-}
-
-function selectPolicyPath(preferredPaths = [], allowedPaths = []) {
-  for (const candidate of preferredPaths) {
-    const normalizedCandidate = normalizePathPattern(candidate);
-    if (isPathAllowed(normalizedCandidate, allowedPaths)) {
-      return normalizedCandidate;
-    }
-  }
-  if (allowedPaths.length === 0) {
-    throw new Error("Target policy has no allowed paths.");
-  }
-  return materializeAllowedPath(allowedPaths[0]);
-}
-
-function parseTargetUrl(urlValue) {
-  const normalized = normalizeString(urlValue);
-  if (!normalized) {
-    throw new Error("targetUrl is required.");
-  }
-  let parsed;
-  try {
-    parsed = new URL(normalized);
-  } catch {
-    throw new Error(`Invalid target URL '${normalized}'.`);
-  }
-  if (!/^https?:$/i.test(parsed.protocol)) {
-    throw new Error("targetUrl must use http or https.");
-  }
-  parsed.hash = "";
-  return parsed;
-}
-
-function normalizePolicy(policy = {}) {
-  const allowedPaths = Array.isArray(policy.allowedPaths)
-    ? [...new Set(policy.allowedPaths.map((item) => normalizePathPattern(item)).filter(Boolean))]
-    : [];
-  const allowedMethods = Array.isArray(policy.allowedMethods)
-    ? [...new Set(policy.allowedMethods.map((item) => normalizeUpper(item)).filter(Boolean))]
-    : [];
-  const allowedScenarios = Array.isArray(policy.allowedScenarios)
-    ? [...new Set(policy.allowedScenarios.map((item) => normalizeLower(item)).filter(Boolean))]
-    : [];
-  const maxRps = Number(policy.maxRps);
-  const maxConcurrency = Number(policy.maxConcurrency);
-
-  return {
-    allowedPaths,
-    allowedMethods,
-    allowedScenarios,
-    maxRps: Number.isFinite(maxRps) && maxRps > 0 ? Math.floor(maxRps) : 1,
-    maxConcurrency: Number.isFinite(maxConcurrency) && maxConcurrency > 0 ? Math.floor(maxConcurrency) : 1,
-    stopConditions:
-      policy.stopConditions && typeof policy.stopConditions === "object" ? policy.stopConditions : {},
-  };
-}
-
-function ensureScenarioAllowed(policy = {}, scenarioId = "") {
-  const allowed = new Set((policy.allowedScenarios || []).map((item) => normalizeLower(item)));
-  if (allowed.has("*") || allowed.has("all") || allowed.has("pen-test") || allowed.has(scenarioId)) {
-    return;
-  }
-  throw new Error(
-    `Target policy does not allow scenario '${scenarioId}'. Allowed scenarios: ${[...allowed].join(", ") || "(none)"}`
-  );
-}
-
-function ensureMethodAllowed(policy = {}, method = "", scenarioId = "") {
-  const normalizedMethod = normalizeUpper(method);
-  const allowedMethods = new Set((policy.allowedMethods || []).map((item) => normalizeUpper(item)));
-  if (allowedMethods.has(normalizedMethod)) {
-    return;
-  }
-  throw new Error(
-    `Target policy does not allow HTTP method '${normalizedMethod}' required for scenario '${scenarioId}'.`
-  );
-}
-
-function resolveScenarioSelection({ scenario = "pen-test", pentestScenario = "auth-bypass" } = {}) {
-  const normalizedScenario = normalizeLower(scenario || "pen-test");
-  if (!SUPPORTED_SCENARIOS.has(normalizedScenario)) {
-    throw new Error(
-      `Unsupported pen-test scenario '${normalizedScenario}'. Use one of: ${[...SUPPORTED_SCENARIOS].join(", ")}`
-    );
-  }
-  if (normalizedScenario === "pen-test") {
-    const selected = normalizeLower(pentestScenario || "auth-bypass");
-    if (!BUILTIN_PENTEST_SCENARIOS.some((item) => item.id === selected)) {
-      throw new Error(
-        `Unsupported --pen-test-scenario '${selected}'. Built-in scenarios: ${BUILTIN_PENTEST_SCENARIOS.map((item) => item.id).join(", ")}`
-      );
-    }
-    return selected;
-  }
-  return normalizedScenario;
-}
-
-function createFinding({
-  severity = "P2",
-  title = "",
-  description = "",
-  owaspCategory = "",
-  checkId = "",
-  evidence = {},
-  index = 1,
-} = {}) {
-  return {
-    findingId: `PENTEST-F${String(index).padStart(3, "0")}`,
-    severity: normalizeUpper(severity || "P2"),
-    title: normalizeString(title),
-    description: normalizeString(description),
-    owaspCategory: normalizeString(owaspCategory),
-    checkId: normalizeString(checkId),
-    evidence,
-  };
-}
-
-function summarizeFindings(findings = []) {
-  const counts = {
-    P0: 0,
-    P1: 0,
-    P2: 0,
-    P3: 0,
-  };
-  for (const finding of findings) {
-    const severity = normalizeUpper(finding.severity || "P3");
-    if (Object.prototype.hasOwnProperty.call(counts, severity)) {
-      counts[severity] += 1;
-    }
-  }
-  return {
-    ...counts,
-    findingCount: findings.length,
-    blocking: counts.P0 > 0 || counts.P1 > 0,
-  };
-}
-
-function buildCheckPlan({ scenarioId, targetUrl, policy }) {
-  if (scenarioId === "auth-bypass") {
-    ensureMethodAllowed(policy, "GET", scenarioId);
-    ensureMethodAllowed(policy, "POST", scenarioId);
-    const adminPath = selectPolicyPath(["/admin", "/admin/users"], policy.allowedPaths);
-    const profilePath = selectPolicyPath(["/account/profile", "/profile"], policy.allowedPaths);
-    return [
-      {
-        checkId: "auth-bypass-expired-token",
-        method: "GET",
-        path: adminPath,
-        headers: {
-          Authorization: "Bearer expired.jwt.token",
-          "X-Sentinelayer-Pentest": "auth-bypass-expired-token",
-        },
-        body: "",
-        evaluation: "deny",
-        owaspCategory: "A07:2021-Identification and Authentication Failures",
-      },
-      {
-        checkId: "auth-bypass-missing-auth",
-        method: "GET",
-        path: adminPath,
-        headers: {
-          "X-Sentinelayer-Pentest": "auth-bypass-missing-auth",
-        },
-        body: "",
-        evaluation: "deny",
-        owaspCategory: "A07:2021-Identification and Authentication Failures",
-      },
-      {
-        checkId: "csrf-missing-token",
-        method: "POST",
-        path: profilePath,
-        headers: {
-          "Content-Type": "application/json",
-          "X-Sentinelayer-Pentest": "csrf-missing-token",
-        },
-        body: JSON.stringify({
-          displayName: "sentinelayer-pentest",
-          csrfToken: "",
-        }),
-        evaluation: "csrf_deny",
-        owaspCategory: "A01:2021-Broken Access Control",
-      },
-    ];
-  }
-
-  if (scenarioId === "rate-limit-probe") {
-    ensureMethodAllowed(policy, "GET", scenarioId);
-    const probePath = selectPolicyPath(["/api/health", "/health", "/"], policy.allowedPaths);
-    const requestCount = Math.max(3, Math.min(30, Number(policy.maxRps || 1) + 2));
-    return Array.from({ length: requestCount }).map((_, index) => ({
-      checkId: `rate-limit-probe-${String(index + 1).padStart(2, "0")}`,
-      method: "GET",
-      path: probePath,
-      headers: {
-        "X-Sentinelayer-Pentest": "rate-limit-probe",
-        "X-Sentinelayer-Probe-Index": String(index + 1),
-      },
-      body: "",
-      evaluation: "rate_limit_series",
-      owaspCategory: "A04:2021-Insecure Design",
-    }));
-  }
-
-  if (scenarioId === "input-validation") {
-    ensureMethodAllowed(policy, "POST", scenarioId);
-    const inputPath = selectPolicyPath(["/search", "/auth/login", "/"], policy.allowedPaths);
-    const xssPayload = "<script>alert(1)</script>";
-    const sqlPayload = "' OR 1=1 --";
-    return [
-      {
-        checkId: "input-validation-xss",
-        method: "POST",
-        path: inputPath,
-        headers: {
-          "Content-Type": "application/json",
-          "X-Sentinelayer-Pentest": "input-validation-xss",
-        },
-        body: JSON.stringify({
-          query: xssPayload,
-          email: "user@example.com",
-        }),
-        evaluation: "reflect_or_reject",
-        expectedPayload: xssPayload,
-        owaspCategory: "A03:2021-Injection",
-      },
-      {
-        checkId: "input-validation-sqli",
-        method: "POST",
-        path: inputPath,
-        headers: {
-          "Content-Type": "application/json",
-          "X-Sentinelayer-Pentest": "input-validation-sqli",
-        },
-        body: JSON.stringify({
-          username: sqlPayload,
-          password: "example-password",
-        }),
-        evaluation: "reflect_or_error",
-        expectedPayload: sqlPayload,
-        owaspCategory: "A03:2021-Injection",
-      },
-    ];
-  }
-
-  if (scenarioId === "privilege-escalation") {
-    ensureMethodAllowed(policy, "GET", scenarioId);
-    const adminPath = selectPolicyPath(["/admin", "/admin/users"], policy.allowedPaths);
-    return [
-      {
-        checkId: "privilege-escalation-admin-endpoint",
-        method: "GET",
-        path: adminPath,
-        headers: {
-          Authorization: "Bearer standard-user-token",
-          "X-Sentinelayer-Pentest": "privilege-escalation",
-        },
-        body: "",
-        evaluation: "deny",
-        owaspCategory: "A01:2021-Broken Access Control",
-      },
-    ];
-  }
-
-  throw new Error(`Unsupported pentest scenario '${scenarioId}'.`);
-}
-
-function appendHeaders(headers) {
-  if (!headers || typeof headers !== "object") {
-    return {};
-  }
-  const normalized = {};
-  for (const [key, value] of Object.entries(headers)) {
-    const nextKey = normalizeString(key);
-    if (!nextKey) {
-      continue;
-    }
-    normalized[nextKey] = String(value ?? "");
-  }
-  return normalized;
-}
-
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function executeCheckRequest({
-  targetUrl,
-  request,
-  execute = false,
-  timeoutMs = 10000,
-} = {}) {
-  const url = new URL(request.path, targetUrl);
-  const requestHeaders = appendHeaders(request.headers);
-  const requestBody = normalizeString(request.body);
-
-  if (!execute) {
-    return {
-      dryRun: true,
-      status: null,
-      headers: {},
-      body: "",
-      durationMs: 0,
-      error: "",
-      request: {
-        method: request.method,
-        url: url.toString(),
-        path: url.pathname,
-        headers: requestHeaders,
-        body: requestBody,
-      },
-    };
-  }
-
-  const startedAt = Date.now();
-  const abortController = new AbortController();
-  const timeoutHandle = setTimeout(() => {
-    abortController.abort();
-  }, timeoutMs);
-
-  try {
-    const response = await fetch(url.toString(), {
-      method: request.method,
-      headers: requestHeaders,
-      body: requestBody || undefined,
-      signal: abortController.signal,
-    });
-    const responseBody = await response.text();
-    const responseHeaders = {};
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value;
-    });
-
-    return {
-      dryRun: false,
-      status: response.status,
-      headers: responseHeaders,
-      body: responseBody,
-      durationMs: Date.now() - startedAt,
-      error: "",
-      request: {
-        method: request.method,
-        url: url.toString(),
-        path: url.pathname,
-        headers: requestHeaders,
-        body: requestBody,
-      },
-    };
-  } catch (error) {
-    return {
-      dryRun: false,
-      status: null,
-      headers: {},
-      body: "",
-      durationMs: Date.now() - startedAt,
-      error: error instanceof Error ? error.message : String(error),
-      request: {
-        method: request.method,
-        url: url.toString(),
-        path: url.pathname,
-        headers: requestHeaders,
-        body: requestBody,
-      },
-    };
-  } finally {
-    clearTimeout(timeoutHandle);
-  }
-}
-
-function evaluateRequestFindings({ scenarioId, check, result, findingStartIndex }) {
-  const findings = [];
-  const status = Number(result.status || 0);
-  const responseBody = String(result.body || "");
-  const checkId = normalizeString(check.checkId);
-  const owaspCategory = normalizeString(check.owaspCategory);
-
-  if (check.evaluation === "deny" && status > 0 && status < 400) {
-    findings.push(
-      createFinding({
-        index: findingStartIndex + findings.length,
-        severity: "P1",
-        title: "Unauthorized access path was accepted",
-        description: `Scenario '${scenarioId}' expected denial, but endpoint returned HTTP ${status}.`,
-        owaspCategory,
-        checkId,
-        evidence: {
-          path: result.request.path,
-          method: result.request.method,
-          status,
-          responseBody,
-        },
-      })
-    );
-  }
-
-  if (check.evaluation === "csrf_deny" && status > 0 && status < 400) {
-    findings.push(
-      createFinding({
-        index: findingStartIndex + findings.length,
-        severity: "P2",
-        title: "CSRF guard appears missing for state-changing request",
-        description: `Scenario '${scenarioId}' submitted state-changing request without CSRF token and received HTTP ${status}.`,
-        owaspCategory,
-        checkId,
-        evidence: {
-          path: result.request.path,
-          method: result.request.method,
-          status,
-          responseBody,
-        },
-      })
-    );
-  }
-
-  if (check.evaluation === "reflect_or_reject" && check.expectedPayload) {
-    if (responseBody.includes(check.expectedPayload)) {
-      findings.push(
-        createFinding({
-          index: findingStartIndex + findings.length,
-          severity: "P1",
-          title: "Potential reflected injection payload",
-          description: "Response body reflected raw XSS payload.",
-          owaspCategory,
-          checkId,
-          evidence: {
-            path: result.request.path,
-            method: result.request.method,
-            status,
-            reflectedPayload: check.expectedPayload,
-          },
-        })
-      );
-    }
-  }
-
-  if (check.evaluation === "reflect_or_error" && check.expectedPayload) {
-    const loweredBody = responseBody.toLowerCase();
-    if (responseBody.includes(check.expectedPayload) || status >= 500 || /sql|syntax|database/.test(loweredBody)) {
-      findings.push(
-        createFinding({
-          index: findingStartIndex + findings.length,
-          severity: "P1",
-          title: "Potential SQL injection handling failure",
-          description:
-            "Endpoint response suggests SQL payload reflection or backend error path under injection input.",
-          owaspCategory,
-          checkId,
-          evidence: {
-            path: result.request.path,
-            method: result.request.method,
-            status,
-            responseBody,
-          },
-        })
-      );
-    }
-  }
-
-  return findings;
-}
-
-function evaluateRateLimitFindings({ scenarioId, checks = [], results = [], execute = false, findingStartIndex = 1 }) {
-  if (!execute) {
-    return [];
-  }
-  const scopedResults = results.filter((item) => item.check.evaluation === "rate_limit_series");
-  if (scopedResults.length === 0) {
-    return [];
-  }
-  const observed429 = scopedResults.some((item) => Number(item.result.status || 0) === 429);
-  if (observed429) {
-    return [];
-  }
-  const first = scopedResults[0];
-  return [
-    createFinding({
-      index: findingStartIndex,
-      severity: "P2",
-      title: "Rate-limit threshold not observed at configured probe pace",
-      description: `Scenario '${scenarioId}' did not observe HTTP 429 responses during rate-limit probing.`,
-      owaspCategory: "A04:2021-Insecure Design",
-      checkId: first?.check?.checkId || "rate-limit-probe",
-      evidence: {
-        requestCount: checks.length,
-        statuses: scopedResults.map((item) => item.result.status),
-      },
-    }),
-  ];
-}
-
-function renderPentestReportMarkdown(report = {}) {
-  const scenarioMeta =
-    BUILTIN_PENTEST_SCENARIOS.find((scenario) => scenario.id === report.scenarioId) || null;
-  const findingRows = (report.findings || [])
-    .map(
-      (finding) =>
-        `- [${finding.severity}] ${finding.findingId} :: ${finding.title} (${finding.owaspCategory}) @ ${finding.checkId}`
-    )
-    .join("\n");
-
-  return `# PENTEST_REPORT
-
-Generated: ${report.generatedAt}
-Run ID: ${report.runId}
-Scenario: ${report.scenarioId}
-Scenario title: ${scenarioMeta?.title || report.scenarioId}
-Target URL: ${report.target.url}
-Target ID: ${report.target.targetId}
-Execute: ${report.execute ? "yes" : "no"}
-
-Target policy:
-- allowed_paths: ${(report.target.policy.allowedPaths || []).join(", ") || "(none)"}
-- allowed_methods: ${(report.target.policy.allowedMethods || []).join(", ") || "(none)"}
-- allowed_scenarios: ${(report.target.policy.allowedScenarios || []).join(", ") || "(none)"}
-- max_rps: ${report.target.policy.maxRps}
-- max_concurrency: ${report.target.policy.maxConcurrency}
-
-Summary:
-- findings: ${report.summary.findingCount}
-- P0: ${report.summary.P0}
-- P1: ${report.summary.P1}
-- P2: ${report.summary.P2}
-- P3: ${report.summary.P3}
-- blocking: ${report.summary.blocking ? "yes" : "no"}
-
-Checks executed:
-- check_count: ${report.checkCount}
-- request_count: ${report.requestCount}
-
-Findings:
-${findingRows || "- none"}
-
-Artifacts:
-- audit_log: ${report.auditLogPath}
-- identity_isolation: ${report.identityIsolationPath}
-- cleanup_contract: ${report.cleanupContractPath}
-- report_json: ${report.reportJsonPath}
-- request_plan_json: ${report.requestPlanPath}
-`;
-}
-
-export function listBuiltinPentestScenarios() {
-  return BUILTIN_PENTEST_SCENARIOS.map((item) => ({
-    id: item.id,
-    title: item.title,
-    description: item.description,
-    owaspCategories: [...item.owaspCategories],
-  }));
-}
-
-export async function runSwarmPentest({
-  targetPath = ".",
-  outputDir = "",
-  targetId = "",
-  targetUrl = "",
-  scenario = "pen-test",
-  pentestScenario = "auth-bypass",
-  execute = false,
-  env,
-  homeDir,
-} = {}) {
-  const normalizedTargetPath = path.resolve(String(targetPath || "."));
-  const normalizedTargetId = normalizeString(targetId);
-  if (!normalizedTargetId) {
-    throw new Error("targetId is required.");
-  }
-  const parsedTargetUrl = parseTargetUrl(targetUrl);
-
-  const outputRoot = await resolveOutputRoot({
-    cwd: normalizedTargetPath,
-    outputDirOverride: outputDir,
-    env,
-    homeDir,
-  });
-  const trackedTarget = await getTargetById({
-    outputRoot,
-    targetId: normalizedTargetId,
-  });
-  if (!trackedTarget.target) {
-    throw new Error(`Target '${normalizedTargetId}' is not present in local registry (${trackedTarget.registryPath}).`);
-  }
-
-  const verificationStatus = normalizeUpper(trackedTarget.target.verificationStatus);
-  const freezeStatus = normalizeUpper(trackedTarget.target.freezeStatus);
-  const status = normalizeUpper(trackedTarget.target.status);
-  if (verificationStatus !== "VERIFIED") {
-    throw new Error(
-      `Target '${normalizedTargetId}' is not verified (verificationStatus=${verificationStatus || "UNKNOWN"}).`
-    );
-  }
-  if (freezeStatus === "FROZEN" || status === "INACTIVE") {
-    throw new Error(
-      `Target '${normalizedTargetId}' is not policy-approved for active testing (freezeStatus=${freezeStatus || "UNKNOWN"}, status=${status || "UNKNOWN"}).`
-    );
-  }
-
-  const expectedHost = normalizeLower(trackedTarget.target.host);
-  const targetHost = normalizeLower(parsedTargetUrl.hostname);
-  if (expectedHost && expectedHost !== targetHost) {
-    throw new Error(
-      `targetUrl host '${targetHost}' does not match approved target host '${expectedHost}' for '${normalizedTargetId}'.`
-    );
-  }
-
-  const selectedScenarioId = resolveScenarioSelection({
-    scenario,
-    pentestScenario,
-  });
-
-  const policy = normalizePolicy(trackedTarget.target.policy || {});
-  if (policy.allowedPaths.length === 0 || policy.allowedMethods.length === 0 || policy.allowedScenarios.length === 0) {
-    throw new Error(
-      `Target '${normalizedTargetId}' policy is not approved for pen-test execution (allowedPaths/allowedMethods/allowedScenarios are required).`
-    );
-  }
-  ensureScenarioAllowed(policy, selectedScenarioId);
-
-  const checks = buildCheckPlan({
-    scenarioId: selectedScenarioId,
-    targetUrl: parsedTargetUrl,
-    policy,
-  });
-  for (const check of checks) {
-    if (!isPathAllowed(check.path, policy.allowedPaths)) {
-      throw new Error(`Check '${check.checkId}' path '${check.path}' violates target policy allowedPaths.`);
-    }
-  }
-
-  const runId = createPentestRunId();
-  const pentestDirectory = path.join(outputRoot, "swarms", runId, "pentest");
-  const auditLogPath = path.join(pentestDirectory, "audit.jsonl");
-  const requestPlanPath = path.join(pentestDirectory, "REQUEST_PLAN.json");
-  const identityIsolationPath = path.join(pentestDirectory, "IDENTITY_ISOLATION.json");
-  const cleanupContractPath = path.join(pentestDirectory, "CLEANUP_CONTRACT.json");
-  const reportJsonPath = path.join(pentestDirectory, "PENTEST_REPORT.json");
-  const reportMarkdownPath = path.join(pentestDirectory, "PENTEST_REPORT.md");
-  await fsp.mkdir(pentestDirectory, { recursive: true });
-  await fsp.writeFile(
-    requestPlanPath,
-    `${JSON.stringify(
-      {
-        schemaVersion: PENTEST_SCHEMA_VERSION,
-        generatedAt: new Date().toISOString(),
-        runId,
-        scenarioId: selectedScenarioId,
-        targetUrl: parsedTargetUrl.toString(),
-        targetId: normalizedTargetId,
-        checks,
-      },
-      null,
-      2
-    )}\n`,
-    "utf-8"
-  );
-
-  const results = [];
-  const auditEntries = [];
-  const minDelayMs = Math.max(0, Math.ceil(1000 / Math.max(1, policy.maxRps)));
-  const auditHmacKey = normalizeString(env?.SENTINELAYER_AUDIT_HMAC_KEY) || randomUUID();
-  const auditKeySource = normalizeString(env?.SENTINELAYER_AUDIT_HMAC_KEY)
-    ? "env:SENTINELAYER_AUDIT_HMAC_KEY"
-    : "ephemeral";
-  let previousEntryHash = "";
-
-  const runCheckAtIndex = async (index) => {
-    if (index >= checks.length) {
-      return;
-    }
-    const check = checks[index];
-    const result = await executeCheckRequest({
-      targetUrl: parsedTargetUrl,
-      request: check,
-      execute: Boolean(execute),
-      timeoutMs: 10000,
-    });
-    const auditPayload = {
-      timestamp: new Date().toISOString(),
-      runId,
-      scenarioId: selectedScenarioId,
-      checkId: check.checkId,
-      request: result.request,
-      response: {
-        dryRun: result.dryRun,
-        status: result.status,
-        headers: result.headers,
-        body: result.body,
-        durationMs: result.durationMs,
-        error: result.error,
-      },
-    };
-    const entrySerialized = JSON.stringify({
-      ...auditPayload,
-      previousEntryHash,
-    });
-    const entryHash = sha256Hex(entrySerialized);
-    const entryHmac = hmacSha256Hex(auditHmacKey, entrySerialized);
-    const auditEntry = {
-      ...auditPayload,
-      previousEntryHash,
-      entryHash,
-      entryHmac,
-    };
-    previousEntryHash = entryHash;
-    auditEntries.push(auditEntry);
-    results.push({
-      check,
-      result,
-    });
-    if (execute && index < checks.length - 1 && minDelayMs > 0) {
-      await delay(minDelayMs);
-    }
-    await runCheckAtIndex(index + 1);
-  };
-
-  await runCheckAtIndex(0);
-  await fsp.writeFile(
-    auditLogPath,
-    auditEntries.length > 0 ? `${auditEntries.map((entry) => JSON.stringify(entry)).join("\n")}\n` : "",
-    "utf-8"
-  );
-
-  const identityIsolation = {
-    schemaVersion: 1,
-    generatedAt: new Date().toISOString(),
-    mode: "zero_trust",
-    interAgentCommunication: "blocked",
-    scrubbedEnvKeys: ["AIDENID_API_KEY", "AIDENID_ORG_ID", "AIDENID_PROJECT_ID"],
-    agents: [
-      {
-        agentId: "omar",
-        credentialRef: `identity://${normalizedTargetId}/agent/omar`,
-        canViewOtherAgents: false,
-      },
-      {
-        agentId: "security",
-        credentialRef: `identity://${normalizedTargetId}/agent/security`,
-        canViewOtherAgents: false,
-      },
-      {
-        agentId: "testing",
-        credentialRef: `identity://${normalizedTargetId}/agent/testing`,
-        canViewOtherAgents: false,
-      },
-    ],
-  };
-  await fsp.writeFile(identityIsolationPath, `${JSON.stringify(identityIsolation, null, 2)}\n`, "utf-8");
-
-  const cleanupContract = {
-    schemaVersion: 1,
-    generatedAt: new Date().toISOString(),
-    runId,
-    targetId: normalizedTargetId,
-    scheduleMode: "aidenid_scheduler",
-    crashSafeCleanup: true,
-    cleanupRequested: true,
-    cleanupTaskId: `cleanup-${runId}`,
-  };
-  await fsp.writeFile(cleanupContractPath, `${JSON.stringify(cleanupContract, null, 2)}\n`, "utf-8");
-
-  const findings = [];
-  for (const entry of results) {
-    const scoped = evaluateRequestFindings({
-      scenarioId: selectedScenarioId,
-      check: entry.check,
-      result: entry.result,
-      findingStartIndex: findings.length + 1,
-    });
-    findings.push(...scoped);
-  }
-  findings.push(
-    ...evaluateRateLimitFindings({
-      scenarioId: selectedScenarioId,
-      checks,
-      results,
-      execute: Boolean(execute),
-      findingStartIndex: findings.length + 1,
-    })
-  );
-
-  const report = {
-    schemaVersion: PENTEST_SCHEMA_VERSION,
-    generatedAt: new Date().toISOString(),
-    runId,
-    target: {
-      targetId: normalizedTargetId,
-      url: parsedTargetUrl.toString(),
-      host: expectedHost || targetHost,
-      registryPath: trackedTarget.registryPath,
-      policy,
-    },
-    scenario: normalizeLower(scenario || "pen-test"),
-    scenarioId: selectedScenarioId,
-    execute: Boolean(execute),
-    checkCount: checks.length,
-    requestCount: results.length,
-    findings,
-    summary: summarizeFindings(findings),
-    auditChain: {
-      keySource: auditKeySource,
-      entryCount: auditEntries.length,
-      tailEntryHash: previousEntryHash || null,
-      rootEntryHash: auditEntries.length > 0 ? auditEntries[0].entryHash : null,
-    },
-    identityIsolationPath,
-    cleanupContractPath,
-    auditLogPath,
-    requestPlanPath,
-    reportJsonPath,
-    reportMarkdownPath,
-  };
-
-  await fsp.writeFile(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
-  await fsp.writeFile(reportMarkdownPath, `${renderPentestReportMarkdown(report).trim()}\n`, "utf-8");
-
-  return {
-    ...report,
-    targetPath: normalizedTargetPath,
-    outputRoot,
-    runDirectory: toPosixPath(path.relative(outputRoot, path.join(outputRoot, "swarms", runId))),
-  };
-}
+import { createHash, createHmac, randomUUID } from "node:crypto";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { getTargetById } from "../ai/domain-target-store.js";
+import { resolveOutputRoot } from "../config/service.js";
+
+const PENTEST_SCHEMA_VERSION = 1;
+
+const BUILTIN_PENTEST_SCENARIOS = Object.freeze([
+  {
+    id: "auth-bypass",
+    title: "Auth Bypass",
+    description:
+      "Probe authentication and session controls using expired tokens, missing headers, and CSRF token omission.",
+    owaspCategories: ["A07:2021-Identification and Authentication Failures", "A01:2021-Broken Access Control"],
+  },
+  {
+    id: "rate-limit-probe",
+    title: "Rate Limit Probe",
+    description: "Probe API threshold behavior to verify rate-limit enforcement at configured policy ceilings.",
+    owaspCategories: ["A04:2021-Insecure Design"],
+  },
+  {
+    id: "input-validation",
+    title: "Input Validation",
+    description: "Inject XSS and SQL-like payloads to detect reflection and server-side validation failures.",
+    owaspCategories: ["A03:2021-Injection"],
+  },
+  {
+    id: "privilege-escalation",
+    title: "Privilege Escalation",
+    description: "Attempt privileged endpoints with standard-user context to detect broken access boundaries.",
+    owaspCategories: ["A01:2021-Broken Access Control"],
+  },
+]);
+
+const SUPPORTED_SCENARIOS = new Set(["pen-test", ...BUILTIN_PENTEST_SCENARIOS.map((scenario) => scenario.id)]);
+
+function normalizeString(value) {
+  return String(value || "").trim();
+}
+
+function normalizeLower(value) {
+  return normalizeString(value).toLowerCase();
+}
+
+function normalizeUpper(value) {
+  return normalizeString(value).toUpperCase();
+}
+
+function formatTimestampToken() {
+  const now = new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}-${pad(
+    now.getUTCHours()
+  )}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`;
+}
+
+function createPentestRunId() {
+  return `swarm-pentest-${formatTimestampToken()}-${randomUUID().slice(0, 8)}`;
+}
+
+function sha256Hex(value) {
+  return createHash("sha256").update(String(value || ""), "utf-8").digest("hex");
+}
+
+function hmacSha256Hex(key, value) {
+  return createHmac("sha256", String(key || "")).update(String(value || ""), "utf-8").digest("hex");
+}
+
+function toPosixPath(value) {
+  return String(value || "").replace(/\\/g, "/");
+}
+
+function normalizePathPattern(value) {
+  const raw = normalizeString(value);
+  if (!raw) {
+    return "/";
+  }
+  if (raw === "*" || raw === "/*") {
+    return "/*";
+  }
+  return raw.startsWith("/") ? raw : `/${raw}`;
+}
+
+function escapeRegex(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function compilePathPattern(pattern) {
+  const normalized = normalizePathPattern(pattern);
+  if (normalized === "/" || normalized === "/*") {
+    return /^\/.*/;
+  }
+  const source = `^${normalized.split("*").map(escapeRegex).join(".*")}$`;
+  return new RegExp(source);
+}
+
+function isPathAllowed(pathname, allowedPaths = []) {
+  const targetPath = normalizePathPattern(pathname);
+  if (!Array.isArray(allowedPaths) || allowedPaths.length === 0) {
+    return false;
+  }
+  return allowedPaths.some((pattern) => compilePathPattern(pattern).test(targetPath));
+}
+
+function materializeAllowedPath(pattern) {
+  const normalized = normalizePathPattern(pattern);
+  if (normalized === "/" || normalized === "/*") {
+    return "/";
+  }
+  const withoutWildcard = normalized.replace(/\*/g, "probe");
+  return withoutWildcard || "/";
+}
+
+function selectPolicyPath(preferredPaths = [], allowedPaths = []) {
+  for (const candidate of preferredPaths) {
+    const normalizedCandidate = normalizePathPattern(candidate);
+    if (isPathAllowed(normalizedCandidate, allowedPaths)) {
+      return normalizedCandidate;
+    }
+  }
+  if (allowedPaths.length === 0) {
+    throw new Error("Target policy has no allowed paths.");
+  }
+  return materializeAllowedPath(allowedPaths[0]);
+}
+
+function parseTargetUrl(urlValue) {
+  const normalized = normalizeString(urlValue);
+  if (!normalized) {
+    throw new Error("targetUrl is required.");
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error(`Invalid target URL '${normalized}'.`);
+  }
+  if (!/^https?:$/i.test(parsed.protocol)) {
+    throw new Error("targetUrl must use http or https.");
+  }
+  parsed.hash = "";
+  return parsed;
+}
+
+function normalizePolicy(policy = {}) {
+  const allowedPaths = Array.isArray(policy.allowedPaths)
+    ? [...new Set(policy.allowedPaths.map((item) => normalizePathPattern(item)).filter(Boolean))]
+    : [];
+  const allowedMethods = Array.isArray(policy.allowedMethods)
+    ? [...new Set(policy.allowedMethods.map((item) => normalizeUpper(item)).filter(Boolean))]
+    : [];
+  const allowedScenarios = Array.isArray(policy.allowedScenarios)
+    ? [...new Set(policy.allowedScenarios.map((item) => normalizeLower(item)).filter(Boolean))]
+    : [];
+  const maxRps = Number(policy.maxRps);
+  const maxConcurrency = Number(policy.maxConcurrency);
+
+  return {
+    allowedPaths,
+    allowedMethods,
+    allowedScenarios,
+    maxRps: Number.isFinite(maxRps) && maxRps > 0 ? Math.floor(maxRps) : 1,
+    maxConcurrency: Number.isFinite(maxConcurrency) && maxConcurrency > 0 ? Math.floor(maxConcurrency) : 1,
+    stopConditions:
+      policy.stopConditions && typeof policy.stopConditions === "object" ? policy.stopConditions : {},
+  };
+}
+
+function ensureScenarioAllowed(policy = {}, scenarioId = "") {
+  const allowed = new Set((policy.allowedScenarios || []).map((item) => normalizeLower(item)));
+  if (allowed.has("*") || allowed.has("all") || allowed.has("pen-test") || allowed.has(scenarioId)) {
+    return;
+  }
+  throw new Error(
+    `Target policy does not allow scenario '${scenarioId}'. Allowed scenarios: ${[...allowed].join(", ") || "(none)"}`
+  );
+}
+
+function ensureMethodAllowed(policy = {}, method = "", scenarioId = "") {
+  const normalizedMethod = normalizeUpper(method);
+  const allowedMethods = new Set((policy.allowedMethods || []).map((item) => normalizeUpper(item)));
+  if (allowedMethods.has(normalizedMethod)) {
+    return;
+  }
+  throw new Error(
+    `Target policy does not allow HTTP method '${normalizedMethod}' required for scenario '${scenarioId}'.`
+  );
+}
+
+function resolveScenarioSelection({ scenario = "pen-test", pentestScenario = "auth-bypass" } = {}) {
+  const normalizedScenario = normalizeLower(scenario || "pen-test");
+  if (!SUPPORTED_SCENARIOS.has(normalizedScenario)) {
+    throw new Error(
+      `Unsupported pen-test scenario '${normalizedScenario}'. Use one of: ${[...SUPPORTED_SCENARIOS].join(", ")}`
+    );
+  }
+  if (normalizedScenario === "pen-test") {
+    const selected = normalizeLower(pentestScenario || "auth-bypass");
+    if (!BUILTIN_PENTEST_SCENARIOS.some((item) => item.id === selected)) {
+      throw new Error(
+        `Unsupported --pen-test-scenario '${selected}'. Built-in scenarios: ${BUILTIN_PENTEST_SCENARIOS.map((item) => item.id).join(", ")}`
+      );
+    }
+    return selected;
+  }
+  return normalizedScenario;
+}
+
+function createFinding({
+  severity = "P2",
+  title = "",
+  description = "",
+  owaspCategory = "",
+  checkId = "",
+  evidence = {},
+  index = 1,
+} = {}) {
+  return {
+    findingId: `PENTEST-F${String(index).padStart(3, "0")}`,
+    severity: normalizeUpper(severity || "P2"),
+    title: normalizeString(title),
+    description: normalizeString(description),
+    owaspCategory: normalizeString(owaspCategory),
+    checkId: normalizeString(checkId),
+    evidence,
+  };
+}
+
+function summarizeFindings(findings = []) {
+  const counts = {
+    P0: 0,
+    P1: 0,
+    P2: 0,
+    P3: 0,
+  };
+  for (const finding of findings) {
+    const severity = normalizeUpper(finding.severity || "P3");
+    if (Object.prototype.hasOwnProperty.call(counts, severity)) {
+      counts[severity] += 1;
+    }
+  }
+  return {
+    ...counts,
+    findingCount: findings.length,
+    blocking: counts.P0 > 0 || counts.P1 > 0,
+  };
+}
+
+function buildCheckPlan({ scenarioId, targetUrl, policy }) {
+  if (scenarioId === "auth-bypass") {
+    ensureMethodAllowed(policy, "GET", scenarioId);
+    ensureMethodAllowed(policy, "POST", scenarioId);
+    const adminPath = selectPolicyPath(["/admin", "/admin/users"], policy.allowedPaths);
+    const profilePath = selectPolicyPath(["/account/profile", "/profile"], policy.allowedPaths);
+    return [
+      {
+        checkId: "auth-bypass-expired-token",
+        method: "GET",
+        path: adminPath,
+        headers: {
+          Authorization: "Bearer expired.jwt.token",
+          "X-Sentinelayer-Pentest": "auth-bypass-expired-token",
+        },
+        body: "",
+        evaluation: "deny",
+        owaspCategory: "A07:2021-Identification and Authentication Failures",
+      },
+      {
+        checkId: "auth-bypass-missing-auth",
+        method: "GET",
+        path: adminPath,
+        headers: {
+          "X-Sentinelayer-Pentest": "auth-bypass-missing-auth",
+        },
+        body: "",
+        evaluation: "deny",
+        owaspCategory: "A07:2021-Identification and Authentication Failures",
+      },
+      {
+        checkId: "csrf-missing-token",
+        method: "POST",
+        path: profilePath,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Sentinelayer-Pentest": "csrf-missing-token",
+        },
+        body: JSON.stringify({
+          displayName: "sentinelayer-pentest",
+          csrfToken: "",
+        }),
+        evaluation: "csrf_deny",
+        owaspCategory: "A01:2021-Broken Access Control",
+      },
+    ];
+  }
+
+  if (scenarioId === "rate-limit-probe") {
+    ensureMethodAllowed(policy, "GET", scenarioId);
+    const probePath = selectPolicyPath(["/api/health", "/health", "/"], policy.allowedPaths);
+    const requestCount = Math.max(3, Math.min(30, Number(policy.maxRps || 1) + 2));
+    return Array.from({ length: requestCount }).map((_, index) => ({
+      checkId: `rate-limit-probe-${String(index + 1).padStart(2, "0")}`,
+      method: "GET",
+      path: probePath,
+      headers: {
+        "X-Sentinelayer-Pentest": "rate-limit-probe",
+        "X-Sentinelayer-Probe-Index": String(index + 1),
+      },
+      body: "",
+      evaluation: "rate_limit_series",
+      owaspCategory: "A04:2021-Insecure Design",
+    }));
+  }
+
+  if (scenarioId === "input-validation") {
+    ensureMethodAllowed(policy, "POST", scenarioId);
+    const inputPath = selectPolicyPath(["/search", "/auth/login", "/"], policy.allowedPaths);
+    const xssPayload = "<script>alert(1)</script>";
+    const sqlPayload = "' OR 1=1 --";
+    return [
+      {
+        checkId: "input-validation-xss",
+        method: "POST",
+        path: inputPath,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Sentinelayer-Pentest": "input-validation-xss",
+        },
+        body: JSON.stringify({
+          query: xssPayload,
+          email: "user@example.com",
+        }),
+        evaluation: "reflect_or_reject",
+        expectedPayload: xssPayload,
+        owaspCategory: "A03:2021-Injection",
+      },
+      {
+        checkId: "input-validation-sqli",
+        method: "POST",
+        path: inputPath,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Sentinelayer-Pentest": "input-validation-sqli",
+        },
+        body: JSON.stringify({
+          username: sqlPayload,
+          password: "example-password",
+        }),
+        evaluation: "reflect_or_error",
+        expectedPayload: sqlPayload,
+        owaspCategory: "A03:2021-Injection",
+      },
+    ];
+  }
+
+  if (scenarioId === "privilege-escalation") {
+    ensureMethodAllowed(policy, "GET", scenarioId);
+    const adminPath = selectPolicyPath(["/admin", "/admin/users"], policy.allowedPaths);
+    return [
+      {
+        checkId: "privilege-escalation-admin-endpoint",
+        method: "GET",
+        path: adminPath,
+        headers: {
+          Authorization: "Bearer standard-user-token",
+          "X-Sentinelayer-Pentest": "privilege-escalation",
+        },
+        body: "",
+        evaluation: "deny",
+        owaspCategory: "A01:2021-Broken Access Control",
+      },
+    ];
+  }
+
+  throw new Error(`Unsupported pentest scenario '${scenarioId}'.`);
+}
+
+function appendHeaders(headers) {
+  if (!headers || typeof headers !== "object") {
+    return {};
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const nextKey = normalizeString(key);
+    if (!nextKey) {
+      continue;
+    }
+    normalized[nextKey] = String(value ?? "");
+  }
+  return normalized;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function executeCheckRequest({
+  targetUrl,
+  request,
+  execute = false,
+  timeoutMs = 10000,
+} = {}) {
+  const url = new URL(request.path, targetUrl);
+  const requestHeaders = appendHeaders(request.headers);
+  const requestBody = normalizeString(request.body);
+
+  if (!execute) {
+    return {
+      dryRun: true,
+      status: null,
+      headers: {},
+      body: "",
+      durationMs: 0,
+      error: "",
+      request: {
+        method: request.method,
+        url: url.toString(),
+        path: url.pathname,
+        headers: requestHeaders,
+        body: requestBody,
+      },
+    };
+  }
+
+  const startedAt = Date.now();
+  const abortController = new AbortController();
+  const timeoutHandle = setTimeout(() => {
+    abortController.abort();
+  }, timeoutMs);
+
+  try {
+    const response = await fetch(url.toString(), {
+      method: request.method,
+      headers: requestHeaders,
+      body: requestBody || undefined,
+      signal: abortController.signal,
+    });
+    const responseBody = await response.text();
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+
+    return {
+      dryRun: false,
+      status: response.status,
+      headers: responseHeaders,
+      body: responseBody,
+      durationMs: Date.now() - startedAt,
+      error: "",
+      request: {
+        method: request.method,
+        url: url.toString(),
+        path: url.pathname,
+        headers: requestHeaders,
+        body: requestBody,
+      },
+    };
+  } catch (error) {
+    return {
+      dryRun: false,
+      status: null,
+      headers: {},
+      body: "",
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error),
+      request: {
+        method: request.method,
+        url: url.toString(),
+        path: url.pathname,
+        headers: requestHeaders,
+        body: requestBody,
+      },
+    };
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+function evaluateRequestFindings({ scenarioId, check, result, findingStartIndex }) {
+  const findings = [];
+  const status = Number(result.status || 0);
+  const responseBody = String(result.body || "");
+  const checkId = normalizeString(check.checkId);
+  const owaspCategory = normalizeString(check.owaspCategory);
+
+  if (check.evaluation === "deny" && status > 0 && status < 400) {
+    findings.push(
+      createFinding({
+        index: findingStartIndex + findings.length,
+        severity: "P1",
+        title: "Unauthorized access path was accepted",
+        description: `Scenario '${scenarioId}' expected denial, but endpoint returned HTTP ${status}.`,
+        owaspCategory,
+        checkId,
+        evidence: {
+          path: result.request.path,
+          method: result.request.method,
+          status,
+          responseBody,
+        },
+      })
+    );
+  }
+
+  if (check.evaluation === "csrf_deny" && status > 0 && status < 400) {
+    findings.push(
+      createFinding({
+        index: findingStartIndex + findings.length,
+        severity: "P2",
+        title: "CSRF guard appears missing for state-changing request",
+        description: `Scenario '${scenarioId}' submitted state-changing request without CSRF token and received HTTP ${status}.`,
+        owaspCategory,
+        checkId,
+        evidence: {
+          path: result.request.path,
+          method: result.request.method,
+          status,
+          responseBody,
+        },
+      })
+    );
+  }
+
+  if (check.evaluation === "reflect_or_reject" && check.expectedPayload) {
+    if (responseBody.includes(check.expectedPayload)) {
+      findings.push(
+        createFinding({
+          index: findingStartIndex + findings.length,
+          severity: "P1",
+          title: "Potential reflected injection payload",
+          description: "Response body reflected raw XSS payload.",
+          owaspCategory,
+          checkId,
+          evidence: {
+            path: result.request.path,
+            method: result.request.method,
+            status,
+            reflectedPayload: check.expectedPayload,
+          },
+        })
+      );
+    }
+  }
+
+  if (check.evaluation === "reflect_or_error" && check.expectedPayload) {
+    const loweredBody = responseBody.toLowerCase();
+    if (responseBody.includes(check.expectedPayload) || status >= 500 || /sql|syntax|database/.test(loweredBody)) {
+      findings.push(
+        createFinding({
+          index: findingStartIndex + findings.length,
+          severity: "P1",
+          title: "Potential SQL injection handling failure",
+          description:
+            "Endpoint response suggests SQL payload reflection or backend error path under injection input.",
+          owaspCategory,
+          checkId,
+          evidence: {
+            path: result.request.path,
+            method: result.request.method,
+            status,
+            responseBody,
+          },
+        })
+      );
+    }
+  }
+
+  return findings;
+}
+
+function evaluateRateLimitFindings({ scenarioId, checks = [], results = [], execute = false, findingStartIndex = 1 }) {
+  if (!execute) {
+    return [];
+  }
+  const scopedResults = results.filter((item) => item.check.evaluation === "rate_limit_series");
+  if (scopedResults.length === 0) {
+    return [];
+  }
+  const observed429 = scopedResults.some((item) => Number(item.result.status || 0) === 429);
+  if (observed429) {
+    return [];
+  }
+  const first = scopedResults[0];
+  return [
+    createFinding({
+      index: findingStartIndex,
+      severity: "P2",
+      title: "Rate-limit threshold not observed at configured probe pace",
+      description: `Scenario '${scenarioId}' did not observe HTTP 429 responses during rate-limit probing.`,
+      owaspCategory: "A04:2021-Insecure Design",
+      checkId: first?.check?.checkId || "rate-limit-probe",
+      evidence: {
+        requestCount: checks.length,
+        statuses: scopedResults.map((item) => item.result.status),
+      },
+    }),
+  ];
+}
+
+function renderPentestReportMarkdown(report = {}) {
+  const scenarioMeta =
+    BUILTIN_PENTEST_SCENARIOS.find((scenario) => scenario.id === report.scenarioId) || null;
+  const findingRows = (report.findings || [])
+    .map(
+      (finding) =>
+        `- [${finding.severity}] ${finding.findingId} :: ${finding.title} (${finding.owaspCategory}) @ ${finding.checkId}`
+    )
+    .join("\n");
+
+  return `# PENTEST_REPORT
+
+Generated: ${report.generatedAt}
+Run ID: ${report.runId}
+Scenario: ${report.scenarioId}
+Scenario title: ${scenarioMeta?.title || report.scenarioId}
+Target URL: ${report.target.url}
+Target ID: ${report.target.targetId}
+Execute: ${report.execute ? "yes" : "no"}
+
+Target policy:
+- allowed_paths: ${(report.target.policy.allowedPaths || []).join(", ") || "(none)"}
+- allowed_methods: ${(report.target.policy.allowedMethods || []).join(", ") || "(none)"}
+- allowed_scenarios: ${(report.target.policy.allowedScenarios || []).join(", ") || "(none)"}
+- max_rps: ${report.target.policy.maxRps}
+- max_concurrency: ${report.target.policy.maxConcurrency}
+
+Summary:
+- findings: ${report.summary.findingCount}
+- P0: ${report.summary.P0}
+- P1: ${report.summary.P1}
+- P2: ${report.summary.P2}
+- P3: ${report.summary.P3}
+- blocking: ${report.summary.blocking ? "yes" : "no"}
+
+Checks executed:
+- check_count: ${report.checkCount}
+- request_count: ${report.requestCount}
+
+Findings:
+${findingRows || "- none"}
+
+Artifacts:
+- audit_log: ${report.auditLogPath}
+- identity_isolation: ${report.identityIsolationPath}
+- cleanup_contract: ${report.cleanupContractPath}
+- report_json: ${report.reportJsonPath}
+- request_plan_json: ${report.requestPlanPath}
+`;
+}
+
+export function listBuiltinPentestScenarios() {
+  return BUILTIN_PENTEST_SCENARIOS.map((item) => ({
+    id: item.id,
+    title: item.title,
+    description: item.description,
+    owaspCategories: [...item.owaspCategories],
+  }));
+}
+
+export async function runSwarmPentest({
+  targetPath = ".",
+  outputDir = "",
+  targetId = "",
+  targetUrl = "",
+  scenario = "pen-test",
+  pentestScenario = "auth-bypass",
+  execute = false,
+  env,
+  homeDir,
+} = {}) {
+  const normalizedTargetPath = path.resolve(String(targetPath || "."));
+  const normalizedTargetId = normalizeString(targetId);
+  if (!normalizedTargetId) {
+    throw new Error("targetId is required.");
+  }
+  const parsedTargetUrl = parseTargetUrl(targetUrl);
+
+  const outputRoot = await resolveOutputRoot({
+    cwd: normalizedTargetPath,
+    outputDirOverride: outputDir,
+    env,
+    homeDir,
+  });
+  const trackedTarget = await getTargetById({
+    outputRoot,
+    targetId: normalizedTargetId,
+  });
+  if (!trackedTarget.target) {
+    throw new Error(`Target '${normalizedTargetId}' is not present in local registry (${trackedTarget.registryPath}).`);
+  }
+
+  const verificationStatus = normalizeUpper(trackedTarget.target.verificationStatus);
+  const freezeStatus = normalizeUpper(trackedTarget.target.freezeStatus);
+  const status = normalizeUpper(trackedTarget.target.status);
+  if (verificationStatus !== "VERIFIED") {
+    throw new Error(
+      `Target '${normalizedTargetId}' is not verified (verificationStatus=${verificationStatus || "UNKNOWN"}).`
+    );
+  }
+  if (freezeStatus === "FROZEN" || status === "INACTIVE") {
+    throw new Error(
+      `Target '${normalizedTargetId}' is not policy-approved for active testing (freezeStatus=${freezeStatus || "UNKNOWN"}, status=${status || "UNKNOWN"}).`
+    );
+  }
+
+  const expectedHost = normalizeLower(trackedTarget.target.host);
+  const targetHost = normalizeLower(parsedTargetUrl.hostname);
+  if (expectedHost && expectedHost !== targetHost) {
+    throw new Error(
+      `targetUrl host '${targetHost}' does not match approved target host '${expectedHost}' for '${normalizedTargetId}'.`
+    );
+  }
+
+  const selectedScenarioId = resolveScenarioSelection({
+    scenario,
+    pentestScenario,
+  });
+
+  const policy = normalizePolicy(trackedTarget.target.policy || {});
+  if (policy.allowedPaths.length === 0 || policy.allowedMethods.length === 0 || policy.allowedScenarios.length === 0) {
+    throw new Error(
+      `Target '${normalizedTargetId}' policy is not approved for pen-test execution (allowedPaths/allowedMethods/allowedScenarios are required).`
+    );
+  }
+  ensureScenarioAllowed(policy, selectedScenarioId);
+
+  const checks = buildCheckPlan({
+    scenarioId: selectedScenarioId,
+    targetUrl: parsedTargetUrl,
+    policy,
+  });
+  for (const check of checks) {
+    if (!isPathAllowed(check.path, policy.allowedPaths)) {
+      throw new Error(`Check '${check.checkId}' path '${check.path}' violates target policy allowedPaths.`);
+    }
+  }
+
+  const runId = createPentestRunId();
+  const pentestDirectory = path.join(outputRoot, "swarms", runId, "pentest");
+  const auditLogPath = path.join(pentestDirectory, "audit.jsonl");
+  const requestPlanPath = path.join(pentestDirectory, "REQUEST_PLAN.json");
+  const identityIsolationPath = path.join(pentestDirectory, "IDENTITY_ISOLATION.json");
+  const cleanupContractPath = path.join(pentestDirectory, "CLEANUP_CONTRACT.json");
+  const reportJsonPath = path.join(pentestDirectory, "PENTEST_REPORT.json");
+  const reportMarkdownPath = path.join(pentestDirectory, "PENTEST_REPORT.md");
+  await fsp.mkdir(pentestDirectory, { recursive: true });
+  await fsp.writeFile(
+    requestPlanPath,
+    `${JSON.stringify(
+      {
+        schemaVersion: PENTEST_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        runId,
+        scenarioId: selectedScenarioId,
+        targetUrl: parsedTargetUrl.toString(),
+        targetId: normalizedTargetId,
+        checks,
+      },
+      null,
+      2
+    )}\n`,
+    "utf-8"
+  );
+
+  const results = [];
+  const auditEntries = [];
+  const minDelayMs = Math.max(0, Math.ceil(1000 / Math.max(1, policy.maxRps)));
+  const auditHmacKey = normalizeString(env?.SENTINELAYER_AUDIT_HMAC_KEY) || randomUUID();
+  const auditKeySource = normalizeString(env?.SENTINELAYER_AUDIT_HMAC_KEY)
+    ? "env:SENTINELAYER_AUDIT_HMAC_KEY"
+    : "ephemeral";
+  let previousEntryHash = "";
+
+  const runCheckAtIndex = async (index) => {
+    if (index >= checks.length) {
+      return;
+    }
+    const check = checks[index];
+    const result = await executeCheckRequest({
+      targetUrl: parsedTargetUrl,
+      request: check,
+      execute: Boolean(execute),
+      timeoutMs: 10000,
+    });
+    const auditPayload = {
+      timestamp: new Date().toISOString(),
+      runId,
+      scenarioId: selectedScenarioId,
+      checkId: check.checkId,
+      request: result.request,
+      response: {
+        dryRun: result.dryRun,
+        status: result.status,
+        headers: result.headers,
+        body: result.body,
+        durationMs: result.durationMs,
+        error: result.error,
+      },
+    };
+    const entrySerialized = JSON.stringify({
+      ...auditPayload,
+      previousEntryHash,
+    });
+    const entryHash = sha256Hex(entrySerialized);
+    const entryHmac = hmacSha256Hex(auditHmacKey, entrySerialized);
+    const auditEntry = {
+      ...auditPayload,
+      previousEntryHash,
+      entryHash,
+      entryHmac,
+    };
+    previousEntryHash = entryHash;
+    auditEntries.push(auditEntry);
+    results.push({
+      check,
+      result,
+    });
+    if (execute && index < checks.length - 1 && minDelayMs > 0) {
+      await delay(minDelayMs);
+    }
+    await runCheckAtIndex(index + 1);
+  };
+
+  await runCheckAtIndex(0);
+  await fsp.writeFile(
+    auditLogPath,
+    auditEntries.length > 0 ? `${auditEntries.map((entry) => JSON.stringify(entry)).join("\n")}\n` : "",
+    "utf-8"
+  );
+
+  const identityIsolation = {
+    schemaVersion: 1,
+    generatedAt: new Date().toISOString(),
+    mode: "zero_trust",
+    interAgentCommunication: "blocked",
+    scrubbedEnvKeys: ["AIDENID_API_KEY", "AIDENID_ORG_ID", "AIDENID_PROJECT_ID"],
+    agents: [
+      {
+        agentId: "omar",
+        credentialRef: `identity://${normalizedTargetId}/agent/omar`,
+        canViewOtherAgents: false,
+      },
+      {
+        agentId: "security",
+        credentialRef: `identity://${normalizedTargetId}/agent/security`,
+        canViewOtherAgents: false,
+      },
+      {
+        agentId: "testing",
+        credentialRef: `identity://${normalizedTargetId}/agent/testing`,
+        canViewOtherAgents: false,
+      },
+    ],
+  };
+  await fsp.writeFile(identityIsolationPath, `${JSON.stringify(identityIsolation, null, 2)}\n`, "utf-8");
+
+  const cleanupContract = {
+    schemaVersion: 1,
+    generatedAt: new Date().toISOString(),
+    runId,
+    targetId: normalizedTargetId,
+    scheduleMode: "aidenid_scheduler",
+    crashSafeCleanup: true,
+    cleanupRequested: true,
+    cleanupTaskId: `cleanup-${runId}`,
+  };
+  await fsp.writeFile(cleanupContractPath, `${JSON.stringify(cleanupContract, null, 2)}\n`, "utf-8");
+
+  const findings = [];
+  for (const entry of results) {
+    const scoped = evaluateRequestFindings({
+      scenarioId: selectedScenarioId,
+      check: entry.check,
+      result: entry.result,
+      findingStartIndex: findings.length + 1,
+    });
+    findings.push(...scoped);
+  }
+  findings.push(
+    ...evaluateRateLimitFindings({
+      scenarioId: selectedScenarioId,
+      checks,
+      results,
+      execute: Boolean(execute),
+      findingStartIndex: findings.length + 1,
+    })
+  );
+
+  const report = {
+    schemaVersion: PENTEST_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    runId,
+    target: {
+      targetId: normalizedTargetId,
+      url: parsedTargetUrl.toString(),
+      host: expectedHost || targetHost,
+      registryPath: trackedTarget.registryPath,
+      policy,
+    },
+    scenario: normalizeLower(scenario || "pen-test"),
+    scenarioId: selectedScenarioId,
+    execute: Boolean(execute),
+    checkCount: checks.length,
+    requestCount: results.length,
+    findings,
+    summary: summarizeFindings(findings),
+    auditChain: {
+      keySource: auditKeySource,
+      entryCount: auditEntries.length,
+      tailEntryHash: previousEntryHash || null,
+      rootEntryHash: auditEntries.length > 0 ? auditEntries[0].entryHash : null,
+    },
+    identityIsolationPath,
+    cleanupContractPath,
+    auditLogPath,
+    requestPlanPath,
+    reportJsonPath,
+    reportMarkdownPath,
+  };
+
+  await fsp.writeFile(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
+  await fsp.writeFile(reportMarkdownPath, `${renderPentestReportMarkdown(report).trim()}\n`, "utf-8");
+
+  return {
+    ...report,
+    targetPath: normalizedTargetPath,
+    outputRoot,
+    runDirectory: toPosixPath(path.relative(outputRoot, path.join(outputRoot, "swarms", runId))),
+  };
+}