0sec-cli 0.22.4 → 0.24.0

package/chunks/{chunk-6KFB6AYN.js → chunk-RZR2XXAK.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.24.0";
   }
   try {
     const here = dirname(fileURLToPath(import.meta.url));
@@ -189,6 +189,22 @@ var MANUAL_PRICING = {
   "qwen3.7-plus": { input: 0.5, output: 3, cachedInput: 0.05 },
   "qwen3.6-plus": { input: 0.5, output: 3, cachedInput: 0.05 },
   "qwen3.6-flash": { input: 0.1875, output: 1.125 },
+  // ClinePass reference quota rates, not incremental subscription charges.
+  // https://github.com/cline/cline/blob/main/docs/getting-started/clinepass.mdx
+  // checked 2026-10-05; DeepSeek uses peak rates; Qwen Plus <=256K only.
+  "cline-pass/glm-5.3": { input: 1.4, output: 4.4, cachedInput: 0.26 },
+  "cline-pass/glm-5.2": { input: 1.4, output: 4.4, cachedInput: 0.26 },
+  "cline-pass/kimi-k3": { input: 3, output: 15, cachedInput: 0.3 },
+  "cline-pass/kimi-k2.7-code": { input: 0.95, output: 4, cachedInput: 0.19 },
+  "cline-pass/kimi-k2.6": { input: 0.95, output: 4, cachedInput: 0.16 },
+  "cline-pass/deepseek-v4-pro": { input: 1.32, output: 3.96, cachedInput: 0.044 },
+  "cline-pass/deepseek-v4-flash": { input: 0.44, output: 1.32, cachedInput: 0.014 },
+  "cline-pass/mimo-v2.5": { input: 0.14, output: 0.28, cachedInput: 28e-4 },
+  "cline-pass/mimo-v2.5-pro": { input: 1.74, output: 3.48, cachedInput: 0.0145 },
+  "cline-pass/minimax-m3": { input: 0.3, output: 1.2, cachedInput: 0.06 },
+  "cline-pass/qwen3.8-max": { input: 2, output: 6, cachedInput: 0.25, cacheWrite: 2.5 },
+  "cline-pass/qwen3.7-max": { input: 2.5, output: 7.5, cachedInput: 0.5, cacheWrite: 3.125 },
+  "cline-pass/qwen3.7-plus": { input: 0.4, output: 1.6, cachedInput: 0.04, cacheWrite: 0.5 },
   // OpenCode Zen free tier (https://opencode.ai/docs/zen/) — zero-rate gateway
   // models; actual spend is $0 while the free period lasts.
   "muse-spark-1.3-contributor-free": { input: 0, output: 0 },
@@ -293,7 +309,9 @@ var MODEL_VENDOR_PREFIXES = [
   "openrouter/",
   "opencode/",
   "xai/",
-  "x-ai/"
+  "x-ai/",
+  "cline/",
+  "cline-pass/"
 ];
 function normalizeModel(model) {
   let key = model;
@@ -313,7 +331,7 @@ function normalizeModel(model) {
 function getRates(model) {
   const key = model ? normalizeModel(model) : "";
   const aliasKey = azureDeploymentPriceKey(key);
-  const rates = (model && Object.hasOwn(MODEL_PRICING, model) ? MODEL_PRICING[model] : void 0) ?? (model ? DISCOVERED_PRICING.get(model) : void 0) ?? (Object.hasOwn(MODEL_PRICING, key) ? MODEL_PRICING[key] : void 0) ?? (aliasKey ? MODEL_PRICING[aliasKey] : void 0) ?? DISCOVERED_PRICING.get(key);
+  const rates = (model && Object.hasOwn(MODEL_PRICING, model) ? MODEL_PRICING[model] : void 0) ?? (model ? DISCOVERED_PRICING.get(model) : void 0) ?? (model?.startsWith("cline/") && Object.hasOwn(MODEL_PRICING, model.slice(6)) ? MODEL_PRICING[model.slice(6)] : void 0) ?? (Object.hasOwn(MODEL_PRICING, key) ? MODEL_PRICING[key] : void 0) ?? (aliasKey ? MODEL_PRICING[aliasKey] : void 0) ?? DISCOVERED_PRICING.get(key);
   if (!rates) {
     if (model)
       console.warn(`[0] Unknown model for cost estimation: ${model}`);
@@ -336,6 +354,8 @@ function modelProvider(model) {
   if (!model)
     return "unknown";
   const lowered = model.toLowerCase();
+  if (lowered.startsWith("cline/") || lowered.startsWith("cline-pass/"))
+    return "cline";
   if (lowered.startsWith("openai/"))
     return "openai";
   if (lowered.startsWith("azure/"))
@@ -1546,10 +1566,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 +1638,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 +1661,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 +1710,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 +1741,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 +1787,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 +1827,364 @@ 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",
+  "learning"
+];
+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" || pathname === "/api/findings/export")
+    add("artifacts");
+  if (parts[0] === "findings" && parts.length === 3 && parts[2] === "impact-assessment")
+    add("artifacts");
+  if (parts[0] === "scans" && parts[2] === "resume") {
+    add("workflows");
+    add("sessions");
+  } 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 (family === "learning")
+      add("learning");
+    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];
+}
+
+// packages/shared/dist/scan-resume.js
+var ScanResumeRequestSchema = external_exports.object({
+  sessionId: external_exports.string().trim().min(1).max(160),
+  approval: external_exports.literal("launch-authorized-run"),
+  branchFromEntry: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+  timeCapMs: external_exports.number().int().positive().max(864e5).optional(),
+  costCapUsd: external_exports.number().finite().positive().max(1e3).optional()
+}).strict();
+function resolvePersistedScanResume(scan) {
+  if (!scan.id || scan.id.startsWith("console-"))
+    throw new Error("Choose a persisted assessment scan, not a console conversation.");
+  const depth = external_exports.enum(["quick", "default", "deep"]).parse(scan.depth);
+  const storedMode = scan.mode ? external_exports.enum(["probe", "deep", "mcp", "web", "http_audit", "llm-ipi"]).parse(scan.mode) : void 0;
+  const raw = external_exports.string().trim().min(1).max(4096).parse(scan.target);
+  let parsed;
+  let impliedMode;
+  if (/^https?:\/\//.test(raw))
+    parsed = { target: raw, targetType: "url", sourceDescription: "url" };
+  else if (raw.startsWith("web:")) {
+    parsed = { target: raw.slice(4), targetType: "web-app", sourceDescription: "web-app" };
+    impliedMode = "web";
+  } else if (raw.startsWith("mcp://")) {
+    parsed = { target: raw, targetType: "url", sourceDescription: "mcp target" };
+    impliedMode = "mcp";
+  } else if (raw.startsWith("scan:"))
+    parsed = { target: raw.slice(5), targetType: "url", sourceDescription: "url" };
+  else if (raw.startsWith("repo:"))
+    parsed = { target: raw.slice(5), targetType: "source-code", sourceDescription: "repository" };
+  else {
+    const match = /^(npm|pypi|cargo|oci):(.+)$/.exec(raw);
+    if (!match)
+      throw new Error(`Resume does not know how to route this persisted target yet: ${raw}`);
+    const ecosystem = match[1];
+    const spec = match[2];
+    const at = spec.lastIndexOf("@");
+    const target = at > 0 ? spec.slice(0, at) : spec;
+    const packageVersion = at > 0 ? spec.slice(at + 1) : void 0;
+    if (!target.trim() || packageVersion === "")
+      throw new Error("Persisted package identity is incomplete.");
+    const types = { npm: "npm-package", pypi: "pypi-package", cargo: "cargo-package", oci: "oci-image" };
+    parsed = { target, targetType: types[ecosystem], ...packageVersion ? { packageVersion } : {}, sourceDescription: `${ecosystem} package` };
+  }
+  if (!parsed.target.trim())
+    throw new Error("Persisted scan target is empty.");
+  const targetType = storedMode === "web" ? "web-app" : parsed.targetType;
+  return { ...parsed, targetType, depth, mode: impliedMode ?? storedMode ?? (targetType === "web-app" ? "web" : "deep") };
+}
+
+// packages/shared/dist/engine-operations.js
+var ENGINE_OPERATION_DEFINITIONS = [
+  { id: "get_capabilities", capability: "operator-services", effect: "read" },
+  { id: "start_assessment", capability: "workflows", effect: "execute" },
+  { id: "attach_session", capability: "sessions", effect: "read" },
+  { id: "get_session_events", capability: "events", effect: "read" },
+  { id: "list_templates", capability: "workflows", effect: "read" },
+  { id: "get_template", capability: "workflows", effect: "read" },
+  { id: "list_workflows", capability: "workflows", effect: "read" },
+  { id: "get_workflow", capability: "workflows", effect: "read" },
+  { id: "save_workflow", capability: "workflows", effect: "write" },
+  { id: "start_run", capability: "workflows", effect: "execute" },
+  { id: "list_runs", capability: "workflows", effect: "read" },
+  { id: "get_run", capability: "workflows", effect: "read" },
+  { id: "get_run_results", capability: "workflows", effect: "read" },
+  { id: "cancel_run", capability: "workflows", effect: "cancel" },
+  { id: "list_sessions", capability: "sessions", effect: "read" },
+  { id: "create_session", capability: "sessions", effect: "write" },
+  { id: "get_session", capability: "sessions", effect: "read" },
+  { id: "send_message", capability: "sessions", effect: "execute" },
+  { id: "continue_session", capability: "sessions", effect: "execute" },
+  { id: "cancel_session", capability: "sessions", effect: "cancel" },
+  { id: "resolve_decision", capability: "approvals", effect: "approve" },
+  { id: "list_saved_sessions", capability: "sessions", effect: "read" },
+  { id: "resume_session", capability: "sessions", effect: "execute" },
+  { id: "resume_scan", capability: "scan-resume", effect: "execute" }
+];
+var ENGINE_REPORT_FORMATS = ["json", "md", "html", "sarif", "pdf"];
+var operationIds = ENGINE_OPERATION_DEFINITIONS.map((operation) => operation.id);
+var OperationIdSchema = external_exports.enum(operationIds);
+var unique = (values) => new Set(values).size === values.length;
+var EngineCapabilityManifestSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  operations: external_exports.array(OperationIdSchema).refine(unique, "Engine operations must be unique"),
+  reportExport: external_exports.object({ formats: external_exports.array(external_exports.enum(ENGINE_REPORT_FORMATS)).refine(unique, "Report formats must be unique") }).strict(),
+  resume: external_exports.object({ session: external_exports.boolean(), scan: external_exports.boolean(), workflow: external_exports.literal(false) }).strict()
+}).strict().superRefine((manifest, context) => {
+  if (manifest.resume.session !== manifest.operations.includes("resume_session") || manifest.resume.scan !== manifest.operations.includes("resume_scan")) {
+    context.addIssue({ code: external_exports.ZodIssueCode.custom, message: "Resume support must match registered operations" });
+  }
+});
+function createEngineCapabilityManifest(options) {
+  return EngineCapabilityManifestSchema.parse({
+    schemaVersion: 1,
+    operations: [...options.operations],
+    reportExport: { formats: [...options.reportFormats ?? []] },
+    resume: { session: options.operations.includes("resume_session"), scan: options.operations.includes("resume_scan"), workflow: false }
+  });
+}
+function requireEngineOperation(manifest, operation) {
+  const valid = EngineCapabilityManifestSchema.parse(manifest);
+  if (!valid.operations.includes(operation))
+    throw new Error(`Engine does not support operation ${operation}.`);
+}
+var ENGINE_COMMAND_COVERAGE = [
+  { id: "assessment", classification: "workflow", cliCommands: ["scan", "review", "audit", "secure"], workflowSteps: ["audit"], templateIds: ["repository-review", "dependency-review", "api-security", "web-configuration", "scoped-penetration-test", "package-behavior", "contract-review", "native-code-review"], chatTools: [], limits: "Target-specific assessment options and admission still apply.", source: "packages/core/src/assessment.ts" },
+  { id: "fix", classification: "workflow", cliCommands: ["fix"], workflowSteps: ["fix"], templateIds: ["fix-candidate"], chatTools: ["generate_fix"], limits: "Chat generation is distinct from workflow candidate validation; applying requires exact live candidate proof and host/request approval.", source: "packages/cli/src/finding-workflow-executors.ts" },
+  { id: "verification", classification: "workflow", cliCommands: ["verify", "replay"], workflowSteps: ["verify"], templateIds: ["finding-verification"], chatTools: ["verify_finding"], limits: "Managed verification uses supported replay runners; CLI kernel verification is not a portable workflow operation.", source: "packages/cli/src/finding-workflow-executors.ts" },
+  { id: "research", classification: "workflow", cliCommands: ["research pipeline", "research mobile", "research linux-matrix"], workflowSteps: ["research"], templateIds: ["security-research"], chatTools: [], limits: "Managed modes pipeline/mobile/linux-matrix require authorized local workspace; pipeline is source-only. linux-matrix imports external evidence and does not execute boots.", source: "packages/cli/src/workflow-research-executors.ts" },
+  { id: "deep-review", classification: "workflow", cliCommands: ["deep-review"], workflowSteps: ["deep-review"], templateIds: ["deep-source-review"], chatTools: [], limits: "Authorized local source workspace and provider prerequisites apply.", source: "packages/cli/src/workflow-research-executors.ts" },
+  { id: "offensive-tools", classification: "chat-tool", cliCommands: ["hunt", "assumption-hunt", "protocol-check", "specdrift", "memsafety", "npm-discovery", "kernel", "cve"], workflowSteps: [], templateIds: [], chatTools: ["variant_hunt", "assumption_hunt", "protocol_conformance", "spec_drift", "safety_eval", "memsafety_fuzz", "npm_dynamic_discovery", "weaponize_kernel", "cve_adapt"], limits: "Tool availability is scope/feature/prerequisite gated. CLI engines and tools have different contracts; no portable specialist workflow executor is registered by this manifest.", source: "packages/core/src/agent/tools/offensive-engines.ts" },
+  { id: "kernel-research", classification: "cli-specialist", cliCommands: ["research linux"], workflowSteps: [], templateIds: [], chatTools: [], limits: "Managed kernel research rejects execution until the VM/build runner supports workflow cancellation and deadlines.", source: "packages/cli/src/workflow-research-executors.ts" },
+  { id: "specialist-cli", classification: "cli-specialist", cliCommands: ["binary", "exploit", "recency-hunt", "lens-synth", "xnu-fuzz", "disclose", "eval", "bench", "ingest"], workflowSteps: [], templateIds: [], chatTools: [], limits: "These CLI contracts are not exposed as portable workflow steps here; model-driven source review is not equivalent to their native proof engines.", source: "packages/cli/src/index.ts" },
+  { id: "maintenance", classification: "cli-maintenance", cliCommands: ["doctor", "db", "upgrade", "config", "plugin", "theme", "login", "logout"], workflowSteps: [], templateIds: [], chatTools: [], limits: "Host maintenance and credential changes are not workflow execution or model-tool grants.", source: "packages/cli/src/index.ts" }
+];
+
+// packages/shared/dist/finding-priority.js
+var ImpactAssessmentSchema = external_exports.object({
+  reachability_tier: external_exports.enum(["remote-unauth", "remote-auth", "proximity-rf", "local-unpriv", "local-priv", "needs-hardware", "needs-host-migration", "unknown"]),
+  blast_radius: external_exports.string().trim().min(1).max(4096),
+  weaponizability: external_exports.enum(["dos-crash", "info-leak", "integrity-tampering", "lpe-to-root", "rce", "unknown"]),
+  business_impact: external_exports.enum(["headline", "notable", "modest", "noise", "unassessed"]),
+  rationale: external_exports.string().trim().min(1).max(8192),
+  assessment_source: external_exports.enum(["model", "provided", "heuristic"]).optional()
+}).strip();
+var UNKNOWN_PRIORITY = {
+  rank: 1.5,
+  label: "Not assessed",
+  assessed: false,
+  rationale: "Business impact has not been assessed. Establish the affected services, customers, data, and operational consequences."
+};
+var PRIORITIES = {
+  headline: { rank: 3, label: "Urgent" },
+  notable: { rank: 2, label: "High" },
+  modest: { rank: 1, label: "Moderate" },
+  noise: { rank: 0, label: "Low" }
+};
+function isHeuristicImpactAssessment(assessment) {
+  return assessment.assessment_source === "heuristic" || /^deterministic fallback derived from severity\s*\+\s*category/i.test(assessment.rationale) || /^heuristic baseline for a /i.test(assessment.blast_radius);
+}
+function getFindingPriority(finding) {
+  const parsed = ImpactAssessmentSchema.safeParse(finding.impactAssessment);
+  if (!parsed.success || parsed.data.business_impact === "unassessed" || isHeuristicImpactAssessment(parsed.data)) {
+    return { ...UNKNOWN_PRIORITY };
+  }
+  const priority = PRIORITIES[parsed.data.business_impact];
+  return { ...priority, assessed: true, rationale: parsed.data.rationale };
+}
+var TECHNICAL_SEVERITY = { critical: 4, high: 3, medium: 2, low: 1, info: 0 };
+function technicalCvss(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 10 ? value : -1;
+}
+function compareFindingsByBusinessPriority(a, b) {
+  return getFindingPriority(b).rank - getFindingPriority(a).rank || (TECHNICAL_SEVERITY[b.severity?.toLowerCase() ?? ""] ?? -1) - (TECHNICAL_SEVERITY[a.severity?.toLowerCase() ?? ""] ?? -1) || technicalCvss(b.cvssScore) - technicalCvss(a.cvssScore);
+}
+
+// packages/shared/dist/access-milestone.js
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var successfulObservation = (value) => {
+  const item = record(value);
+  return item && typeof item.status === "number" && Number.isInteger(item.status) && item.status >= 200 && item.status < 300 && item.truncated === false && item.field_present === true && (typeof item.json_pointer_value === "string" || item.json_pointer_value === null) ? item : void 0;
+};
+function accessMilestoneFromArtifact(eventType, value, scopeId, evidenceEventId) {
+  const item = record(value);
+  if (eventType !== "tool_artifact" || !item || item.tool !== "access_control_workflow" || item.workflow !== "access_control_workflow" || item.verdict !== "confirmed" || typeof item.owner_identity !== "string" || !item.owner_identity || typeof item.actor_identity !== "string" || !item.actor_identity || item.owner_identity === item.actor_identity || typeof item.expected_state !== "string" || item.expected_state.length > 500 || typeof item.observation_url !== "string" || item.observation_url.length > 8192 || !scopeId || scopeId.length > 512)
+    return null;
+  const before = successfulObservation(item.observation_before);
+  const after = successfulObservation(item.observation_after);
+  if (!before || !after || before.json_pointer_value === item.expected_state || after.json_pointer_value !== item.expected_state || !Array.isArray(item.steps) || item.steps.length === 0 || item.steps.length > 10)
+    return null;
+  if (item.steps.some((value2, index) => {
+    const step = record(value2);
+    return !step || step.step_index !== index || typeof step.url !== "string" || !["GET", "POST", "PUT", "DELETE", "PATCH"].includes(String(step.method)) || typeof step.status !== "number" || !Number.isInteger(step.status) || step.status < 100 || step.status > 599 || step.error !== void 0;
+  }))
+    return null;
+  let asset;
+  try {
+    const url = new URL(item.observation_url);
+    if (!["https:", "http:"].includes(url.protocol) || url.username || url.password)
+      return null;
+    asset = url.origin;
+  } catch {
+    return null;
+  }
+  return {
+    key: JSON.stringify([scopeId, "cross-identity-write", item.observation_url]),
+    asset,
+    status: "conditional",
+    accessClass: "cross-identity-write",
+    headline: "State change confirmed across request contexts",
+    summary: "The observing context saw the declared marker after requests using different configured authentication headers. Authorization impact requires validation. Cleanup was not verified.",
+    cleanup: "unknown",
+    ...evidenceEventId && evidenceEventId.length <= 512 ? { evidenceEventId } : {}
+  };
+}
+function appendAccessMilestone(current, next, limit = 80) {
+  if (current.some((item) => item.milestone.key === next.milestone.key))
+    return [...current];
+  return [...current, next].slice(-Math.max(1, Math.min(80, limit)));
+}
+
 export {
   validateScanPlan,
   defaultRoleFor,
@@ -1747,6 +2219,8 @@ export {
   VerificationAssertionSchema,
   EvidenceArtifactSchema,
   VerificationResultSchema,
+  pocStepActionSchema,
+  pocStepExpectSchema,
   pocStepSchema,
   pocStepArraySchema,
   findingSchema,
@@ -1799,11 +2273,51 @@ 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,
+  ScanResumeRequestSchema,
+  resolvePersistedScanResume,
+  ENGINE_OPERATION_DEFINITIONS,
+  ENGINE_REPORT_FORMATS,
+  EngineCapabilityManifestSchema,
+  createEngineCapabilityManifest,
+  requireEngineOperation,
+  ENGINE_COMMAND_COVERAGE,
+  ImpactAssessmentSchema,
+  isHeuristicImpactAssessment,
+  getFindingPriority,
+  compareFindingsByBusinessPriority,
+  accessMilestoneFromArtifact,
+  appendAccessMilestone
 };