0sec-cli 0.22.4 → 0.23.0

package/chunks/{chunk-6KFB6AYN.js → chunk-LTEE2JWK.js}

@@ -67,7 +67,7 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 function loadVersion() {
   if (true) {
-    return "0.22.4";
+    return "0.23.0";
   }
   try {
     const here = dirname(fileURLToPath(import.meta.url));
@@ -1546,10 +1546,63 @@ var executionSchema = external_exports.object({
   instructions: external_exports.string().trim().max(16e3),
   allowedAgentTools: external_exports.array(external_exports.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/)).max(128).refine((tools) => new Set(tools).size === tools.length, "Agent tool names must be unique.").optional()
 }).strict();
-var nodeSchema = external_exports.object({ id: identifier, type: external_exports.enum(["trigger", "audit", "report"]), label: external_exports.string().trim().min(1).max(160), enabled: external_exports.boolean(), plan: planSchema.optional(), execution: executionSchema.optional() }).strict();
+var SECURITY_WORKFLOW_OPERATIONS = ["audit", "verify", "fix", "research", "deep-review"];
+function isSecurityWorkflowOperation(node) {
+  return SECURITY_WORKFLOW_OPERATIONS.includes(node.type);
+}
+var SecurityWorkflowBindingsSchema = external_exports.unknown().superRefine((bindings, context) => {
+  const pending = [{ value: bindings, depth: 0 }];
+  const seen = /* @__PURE__ */ new Set();
+  let visited = 0;
+  while (pending.length) {
+    const { value, depth } = pending.pop();
+    if (++visited > 1e4 || depth > 20) {
+      context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Workflow inputs exceed nesting or item limits." });
+      return;
+    }
+    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+      continue;
+    if (typeof value !== "object" || seen.has(value)) {
+      context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Workflow inputs must contain finite JSON values without cycles." });
+      return;
+    }
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Workflow inputs must contain plain JSON objects." });
+      return;
+    }
+    seen.add(value);
+    for (const [key, entry] of Object.entries(value)) {
+      if (["__proto__", "constructor", "prototype"].includes(key)) {
+        context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Reserved workflow input key." });
+        return;
+      }
+      pending.push({ value: entry, depth: depth + 1 });
+    }
+  }
+  if (new TextEncoder().encode(JSON.stringify(bindings)).byteLength > 32768)
+    context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Workflow inputs must be at most 32 KiB." });
+}).pipe(external_exports.record(external_exports.unknown()));
+var inputSchema = external_exports.object({ findingId: identifier.optional(), scanId: identifier.optional(), dbPath: external_exports.string().trim().min(1).max(4096).optional(), fromStep: identifier.optional(), artifactId: identifier.optional() }).strict();
+var nodeSchema = external_exports.object({ id: identifier, type: external_exports.enum(["trigger", "audit", "report", "verify", "fix", "research", "deep-review"]), label: external_exports.string().trim().min(1).max(160), enabled: external_exports.boolean(), plan: planSchema.optional(), execution: executionSchema.optional(), input: inputSchema.optional(), inputs: SecurityWorkflowBindingsSchema.superRefine((bindings, context) => {
+  const pending = [bindings];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length) {
+    const value = pending.pop();
+    if (!value || typeof value !== "object" || visited.has(value))
+      continue;
+    visited.add(value);
+    for (const [key, entry] of Object.entries(value)) {
+      if (["allowApply", "applyApproval", "approval", "secrets", "apiKey"].includes(key))
+        context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Portable step inputs cannot contain authorization grants or secrets." });
+      if (entry && typeof entry === "object")
+        pending.push(entry);
+    }
+  }
+}).optional(), fix: external_exports.object({ mode: external_exports.enum(["candidate", "apply"]) }).strict().optional() }).strict();
 var SecurityWorkflowInputSchema = external_exports.object({
   id: identifier.optional(),
   revision: external_exports.number().int().positive().optional(),
+  template: external_exports.object({ id: identifier, revision: external_exports.number().int().positive() }).strict().optional(),
   name: external_exports.string().trim().min(1).max(160),
   instructions: external_exports.string().trim().max(16e3),
   target: external_exports.string().trim().max(4096),
@@ -1565,12 +1618,14 @@ var SecurityWorkflowInputSchema = external_exports.object({
     issue("A workflow requires exactly one trigger.");
   if (triggers.some((node) => !node.enabled))
     issue("The manual trigger must remain enabled.");
-  if (!workflow.nodes.some((node) => node.type === "audit"))
-    issue("A workflow requires at least one audit.");
+  if (!workflow.nodes.some(isSecurityWorkflowOperation))
+    issue("A workflow requires at least one executable step.");
   if (workflow.nodes.filter((node) => node.type === "report").length > 1)
     issue("A workflow supports at most one report.");
-  if (workflow.nodes.some((node) => node.type !== "audit" && (node.plan !== void 0 || node.execution !== void 0)))
-    issue("Only audit nodes accept scan plans and execution policies.");
+  if (workflow.nodes.some((node) => !isSecurityWorkflowOperation(node) && (node.plan !== void 0 || node.execution !== void 0 || node.input !== void 0 || node.inputs !== void 0)))
+    issue("Only executable steps accept plans, policies, and input bindings.");
+  if (workflow.nodes.some((node) => node.type !== "fix" && node.fix !== void 0))
+    issue("Only fix steps accept fix options.");
   const edges = /* @__PURE__ */ new Set();
   const successors = /* @__PURE__ */ new Map();
   for (const edge of workflow.edges) {
@@ -1586,6 +1641,22 @@ var SecurityWorkflowInputSchema = external_exports.object({
     if (target?.type === "trigger" || source?.type === "report")
       issue("Triggers must start the graph and reports must end it.");
   }
+  for (const node of workflow.nodes) {
+    if (!node.input?.fromStep)
+      continue;
+    const ancestors = /* @__PURE__ */ new Set();
+    const pending = workflow.edges.filter((edge) => edge.target === node.id).map((edge) => edge.source);
+    while (pending.length) {
+      const id = pending.pop();
+      if (ancestors.has(id))
+        continue;
+      ancestors.add(id);
+      pending.push(...workflow.edges.filter((edge) => edge.target === id).map((edge) => edge.source));
+    }
+    const referenced = workflow.nodes.find((entry) => entry.id === node.input.fromStep);
+    if (node.input.fromStep === node.id || !referenced || !isSecurityWorkflowOperation(referenced) || !ancestors.has(node.input.fromStep))
+      issue("Step input references must name a connected preceding executable step.");
+  }
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const visit = (id) => {
@@ -1619,12 +1690,12 @@ var SecurityWorkflowInputSchema = external_exports.object({
 });
 function parseSecurityWorkflowInput(value) {
   const workflow = SecurityWorkflowInputSchema.parse(value);
-  return { ...workflow, nodes: workflow.nodes.map((node) => node.type === "audit" ? { ...node, plan: node.plan ?? { ...DEFAULT_SECURITY_WORKFLOW_PLAN } } : node) };
+  return { ...workflow, nodes: workflow.nodes.map((node) => isSecurityWorkflowOperation(node) ? { ...node, plan: node.plan ?? { ...DEFAULT_SECURITY_WORKFLOW_PLAN }, ...node.type === "fix" ? { fix: node.fix ?? { mode: "candidate" } } : {} } : node) };
 }
 var codeEnvelope = external_exports.object({ schemaVersion: external_exports.literal(1), workflow: external_exports.unknown() }).strict();
 function exportSecurityWorkflowCode(value) {
-  const { name, instructions, target, nodes, edges } = value;
-  const parsed = parseSecurityWorkflowInput({ name, instructions, target, nodes, edges });
+  const { name, instructions, target, nodes, edges, template: template2 } = value;
+  const parsed = parseSecurityWorkflowInput({ name, instructions, target, nodes, edges, ...template2 ? { template: template2 } : {} });
   const json = JSON.stringify({ schemaVersion: 1, workflow: parsed }, null, 2);
   if (new TextEncoder().encode(json).byteLength > 65536)
     throw new Error("Workflow JSON must be at most 64 KiB.");
@@ -1650,9 +1721,15 @@ function phase(id, label, goal, instructions, depth = "default") {
   return { id, type: "audit", label, enabled: true, plan: { goal, depth, runCount: 1, executionMode: "sequential", timeCapMs: 6e5, costCapUsd: 5 }, execution: { instructions } };
 }
 function template(id, name, description, category, phases) {
-  const nodes = [{ id: "start", type: "trigger", label: "Start manually", enabled: true }, ...phases, { id: "report", type: "report", label: "Collect reports", enabled: true }];
-  return { id, name, description, category, definition: parseSecurityWorkflowInput({ name, instructions: description, target: "", nodes, edges: nodes.slice(1).map((node, index) => ({ source: nodes[index].id, target: node.id })) }) };
+  const nodes = [{ id: "start", type: "trigger", label: "Start manually", enabled: true }, ...phases, { id: "report", type: "report", label: "Collect results", enabled: true }];
+  const compatibleTargetTypes = category === "web" || category === "security" ? ["url", "web-app"] : category === "package" ? ["source-code", "npm-package", "pypi-package", "cargo-package"] : ["source-code"];
+  return { id, revision: 1, name, description, category, compatibleTargetTypes, executor: "assessment", profile: "default", expectedOutputs: ["findings", "artifacts"], inputRequirements: [], definition: parseSecurityWorkflowInput({ name, instructions: description, target: "", nodes, edges: nodes.slice(1).map((node, index) => ({ source: nodes[index].id, target: node.id })) }) };
+}
+function operationTemplate(id, name, description, operation, compatibleTargetTypes, inputRequirements, inputs) {
+  const base = template(id, name, description, "repository", [{ id: "operation", type: operation, label: name, enabled: true, ...inputs ? { inputs } : {} }]);
+  return { ...base, executor: operation, compatibleTargetTypes, inputRequirements, expectedOutputs: operation === "fix" ? ["candidate", "validation", "artifacts"] : operation === "verify" ? ["verification", "artifacts"] : ["findings", "artifacts"] };
 }
+var FINDING_INPUT_REQUIREMENT = { names: ["finding", "findingPath", "findingId"], required: true, description: "Supply an existing finding, a finding JSON path, or a retained finding ID. Connected earlier finding evidence can also provide the input." };
 var SECURITY_WORKFLOW_TEMPLATES = [
   template("repository-review", "Repository security review", "Review a local repository's trust boundaries, dependency exposure, and security-sensitive code.", "repository", [
     phase("dependencies", "Dependency exposure", "known-vulnerabilities", "Inspect dependency manifests and lockfiles. Prioritize reachable vulnerable dependencies and supply-chain trust boundaries; distinguish confirmed exposure from version-only matches.", "quick"),
@@ -1690,13 +1767,30 @@ var SECURITY_WORKFLOW_TEMPLATES = [
   template("native-code-review", "Native code boundary review", "Review an authorized native source repository for parser, memory, and privilege-boundary issues.", "repository", [
     phase("parsers", "Parsers and memory boundaries", "unknown-vulnerabilities", "Trace untrusted input through parsing, length calculations, ownership, and memory operations. Prioritize reachable paths and concrete invalid-state evidence in the authorized source.", "deep"),
     phase("privileges", "Privilege and resource boundaries", "unknown-vulnerabilities", "Review privilege transitions, filesystem paths, subprocess inputs, concurrency, and resource lifetime. Avoid speculative issues without a supported attacker-controlled path.", "deep")
-  ])
+  ]),
+  operationTemplate("finding-verification", "Finding verification", "Verify an existing finding using an explicitly selected execution runner and preserve the verification evidence.", "verify", ["source-code", "url", "web-app"], [FINDING_INPUT_REQUIREMENT, { names: ["runner"], required: true, description: "Select local, smolvm, docker, or qemu. Existing verification scope and prerequisite checks apply." }]),
+  operationTemplate("fix-candidate", "Fix candidate and validation", "Propose and test a source fix candidate without applying it to the repository.", "fix", ["source-code"], [FINDING_INPUT_REQUIREMENT, { names: ["testCommand"], required: true, description: "Provide the explicit repository regression test command." }]),
+  operationTemplate("security-research", "Security research", "Run the existing security research pipeline against an authorized source repository, retaining findings and research artifacts.", "research", ["source-code"], [], { engine: "pipeline" }),
+  operationTemplate("deep-source-review", "Deep source review", "Run the existing deep source review engine against an authorized repository, retaining its supported evidence and results.", "deep-review", ["source-code"], [])
 ];
-function createSecurityWorkflowTemplate(id) {
+function getSecurityWorkflowTemplate(id, revision) {
   const found = SECURITY_WORKFLOW_TEMPLATES.find((entry) => entry.id === id);
   if (!found)
     throw new Error("Unknown security workflow template.");
-  return parseSecurityWorkflowInput(found.definition);
+  if (revision !== void 0 && revision !== found.revision)
+    throw new Error(`Template revision mismatch: ${id} is revision ${found.revision}.`);
+  return structuredClone(found);
+}
+function checkSecurityWorkflowTemplateTarget(template2, targetType) {
+  if (!template2.compatibleTargetTypes.includes(targetType)) {
+    throw new Error(`Template ${template2.id} does not support target type ${targetType}. Supported types: ${template2.compatibleTargetTypes.join(", ")}.`);
+  }
+}
+function createSecurityWorkflowTemplate(id, options = {}) {
+  const found = getSecurityWorkflowTemplate(id, options.revision);
+  if (options.targetType !== void 0)
+    checkSecurityWorkflowTemplateTarget(found, options.targetType);
+  return parseSecurityWorkflowInput({ ...found.definition, template: { id: found.id, revision: found.revision }, ...options.target !== void 0 ? { target: options.target } : {} });
 }
 
 // packages/shared/dist/service-plugins.js
@@ -1713,6 +1807,157 @@ var SERVICE_PLUGIN_CATALOG = [
   { id: "teams", name: "Microsoft Teams", description: "Read teams and share channel summaries.", category: "Messaging", docsUrl: "https://learn.microsoft.com/en-us/graph/auth/auth-concepts", fields: [{ ...token, label: "Microsoft Graph access token" }], credentialNote: "Delegated token with Teams access. Reconnect when it expires." }
 ];
 
+// packages/shared/dist/backend-protocol.js
+var BACKEND_PROTOCOL_VERSION = 1;
+var BACKEND_CAPABILITIES = [
+  "sessions",
+  "workflows",
+  "workflow-engine",
+  "schedules",
+  "approvals",
+  "events",
+  "workspaces",
+  "artifacts",
+  "model-connections",
+  "process-controls",
+  "operator-services"
+];
+var BackendCapabilitySchema = external_exports.enum(BACKEND_CAPABILITIES);
+var BackendIdSchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*$/).refine((value) => !["__proto__", "constructor", "prototype"].includes(value), "Reserved backend identifier.");
+var backendId = BackendIdSchema;
+var BackendRequestIdSchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/).refine((value) => !["__proto__", "constructor", "prototype"].includes(value), "Reserved request identifier.");
+var resourceId = external_exports.string().min(1).max(4096);
+var capabilityList = external_exports.array(external_exports.string().min(1).max(128).regex(/^[a-z][a-z0-9.-]*$/)).max(128).refine((values) => new Set(values).size === values.length, "Backend capabilities must be unique.");
+var BackendConnectionStatusSchema = external_exports.enum(["connecting", "connected", "disconnected", "incompatible", "error"]);
+var BackendPlatformSchema = external_exports.object({ os: external_exports.string().min(1).max(64), pathStyle: external_exports.enum(["posix", "windows"]) }).strict();
+var BackendDescriptorSchema = external_exports.object({
+  id: backendId,
+  name: external_exports.string().trim().min(1).max(160),
+  transport: external_exports.enum(["local", "http"]),
+  status: BackendConnectionStatusSchema,
+  protocolVersion: external_exports.number().int().positive().optional(),
+  /** Unknown advertised names are retained for forward compatibility, never implicitly dispatched. */
+  capabilities: capabilityList.default([]),
+  platform: BackendPlatformSchema.optional(),
+  error: external_exports.string().max(4096).optional()
+}).strict();
+var BackendListSchema = external_exports.object({ backends: external_exports.array(BackendDescriptorSchema).min(1).max(64) }).strict().superRefine((value, context) => {
+  if (new Set(value.backends.map((backend) => backend.id)).size !== value.backends.length)
+    context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Backend IDs must be unique." });
+});
+var BackendHandshakeSchema = external_exports.object({
+  protocolVersion: external_exports.number().int().positive(),
+  engineId: backendId,
+  capabilities: capabilityList,
+  platform: BackendPlatformSchema,
+  /** Connection epoch for detecting restarted event streams; does not replace retained run identity. */
+  serverInstanceId: backendId.optional()
+}).strict();
+function parseBackendHandshake(value) {
+  const handshake = BackendHandshakeSchema.parse(value);
+  if (handshake.protocolVersion !== BACKEND_PROTOCOL_VERSION)
+    throw new Error(`Incompatible backend protocol ${handshake.protocolVersion}; this client supports ${BACKEND_PROTOCOL_VERSION}.`);
+  return handshake;
+}
+function hasBackendCapability(backend, capability) {
+  return backend.capabilities.includes(capability);
+}
+function requireBackendCapability(backend, capability) {
+  if (backend.status !== "connected")
+    throw new Error(`Backend ${backend.id} is ${backend.status}.`);
+  if (backend.protocolVersion !== BACKEND_PROTOCOL_VERSION)
+    throw new Error(`Backend ${backend.id} uses an incompatible protocol.`);
+  if (!hasBackendCapability(backend, capability))
+    throw new Error(`Backend ${backend.id} does not support ${capability}.`);
+}
+var BackendResourceRefSchema = external_exports.object({ backendId, id: resourceId }).strict();
+function backendResourceKey(kind, reference) {
+  const ref = BackendResourceRefSchema.parse(reference);
+  return JSON.stringify(["backend", ref.backendId, kind, ref.id]);
+}
+function backendResourceQueryKey(kind, reference) {
+  const ref = BackendResourceRefSchema.parse(reference);
+  return ["backend", ref.backendId, kind, ref.id];
+}
+var BackendRequestContextSchema = external_exports.object({
+  backendId,
+  requestId: BackendRequestIdSchema,
+  idempotencyKey: external_exports.string().min(1).max(128).optional()
+}).strict();
+var BackendEventCursorSchema = external_exports.object({
+  backendId,
+  resourceId,
+  sequence: external_exports.number().int().nonnegative().safe(),
+  serverInstanceId: backendId.optional()
+}).strict();
+var BackendApprovalRefSchema = external_exports.object({
+  backendId,
+  id: resourceId,
+  sessionId: resourceId,
+  runId: resourceId.optional(),
+  requestId: BackendRequestIdSchema,
+  operationDigest: external_exports.string().min(1).max(256)
+}).strict();
+function assertBackendReference(backendIdValue, reference) {
+  backendId.parse(backendIdValue);
+  const ref = BackendResourceRefSchema.parse(reference);
+  if (ref.backendId !== backendIdValue)
+    throw new Error("Resource belongs to another backend.");
+}
+function backendCapabilitiesForApiPath(pathname) {
+  if (!pathname.startsWith("/api/") || /[?#\\\x00-\x20]/.test(pathname) || new URL(pathname, "http://backend.invalid").pathname !== pathname)
+    throw new Error("Backend capability classification requires a canonical API pathname.");
+  const parts = pathname.slice("/api/".length).split("/");
+  const capabilities = /* @__PURE__ */ new Set();
+  const add = (capability) => {
+    capabilities.add(capability);
+  };
+  if (pathname === "/api/backend/handshake")
+    return [];
+  if (pathname === "/api/workflow-engine/call")
+    return ["workflow-engine"];
+  if (parts[0] === "control" && parts.length === 2 && ["recover-stale-workers", "prune-stopped-workers", "reset-database", "start-daemon", "stop-daemon", "launch-run"].includes(parts[1]))
+    return ["process-controls"];
+  if (pathname === "/api/dashboard" || parts[0] === "scans" || parts[0] === "finding-family")
+    add("artifacts");
+  else if (parts[0] === "events" || pathname === "/api/v1/presentation/events")
+    add("events");
+  else if (parts[0] === "console") {
+    const family = parts[1];
+    if (["sessions", "saved"].includes(family ?? "")) {
+      add("sessions");
+      const operation = parts[3];
+      if (operation === "decisions" || operation === "approvals")
+        add("approvals");
+      if (operation === "events")
+        add("events");
+      if (["models", "providers", "connections", "accounts", "runtime"].includes(operation ?? ""))
+        add("model-connections");
+      if (["files", "directories", "paths", "workspace", "project"].includes(operation ?? ""))
+        add("workspaces");
+    } else if (["workflow-triggers", "workflow-schedules"].includes(family ?? ""))
+      add("schedules");
+    else if (["workflows", "workflow-definitions", "workflow-executions", "workflow-tool-catalog", "fixes"].includes(family ?? "")) {
+      add("workflows");
+      if (family === "fixes" && (["apply", "publish"].includes(parts[2] ?? "") || ["apply", "publish"].includes(parts[3] ?? "")))
+        add("approvals");
+      if (parts[3] === "events")
+        add("events");
+    } else if (["connections", "providers", "accounts", "runtime", "models", "auth"].includes(family ?? ""))
+      add("model-connections");
+    else if (["files", "directories", "paths", "workspace", "project"].includes(family ?? ""))
+      add("workspaces");
+    else if (["settings", "themes", "plugins", "service-plugins", "doctor", "tools", "checks", "feedback", "github", "execution"].includes(family ?? "")) {
+      add("operator-services");
+      if (family === "checks")
+        add("workspaces");
+    }
+  }
+  if (capabilities.has("artifacts") && parts[0] === "scans" && parts[2] === "events")
+    add("events");
+  return [...capabilities];
+}
+
 export {
   validateScanPlan,
   defaultRoleFor,
@@ -1799,11 +2044,37 @@ export {
   findCommand,
   filterCommands,
   DEFAULT_SECURITY_WORKFLOW_PLAN,
+  SECURITY_WORKFLOW_OPERATIONS,
+  isSecurityWorkflowOperation,
+  SecurityWorkflowBindingsSchema,
   SecurityWorkflowInputSchema,
   parseSecurityWorkflowInput,
   exportSecurityWorkflowCode,
   parseSecurityWorkflowCode,
   SECURITY_WORKFLOW_TEMPLATES,
+  getSecurityWorkflowTemplate,
+  checkSecurityWorkflowTemplateTarget,
   createSecurityWorkflowTemplate,
-  SERVICE_PLUGIN_CATALOG
+  SERVICE_PLUGIN_CATALOG,
+  BACKEND_PROTOCOL_VERSION,
+  BACKEND_CAPABILITIES,
+  BackendCapabilitySchema,
+  BackendIdSchema,
+  BackendRequestIdSchema,
+  BackendConnectionStatusSchema,
+  BackendPlatformSchema,
+  BackendDescriptorSchema,
+  BackendListSchema,
+  BackendHandshakeSchema,
+  parseBackendHandshake,
+  hasBackendCapability,
+  requireBackendCapability,
+  BackendResourceRefSchema,
+  backendResourceKey,
+  backendResourceQueryKey,
+  BackendRequestContextSchema,
+  BackendEventCursorSchema,
+  BackendApprovalRefSchema,
+  assertBackendReference,
+  backendCapabilitiesForApiPath
 };

package/chunks/{chunk-DPUXXMJW.js → chunk-LVGZGG63.js}

@@ -3,7 +3,7 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   severityRank
-} from "./chunk-6KFB6AYN.js";
+} from "./chunk-LTEE2JWK.js";
 
 // packages/core/dist/triage/kernel-primitive.js
 function maxSeverity(a, b) {

package/chunks/{chunk-PS5E7LUQ.js → chunk-MQJVU2GZ.js}

@@ -9,21 +9,21 @@ import {
   resolveWorkbenchGuestSettings,
   workbenchConfigPath,
   workbenchNetworkEnabled
-} from "./chunk-XODDLNBI.js";
+} from "./chunk-HFDSIHTE.js";
 import {
   createWorkbenchProviderBroker
-} from "./chunk-OAS5SAVZ.js";
+} from "./chunk-4HGGNBKK.js";
 import {
   osecDB
-} from "./chunk-L2CCO4KE.js";
+} from "./chunk-T7ZEVY5G.js";
 import {
   isAdmittedSmolvmWorkbench
-} from "./chunk-2WWAPKAW.js";
+} from "./chunk-NI6QYQSK.js";
 import {
   SERVICE_PLUGIN_CATALOG,
   findingSchema,
   homeStateDir
-} from "./chunk-6KFB6AYN.js";
+} from "./chunk-LTEE2JWK.js";
 
 // packages/cli/src/web/service-plugins.ts
 import { constants, closeSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, chmodSync } from "node:fs";
@@ -217,7 +217,7 @@ var ServicePluginServices = class {
   }
   async #probe(connection) {
     try {
-      const probe = this.#options.probe ?? (await import("./dist-27BNG6WD.js")).testServicePluginConnection;
+      const probe = this.#options.probe ?? (await import("./dist-4LGRIBOC.js")).testServicePluginConnection;
       const result = await probe(connection);
       if (!Array.isArray(result.tools) || result.tools.length > 512 || result.tools.some((tool) => typeof tool.name !== "string" || tool.name.length > 256 || typeof tool.description !== "string" || tool.description.length > 16384)) throw new Error("Invalid tool catalog.");
       const configurations = [...readStore(this.#options.homeDir), connection];

package/chunks/{chunk-2WWAPKAW.js → chunk-NI6QYQSK.js}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-UELXHK2Y.js";
 import {
   eventBus
-} from "./chunk-4ZYYX5GY.js";
+} from "./chunk-A5QO7N3S.js";
 import {
   ScopePolicy
-} from "./chunk-C6JPA32H.js";
+} from "./chunk-ITES7BCY.js";
 import {
   allowlistedChildEnv,
   sanitizedEnv
@@ -18,7 +18,7 @@ import {
   VERSION,
   cloudStateDir,
   homeStateDir
-} from "./chunk-6KFB6AYN.js";
+} from "./chunk-LTEE2JWK.js";
 import {
   external_exports
 } from "./chunk-VIT5ALXF.js";

package/chunks/{chunk-5JNTMWPK.js → chunk-NX4H6L4M.js}

@@ -4,10 +4,10 @@ const require = __0CreateRequire(import.meta.url);
 import {
   getToolsForRole,
   runNativeAgentLoop
-} from "./chunk-H6Q2QAIY.js";
+} from "./chunk-EH2WTNY7.js";
 import {
   LlmApiRuntime
-} from "./chunk-QVIRWJ45.js";
+} from "./chunk-BF5FIK7H.js";
 
 // packages/core/dist/eval-runner.js
 import { randomUUID } from "node:crypto";

package/chunks/{chunk-WHUAUFSX.js → chunk-O6Z4XPOM.js}

@@ -8,7 +8,7 @@ import {
   osecDB,
   repairOsecDatabase,
   resetOsecDatabase
-} from "./chunk-L2CCO4KE.js";
+} from "./chunk-T7ZEVY5G.js";
 
 // packages/cli/src/commands/db.ts
 import { randomUUID } from "node:crypto";

package/chunks/{chunk-RTBZ36BD.js → chunk-OLSKXTQZ.js}

@@ -3,10 +3,10 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   loadLayeredSettings
-} from "./chunk-XODDLNBI.js";
+} from "./chunk-HFDSIHTE.js";
 import {
   homeStateDir
-} from "./chunk-6KFB6AYN.js";
+} from "./chunk-LTEE2JWK.js";
 import {
   __commonJS,
   __require,

package/chunks/{chunk-H4DH7COV.js → chunk-P7KDN5PK.js}

@@ -17,10 +17,10 @@ import {
   registerSignalCleanup,
   runNativeAgentLoop,
   toolCallPreview
-} from "./chunk-H6Q2QAIY.js";
+} from "./chunk-EH2WTNY7.js";
 import {
   WafDetector
-} from "./chunk-SCWWLABR.js";
+} from "./chunk-JEYIWMGL.js";
 import {
   RECIPE_LIBRARY
 } from "./chunk-UEX7PFSE.js";
@@ -28,29 +28,29 @@ import {
   createRuntime,
   detectAvailableRuntimes,
   pickRuntimeForStage
-} from "./chunk-WBRGXCU2.js";
+} from "./chunk-UZUELPFW.js";
 import {
   osecDB
-} from "./chunk-L2CCO4KE.js";
+} from "./chunk-T7ZEVY5G.js";
 import {
   CLI_RUNTIME_TYPES
-} from "./chunk-CPCHLL6A.js";
+} from "./chunk-65H3MRBF.js";
 import {
   addRuntimeUsage,
   scanGoalPrompt
-} from "./chunk-YAZARMJY.js";
+} from "./chunk-CP6HANBE.js";
 import {
   LlmApiRuntime,
   features
-} from "./chunk-QVIRWJ45.js";
+} from "./chunk-BF5FIK7H.js";
 import {
   analyticsPipeline,
   reportUnsupportedContributionMode
-} from "./chunk-2WWAPKAW.js";
+} from "./chunk-NI6QYQSK.js";
 import {
   estimateCost,
   modelProvider
-} from "./chunk-6KFB6AYN.js";
+} from "./chunk-LTEE2JWK.js";
 import {
   external_exports
 } from "./chunk-VIT5ALXF.js";
@@ -5087,7 +5087,7 @@ function cleanupHuntDb(path2) {
   }
 }
 async function runSourceHunt(config, hint, purpose, emit = () => {
-}) {
+}, nativeRuntime) {
   const dbPath = freshHuntDb();
   const db = new osecDB(dbPath);
   try {
@@ -5100,7 +5100,7 @@ async function runSourceHunt(config, hint, purpose, emit = () => {
       scopePath: sourceRoot,
       target: config.target,
       scanId,
-      config,
+      config: { ...config, ...nativeRuntime ? { nativeRuntime } : {} },
       db,
       emit,
       cliPrompt: prompt,
@@ -5316,6 +5316,8 @@ LENS FOCUS \u2014 concentrate this refute pass specifically on: ${opts.focus}`;
     const baseConfig = {
       ...opts.costCeilingUsd !== void 0 ? { costCeilingUsd: opts.costCeilingUsd } : {},
       ...opts.costLedger ? { costLedger: opts.costLedger } : {},
+      ...opts.signal ? { signal: opts.signal } : {},
+      ...opts.plan ? { plan: opts.plan } : {},
       target: resolve(opts.sourceRoot, candidate.path),
       depth: "quick",
       format: "json",
@@ -5326,7 +5328,7 @@ LENS FOCUS \u2014 concentrate this refute pass specifically on: ${opts.focus}`;
     };
     const refutePass = async (model) => {
       const config = { ...baseConfig, ...model ? { model } : {} };
-      const report = await runSourceHunt(config, hint, "verify");
+      const report = await runSourceHunt(config, hint, "verify", void 0, opts.nativeRuntime);
       return report.findings.length > 0;
     };
     let choice = refuter;
@@ -5404,6 +5406,9 @@ function makeMultiLensVerifier(lenses, opts) {
   const makePass = opts.makePass ?? ((lens) => makeSkepticVerifier({
     sourceRoot: opts.sourceRoot,
     runtime: opts.runtime,
+    ...opts.signal ? { signal: opts.signal } : {},
+    ...opts.nativeRuntime ? { nativeRuntime: opts.nativeRuntime } : {},
+    ...opts.plan ? { plan: opts.plan } : {},
     ...opts.model ? { model: opts.model } : {},
     ...opts.negatives ? { negatives: opts.negatives } : {},
     ...opts.costCeilingUsd !== void 0 ? { costCeilingUsd: opts.costCeilingUsd } : {},
@@ -5474,6 +5479,7 @@ function siteGroupKey(candidatePath, model, lensId) {
   return lensId ? `${base} ${lensId}` : base;
 }
 async function runHuntScan(opts) {
+  opts.signal?.throwIfAborted();
   const log = opts.log ?? (() => {
   });
   const models = opts.models && opts.models.length > 0 ? opts.models : [void 0];
@@ -5515,6 +5521,7 @@ async function runHuntScan(opts) {
   const aimd = huntAimdEnabled() ? new AimdState(concurrency) : null;
   const effectiveConcurrency = costCeilingEnabled ? 1 : aimd ?? concurrency;
   const reports = await pool(runs, effectiveConcurrency, async (run) => {
+    opts.signal?.throwIfAborted();
     const version = run.lens.versionDigest ? { lensVersionDigest: run.lens.versionDigest } : {};
     if (costCeilingReached()) {
       return {
@@ -5538,7 +5545,7 @@ async function runHuntScan(opts) {
           model: run.model,
           attempt: run.attempt,
           challengeHint: huntHint(opts.brief, run.candidate, run.lens.challengeHint),
-          ...finderAbort ? { signal: finderAbort.signal } : {}
+          ...opts.signal || finderAbort ? { signal: opts.signal && finderAbort ? AbortSignal.any([opts.signal, finderAbort.signal]) : opts.signal ?? finderAbort?.signal } : {}
         });
         lateRef.current = scanPromise2;
         return await scanPromise2;
@@ -5553,7 +5560,9 @@ async function runHuntScan(opts) {
         repoPath: opts.sourceRoot,
         ...run.model ? { model: run.model } : {},
         ...costCeilingUsd !== void 0 ? { costCeilingUsd } : {},
-        ...costLedger ? { costLedger } : {}
+        ...costLedger ? { costLedger } : {},
+        ...opts.signal ? { signal: opts.signal } : {},
+        ...opts.plan ? { plan: opts.plan } : {}
       };
       const scanPromise = runSourceHunt(config, huntHint(opts.brief, run.candidate, run.lens.challengeHint), "research", (event) => {
         if (event.type !== "finding")
@@ -5561,11 +5570,12 @@ async function runHuntScan(opts) {
         const partial = partialFindingFromEvent(event.data);
         if (partial)
           partials.push(partial);
-      });
+      }, opts.nativeRuntime);
       lateRef.current = scanPromise;
       return await scanPromise;
     };
     const outcome = await runFinderResilient(attemptOnce, { timeoutMs: finderTimeoutMs, maxRetries: finderMaxRetries });
+    opts.signal?.throwIfAborted();
     if (outcome.status === "timed-out")
       finderAbort?.abort();
     let findings;