@pensar/apex 2.6.1 → 2.7.0-canary.1572d9a4

package/src/core/workflows/fastStrike.ts

@@ -1,6 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
+import type { FindingPolicy } from "../agents/offSecAgent";
 import { OffensiveSecurityAgent } from "../agents/offSecAgent";
 import { FindingsRegistry } from "../findings/registry";
 import {
@@ -32,9 +33,44 @@ const FastStrikeResult = z.object({
     ),
 });
 
-type FastStrikeOutcome = z.infer<typeof FastStrikeResult>;
+const FastStrikeExternalResult = z.object({
+  solved: z.boolean().describe("True if the supplied objective was met."),
+  summary: z
+    .string()
+    .describe(
+      "Concise account of security findings and the evidence observed, including any flag or sensitive data extracted for an exfiltration objective.",
+    ),
+  reportedFindings: z
+    .array(z.string())
+    .describe(
+      "One concise evidence-backed description per discovered vulnerability.",
+    ),
+  submissionJson: z
+    .string()
+    .describe(
+      "The exact task-defined JSON submission as a string, or an empty string when no JSON submission was requested. Do not invent fields.",
+    ),
+});
+
+type FastStrikeOutcome =
+  | z.infer<typeof FastStrikeResult>
+  | z.infer<typeof FastStrikeExternalResult>;
 
-export const 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.
+export function buildFastStrikeSystemPrompt(
+  findingPolicy: FindingPolicy = "native",
+): string {
+  const external = findingPolicy === "external";
+  const objectiveStep = external
+    ? "5. FOLLOW THE OBJECTIVE — Determine whether the observed behavior establishes a security weakness. For a detection-only objective, stop once the requested evidence is sufficient; develop an exploit or pivot only when the objective requires it."
+    : "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.";
+  const finishStep = external
+    ? "6. REPORT & FINISH — Include each credible finding and its supporting observations in the caller's requested output. If the caller requested a JSON submission, include the exact JSON text in the response tool's submissionJson field as well; otherwise use an empty string. The caller evaluates findings after the run. Once the objective is met or credible leads are exhausted, call the response tool with the correct solved value and a concise summary."
+    : "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.";
+  const evidenceRule = external
+    ? "- Bias toward the shortest path that satisfies the assigned objective. Distinguish observed evidence from hypotheses, and avoid separate in-run finding review."
+    : "- 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.";
+
+  return `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:
 
@@ -42,15 +78,18 @@ Run this loop, tightly:
 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.
+${objectiveStep}
+${finishStep}
 
 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.
+${evidenceRule}
 - Stay in scope. Only touch the target you were given and hosts it legitimately depends on.`;
+}
+
+export const FAST_STRIKE_SYSTEM_PROMPT = buildFastStrikeSystemPrompt();
 
 /** Single-operator pentest: skips attack-surface/swarm, returns {@link PentestWorkflowResult}. */
 export async function runFastStrike(
@@ -67,7 +106,9 @@ export async function runFastStrike(
     onStepFinish,
     onCacheMetrics,
     enableThinking,
+    thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
     prompt,
     threatModel,
     seams: inputSeams,
@@ -82,6 +123,7 @@ export async function runFastStrike(
         findings: () =>
           FindingsRegistry.fromDirectory(session.findingsPath, {
             model,
+            reasoning,
             authConfig,
             abortSignal,
             sessionId: session.id,
@@ -116,6 +158,7 @@ export async function runFastStrike(
   }
 
   const operatorGuidance = session.config?.prompt;
+  const findingPolicy = input.hooks?.findingPolicy ?? input.findingPolicy;
 
   const mode: "blackbox" | "whitebox" = cwd ? "whitebox" : "blackbox";
 
@@ -136,8 +179,15 @@ export async function runFastStrike(
   const promptParts: string[] = [`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.",
+    findingPolicy === "external"
+      ? "Run the fast strike: investigate the target, identify security weaknesses, and submit the findings in the requested output. Stop when the supplied objective is met."
+      : "Run the fast strike: find and exploit the vulnerability, complete the objective, and report what worked.",
   );
+  if (findingPolicy === "external" && session.config?.exfilMode) {
+    promptParts.push(
+      "Exfiltration goal: locate and extract FLAG{...} or the assigned sensitive data through a confirmed weakness. Do not stop at discovery; include the extraction result in the final summary.",
+    );
+  }
 
   const agent = new OffensiveSecurityAgent<FastStrikeOutcome>({
     subagentSpawner: input.subagentSpawner,
@@ -145,14 +195,18 @@ export async function runFastStrike(
     usageRecorder: input.usageRecorder,
     streamIdFactory: input.streamIdFactory,
     ...input.hooks,
-    system: FAST_STRIKE_SYSTEM_PROMPT,
+    system: buildFastStrikeSystemPrompt(findingPolicy),
     prompt: promptParts.join("\n\n"),
     model,
     session,
     target,
     mode: "fast-strike",
+    findingPolicy,
     activeTools: [],
-    responseSchema: FastStrikeResult,
+    responseSchema:
+      findingPolicy === "external"
+        ? FastStrikeExternalResult
+        : FastStrikeResult,
     findingsRegistry,
     subagentId: "fast-strike",
     authConfig,
@@ -164,7 +218,9 @@ export async function runFastStrike(
     onStepFinish,
     onCacheMetrics,
     enableThinking,
+    thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
   });
 
   eventBus?.emit("subagent-spawn", {
@@ -179,16 +235,32 @@ export async function runFastStrike(
     target,
   });
 
-  let strikeResult: FastStrikeOutcome;
+  let completed:
+    | { policy: "native"; outcome: FastStrikeOutcome }
+    | {
+        policy: "external";
+        outcome: z.infer<typeof FastStrikeExternalResult>;
+      };
   try {
-    strikeResult = await agent.consume();
+    const strikeResult = await agent.consume();
+    if (findingPolicy === "external") {
+      const parsed = FastStrikeExternalResult.safeParse(strikeResult);
+      if (!parsed.success) {
+        throw new Error(
+          "Externally graded Fast Strike ended without a structured findings response",
+        );
+      }
+      completed = { policy: "external", outcome: parsed.data };
+    } else {
+      completed = { policy: "native", outcome: strikeResult };
+    }
     eventBus?.emit("subagent-complete", {
       subagentId: "fast-strike",
       status: "completed",
     });
     await seams.hooks.onEndpointDone?.(
       { subagentId: "fast-strike", subagentName: "Fast Strike", target },
-      strikeResult,
+      completed.outcome,
     );
   } catch (e) {
     eventBus?.emit("subagent-complete", {
@@ -206,8 +278,31 @@ export async function runFastStrike(
     throw new DOMException("Pentest aborted by user", "AbortError");
   }
 
+  if (completed.policy === "external") {
+    const strikeResult = completed.outcome;
+    eventBus?.emit("workflow-phase-complete", {
+      phase: "pentesting",
+      summary: {
+        findingsCount: strikeResult.reportedFindings.length,
+        solved: strikeResult.solved,
+        operatorSummary: strikeResult.summary,
+      },
+    });
+    return {
+      findings: [],
+      findingsPath: session.findingsPath,
+      pocsPath: session.pocsPath,
+      reportPath: null,
+      reportedFindings: strikeResult.reportedFindings,
+      submissionJson: strikeResult.submissionJson,
+      solved: strikeResult.solved,
+      summary: strikeResult.summary,
+    };
+  }
+
   await findingsRegistry.groupByRootCause();
   const findings = [...findingsRegistry.getFindings()];
+  const strikeResult = completed.outcome;
 
   const report = buildPentestReport(findings, {
     target,

package/src/core/workflows/pentest.test.ts

@@ -573,3 +573,107 @@ describe("runPentestWorkflow — threads seams into the whitebox discovery phase
     expect(mocks.whiteboxCalls[0]?.seams).toBe(seams);
   });
 });
+
+describe("external pentest workflow", () => {
+  it("returns worker findings without native report generation and retains them on resume", async () => {
+    const emit = vi.fn();
+    mocks.consumeImpl = async () => ({
+      findings: [],
+      reportedFindings: ["GET /api reveals another tenant's data"],
+      objectiveResults: [
+        {
+          objective: "Test the target",
+          completed: true,
+          result: "Extracted FLAG{example} through the confirmed weakness",
+        },
+      ],
+      findingsPath: session.findingsPath,
+      pocsPath: session.pocsPath,
+    });
+    const input: PentestWorkflowInput = {
+      target: "https://example.com",
+      model: {} as PentestWorkflowInput["model"],
+      session,
+      findingPolicy: "external",
+      eventBus: { emit } as unknown as NonNullable<
+        PentestWorkflowInput["eventBus"]
+      >,
+      hooks: { findingPolicy: undefined },
+    };
+
+    const first = await runPentestWorkflow(input);
+    expect(first).toMatchObject({
+      findings: [],
+      reportedFindings: ["GET /api reveals another tenant's data"],
+      objectiveResults: [
+        {
+          objective: "Test the target",
+          completed: true,
+          result: "Extracted FLAG{example} through the confirmed weakness",
+        },
+      ],
+      reportPath: null,
+    });
+    expect(mocks.targetedInputs).toHaveLength(1);
+    expect(mocks.targetedInputs[0]?.findingPolicy).toBe("external");
+    expect(emit).toHaveBeenCalledWith("workflow-phase-complete", {
+      phase: "pentesting",
+      summary: { findingsCount: 1 },
+    });
+
+    mocks.consumeImpl = async () => {
+      throw new Error("completed worker was rerun");
+    };
+    const resumed = await runPentestWorkflow(input);
+    expect(resumed.reportedFindings).toEqual(first.reportedFindings);
+    expect(resumed.objectiveResults).toEqual(first.objectiveResults);
+    expect(mocks.targetedInputs).toHaveLength(1);
+  });
+
+  it("does not generate a native report when discovery has no targets", async () => {
+    mocks.loadAttackSurfaceResults.mockReturnValue({ targets: [] });
+    const result = await runPentestWorkflow({
+      target: "https://example.com",
+      model: {} as PentestWorkflowInput["model"],
+      session,
+      findingPolicy: "external",
+    });
+    expect(result).toMatchObject({
+      findings: [],
+      reportedFindings: [],
+      objectiveResults: [],
+      reportPath: null,
+    });
+  });
+
+  it("rejects an external worker result without objective outcomes", async () => {
+    mocks.consumeImpl = async () => ({
+      findings: [],
+      reportedFindings: ["A finding"],
+      findingsPath: session.findingsPath,
+      pocsPath: session.pocsPath,
+    });
+    await expect(
+      runPentestWorkflow({
+        target: "https://example.com",
+        model: {} as PentestWorkflowInput["model"],
+        session,
+        findingPolicy: "external",
+      }),
+    ).rejects.toThrow("incomplete swarm target");
+  });
+
+  it("fails rather than treating an incomplete external worker as no finding", async () => {
+    mocks.consumeImpl = async () => {
+      throw new Error("worker failed");
+    };
+    await expect(
+      runPentestWorkflow({
+        target: "https://example.com",
+        model: {} as PentestWorkflowInput["model"],
+        session,
+        findingPolicy: "external",
+      }),
+    ).rejects.toThrow("incomplete swarm target");
+  });
+});

package/src/core/workflows/pentest.ts

@@ -7,7 +7,7 @@ import type {
   ToolSet,
 } from "ai";
 import { hasToolCall } from "ai";
-import type { AgentHooks, Finding } from "../agents/offSecAgent";
+import type { AgentHooks, Finding, FindingPolicy } from "../agents/offSecAgent";
 import {
   OffensiveSecurityAgent,
   PLAN_MODE_TOOL_NAMES,
@@ -39,6 +39,7 @@ import type {
   AIModel,
   CacheMetrics,
   OpenAIReasoningEffort,
+  ReasoningSetting,
   ThinkingEffort,
   UsageRecorder,
 } from "../ai";
@@ -64,6 +65,8 @@ import {
   finalizeManifest,
   getCompletedAgentIds,
   loadSubagentMessages,
+  loadSubagentObjectiveResults,
+  loadSubagentReportedFindings,
   readAgentManifest,
   reconcileManifestOnResume,
   type SwarmTarget,
@@ -99,6 +102,7 @@ export const DEFAULT_CONCURRENCY = 10;
 // ---------------------------------------------------------------------------
 
 export interface PentestWorkflowInput {
+  findingPolicy?: FindingPolicy;
   /** Live target URL — always required */
   target: string;
 
@@ -125,6 +129,7 @@ export interface PentestWorkflowInput {
 
   /** OpenAI reasoning effort for GPT/o-series reasoning models. */
   openAIReasoningEffort?: OpenAIReasoningEffort | null;
+  reasoning?: ReasoningSetting;
 
   /** Optional guidance prompt injected into discovery agent system prompts */
   prompt?: string;
@@ -170,6 +175,11 @@ export interface PentestWorkflowInput {
 
 export interface PentestWorkflowResult {
   findings: Finding[];
+  reportedFindings?: string[];
+  objectiveResults?: PentestResult["objectiveResults"];
+  submissionJson?: string;
+  solved?: boolean;
+  summary?: string;
   findingsPath: string;
   pocsPath: string;
   reportPath: string | null;
@@ -178,6 +188,7 @@ export interface PentestWorkflowResult {
 export type { SwarmTarget } from "../session/persistence";
 
 export interface PentestSwarmInput {
+  findingPolicy?: FindingPolicy;
   targets: SwarmTarget[];
   model: AIModel;
   session: SessionInfo;
@@ -192,6 +203,7 @@ export interface PentestSwarmInput {
   enableThinking?: boolean;
   thinkingEffort?: ThinkingEffort | null;
   openAIReasoningEffort?: OpenAIReasoningEffort | null;
+  reasoning?: ReasoningSetting;
   /**
    * X display (e.g. `":11"`) for every swarm sub-agent's browser, so a swarm
    * launched by an orchestrator on a per-endpoint virtual desktop keeps its
@@ -243,6 +255,7 @@ export interface PentestSwarmTargetInput {
   enableThinking?: boolean;
   thinkingEffort?: ThinkingEffort | null;
   openAIReasoningEffort?: OpenAIReasoningEffort | null;
+  reasoning?: ReasoningSetting;
   display?: string;
   onError?: (e: unknown) => void;
   /** The swarm's shared {@link AgentHooks}; merged with `seams.hooksForItem` for this target. */
@@ -278,6 +291,7 @@ export async function runPentestSwarmTarget(
     enableThinking,
     thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
     display,
     onError,
     hooks: sharedHooks,
@@ -290,7 +304,23 @@ export async function runPentestSwarmTarget(
   const subagentId = entry.id;
   const subagentName = target.name ?? entry.name;
 
-  if (completedIds.has(subagentId)) return null;
+  if (completedIds.has(subagentId)) {
+    if (sharedHooks.findingPolicy !== "external") return null;
+    const reportedFindings = loadSubagentReportedFindings(session, subagentId);
+    const objectiveResults = loadSubagentObjectiveResults(session, subagentId);
+    if (!reportedFindings || !objectiveResults) {
+      throw new Error(
+        `Cannot resume externally graded pentest: findings or objective results for completed agent ${subagentId} are unavailable`,
+      );
+    }
+    return {
+      findings: [],
+      reportedFindings,
+      objectiveResults,
+      findingsPath: session.findingsPath,
+      pocsPath: session.pocsPath,
+    };
+  }
 
   // Per-target AgentHooks: seams.hooksForItem can give this one target
   // (e.g. its own lease/backends, its own politeness budget) different
@@ -367,6 +397,7 @@ export async function runPentestSwarmTarget(
         enableThinking,
         thinkingEffort,
         openAIReasoningEffort,
+        reasoning,
         display,
         ...itemHooks,
         abortSignal: childSignal,
@@ -412,21 +443,44 @@ export async function runPentestSwarmTarget(
       enableThinking,
       thinkingEffort,
       openAIReasoningEffort,
+      reasoning,
       display,
       ...itemHooks,
       abortSignal: childSignal,
     });
 
     const result = await agent.consume();
+    if (
+      itemHooks.findingPolicy === "external" &&
+      (!Array.isArray(result.reportedFindings) ||
+        !Array.isArray(result.objectiveResults))
+    ) {
+      throw new Error(
+        `Externally graded pentest worker ${subagentId} ended without structured findings and objective results`,
+      );
+    }
 
     saveSubagentData(session, {
       agentName: subagentId,
       target: target.target,
       objective: objectiveStr,
       status: "completed",
-      findingsCount: result.findings.length,
+      findingsCount: result.reportedFindings?.length ?? result.findings.length,
+      ...(itemHooks.findingPolicy === "external"
+        ? {
+            reportedFindings: result.reportedFindings,
+            objectiveResults: result.objectiveResults,
+          }
+        : {}),
       messages: [...previousMessages, ...lastMessages],
-      systemPrompt: buildPentestSystemPrompt(session),
+      systemPrompt: buildPentestSystemPrompt(
+        session,
+        "orchestrator",
+        "default",
+        undefined,
+        undefined,
+        itemHooks.findingPolicy,
+      ),
       userPrompt: agent.userPrompt,
     });
     updateManifestEntryStatus(session, subagentId, "completed");
@@ -450,7 +504,14 @@ export async function runPentestSwarmTarget(
       status: "failed",
       error: error instanceof Error ? error.message : String(error),
       messages: [...previousMessages, ...lastMessages],
-      systemPrompt: buildPentestSystemPrompt(session),
+      systemPrompt: buildPentestSystemPrompt(
+        session,
+        "orchestrator",
+        "default",
+        undefined,
+        undefined,
+        itemHooks.findingPolicy,
+      ),
       userPrompt: agent?.userPrompt ?? "",
     });
     updateManifestEntryStatus(session, subagentId, "failed");
@@ -497,6 +558,7 @@ export async function runPentestSwarm(
     enableThinking,
     thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
     display,
     subagentSpawner,
     languageModelMiddleware,
@@ -522,6 +584,7 @@ export async function runPentestSwarm(
     usageRecorder,
     streamIdFactory,
     ...hooks,
+    findingPolicy: hooks?.findingPolicy ?? input.findingPolicy,
   };
 
   // Ops-typed by the seam; TargetedPentestAgent/OffensiveSecurityAgent only
@@ -558,6 +621,7 @@ export async function runPentestSwarm(
     enableThinking,
     thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
     display,
     onError,
     hooks: sharedHooks,
@@ -574,6 +638,15 @@ export async function runPentestSwarm(
 
   finalizeManifest(session, manifestEntries, results);
 
+  if (
+    sharedHooks.findingPolicy === "external" &&
+    results.some((result) => result === null)
+  ) {
+    throw new Error(
+      "Externally graded pentest has an incomplete swarm target; findings cannot be aggregated",
+    );
+  }
+
   return results;
 }
 
@@ -609,10 +682,12 @@ export async function runPentestWorkflow(
     enableThinking,
     thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
     prompt,
     threatModel,
     surfaceIntegrationEnabled,
   } = input;
+  const findingPolicy = input.hooks?.findingPolicy ?? input.findingPolicy;
 
   // Default registries mirror today's `FindingsRegistry.fromDirectory` resume
   // behavior (dedup against on-disk findings, model-backed semantic dedup).
@@ -626,6 +701,7 @@ export async function runPentestWorkflow(
         findings: () =>
           FindingsRegistry.fromDirectory(session.findingsPath, {
             model,
+            reasoning,
             authConfig,
             abortSignal,
             sessionId: session.id,
@@ -698,6 +774,7 @@ export async function runPentestWorkflow(
           onStepFinish,
           onCacheMetrics,
           openAIReasoningEffort,
+          reasoning,
           surfaceIntegrationEnabled,
           subagentSpawner: input.subagentSpawner,
           hooks: {
@@ -706,6 +783,7 @@ export async function runPentestWorkflow(
             usageRecorder: input.usageRecorder,
             streamIdFactory: input.streamIdFactory,
             ...input.hooks,
+            findingPolicy,
           },
           seams,
         });
@@ -720,12 +798,14 @@ export async function runPentestWorkflow(
           onStepFinish,
           onCacheMetrics,
           openAIReasoningEffort,
+          reasoning,
           hooks: {
             subagentSpawner: input.subagentSpawner,
             languageModelMiddleware: input.languageModelMiddleware,
             usageRecorder: input.usageRecorder,
             streamIdFactory: input.streamIdFactory,
             ...input.hooks,
+            findingPolicy,
           },
         });
       }
@@ -744,6 +824,16 @@ export async function runPentestWorkflow(
     }
 
     if (swarmTargets.length === 0) {
+      if (findingPolicy === "external") {
+        return {
+          findings: [],
+          reportedFindings: [],
+          objectiveResults: [],
+          findingsPath: session.findingsPath,
+          pocsPath: session.pocsPath,
+          reportPath: null,
+        };
+      }
       const report = buildPentestReport([], {
         target,
         model,
@@ -778,10 +868,15 @@ export async function runPentestWorkflow(
     const findingsRegistry = seams.registries.findings() as FindingsRegistry;
 
     const completedCount = getCompletedAgentIds(session).size;
+    let externalReportedFindings: string[] = [];
+    let externalObjectiveResults: NonNullable<
+      PentestResult["objectiveResults"]
+    > = [];
 
-    if (completedCount < swarmTargets.length) {
-      await runPentestSwarm({
+    if (findingPolicy === "external" || completedCount < swarmTargets.length) {
+      const swarmResults = await runPentestSwarm({
         targets: swarmTargets,
+        findingPolicy,
         model,
         session,
         authConfig,
@@ -793,6 +888,7 @@ export async function runPentestWorkflow(
         enableThinking,
         thinkingEffort,
         openAIReasoningEffort,
+        reasoning,
         subagentSpawner: input.subagentSpawner,
         languageModelMiddleware: input.languageModelMiddleware,
         usageRecorder: input.usageRecorder,
@@ -800,12 +896,33 @@ export async function runPentestWorkflow(
         hooks: input.hooks,
         seams,
       });
+      externalReportedFindings = swarmResults.flatMap(
+        (result) => result?.reportedFindings ?? [],
+      );
+      externalObjectiveResults = swarmResults.flatMap(
+        (result) => result?.objectiveResults ?? [],
+      );
     }
 
     if (abortSignal?.aborted) {
       throw new DOMException("Pentest aborted by user", "AbortError");
     }
 
+    if (findingPolicy === "external") {
+      eventBus?.emit("workflow-phase-complete", {
+        phase: "pentesting",
+        summary: { findingsCount: externalReportedFindings.length },
+      });
+      return {
+        findings: [],
+        reportedFindings: externalReportedFindings,
+        objectiveResults: externalObjectiveResults,
+        findingsPath: session.findingsPath,
+        pocsPath: session.pocsPath,
+        reportPath: null,
+      };
+    }
+
     // =========================================================================
     // Phase 3: Aggregate results
     // =========================================================================
@@ -881,6 +998,7 @@ async function runWhiteboxPhase(opts: {
   onStepFinish?: StreamTextOnStepFinishCallback<ToolSet>;
   onCacheMetrics?: (metrics: CacheMetrics) => void;
   openAIReasoningEffort?: OpenAIReasoningEffort | null;
+  reasoning?: ReasoningSetting;
   surfaceIntegrationEnabled?: boolean;
   subagentSpawner?: SubagentSpawner;
   hooks?: AgentHooks;
@@ -896,6 +1014,7 @@ async function runWhiteboxPhase(opts: {
     onStepFinish: opts.onStepFinish,
     onCacheMetrics: opts.onCacheMetrics,
     openAIReasoningEffort: opts.openAIReasoningEffort,
+    reasoning: opts.reasoning,
     surfaceIntegrationEnabled: opts.surfaceIntegrationEnabled,
     subagentSpawner: opts.subagentSpawner,
     hooks: opts.hooks,
@@ -931,6 +1050,7 @@ async function runBlackboxPhase(opts: {
   onStepFinish?: StreamTextOnStepFinishCallback<ToolSet>;
   onCacheMetrics?: (metrics: CacheMetrics) => void;
   openAIReasoningEffort?: OpenAIReasoningEffort | null;
+  reasoning?: ReasoningSetting;
 }): Promise<SwarmTarget[]> {
   let lastMessages: ModelMessage[] = [];
 
@@ -954,6 +1074,7 @@ async function runBlackboxPhase(opts: {
     },
     onCacheMetrics: opts.onCacheMetrics,
     openAIReasoningEffort: opts.openAIReasoningEffort,
+    reasoning: opts.reasoning,
   };
 
   const agent = new BlackboxAttackSurfaceAgent(agentInput);