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

package/src/core/session/index.ts

@@ -96,6 +96,8 @@ const OperatorSettingsObject = z.object({
   enableSuggestions: z.boolean().default(true),
   /** Run the top-level operator as a focused solo researcher without orchestration tools. */
   strikeMode: z.boolean().optional(),
+  lanceMode: z.boolean().optional(),
+  findingPolicy: z.enum(["native", "external"]).optional(),
 });
 
 export type OperatorSettings = z.infer<typeof OperatorSettingsObject>;
@@ -216,6 +218,23 @@ function resolveSmtpConfig(explicit?: SmtpConfig): SmtpConfig | undefined {
 }
 
 const SessionConfigObject = z.object({
+  modelReasoning: z
+    .object({
+      model: z.string(),
+      setting: z.enum([
+        "default",
+        "enabled",
+        "disabled",
+        "none",
+        "minimal",
+        "low",
+        "medium",
+        "high",
+        "xhigh",
+        "max",
+      ]),
+    })
+    .optional(),
   /**
    * Custom HTTP headers for outbound target requests. Snapshotted from
    * `config.defaultHeaders` at create time; read via the resolver in
@@ -989,6 +1008,7 @@ export async function updateOperatorSettings(
         requireApproval: true,
         enableSuggestions: true,
         strikeMode: false,
+        findingPolicy: "native",
       };
     }
 
@@ -1004,9 +1024,15 @@ export async function updateOperatorSettings(
       session.config.operatorSettings.enableSuggestions =
         settings.enableSuggestions;
     }
+    if (settings.lanceMode !== undefined) {
+      session.config.operatorSettings.lanceMode = settings.lanceMode;
+    }
     if (settings.strikeMode !== undefined) {
       session.config.operatorSettings.strikeMode = settings.strikeMode;
     }
+    if (settings.findingPolicy !== undefined) {
+      session.config.operatorSettings.findingPolicy = settings.findingPolicy;
+    }
   });
 }
 
@@ -1082,4 +1108,16 @@ export const sessions = {
   getResumeMessages,
   updateOperatorSettings,
   updateSessionHeaders,
+  updateModelReasoning,
 };
+
+export async function updateModelReasoning(
+  id: string,
+  model: string,
+  setting: NonNullable<SessionConfig["modelReasoning"]>["setting"],
+): Promise<SessionInfo> {
+  return update(id, (session) => {
+    session.config ??= {};
+    session.config.modelReasoning = { model, setting };
+  });
+}

package/src/core/session/persistence.test.ts

@@ -18,6 +18,7 @@ import {
   convertModelMessagesToUI,
   finalizeManifest,
   getCompletedAgentIds,
+  loadSubagentObjectiveResults,
   loadSubagents,
   readAgentManifest,
   reconcileManifestOnResume,
@@ -239,6 +240,67 @@ describe("saveSubagentData + loadSubagents roundtrip", () => {
   });
 });
 
+describe("loadSubagentObjectiveResults", () => {
+  it("roundtrips completed objective coverage, including an empty result", () => {
+    const session = makeSession();
+    const objectiveResults = [
+      { objective: "Test authorization", completed: true, result: "No bypass" },
+      { objective: "Test injection", completed: false },
+    ];
+    saveSubagentData(session, {
+      agentName: "pentest-agent-1",
+      target: "http://localhost:8080",
+      status: "completed",
+      reportedFindings: [],
+      objectiveResults,
+      messages: [],
+    });
+
+    expect(loadSubagentObjectiveResults(session, "pentest-agent-1")).toEqual(
+      objectiveResults,
+    );
+
+    saveSubagentData(session, {
+      agentName: "pentest-agent-1",
+      target: "http://localhost:8080",
+      status: "completed",
+      reportedFindings: [],
+      objectiveResults: [],
+      messages: [],
+    });
+    expect(loadSubagentObjectiveResults(session, "pentest-agent-1")).toEqual(
+      [],
+    );
+  });
+
+  it("rejects missing, failed, and malformed objective coverage", () => {
+    const session = makeSession();
+    const key = "pentest-agent-1";
+    const snapshotPath = join(tmpDir, "subagents", `${key}.json`);
+    expect(loadSubagentObjectiveResults(session, key)).toBeNull();
+    mkdirSync(join(tmpDir, "subagents"));
+
+    const invalidSnapshots = [
+      { status: "failed", objectiveResults: [] },
+      { status: "completed" },
+      { status: "completed", objectiveResults: null },
+      { status: "completed", objectiveResults: [{ objective: "Test" }] },
+      {
+        status: "completed",
+        objectiveResults: [{ objective: "Test", completed: "true" }],
+      },
+      {
+        status: "completed",
+        objectiveResults: [{ objective: "Test", completed: true, result: 42 }],
+      },
+    ];
+    for (const snapshot of invalidSnapshots) {
+      writeFileSync(snapshotPath, JSON.stringify(snapshot));
+      expect(loadSubagentObjectiveResults(session, key)).toBeNull();
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Manifest roundtrip
 // ---------------------------------------------------------------------------

package/src/core/session/persistence.ts

@@ -28,6 +28,7 @@ export type { SessionInfo };
 
 import type { ModelMessage } from "ai";
 import type { GrpcPentestContext } from "../agents/specialized/attackSurface/grpcSchema";
+import type { ObjectiveResult } from "../agents/specialized/pentest/agent";
 import { newSessionId, type SessionID } from "../id/id";
 import type { AuthenticationInfo } from "./types";
 
@@ -56,6 +57,8 @@ interface SavedSubagentData {
   toolCallCount?: number;
   stepCount?: number;
   findingsCount?: number;
+  reportedFindings?: string[];
+  objectiveResults?: ObjectiveResult[];
   status?: string;
   error?: string;
   messages?: ModelMessage[];
@@ -115,6 +118,8 @@ export interface SubagentSaveInput {
   status: string;
   error?: string;
   findingsCount?: number;
+  reportedFindings?: string[];
+  objectiveResults?: ObjectiveResult[];
   /** Raw AI SDK messages from onStepFinish (e.response.messages) */
   messages: ModelMessage[];
   /** System prompt used for this agent (for training data export) */
@@ -150,6 +155,55 @@ export function loadSubagentMessages(
   }
 }
 
+/** Read external findings from a completed swarm target on resume. */
+export function loadSubagentReportedFindings(
+  session: SessionInfo,
+  key: string,
+): string[] | null {
+  const snapshotPath = join(session.rootPath, SUBAGENTS_DIR, `${key}.json`);
+  if (!existsSync(snapshotPath)) return null;
+  try {
+    const data = JSON.parse(
+      readFileSync(snapshotPath, "utf-8"),
+    ) as SavedSubagentData;
+    return data.status === "completed" &&
+      Array.isArray(data.reportedFindings) &&
+      data.reportedFindings.every((finding) => typeof finding === "string")
+      ? data.reportedFindings
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Read completed objective coverage from a swarm target on resume. */
+export function loadSubagentObjectiveResults(
+  session: SessionInfo,
+  key: string,
+): ObjectiveResult[] | null {
+  const snapshotPath = join(session.rootPath, SUBAGENTS_DIR, `${key}.json`);
+  if (!existsSync(snapshotPath)) return null;
+  try {
+    const data = JSON.parse(
+      readFileSync(snapshotPath, "utf-8"),
+    ) as SavedSubagentData;
+    return data.status === "completed" &&
+      Array.isArray(data.objectiveResults) &&
+      data.objectiveResults.every(
+        (result) =>
+          result !== null &&
+          typeof result === "object" &&
+          typeof result.objective === "string" &&
+          typeof result.completed === "boolean" &&
+          (result.result === undefined || typeof result.result === "string"),
+      )
+      ? data.objectiveResults
+      : null;
+  } catch {
+    return null;
+  }
+}
+
 /** Writes to `{session.rootPath}/{SUBAGENTS_DIR}/{name}.json`. */
 export function saveSubagentData(
   session: SessionInfo,
@@ -181,6 +235,8 @@ export function saveSubagentData(
     toolCallCount,
     stepCount,
     findingsCount: data.findingsCount ?? 0,
+    reportedFindings: data.reportedFindings,
+    objectiveResults: data.objectiveResults,
     status: data.status,
     error: data.error,
     messages: data.messages,

package/src/core/tools/backends/resolve.ts

@@ -1,3 +1,4 @@
+import { posix } from "node:path";
 import { appendLocalWorkspaceFile } from "../../agents/offSecAgent/tools/fileWorkspace";
 import type { ToolContext } from "../../agents/offSecAgent/tools/types";
 import { LocalBackends, runLocalProgram } from "./local";
@@ -6,6 +7,12 @@ import { windowsProgramInvocation } from "./windowsProgram";
 
 export const SANDBOX_ARTIFACTS_ROOT = "/workspace/repo/.pensar";
 
+export function sandboxArtifactsRoot(session: ToolContext["session"]): string {
+  return session.config?.remoteFileWorkspaceRoot
+    ? posix.join(session.config.remoteFileWorkspaceRoot, ".pensar")
+    : SANDBOX_ARTIFACTS_ROOT;
+}
+
 const localByContext = new WeakMap<ToolContext, ToolBackends>();
 
 /** The backends a tool should execute against: injected, else local (memoised per context). */

package/src/core/tools/backends/whiteboxJobs.test.ts

@@ -12,7 +12,7 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import type { ToolContext } from "../../agents/offSecAgent/tools/types";
 import * as tools from "../../agents/offSecAgent/tools/whiteboxJobs";
 import { LocalBackends } from "./local";
@@ -363,13 +363,14 @@ it.skipIf(process.platform !== "win32")(
       });
     stops.push(() => jobs.stop(record.id));
     expect((await jobs.poll(record.id))?.status).toBe("running");
-    let output = "";
-    for (let i = 0; i < 20 && !output.includes("\n\nready & quoted"); i++) {
-      output = (await jobs.read(record.id)).content;
-      if (!output.includes("\n\nready & quoted"))
-        await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-    expect(output).toContain("\n\nready & quoted");
+    await vi.waitFor(
+      async () => {
+        expect((await jobs.read(record.id)).content).toContain(
+          "\n\nready & quoted",
+        );
+      },
+      { timeout: 15_000, interval: 100 },
+    );
     expect((await jobs.stop(record.id))?.status).toBe("stopped");
   },
 );

package/src/core/workflows/fastStrike.seams.test.ts

@@ -61,6 +61,7 @@ let rootPath: string;
 let session: SessionInfo;
 
 beforeEach(() => {
+  mocks.registry.groupByRootCause.mockClear();
   rootPath = mkdtempSync(join(tmpdir(), "faststrike-seams-"));
   session = {
     id: "ses_faststrike_seams",
@@ -215,3 +216,151 @@ it("forwards canonical hooks and legacy fields to the fast-strike operator", asy
   });
   expect(mocks.fastStrikeInputs[0]).toMatchObject({ ...hooks, usageRecorder });
 });
+
+describe("external Fast Strike", () => {
+  it("keeps exfiltration mode explicit and returns the extracted result", async () => {
+    session.config = { exfilMode: true };
+    mocks.consumeImpl = async () => ({
+      solved: true,
+      summary: "Extracted FLAG{example}",
+      reportedFindings: ["Confirmed scoped weakness"],
+      submissionJson: "",
+    });
+
+    const result = await runFastStrike({
+      target: "https://example.com",
+      model: {} as PentestWorkflowInput["model"],
+      session,
+      findingPolicy: "external",
+    });
+
+    expect(String(mocks.fastStrikeInputs.at(-1)?.prompt)).toContain(
+      "Exfiltration goal: locate and extract FLAG{...}",
+    );
+    expect(result).toMatchObject({
+      solved: true,
+      summary: "Extracted FLAG{example}",
+    });
+  });
+
+  it("returns exact submission JSON and skips native finding aggregation", async () => {
+    const submissionJson = JSON.stringify({
+      schema_version: "penbench-finding/v1",
+      status: "finding",
+      surfaces: ["GET /private"],
+      root_cause: "Tenant scope is not enforced",
+      impact: "Cross-tenant read",
+    });
+    mocks.consumeImpl = async () => ({
+      solved: true,
+      summary: "Cross-tenant read found",
+      reportedFindings: ["GET /private reads another tenant's data"],
+      submissionJson,
+    });
+
+    const result = await runFastStrike({
+      target: "https://example.com",
+      model: {} as PentestWorkflowInput["model"],
+      session,
+      findingPolicy: "external",
+      enableThinking: true,
+      thinkingEffort: "high",
+    });
+
+    expect(result).toMatchObject({
+      findings: [],
+      reportedFindings: ["GET /private reads another tenant's data"],
+      submissionJson,
+      solved: true,
+      summary: "Cross-tenant read found",
+      reportPath: null,
+    });
+    expect(mocks.registry.groupByRootCause).not.toHaveBeenCalled();
+    const input = mocks.fastStrikeInputs.at(-1);
+    expect(input).toMatchObject({
+      findingPolicy: "external",
+      enableThinking: true,
+      thinkingEffort: "high",
+    });
+    expect(String(input?.system)).not.toContain("document_vulnerability");
+    const responseSchema = input?.responseSchema as {
+      safeParse: (value: unknown) => { success: boolean };
+    };
+    expect(
+      responseSchema.safeParse({
+        solved: true,
+        summary: "Found it",
+        reportedFindings: [],
+        submissionJson,
+      }).success,
+    ).toBe(true);
+    expect(
+      responseSchema.safeParse({ solved: true, summary: "Found it" }).success,
+    ).toBe(false);
+  });
+
+  it("fails closed when the external response omits the submission", async () => {
+    mocks.consumeImpl = async () => ({
+      solved: true,
+      summary: "Found it",
+      reportedFindings: ["finding"],
+    });
+    await expect(
+      runFastStrike({
+        target: "https://example.com",
+        model: {} as PentestWorkflowInput["model"],
+        session,
+        findingPolicy: "external",
+      }),
+    ).rejects.toThrow("without a structured findings response");
+  });
+
+  it.each([
+    ["undefined", undefined],
+    ["null", null],
+    [
+      "wrong field types",
+      {
+        solved: true,
+        summary: "claimed",
+        reportedFindings: "claimed",
+        submissionJson: "{}",
+      },
+    ],
+  ])("marks a %s external response as failed before completion hooks", async (_label, outcome) => {
+    mocks.consumeImpl = async () => outcome;
+    const emit = vi.fn();
+    const onEndpointDone = vi.fn();
+    const onEndpointFailed = vi.fn();
+
+    await expect(
+      runFastStrike({
+        target: "https://example.com",
+        model: {} as PentestWorkflowInput["model"],
+        session,
+        findingPolicy: "external",
+        eventBus: { emit } as unknown as NonNullable<
+          PentestWorkflowInput["eventBus"]
+        >,
+        seams: inProcessSeams({
+          hooks: { onEndpointDone, onEndpointFailed },
+          registries: {
+            findings: () => mocks.registry,
+            attackSurface: () => ({}) as never,
+          },
+        }),
+      }),
+    ).rejects.toThrow("without a structured findings response");
+
+    expect(onEndpointDone).not.toHaveBeenCalled();
+    expect(onEndpointFailed).toHaveBeenCalledOnce();
+    expect(emit).toHaveBeenCalledWith("subagent-complete", {
+      subagentId: "fast-strike",
+      status: "failed",
+    });
+    expect(emit).not.toHaveBeenCalledWith("subagent-complete", {
+      subagentId: "fast-strike",
+      status: "completed",
+    });
+  });
+});

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

@@ -1,5 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { FAST_STRIKE_SYSTEM_PROMPT } from "./fastStrike";
+import {
+  buildFastStrikeSystemPrompt,
+  FAST_STRIKE_SYSTEM_PROMPT,
+} from "./fastStrike";
 
 describe("Fast Strike system prompt", () => {
   it("externalizes complex exploit chains into editable scripts", () => {
@@ -26,4 +29,18 @@ describe("Fast Strike system prompt", () => {
       "call the response tool with the correct solved value",
     );
   });
+
+  it("keeps the native prompt as the default policy", () => {
+    expect(buildFastStrikeSystemPrompt()).toBe(FAST_STRIKE_SYSTEM_PROMPT);
+  });
+
+  it("keeps the Strike loop but hands finding acceptance to the caller", () => {
+    const prompt = buildFastStrikeSystemPrompt("external");
+    expect(prompt).toContain("OBSERVE");
+    expect(prompt).toContain("HYPOTHESIZE");
+    expect(prompt).toContain("editable script");
+    expect(prompt).toContain("submissionJson");
+    expect(prompt).not.toContain("document_vulnerability");
+    expect(prompt).not.toContain("validation judge");
+  });
 });