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

package/build/{targetedPentest-rcbs4nvp.js → targetedPentest-t9snxcj2.js}

@@ -1,30 +1,37 @@
-import"./cli-fy6vh2a7.js";
-import"./cli-c05y640n.js";
-import"./cli-qgz1q9g5.js";
+import"./cli-98wmmphf.js";
+import"./cli-9jscnhtg.js";
+import"./cli-t4q4t4dx.js";
 import {
   TargetedPentestAgent2
-} from "./cli-xtc2t6me.js";
+} from "./cli-vdd1s3x9.js";
 import {
   startAgentExecution
 } from "./cli-g06s7edq.js";
-import"./cli-1ve18npr.js";
+import"./cli-72y76bpg.js";
 import"./cli-qba2x69h.js";
-import"./cli-dpsw2fe6.js";
+import"./cli-a6x4jm5a.js";
 import"./cli-c2k4xxaw.js";
 
 // src/core/api/targetedPentest.ts
-function normalizeResult(result) {
+function normalizeResult(result, findingPolicy) {
   const r = result;
   if (!r || !Array.isArray(r.findings)) {
     console.error("runTargetedPentestAgent: consume() returned unexpected shape", { keys: result ? Object.keys(result) : null });
   }
   const findings = Array.isArray(r?.findings) ? r.findings : [];
-  console.log(`
+  const reportedFindings = Array.isArray(r?.reportedFindings) ? r.reportedFindings : [];
+  if (findingPolicy === "external") {
+    console.log(`
+Reported ${reportedFindings.length} finding(s) for external evaluation`);
+  } else {
+    console.log(`
 Found ${findings.length} vulnerabilities`);
-  console.log(`Findings: ${r?.findingsPath}`);
-  console.log(`POCs: ${r?.pocsPath}`);
+    console.log(`Findings: ${r?.findingsPath}`);
+    console.log(`POCs: ${r?.pocsPath}`);
+  }
   return {
     findings,
+    ...findingPolicy === "external" ? { reportedFindings } : {},
     findingsPath: r?.findingsPath,
     pocsPath: r?.pocsPath,
     objectiveResults: r?.objectiveResults,
@@ -41,7 +48,7 @@ function startTargetedPentestAgent(input) {
   }
   const { result, abortAndDrain, drained } = startAgentExecution(agent);
   return {
-    result: result.then(normalizeResult),
+    result: result.then((value) => normalizeResult(value, input.findingPolicy)),
     abortAndDrain,
     drained
   };

package/build/{targets-xj9g3q0z.js → targets-1pyf21c7.js}

@@ -1,26 +1,26 @@
 #!/usr/bin/env bun
-import"./cli-fy6vh2a7.js";
-import"./cli-c05y640n.js";
+import"./cli-t4q4t4dx.js";
+import"./cli-98wmmphf.js";
+import"./cli-9jscnhtg.js";
 import {
   listPentestTargets2,
   listTargetLogs2,
   searchTargetLogs2
-} from "./cli-7eea4e2y.js";
-import"./cli-qgz1q9g5.js";
-import"./cli-k2nwxta0.js";
-import"./cli-kb21qhvm.js";
-import"./cli-ngq9dr8n.js";
-import"./cli-d37a42dc.js";
-import"./cli-3sp6nd8d.js";
-import"./cli-xtc2t6me.js";
-import"./cli-n2en7j5b.js";
+} from "./cli-5ab346kd.js";
+import"./cli-t09zj814.js";
+import"./cli-1pmfnz1a.js";
+import"./cli-fdrrbb9p.js";
+import"./cli-9pz9wjt2.js";
+import"./cli-9kk9tm58.js";
+import"./cli-vdd1s3x9.js";
+import"./cli-z7ysyrr4.js";
 import"./cli-xcy2vxj2.js";
 import {
   markCommandFailed
 } from "./cli-z82n3qk1.js";
-import"./cli-1ve18npr.js";
+import"./cli-72y76bpg.js";
 import"./cli-qba2x69h.js";
-import"./cli-dpsw2fe6.js";
+import"./cli-a6x4jm5a.js";
 import"./cli-c2k4xxaw.js";
 
 // src/cli/targets.ts

package/build/threatModel-48y5qjze.js

@@ -0,0 +1,21 @@
+import"./cli-t4q4t4dx.js";
+import"./cli-98wmmphf.js";
+import"./cli-9jscnhtg.js";
+import {
+  runThreatModelWorkflow2
+} from "./cli-5ab346kd.js";
+import"./cli-t09zj814.js";
+import"./cli-1pmfnz1a.js";
+import"./cli-fdrrbb9p.js";
+import"./cli-9pz9wjt2.js";
+import"./cli-9kk9tm58.js";
+import"./cli-vdd1s3x9.js";
+import"./cli-z7ysyrr4.js";
+import"./cli-xcy2vxj2.js";
+import"./cli-72y76bpg.js";
+import"./cli-qba2x69h.js";
+import"./cli-a6x4jm5a.js";
+import"./cli-c2k4xxaw.js";
+export {
+  runThreatModelWorkflow2 as runThreatModelWorkflow
+};

package/build/{uninstall-7s784q4a.js → uninstall-fbydd9t6.js}

@@ -5,7 +5,7 @@ import {
 import {
   detectInstallMethod,
   init_installation
-} from "./cli-65g6rcat.js";
+} from "./cli-w9nw2a4z.js";
 import {
   __require
 } from "./cli-h6y3bt60.js";

package/build/{upload-4gvhwmvr.js → upload-sbhwe2fq.js}

@@ -1,10 +1,10 @@
-import"./cli-fy6vh2a7.js";
-import"./cli-c05y640n.js";
+import"./cli-98wmmphf.js";
+import"./cli-9jscnhtg.js";
 import {
   resolveConfig,
   createWeaveTracer
-} from "./cli-az3xq70v.js";
-import"./cli-dpsw2fe6.js";
+} from "./cli-cfrdr25z.js";
+import"./cli-a6x4jm5a.js";
 import"./cli-c2k4xxaw.js";
 
 // src/core/integrations/wandb/upload.ts

package/build/{utils-cjrz64pc.js → utils-23903gcj.js}

@@ -1,12 +1,12 @@
-import"./cli-fy6vh2a7.js";
-import"./cli-c05y640n.js";
+import"./cli-98wmmphf.js";
+import"./cli-9jscnhtg.js";
 import {
   init_types
 } from "./cli-3gt761d2.js";
 import {
   AVAILABLE_MODELS,
   init_ai
-} from "./cli-dpsw2fe6.js";
+} from "./cli-a6x4jm5a.js";
 import"./cli-c2k4xxaw.js";
 
 // src/core/providers/utils.ts

package/package.json

@@ -344,5 +344,5 @@
     "tsc": "tsc --noEmit"
   },
   "type": "module",
-  "version": "2.6.1"
+  "version": "2.7.0-canary.21cb83dc"
 }

package/src/cli.ts

@@ -301,6 +301,7 @@ pentest options:
   --task-driven             Enable task-driven architecture (experimental)
   --fast-strike            Single-operator fast strike: skip attack-surface/swarm
                            phases, one tight recon→exploit loop against the target
+  --external-findings      Return findings without Apex's in-run finding judge
   --prompt <text|@file>    Guidance for the pentest agent (inline text or @filepath)
   --threat-model <text|@file>  Threat model to guide the pentest (inline or @filepath)
   --header "Name: Value"   Custom HTTP header (repeatable)
@@ -366,6 +367,7 @@ async function runPentest() {
   const enableThinking = hasFlag("--extended-thinking");
   const taskDriven = hasFlag("--task-driven");
   const fastStrike = hasFlag("--fast-strike");
+  const externalFindings = hasFlag("--external-findings");
   const evidenceOutput = nativeRolloutEvidenceOutput();
 
   // Resolve and combine threat model + prompt
@@ -395,7 +397,7 @@ async function runPentest() {
 PENTEST ORCHESTRATION
 ${sep}
 Target:  ${target}${cwd ? `\nCwd:     ${cwd} (whitebox)` : ""}${exfilMode ? "\nMode:    exfil" : ""}
-Model:   ${model}${enableThinking ? "\nThinking: enabled" : ""}${taskDriven ? "\nTask-driven: enabled" : ""}${fastStrike ? "\nFast strike: enabled" : ""}${headers ? `\nHeaders: ${Object.keys(headers).length} configured` : ""}
+Model:   ${model}${enableThinking ? "\nThinking: enabled" : ""}${taskDriven ? "\nTask-driven: enabled" : ""}${fastStrike ? "\nFast strike: enabled" : ""}${externalFindings ? "\nFindings: external evaluation" : ""}${headers ? `\nHeaders: ${Object.keys(headers).length} configured` : ""}
 `);
 
   const session = await sessions.create({
@@ -424,26 +426,58 @@ Model:   ${model}${enableThinking ? "\nThinking: enabled" : ""}${taskDriven ? "\
       const { bus: pentestBus, cleanup: wandbCleanup } =
         await createInstrumentedBus(session, model);
       try {
-        const { findings, findingsPath, pocsPath, reportPath } =
-          await runPentestAgent({
-            target,
-            ...(cwd ? { cwd } : {}),
-            session,
-            model,
-            enableThinking,
-            ...(fastStrike ? { fastStrike: true } : {}),
-            surfaceIntegrationEnabled: pensarConfig.surfaceIntegrationEnabled,
-            authConfig: buildAuthConfig(pensarConfig),
-            eventBus: pentestBus,
-          });
+        const {
+          findings,
+          findingsPath,
+          pocsPath,
+          reportPath,
+          reportedFindings,
+          objectiveResults,
+          submissionJson,
+          solved,
+          summary,
+        } = await runPentestAgent({
+          target,
+          ...(cwd ? { cwd } : {}),
+          session,
+          model,
+          enableThinking,
+          ...(externalFindings ? { findingPolicy: "external" as const } : {}),
+          ...(fastStrike ? { fastStrike: true } : {}),
+          surfaceIntegrationEnabled: pensarConfig.surfaceIntegrationEnabled,
+          authConfig: buildAuthConfig(pensarConfig),
+          eventBus: pentestBus,
+        });
 
-        console.log(`
+        if (externalFindings) {
+          console.log(`
+${sep}
+RESULTS
+${sep}
+Findings:  ${reportedFindings?.length ?? 0}
+Evaluation: external`);
+          console.log(
+            JSON.stringify(
+              {
+                reportedFindings: reportedFindings ?? [],
+                ...(objectiveResults ? { objectiveResults } : {}),
+                ...(submissionJson ? { submissionJson } : {}),
+                ...(solved === undefined ? {} : { solved }),
+                ...(summary === undefined ? {} : { summary }),
+              },
+              null,
+              2,
+            ),
+          );
+        } else {
+          console.log(`
 ${sep}
 RESULTS
 ${sep}
 Findings:  ${findings.length}
 Path:      ${findingsPath}
 POCs:      ${pocsPath}${reportPath ? `\nReport:    ${reportPath}` : ""}`);
+        }
       } finally {
         await wandbCleanup();
       }

package/src/core/agents/agentRuntime.test.ts

@@ -175,6 +175,42 @@ describe("AgentRuntime — hook forwarding", () => {
 
     expect(constructorCalls[0]!.stopWhen).toBe(callerStopWhen);
   });
+
+  it("forwards an executed response tool's validated result to the definition resolver", () => {
+    constructorCalls.length = 0;
+    const opts: FakeOpts = {
+      model: "test-model" as AIModel,
+      // biome-ignore lint/suspicious/noExplicitAny: minimal SessionInfo stand-in
+      session: { rootPath: "/tmp", targets: [] } as any,
+      objective: "find a weakness",
+    };
+    const resolveResult = vi.fn(() => ({ reportedFindings: ["verified"] }));
+    const definition = defineAgent<FakeOpts, { reportedFindings: string[] }>({
+      name: "test-agent",
+      role: "worker",
+      prompt: (input) => input.objective,
+      activeTools: () => ["response"],
+      resolveResult,
+    });
+
+    new AgentRuntime(definition, opts);
+
+    const streamResult = { response: Promise.resolve({ messages: [] }) };
+    const validatedResponse = { reportedFindings: ["verified"] };
+    const forwarded = constructorCalls[0]?.resolveResult;
+    if (typeof forwarded !== "function") {
+      throw new Error("Missing forwarded result resolver");
+    }
+    expect(forwarded(streamResult, validatedResponse)).toEqual(
+      validatedResponse,
+    );
+    expect(resolveResult).toHaveBeenCalledWith(
+      opts,
+      undefined,
+      streamResult,
+      validatedResponse,
+    );
+  });
 });
 
 describe("assembleAgentHooks — compile-time completeness", () => {
@@ -197,6 +233,7 @@ describe("assembleAgentHooks — compile-time completeness", () => {
         "abortSignal",
         "extraTools",
         "sandbox",
+        "findingPolicy",
       ].sort(),
     );
   });
@@ -217,6 +254,7 @@ describe("assembleAgentHooks — compile-time completeness", () => {
       abortSignal: undefined,
       extraTools: undefined,
       sandbox: undefined,
+      findingPolicy: undefined,
     };
     expectTypeOf(complete).toEqualTypeOf<RequiredAgentHooks>();
 

package/src/core/agents/agentRuntime.ts

@@ -13,7 +13,7 @@ import type { SubagentSpawner } from "./offSecAgent/subagentSpawner";
 import type { EmailAdapterResolver } from "./offSecAgent/tools/email/adapters";
 import type { UnifiedSandbox } from "./offSecAgent/tools/sandbox";
 import type { SmsInbox } from "./offSecAgent/tools/smsInbox";
-import type { StreamIdFactory } from "./offSecAgent/types";
+import type { FindingPolicy, StreamIdFactory } from "./offSecAgent/types";
 
 /**
  * {@link AgentHooks} with every key required (value types keep their
@@ -23,6 +23,7 @@ import type { StreamIdFactory } from "./offSecAgent/types";
  * "dropping a hook is a type error".
  */
 export interface RequiredAgentHooks {
+  findingPolicy: FindingPolicy | undefined;
   backends: ToolBackends | undefined;
   subagentSpawner: SubagentSpawner | undefined;
   languageModelMiddleware:
@@ -51,6 +52,7 @@ export interface RequiredAgentHooks {
  */
 export function assembleAgentHooks(opts: AgentHooks): RequiredAgentHooks {
   return {
+    findingPolicy: opts.findingPolicy,
     backends: opts.backends,
     subagentSpawner: opts.subagentSpawner,
     languageModelMiddleware: opts.languageModelMiddleware,
@@ -101,7 +103,8 @@ export class AgentRuntime<
         definition.extraTools?.(opts, state),
       ),
       resolveResult: resolveResult
-        ? (streamResult) => resolveResult(opts, state, streamResult)
+        ? (streamResult, validatedResponse) =>
+            resolveResult(opts, state, streamResult, validatedResponse)
         : undefined,
       target: definition.target?.(opts, state) ?? opts.target,
       grpc: definition.grpc?.(opts, state) ?? opts.grpc,

package/src/core/agents/defineAgent.ts

@@ -63,11 +63,13 @@ export interface AgentDefinition<
   /** Extra tools this definition injects, merged on top of `opts.extraTools`. */
   extraTools?: (opts: TOpts, state: TState) => ToolSet | undefined;
 
-  /** Produces `consume()`'s typed result from the finished stream. */
+  /** Produces `consume()`'s typed result from the finished stream and, when
+   * the response tool executes, its schema-validated result. */
   resolveResult?: (
     opts: TOpts,
     state: TState,
     streamResult: StreamTextResult<ToolSet, never>,
+    validatedResponse?: unknown,
   ) => TResult | Promise<TResult>;
 
   /** Target URL/host, when this definition derives one instead of taking it verbatim from `opts`. */

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

@@ -8,6 +8,8 @@ export type { AgentEventMap } from "../../eventBus";
 // ---------------------------------------------------------------------------
 export { AgentEventBus } from "../../eventBus";
 export { OffensiveSecurityAgent } from "./offensiveSecurityAgent";
+/** Runtime marker for hosts that require Apex's externally graded finding policy. */
+export const EXTERNAL_FINDING_POLICY_CAPABILITY = "v1" as const;
 // ---------------------------------------------------------------------------
 // System prompts
 // ---------------------------------------------------------------------------
@@ -156,6 +158,7 @@ export {
   type CommandCancelHandle,
   type CreateAgentInput,
   type Finding,
+  type FindingPolicy,
   type OffensiveSecurityAgentInput,
   type SpecializedAgentInput,
   type SystemPentestScope,

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

@@ -361,6 +361,86 @@ describe("spawned-agent usage callbacks", () => {
 });
 
 describe("auxiliary model events", () => {
+  it("persists prepared context instead of restoring a fitted-away prefix", async () => {
+    streamResponseCalls.length = 0;
+    const rootPath = mkdtempSync(join(tmpdir(), "apex-fitted-history-"));
+    try {
+      const agent = new OffensiveSecurityAgent({
+        prompt: "test",
+        model: "test-model",
+        messages: [{ role: "user", content: "old large prefix" }],
+        session: { id: "ses_fitted_history", rootPath },
+        activeTools: [],
+        sandbox: {},
+      } as never);
+      void agent.streamResult;
+      const call = streamResponseCalls[0] as {
+        onContextPrepared: (context: {
+          messages: Array<{ role: string; content: unknown }>;
+          responseMessageOffset: number;
+        }) => void;
+        onStepFinish: (event: unknown) => Promise<void>;
+      };
+      const firstStep = [
+        { role: "assistant", content: "first call" },
+        { role: "tool", content: "full first result" },
+      ];
+      const cachedSystem = {
+        role: "system",
+        content: "cached effective system prompt",
+        providerOptions: {
+          anthropic: { cacheControl: { type: "ephemeral" } },
+        },
+      };
+      const historySystem = {
+        role: "system",
+        content: "caller-supplied history instruction",
+      };
+      call.onContextPrepared({
+        messages: [
+          cachedSystem,
+          cachedSystem,
+          historySystem,
+          { role: "user", content: "fitted prefix" },
+        ],
+        responseMessageOffset: 0,
+      });
+      await call.onStepFinish({
+        response: { id: "step-1", messages: firstStep },
+        usage: { inputTokens: 10, outputTokens: 2 },
+      });
+
+      const compacted = [
+        historySystem,
+        { role: "user", content: "fitted prefix" },
+        { role: "assistant", content: "first call" },
+        { role: "tool", content: "short first result" },
+      ];
+      call.onContextPrepared({
+        messages: [cachedSystem, cachedSystem, ...compacted],
+        responseMessageOffset: 2,
+      });
+      const secondStep = [
+        { role: "assistant", content: "second call" },
+        { role: "tool", content: "second result" },
+      ];
+      await call.onStepFinish({
+        response: {
+          id: "step-2",
+          messages: [...firstStep, ...secondStep],
+        },
+        usage: { inputTokens: 10, outputTokens: 2 },
+      });
+
+      const writer = (agent as unknown as { writer: AgentMessageWriter })
+        .writer;
+      expect(writer.latest).toEqual([...compacted, ...secondStep]);
+      writer.cancelTimer();
+    } finally {
+      rmSync(rootPath, { recursive: true, force: true });
+    }
+  });
+
   it("keeps the last complete message snapshot while forwarding usage", async () => {
     streamResponseCalls.length = 0;
     traceRecordStepCalls.length = 0;
@@ -2806,6 +2886,11 @@ describe("trace identity and root IO", () => {
 describe("contextRecorder integration", () => {
   const streamTextChunk = { type: "text-delta", id: "t1", delta: "hi" };
   const CANONICAL = [
+    {
+      role: "system",
+      content: "cached effective system prompt",
+      providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
+    },
     { role: "user", content: "recorded prompt" },
     { role: "assistant", content: "recorded answer" },
   ] as never[];
@@ -2874,14 +2959,13 @@ describe("contextRecorder integration", () => {
     expect(streamResponseCalls[0]?.inferenceRecorder).toBe(inferenceRecorder);
 
     const stepEvent = {
-      response: { id: "resp_1", messages: CANONICAL.slice(1) },
+      response: { id: "resp_1", messages: CANONICAL.slice(2) },
       usage: {},
     };
     await streamOpts.onStepFinish(stepEvent);
 
-    // Writer snapshot equals canonical latest() exactly — the step's
-    // response.messages are already part of the committed context, so the
-    // projection must not re-prepend a base or duplicate them.
+    // The cached system message is transport-only; it must not enter the
+    // transcript reloaded with a fresh system prompt on the next turn.
     const writer = agent["writer" as keyof typeof agent] as unknown as {
       waitForPendingWrites: () => Promise<void>;
       latest: unknown[] | null;
@@ -2894,6 +2978,9 @@ describe("contextRecorder integration", () => {
     await streamOpts.onFinish(finishEvent);
 
     expect(recorder.latest).toHaveBeenCalled();
-    expect((captured as unknown[]).length).toBe(CANONICAL.length);
+    expect(captured).toEqual(CANONICAL.slice(1));
+    expect(
+      JSON.parse(readFileSync(join(rootPath, "messages.json"), "utf8")),
+    ).toEqual(CANONICAL.slice(1));
   });
 });