@pensar/apex 2.6.1 → 2.7.0-canary.21cb83dc

package/src/core/agents/offSecAgent/offensiveSecurityAgent.ts

@@ -298,6 +298,7 @@ export class OffensiveSecurityAgent<TResult = void> {
 
   private readonly resolveResult?: (
     streamResult: StreamTextResult<ToolSet, never>,
+    validatedResponse?: unknown,
   ) => TResult | Promise<TResult>;
 
   /** The structured result captured by the `response` tool, or `null` until it fires. */
@@ -552,6 +553,7 @@ export class OffensiveSecurityAgent<TResult = void> {
       input.credentialManager ?? input.session.credentialManager;
 
     const toolCtx = {
+      findingPolicy: input.findingPolicy,
       ...(input.attackSurfaceArtifactsPath
         ? { attackSurfaceArtifactsPath: input.attackSurfaceArtifactsPath }
         : {}),
@@ -658,6 +660,12 @@ export class OffensiveSecurityAgent<TResult = void> {
       }
     }
 
+    if (input.findingPolicy === "external") {
+      activeTools = activeTools.filter(
+        (name) => name !== "document_vulnerability",
+      );
+    }
+
     activeTools = filterWorkspaceToolsForRun(
       activeTools,
       input.prompt,
@@ -666,8 +674,16 @@ export class OffensiveSecurityAgent<TResult = void> {
 
     const builtinTools = createToolsForNames(toolCtx, activeTools);
 
-    let tools: ToolSet = input.extraTools
-      ? { ...builtinTools, ...input.extraTools }
+    const extraTools =
+      input.findingPolicy === "external" && input.extraTools
+        ? Object.fromEntries(
+            Object.entries(input.extraTools).filter(
+              ([name]) => name !== "document_vulnerability",
+            ),
+          )
+        : input.extraTools;
+    let tools: ToolSet = extraTools
+      ? { ...builtinTools, ...extraTools }
       : { ...builtinTools };
 
     // Only approved calls may reach the execution journal.
@@ -712,7 +728,7 @@ export class OffensiveSecurityAgent<TResult = void> {
                         Promise.race([sr.response, this._drainRejection]),
                     },
                   });
-                  return customResolve(guarded);
+                  return customResolve(guarded, result);
                 })
                 .then((resolved) => {
                   this._capturedResponse = resolved;
@@ -759,16 +775,36 @@ export class OffensiveSecurityAgent<TResult = void> {
     }
     this.messagesPath = join(messagesDir, "messages.json");
 
-    // Mutable so that summarization can clear stale history.
-    const initialMessagesRef: { current: ModelMessage[] } = {
-      current: input.messages
-        ? [...input.messages]
-        : [
-            {
-              role: "user" as const,
-              content: [{ type: "text", text: input.prompt }],
-            },
-          ],
+    const preparedContextRef = {
+      current: {
+        messages: input.messages
+          ? [...input.messages]
+          : [
+              {
+                role: "user" as const,
+                content: [{ type: "text" as const, text: input.prompt }],
+              },
+            ],
+        responseMessageOffset: 0,
+      },
+    };
+    const legacyMessages = (responseMessages: ModelMessage[]) => [
+      ...preparedContextRef.current.messages,
+      ...responseMessages.slice(
+        preparedContextRef.current.responseMessageOffset,
+      ),
+    ];
+    const persistedMessages = (messages: ModelMessage[]) => {
+      // Cache-marked system messages are transport context; the next turn
+      // supplies a fresh system prompt and must not replay saved copies.
+      let first = 0;
+      while (
+        messages[first]?.role === "system" &&
+        messages[first]?.providerOptions
+      ) {
+        first++;
+      }
+      return first === 0 ? messages : messages.slice(first);
     };
 
     // Agent-local persistence: debounce, latest snapshot, and the
@@ -796,6 +832,7 @@ export class OffensiveSecurityAgent<TResult = void> {
       input.system ??
       buildBaseSystemPrompt({
         sandboxMode: agentCwd === input.session.rootPath,
+        findingPolicy: input.findingPolicy,
       });
     const commandPlatform = resolveCommandPlatform(toolCtx);
     const workspaceSection = buildSessionWorkspaceSection(
@@ -803,6 +840,7 @@ export class OffensiveSecurityAgent<TResult = void> {
       agentCwd,
       activeTools,
       fileWorkspaceRoot,
+      input.findingPolicy,
     );
     // Bundled wordlist paths are host-local: advertise them only when
     // commands execute locally.
@@ -861,6 +899,12 @@ export class OffensiveSecurityAgent<TResult = void> {
         usageRecorder: input.usageRecorder,
         contextRecorder: input.contextRecorder,
         inferenceRecorder: input.inferenceRecorder,
+        onContextPrepared: (context) => {
+          preparedContextRef.current = {
+            messages: [...context.messages],
+            responseMessageOffset: context.responseMessageOffset,
+          };
+        },
         // Per-subagent so the overflow tool-result dumps land next to this
         // agent's messages.json (`subagents/{id}/tool-results/`) and a host
         // can reclaim them when the subagent finishes, instead of piling up
@@ -880,16 +924,10 @@ export class OffensiveSecurityAgent<TResult = void> {
             return;
           }
 
-          // Recorded runs project the canonical committed context; the
-          // legacy path reconstructs from the (possibly stale after a fit)
-          // initial prefix. Canonical latest() already includes this step's
-          // messages — committing happens upstream in the ai layer's
-          // onStepFinish wrapper, before this user callback runs.
-          const canonical = input.contextRecorder?.latest() ?? [
-            ...initialMessagesRef.current,
-            ...event.response.messages,
-          ];
-          this.writer.setLatest(canonical);
+          const canonical =
+            input.contextRecorder?.latest() ??
+            legacyMessages(event.response.messages);
+          this.writer.setLatest(persistedMessages(canonical));
           schedulePersist();
           traceWriter.recordStep(
             event.response.messages as ModelMessage[],
@@ -905,9 +943,10 @@ export class OffensiveSecurityAgent<TResult = void> {
           await input.onStepFinish?.(event);
         },
         onSummarized: () => {
-          // Context was reset by summarization — discard the old history so
-          // subsequent onStepFinish writes only persist post-summary messages.
-          initialMessagesRef.current = [];
+          preparedContextRef.current = {
+            messages: [],
+            responseMessageOffset: 0,
+          };
           traceWriter.markSummarized();
         },
         onFinish: async (event) => {
@@ -915,11 +954,11 @@ export class OffensiveSecurityAgent<TResult = void> {
           this.writer.cancelTimer();
           // Skip if the interrupted-step finalizer already wrote the abort snapshot.
           if (!this.writer.syntheticsPersisted) {
-            const finalMessages = input.contextRecorder?.latest() ??
-              this.writer.latest ?? [
-                ...initialMessagesRef.current,
-                ...event.response.messages,
-              ];
+            const finalMessages = persistedMessages(
+              input.contextRecorder?.latest() ??
+                this.writer.latest ??
+                legacyMessages(event.response.messages),
+            );
             this.writer.setLatest(finalMessages);
             await this.writer.enqueueWrite(finalMessages).catch(() => {});
           }

package/src/core/agents/offSecAgent/prompt.test.ts

@@ -70,3 +70,49 @@ describe("buildBaseSystemPrompt workspace management", () => {
     );
   });
 });
+
+describe("external finding policy prompts", () => {
+  const session = {
+    rootPath: "/tmp/apex-external-prompt",
+    findingsPath: "/tmp/apex-external-prompt/findings",
+    pocsPath: "/tmp/apex-external-prompt/pocs",
+    scratchpadPath: "/tmp/apex-external-prompt/scratchpad",
+    logsPath: "/tmp/apex-external-prompt/logs",
+  };
+
+  it("keeps exploration guidance without directing an unavailable finding tool", () => {
+    const prompt = buildBaseSystemPrompt({ findingPolicy: "external" });
+    expect(prompt).toContain("Source code analysis");
+    expect(prompt).toContain("caller grades them after the run");
+    expect(prompt).not.toContain("document_vulnerability");
+    expect(prompt).not.toContain("published PoCs");
+  });
+
+  it.each([
+    [session.rootPath, undefined],
+    ["/project", undefined],
+    ["/project", "/tmp/apex-external-prompt/helpers"],
+  ])("uses the caller's finding contract for cwd %s", (cwd, fileWorkspaceRoot) => {
+    const prompt = buildSessionWorkspaceSection(
+      session,
+      cwd,
+      ["execute_command", "read_file"],
+      fileWorkspaceRoot,
+      "external",
+    );
+    expect(prompt).toContain("caller's output contract");
+    expect(prompt).not.toContain("document_vulnerability");
+  });
+
+  it("keeps source guidance policy-safe even when tool names are not supplied", () => {
+    const prompt = buildSessionWorkspaceSection(
+      { ...session, config: { codebasePath: "/project" } },
+      "/project",
+      undefined,
+      undefined,
+      "external",
+    );
+    expect(prompt).toContain("Source Code Assessment");
+    expect(prompt).not.toContain("document_vulnerability");
+  });
+});

package/src/core/agents/offSecAgent/prompt.ts

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
+import type { FindingPolicy } from "./types";
 
 interface SessionPaths {
   rootPath: string;
@@ -77,6 +78,7 @@ export function buildSessionWorkspaceSection(
   agentCwd: string,
   activeTools?: readonly string[],
   fileWorkspaceRoot?: string,
+  findingPolicy: FindingPolicy = "native",
 ): string {
   const sandboxMode = agentCwd === session.rootPath;
   const providedFilesSection = buildProvidedFilesSection(
@@ -87,9 +89,14 @@ export function buildSessionWorkspaceSection(
     session,
     agentCwd,
     { sandboxMode, activeTools, fileWorkspaceRoot },
+    findingPolicy,
   );
 
   if (fileWorkspaceRoot) {
+    const artifactsGuidance =
+      findingPolicy === "external"
+        ? `Session artifacts live at ${session.rootPath}. Follow the caller's output contract for findings; browser tools save their own evidence.`
+        : `Session artifacts live at ${session.rootPath}. Findings and published PoCs are written by \`document_vulnerability\`, and browser tools save their own evidence.`;
     return `
 
 # Working Directory and File Workspace
@@ -98,10 +105,17 @@ Your shell starts in ${agentCwd}. Native file tools are confined to ${fileWorksp
 
 Create and edit helper scripts inside the file workspace. Use absolute helper paths with \`execute_command\` to check and run them. Do not prefix native file-tool paths with \`scratchpad/\` or \`provided_files/\` to reach session directories outside the file workspace.
 
-Session artifacts live at ${session.rootPath}. Findings and published PoCs are written by \`document_vulnerability\`, and browser tools save their own evidence. Session logs and provided files outside the file workspace must be inspected through command tools or copied into the file workspace before native file tools can read them.${providedFilesSection}${sourceAssessmentSection}`;
+${artifactsGuidance} Session logs and provided files outside the file workspace must be inspected through command tools or copied into the file workspace before native file tools can read them.${providedFilesSection}${sourceAssessmentSection}`;
   }
 
   if (sandboxMode) {
+    if (findingPolicy === "external") {
+      return `
+
+# Session Workspace
+
+Your shell is already set to the session directory. Use relative paths for session files. The session provides scratchpad/ for temporary work, logs/ for execution logs, evidence/ for browser evidence, and provided_files/ for supplied inputs. Follow the caller's output contract for findings.${providedFilesSection}${sourceAssessmentSection}`;
+    }
     return `
 
 # Session Workspace
@@ -119,6 +133,15 @@ The session directory (${session.rootPath}) contains these subdirectories:
 Tools like \`document_vulnerability\` and browser evidence capture write to the correct subdirectories automatically.${providedFilesSection}${sourceAssessmentSection}`;
   }
 
+  if (findingPolicy === "external") {
+    return `
+
+# Working Directory
+
+Your shell starts in the user's project directory: ${agentCwd}
+Use relative paths to reference project files. Session artifacts are stored at ${session.rootPath}; use scratchpad/ for temporary work, logs/ for execution logs, and evidence/ for browser evidence. Follow the caller's output contract for findings.${providedFilesSection}${sourceAssessmentSection}`;
+  }
+
   return `
 
 # Working Directory
@@ -168,6 +191,7 @@ function buildSourceAssessmentSection(
     activeTools?: readonly string[];
     fileWorkspaceRoot?: string;
   },
+  findingPolicy: FindingPolicy,
 ): string {
   const codebasePath = session.config?.codebasePath;
   // A helper workspace does not make the shell's cwd an authorized target
@@ -214,7 +238,8 @@ function buildSourceAssessmentSection(
       "- Use `spawn_coding_agent` for independent deep dives.",
     hasTool("create_whitebox_candidate") &&
       "- Track unverified hypotheses with `create_whitebox_candidate`.",
-    hasTool("document_vulnerability") &&
+    findingPolicy !== "external" &&
+      hasTool("document_vulnerability") &&
       "- Only call `document_vulnerability` after a PoC, crash reproducer, or dynamic check confirms exploitability.",
     hasTool("start_whitebox_job") &&
       hasTool("poll_whitebox_job") &&
@@ -238,12 +263,32 @@ ${toolGuidance}${repoEditBullet}`;
 export interface BaseSystemPromptOptions {
   /** When true, include the "Stay in the session folder" instruction. Defaults to true. */
   sandboxMode?: boolean;
+  findingPolicy?: FindingPolicy;
 }
 
 export function buildBaseSystemPrompt(
   options?: BaseSystemPromptOptions,
 ): string {
   const sandboxMode = options?.sandboxMode ?? true;
+  const externalFindings = options?.findingPolicy === "external";
+
+  const exploitationCapability = externalFindings
+    ? "- **Exploitation and proof development** — use the available tools only as far as the assigned objective requires"
+    : "- **Exploitation & proof-of-concept development** — provide PoC scripts inline to document_vulnerability which executes and validates them";
+  const reportingCapability = externalFindings
+    ? "- **Reporting** — submit concise findings through the caller's requested output contract; the caller grades them after the run"
+    : "- **Reporting** — document confirmed findings with evidence, impact, and remediation";
+  const findingToolReference = externalFindings
+    ? `## Findings
+- Use the caller's requested output format for any discovered vulnerabilities. Include the affected surface, observed behavior, and likely security impact.`
+    : `## Findings & PoCs
+- **document_vulnerability** — Create, execute, and validate a proof-of-concept script, then document the confirmed vulnerability with CVSS 4.0 scoring. Provide your POC script inline via pocContent. The tool handles execution, validation, scoring, and persistence.`;
+  const findingWorkRule = externalFindings
+    ? "6. **Report findings through the requested output.** Focus on discovering vulnerabilities and gathering the evidence required by the user's task. Do not spend time on a separate in-run finding review."
+    : "6. **Document security work as you go.** During reconnaissance or pentesting, call `document_app` for discovered applications and `document_endpoint` for individual endpoints. For authenticated workspace additions, use the typed workspace tools instead. Call `document_vulnerability` with your POC script inline when you confirm vulnerabilities. Don't defer documentation to the end.";
+  const reportRule = externalFindings
+    ? "5. **Follow the caller's output contract.** Keep intermediate files in scratchpad/ and submit final finding artifacts only where the caller requested."
+    : "5. **No reports in scratchpad.** Do NOT write synthesized report documents to scratchpad/ (e.g., executive summaries, comprehensive pentest reports, finding compilations, risk assessments, or vulnerability rollups). The official report is generated automatically from the findings/ directory. Use scratchpad/ only for working notes, intermediate data, test scripts, wordlists, and temporary files. Summarize results via the `response` tool or inline text, not standalone report files.";
 
   const stayInSessionParagraph = sandboxMode
     ? `\n\n**Stay in the session folder.** Do not \`cd\` to \`/tmp\`, your home directory, or anywhere else unless the user explicitly asks you to work in a specific location. Create files, clone repos, scaffold projects, and run tools right here — everything belongs in the session. Use relative paths (e.g. \`scratchpad/notes.txt\`, \`test-app/\`) rather than absolute paths to external directories.`
@@ -258,9 +303,9 @@ You work interactively with the user. Execute the task they ask for, report your
 You can perform the full lifecycle of a penetration test and support a wide range of cybersecurity tasks:
 - **Reconnaissance & attack surface mapping** — subdomain enumeration, endpoint discovery, JS analysis, authenticated crawling
 - **Vulnerability testing** — injection flaws, auth bypasses, access control issues, misconfigurations, business logic flaws
-- **Exploitation & proof-of-concept development** — provide PoC scripts inline to document_vulnerability which executes and validates them
+${exploitationCapability}
 - **Source code analysis** — read and search codebases for security-relevant patterns, misconfigurations, and vulnerabilities
-- **Reporting** — document confirmed findings with evidence, impact, and remediation
+${reportingCapability}
 
 # Tool Reference
 
@@ -311,8 +356,7 @@ You can perform the full lifecycle of a penetration test and support a wide rang
 
 These tools use the authenticated API client in the running Apex process. Use them for workspace imports and mutations even when Apex was launched locally with \`bun run dev\`; do not invoke a separate \`pensar apps\` binary through the shell for these operations. A non-HTTP transport classification does not add RPC metadata or make an endpoint scan-ready.
 
-## Findings & PoCs
-- **document_vulnerability** — Create, execute, and validate a proof-of-concept script, then document the confirmed vulnerability with CVSS 4.0 scoring. Provide your POC script inline via pocContent. The tool handles execution, validation, scoring, and persistence.
+${findingToolReference}
 
 ## Orchestration
 - **run_attack_surface** — Launch a full attack surface discovery workflow. Supports blackbox (live target) and whitebox (source code analysis when a codebase path is provided).
@@ -340,7 +384,7 @@ Run \`pensar --help\` or \`pensar <command> --help\` for exact flags — the CLI
 3. **Be thorough within the ask.** When given a task, see it through completely. Don't do half the work and ask whether to continue — finish the job, then report back.
 4. **Use the right level of automation.** For large tasks (e.g., "pentest this entire application"), use orchestration tools like \`run_attack_surface\` and \`spawn_pentest_swarm\` to parallelize the work. For focused tasks (e.g., "check if this parameter is vulnerable to XSS"), work directly with \`http_request\`, \`execute_command\`, or the browser tools.
 5. **Authenticate when needed.** If the user provides credentials or auth instructions, use them. Hand the login off to \`delegate_to_auth_subagent\`, which handles both simple (form/JSON/Basic) and complex flows (OAuth, SAML, CSRF-protected SPAs).
-6. **Document security work as you go.** During reconnaissance or pentesting, call \`document_app\` for discovered applications and \`document_endpoint\` for individual endpoints. For authenticated workspace additions, use the typed workspace tools instead. Call \`document_vulnerability\` with your POC script inline when you confirm vulnerabilities. Don't defer documentation to the end.
+${findingWorkRule}
 7. **Consult memories first.** When you begin testing a specific application, framework, or path, call \`list_memories\` to check for saved knowledge from previous sessions — past findings, useful payloads, endpoint patterns, or target-specific notes. Use relevant memories to inform your approach before starting from scratch.
 
 # Command Execution
@@ -358,7 +402,7 @@ For long-running services (servers, listeners, watchers), background them with *
 2. **Stay in scope.** Only test targets and systems explicitly provided by the user or discovered within the authorized scope. Respect any scope constraints in the session config.
 3. **Handle failures gracefully.** If a tool call fails or a technique doesn't work, try alternative approaches. If your PoC approach fails repeatedly, pivot to a different technique.
 4. **Summarize results.** After completing a task, give the user a clear summary of what you found, what you tried, and what the next steps could be.
-5. **No reports in scratchpad.** Do NOT write synthesized report documents to scratchpad/ (e.g., executive summaries, comprehensive pentest reports, finding compilations, risk assessments, or vulnerability rollups). The official report is generated automatically from the findings/ directory. Use scratchpad/ only for working notes, intermediate data, test scripts, wordlists, and temporary files. Summarize results via the \`response\` tool or inline text, not standalone report files.`;
+${reportRule}`;
 }
 
 /**

package/src/core/agents/offSecAgent/selectiveConstruction.publicPath.test.ts

@@ -201,6 +201,20 @@ describe("OffensiveSecurityAgent public-path construction counts", () => {
     });
   });
 
+  it("external Fast Strike never constructs the native finding tool", async () => {
+    await withRoot(async (root) => {
+      reset();
+      observed.armed = true;
+      makeAgent(root, [], { mode: "fast-strike", findingPolicy: "external" });
+      observed.armed = false;
+      expect(observed.constructed).toBe(42);
+      expect(stream().tools).not.toHaveProperty("document_vulnerability");
+      expect(stream().tools).toHaveProperty("execute_command");
+      expect(stream().tools).toHaveProperty("http_request");
+      expect(stream().tools).toHaveProperty("read_file");
+    });
+  });
+
   it("selected seven plus five available conditional tools construct twelve", async () => {
     await withRoot(async (root) => {
       reset();
@@ -237,6 +251,30 @@ describe("OffensiveSecurityAgent public-path construction counts", () => {
 });
 
 describe("response injection on the real path", () => {
+  it("passes only the executed response tool's validated result to the resolver", async () => {
+    await withRoot(async (root) => {
+      reset();
+      const resolved = vi.fn(
+        (_streamResult: unknown, result: unknown) => result,
+      );
+      const agent = makeAgent(root, ["response"], {
+        responseSchema: z.object({ reportedFindings: z.array(z.string()) }),
+        resolveResult: resolved,
+      });
+      const response = stream().tools.response as {
+        execute: (input: unknown, options: unknown) => Promise<unknown>;
+      };
+      const finding = { reportedFindings: ["Observed cross-tenant access"] };
+      await response.execute(
+        { result: finding },
+        { toolCallId: "tc_response", messages: [] },
+      );
+
+      await expect(agent.responseCaptured).resolves.toEqual(finding);
+      expect(resolved).toHaveBeenCalledWith(expect.anything(), finding);
+    });
+  });
+
   it("fast-strike + responseSchema + non-enumerable own response extra still activates the injected response", async () => {
     await withRoot(async (root) => {
       reset();

package/src/core/agents/offSecAgent/selectiveConstruction.test.ts

@@ -289,6 +289,70 @@ describe("agent-level selective construction", () => {
     expect(Object.keys(streamTools())).toContain("custom_extra");
   });
 
+  it("external grading removes the finding tool before default-mode construction and extra-tool merge", () => {
+    const m = marker();
+    makeAgent(
+      baseInput({
+        findingPolicy: "external",
+        activeTools: [
+          "document_vulnerability",
+          "execute_command",
+          "http_request",
+          "spawn_pentest_agent",
+        ],
+        extraTools: {
+          document_vulnerability: {
+            description: "caller override",
+            inputSchema: {},
+            execute: async () => "should not run",
+          },
+        },
+      }) as never,
+    );
+
+    expect(constructedSince(m)).toEqual([
+      "execute_command",
+      "http_request",
+      "spawn_pentest_agent",
+    ]);
+    expect(streamTools()).not.toHaveProperty("document_vulnerability");
+    expect(streamTools()).toHaveProperty("spawn_pentest_agent");
+    expect(state.toolContexts.at(-1)).toMatchObject({
+      findingPolicy: "external",
+    });
+  });
+
+  it("external Fast Strike retains discovery tools while excluding the finding tool", () => {
+    const m = marker();
+    makeAgent(
+      baseInput({
+        mode: "fast-strike",
+        findingPolicy: "external",
+        activeTools: [],
+        responseSchema: { parse: () => {} },
+        extraTools: {
+          document_vulnerability: {
+            description: "caller override",
+            inputSchema: {},
+            execute: async () => "should not run",
+          },
+        },
+      }) as never,
+    );
+
+    expect(constructedSince(m)).not.toContain("document_vulnerability");
+    expect(streamTools()).not.toHaveProperty("document_vulnerability");
+    for (const name of [
+      "browser_navigate",
+      "http_request",
+      "execute_command",
+      "read_file",
+      "response",
+    ]) {
+      expect(streamTools()).toHaveProperty(name);
+    }
+  });
+
   it("fast-strike keeps a builtin extra override at its builtin position in the provider tool map", () => {
     // Baseline spread semantics: { ...builtinTools, ...extraTools } replaces
     // the value but KEEPS the builtin insertion position. A name-only merge

package/src/core/agents/offSecAgent/subagentSpawner.ts

@@ -38,7 +38,12 @@ import type {
   TargetedPentestAgent,
 } from "../specialized/pentest/agent";
 import type { PlaywrightMcpSession, UnifiedSandbox } from "./tools";
-import type { AgentHooks, StreamIdFactory, SystemPentestScope } from "./types";
+import type {
+  AgentHooks,
+  FindingPolicy,
+  StreamIdFactory,
+  SystemPentestScope,
+} from "./types";
 
 /** Registry key selecting which child agent {@link SubagentSpawner.spawn} builds. */
 export type SubagentType =
@@ -101,6 +106,7 @@ export type SubagentSpec =
  * @public Consumed by Console's durable subagent runtime.
  */
 export interface SpawnRuntime {
+  findingPolicy?: FindingPolicy;
   session: SessionInfo;
   model: AIModel;
   authConfig?: AIAuthConfig;
@@ -354,6 +360,7 @@ const runPentestChild: SubagentRunner<"pentest"> = async (spec, ctx) => {
     openAIReasoningEffort: ctx.openAIReasoningEffort,
     display: ctx.display,
     hooks: {
+      findingPolicy: ctx.findingPolicy,
       backends: ctx.backends,
       sandbox: ctx.sandbox,
       languageModelMiddleware: ctx.languageModelMiddleware,
@@ -374,6 +381,7 @@ const runPentestChild: SubagentRunner<"pentest"> = async (spec, ctx) => {
 const runCodeChild: SubagentRunner<"code"> = async (spec, ctx) => {
   const { CodeAgent } = await import("../specialized/codeAgent/agent");
   const agent = new CodeAgent({
+    findingPolicy: ctx.findingPolicy,
     codebasePath: spec.codebasePath,
     objective: spec.objective,
     system: spec.system,
@@ -412,6 +420,7 @@ const runWhiteboxChild: SubagentRunner<"whitebox-attack-surface"> = async (
     "../specialized/whiteboxAttackSurface"
   );
   const agent = new WhiteboxAttackSurfaceAgent({
+    findingPolicy: ctx.findingPolicy,
     codebasePath: spec.codebasePath,
     attackSurfaceRegistry: spec.attackSurfaceRegistry,
     model: ctx.model,
@@ -438,6 +447,7 @@ const runBlackboxChild: SubagentRunner<"blackbox-attack-surface"> = async (
     "../specialized/attackSurface/blackboxAgent"
   );
   const agent = new BlackboxAttackSurfaceAgent({
+    findingPolicy: ctx.findingPolicy,
     target: spec.target,
     attackSurfaceRegistry: spec.attackSurfaceRegistry,
     model: ctx.model,
@@ -462,6 +472,7 @@ const runAuthChild: SubagentRunner<"authentication"> = async (spec, ctx) => {
   return {
     run: () =>
       runAuthenticationAgent({
+        findingPolicy: ctx.findingPolicy,
         target: spec.target,
         authHints: spec.authHints,
         session: ctx.session,

package/src/core/agents/offSecAgent/tools/delegateAuth.ts

@@ -298,6 +298,7 @@ IMPORTANT: Pass protectedEndpoints in authHints when you've discovered 401/403 e
         const result = await spawner.spawn<AuthenticationResult>({
           spec: { type: "authentication", target, authHints },
           runtime: {
+            findingPolicy: ctx.findingPolicy,
             session: ctx.session,
             model: ctx.model,
             authConfig: ctx.authConfig,