0sec-cli 0.22.0 → 0.22.4

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

@@ -5,6 +5,28 @@ import {
   external_exports
 } from "./chunk-VIT5ALXF.js";
 
+// packages/shared/dist/types.js
+function validateScanPlan(plan) {
+  if (!Number.isInteger(plan.runCount) || plan.runCount < 1) {
+    throw new Error("Scan plan runCount must be a positive integer");
+  }
+  if (plan.depth !== "quick" && plan.depth !== "default" && plan.depth !== "deep") {
+    throw new Error(`Unknown scan depth "${String(plan.depth)}"`);
+  }
+  if (!Number.isFinite(plan.timeCapMs) || plan.timeCapMs <= 0) {
+    throw new Error("Scan plan timeCapMs must be a positive finite number");
+  }
+  if (!Number.isFinite(plan.costCapUsd) || plan.costCapUsd <= 0) {
+    throw new Error("Scan plan costCapUsd must be a positive finite number");
+  }
+  if (plan.executionMode !== "sequential" && plan.executionMode !== "parallel") {
+    throw new Error(`Unknown scan execution mode "${String(plan.executionMode)}"`);
+  }
+  if (plan.goal !== "known-vulnerabilities" && plan.goal !== "unknown-vulnerabilities" && plan.goal !== "misconfigurations") {
+    throw new Error(`Unknown scan goal "${String(plan.goal)}"`);
+  }
+}
+
 // packages/shared/dist/identity.js
 function defaultRoleFor(auth) {
   return auth ? "user" : "anonymous";
@@ -45,7 +67,7 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 function loadVersion() {
   if (true) {
-    return "0.22.0";
+    return "0.22.4";
   }
   try {
     const here = dirname(fileURLToPath(import.meta.url));
@@ -224,13 +246,14 @@ var MODEL_PRICING = {
 };
 var DISCOVERED_PRICING = /* @__PURE__ */ new Map();
 function registerModelPricing(model, rates) {
-  if (!model || model !== model.trim() || /[\s\x00-\x1f\x7f]/.test(model) || Object.hasOwn(MODEL_PRICING, model) || !Number.isFinite(rates.input) || rates.input < 0 || !Number.isFinite(rates.output) || rates.output < 0 || rates.cachedInput !== void 0 && (!Number.isFinite(rates.cachedInput) || rates.cachedInput < 0)) {
+  if (!model || model !== model.trim() || /[\s\x00-\x1f\x7f]/.test(model) || Object.hasOwn(MODEL_PRICING, model) || !Number.isFinite(rates.input) || rates.input < 0 || !Number.isFinite(rates.output) || rates.output < 0 || rates.cachedInput !== void 0 && (!Number.isFinite(rates.cachedInput) || rates.cachedInput < 0) || rates.cacheWrite !== void 0 && (!Number.isFinite(rates.cacheWrite) || rates.cacheWrite < 0)) {
     return false;
   }
   DISCOVERED_PRICING.set(model, Object.freeze({
     input: rates.input,
     output: rates.output,
-    ...rates.cachedInput !== void 0 ? { cachedInput: rates.cachedInput } : {}
+    ...rates.cachedInput !== void 0 ? { cachedInput: rates.cachedInput } : {},
+    ...rates.cacheWrite !== void 0 ? { cacheWrite: rates.cacheWrite } : {}
   }));
   return true;
 }
@@ -302,8 +325,9 @@ function estimateCost(usage, model) {
   const rates = getRates(model);
   const cachedInputRate = rates.cachedInput ?? rates.input;
   const cached = usage.cachedInputTokens ?? 0;
-  const uncachedInput = Math.max(0, usage.inputTokens - cached);
-  return uncachedInput / 1e6 * rates.input + cached / 1e6 * cachedInputRate + usage.outputTokens / 1e6 * rates.output;
+  const writes = usage.cacheWriteTokens ?? 0;
+  const uncachedInput = Math.max(0, usage.inputTokens - cached - writes);
+  return uncachedInput / 1e6 * rates.input + cached / 1e6 * cachedInputRate + writes / 1e6 * (rates.cacheWrite ?? rates.input * 1.25) + usage.outputTokens / 1e6 * rates.output;
 }
 function priceRun(usage, model) {
   return estimateCost(usage, model);
@@ -367,9 +391,10 @@ function splitCost(usage, model) {
   const rates = getRates(model);
   const cachedInputRate = rates.cachedInput ?? rates.input;
   const cached = usage.cachedInputTokens ?? 0;
-  const uncachedInput = Math.max(0, usage.inputTokens - cached);
+  const writes = usage.cacheWriteTokens ?? 0;
+  const uncachedInput = Math.max(0, usage.inputTokens - cached - writes);
   const split = {
-    cost_in: uncachedInput / 1e6 * rates.input,
+    cost_in: uncachedInput / 1e6 * rates.input + writes / 1e6 * (rates.cacheWrite ?? rates.input * 1.25),
     cost_out: usage.outputTokens / 1e6 * rates.output
   };
   if (usage.cachedInputTokens !== void 0) {
@@ -769,27 +794,27 @@ var DANGEROUS_WINDOWS_PRIVILEGES = /* @__PURE__ */ new Set([
   "SeTakeOwnershipPrivilege",
   "SeLoadDriverPrivilege"
 ]);
-function coherentTokenSnapshot(token) {
-  if (typeof token !== "object" || token === null)
+function coherentTokenSnapshot(token2) {
+  if (typeof token2 !== "object" || token2 === null)
     return false;
-  const candidate = token;
+  const candidate = token2;
   return TOKEN_ID.test(candidate.tokenId) && SID.test(candidate.userSid) && Number.isSafeInteger(candidate.integrityRid) && candidate.integrityRid >= 0 && ["default", "limited", "full"].includes(candidate.elevationType) && typeof candidate.elevated === "boolean" && ["absent", "deny-only", "enabled"].includes(candidate.adminGroup) && typeof candidate.appContainer === "boolean" && Number.isSafeInteger(candidate.restrictedSidCount) && candidate.restrictedSidCount >= 0 && Array.isArray(candidate.enabledPrivileges) && candidate.enabledPrivileges.length <= 128 && candidate.enabledPrivileges.every((privilege) => typeof privilege === "string" && PRIVILEGE.test(privilege)) && new Set(candidate.enabledPrivileges).size === candidate.enabledPrivileges.length;
 }
 function equalTokenSnapshot(left, right) {
   return left.tokenId === right.tokenId && left.userSid === right.userSid && left.integrityRid === right.integrityRid && left.elevationType === right.elevationType && left.elevated === right.elevated && left.adminGroup === right.adminGroup && left.appContainer === right.appContainer && left.restrictedSidCount === right.restrictedSidCount && left.enabledPrivileges.length === right.enabledPrivileges.length && left.enabledPrivileges.every((privilege, index) => privilege === right.enabledPrivileges[index]);
 }
-function unprivilegedWindowsToken(token) {
-  return token.integrityRid <= 8448 && !token.elevated && token.elevationType !== "full" && token.adminGroup !== "enabled" && (token.appContainer || token.restrictedSidCount > 0 || token.adminGroup === "absent") && !token.enabledPrivileges.some((privilege) => DANGEROUS_WINDOWS_PRIVILEGES.has(privilege));
+function unprivilegedWindowsToken(token2) {
+  return token2.integrityRid <= 8448 && !token2.elevated && token2.elevationType !== "full" && token2.adminGroup !== "enabled" && (token2.appContainer || token2.restrictedSidCount > 0 || token2.adminGroup === "absent") && !token2.enabledPrivileges.some((privilege) => DANGEROUS_WINDOWS_PRIVILEGES.has(privilege));
 }
-function validWindowsStart(startingContext, token) {
+function validWindowsStart(startingContext, token2) {
   if (startingContext === "lpac")
     return false;
   if (startingContext === "standard-user") {
-    return !token.appContainer && token.restrictedSidCount === 0;
+    return !token2.appContainer && token2.restrictedSidCount === 0;
   }
   if (startingContext === "appcontainer")
-    return token.appContainer;
-  return token.appContainer || token.restrictedSidCount > 0;
+    return token2.appContainer;
+  return token2.appContainer || token2.restrictedSidCount > 0;
 }
 function validWindowsFinish(principal, start, finish) {
   if (finish.appContainer || finish.restrictedSidCount !== 0)
@@ -1062,7 +1087,7 @@ var DEFAULT_AUTONOMY_MODE = "yolo";
 var DEFAULT_ALLOW_MODEL_SELF_EXTENSION = true;
 
 // packages/shared/dist/jev.js
-var FEATURES = ["browser", "memory", "dedupe", "redteam", "kernel", "crash", "radar", "foxguard"];
+var FEATURES = ["browser", "memory", "dedupe", "rank", "specialist", "redteam", "kernel", "crash", "radar", "foxguard"];
 var INPUT_USD_PER_TOKEN = 0.042 / 1e6;
 var MAX_INPUT_TOKENS = 65536;
 var REQUEST_RESERVATION_USD = MAX_INPUT_TOKENS * INPUT_USD_PER_TOKEN;
@@ -1180,8 +1205,8 @@ function createJevEvaluator(config) {
           rawAnswers = body.answers;
         } else {
           const [{ experimental_evaluate: evaluate }, { createGateway }] = await Promise.all([
-            import("./dist-KEULE5IQ.js"),
-            import("./dist-XZB53PS5.js")
+            import("./dist-LNXGATR2.js"),
+            import("./dist-M2X367VW.js")
           ]);
           signal.throwIfAborted();
           const gateway = createGateway({ apiKey: config.apiKey, fetch: fetchImpl });
@@ -1231,7 +1256,465 @@ function createJevEvaluator(config) {
   };
 }
 
+// packages/shared/dist/slash-commands.js
+var SLASH_COMMANDS = [
+  // ── info ────────────────────────────────────────────────────────────────
+  {
+    name: "help",
+    aliases: ["?", "commands"],
+    category: "info",
+    description: "List commands",
+    usage: "/help [command]"
+  },
+  {
+    name: "capabilities",
+    aliases: ["caps"],
+    category: "info",
+    description: "What 0 can do and what needs approval",
+    usage: "/capabilities",
+    tuiOnly: true
+  },
+  {
+    name: "status",
+    aliases: [],
+    category: "info",
+    description: "Session status"
+  },
+  {
+    name: "tools",
+    aliases: [],
+    category: "info",
+    description: "List available tools"
+  },
+  {
+    name: "new-chat",
+    aliases: ["new"],
+    category: "navigation",
+    description: "Start a fresh audit",
+    tuiOnly: true
+  },
+  {
+    name: "onboard",
+    aliases: [],
+    category: "navigation",
+    description: "Run setup again",
+    tuiOnly: true
+  },
+  // ── session ─────────────────────────────────────────────────────────────
+  {
+    name: "clear",
+    aliases: [],
+    category: "session",
+    description: "Clear the conversation"
+  },
+  {
+    name: "history",
+    aliases: [],
+    category: "session",
+    description: "Past scans",
+    tuiOnly: true
+  },
+  {
+    name: "findings",
+    aliases: ["finds"],
+    category: "session",
+    description: "Show findings",
+    tuiOnly: true
+  },
+  {
+    name: "fix",
+    aliases: [],
+    category: "session",
+    description: "Write and test a fix; you approve any PR",
+    usage: "/fix [finding-id] | /fix publish <finding-id> | /fix cancel",
+    tuiOnly: true
+  },
+  {
+    name: "copy",
+    aliases: ["export", "dump"],
+    category: "session",
+    description: "Copy the conversation",
+    usage: "/copy",
+    tuiOnly: true
+  },
+  {
+    name: "sessions",
+    aliases: [],
+    category: "session",
+    description: "Switch or resume a conversation",
+    usage: "/sessions",
+    tuiOnly: true
+  },
+  {
+    name: "explain",
+    aliases: ["eli5"],
+    category: "session",
+    description: "Explain simply",
+    usage: "/explain [topic]",
+    tuiOnly: true
+  },
+  {
+    name: "feedback",
+    aliases: [],
+    category: "system",
+    description: "Send feedback",
+    usage: "/feedback <message> | /feedback submit <message> | /feedback send | /feedback cancel",
+    tuiOnly: true
+  },
+  {
+    name: "settings",
+    aliases: ["config", "prefs"],
+    category: "system",
+    description: "Open settings",
+    usage: "/settings",
+    tuiOnly: true
+  },
+  {
+    name: "keybindings",
+    aliases: ["keys", "keymap"],
+    category: "system",
+    description: "Keyboard shortcuts",
+    usage: "/keybindings",
+    tuiOnly: true
+  },
+  {
+    name: "theme",
+    aliases: ["themes"],
+    category: "system",
+    description: "Change the colour theme",
+    usage: "/theme [name]",
+    tuiOnly: true
+  },
+  {
+    name: "model",
+    aliases: ["models"],
+    category: "session",
+    description: "Choose a model",
+    usage: "/model [id]",
+    tuiOnly: true
+  },
+  // ── navigation ──────────────────────────────────────────────────────────
+  {
+    name: "chat",
+    aliases: [],
+    category: "navigation",
+    description: "Back to the conversation",
+    tuiOnly: true
+  },
+  {
+    name: "launcher",
+    aliases: ["run", "home"],
+    category: "navigation",
+    description: "Scan one target",
+    tuiOnly: true
+  },
+  {
+    name: "ops",
+    aliases: ["runs"],
+    category: "navigation",
+    description: "Running and recent scans",
+    tuiOnly: true
+  },
+  {
+    name: "hackstore",
+    aliases: ["store", "market", "marketplace"],
+    category: "navigation",
+    description: "Install extensions and themes",
+    tuiOnly: true
+  },
+  {
+    name: "connect",
+    aliases: [],
+    category: "navigation",
+    description: "Add an API key or sign in",
+    usage: "/connect",
+    tuiOnly: true
+  },
+  {
+    name: "usage",
+    aliases: ["cost", "tokens"],
+    category: "navigation",
+    description: "Tokens, cost and context",
+    usage: "/usage",
+    tuiOnly: true
+  },
+  {
+    name: "back",
+    aliases: [],
+    category: "navigation",
+    description: "Previous screen",
+    tuiOnly: true
+  },
+  {
+    name: "scope",
+    aliases: [],
+    category: "navigation",
+    description: "What 0 is allowed to test",
+    tuiOnly: true
+  },
+  // ── system ──────────────────────────────────────────────────────────────
+  {
+    name: "doctor",
+    aliases: [],
+    category: "system",
+    description: "Check your setup",
+    tuiOnly: true
+  },
+  {
+    name: "exit",
+    aliases: ["quit"],
+    category: "system",
+    description: "Quit"
+  }
+];
+var NAME_INDEX = {};
+for (const cmd of SLASH_COMMANDS) {
+  NAME_INDEX[cmd.name] = cmd.name;
+  for (const alias of cmd.aliases) {
+    NAME_INDEX[alias] = cmd.name;
+  }
+}
+function getCommandByName(name) {
+  const canonical = NAME_INDEX[name];
+  if (!canonical)
+    return void 0;
+  for (const cmd of SLASH_COMMANDS) {
+    if (cmd.name === canonical)
+      return cmd;
+  }
+  return void 0;
+}
+function findCommand(input) {
+  const trimmed = input.trimStart();
+  if (!trimmed.startsWith("/")) {
+    return {
+      isSlash: false,
+      command: void 0,
+      rawName: "",
+      args: "",
+      isKnown: false,
+      isUnknown: false
+    };
+  }
+  const afterSlash = trimmed.slice(1);
+  const spaceIndex = afterSlash.indexOf(" ");
+  const rawName = spaceIndex >= 0 ? afterSlash.slice(0, spaceIndex) : afterSlash;
+  const args = spaceIndex >= 0 ? afterSlash.slice(spaceIndex + 1).trim() : "";
+  const canonical = NAME_INDEX[rawName];
+  if (canonical) {
+    return {
+      isSlash: true,
+      command: canonical,
+      rawName,
+      args,
+      isKnown: true,
+      isUnknown: false
+    };
+  }
+  return {
+    isSlash: true,
+    command: void 0,
+    rawName,
+    args,
+    isKnown: false,
+    isUnknown: true
+  };
+}
+function filterCommands(query) {
+  const trimmed = query.trim().toLowerCase();
+  if (!trimmed)
+    return [...SLASH_COMMANDS];
+  return SLASH_COMMANDS.filter((cmd) => {
+    if (cmd.name.startsWith(trimmed))
+      return true;
+    return cmd.aliases.some((a) => a.startsWith(trimmed));
+  });
+}
+
+// packages/shared/dist/security-workflows.js
+var DEFAULT_SECURITY_WORKFLOW_PLAN = Object.freeze({ goal: "known-vulnerabilities", depth: "default", runCount: 1, executionMode: "sequential", timeCapMs: 6e5, costCapUsd: 5 });
+var identifier = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/).refine((value) => !["__proto__", "constructor", "prototype"].includes(value), "Reserved identifier.");
+var planSchema = external_exports.object({
+  goal: external_exports.enum(["known-vulnerabilities", "unknown-vulnerabilities", "misconfigurations"]),
+  depth: external_exports.enum(["quick", "default", "deep"]),
+  runCount: external_exports.number().int().min(1).max(16),
+  executionMode: external_exports.enum(["sequential", "parallel"]),
+  timeCapMs: external_exports.number().int().finite().positive().max(864e5),
+  costCapUsd: external_exports.number().finite().positive().max(1e3)
+}).strict();
+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 SecurityWorkflowInputSchema = external_exports.object({
+  id: identifier.optional(),
+  revision: external_exports.number().int().positive().optional(),
+  name: external_exports.string().trim().min(1).max(160),
+  instructions: external_exports.string().trim().max(16e3),
+  target: external_exports.string().trim().max(4096),
+  nodes: external_exports.array(nodeSchema).min(2).max(16),
+  edges: external_exports.array(external_exports.object({ source: identifier, target: identifier }).strict()).min(1).max(120)
+}).strict().superRefine((workflow, context) => {
+  const issue = (message) => context.addIssue({ code: external_exports.ZodIssueCode.custom, message });
+  const ids = new Set(workflow.nodes.map((node) => node.id));
+  if (ids.size !== workflow.nodes.length)
+    issue("Workflow node IDs must be unique.");
+  const triggers = workflow.nodes.filter((node) => node.type === "trigger");
+  if (triggers.length !== 1)
+    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.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.");
+  const edges = /* @__PURE__ */ new Set();
+  const successors = /* @__PURE__ */ new Map();
+  for (const edge of workflow.edges) {
+    if (!ids.has(edge.source) || !ids.has(edge.target))
+      issue("Edges must reference existing nodes.");
+    const key = `${edge.source}:${edge.target}`;
+    if (edges.has(key))
+      issue("Workflow edges must be unique.");
+    edges.add(key);
+    successors.set(edge.source, [...successors.get(edge.source) ?? [], edge.target]);
+    const source = workflow.nodes.find((node) => node.id === edge.source);
+    const target = workflow.nodes.find((node) => node.id === edge.target);
+    if (target?.type === "trigger" || source?.type === "report")
+      issue("Triggers must start the graph and reports must end it.");
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (visiting.has(id))
+      return false;
+    if (visited.has(id))
+      return true;
+    visiting.add(id);
+    for (const next of successors.get(id) ?? [])
+      if (!visit(next))
+        return false;
+    visiting.delete(id);
+    visited.add(id);
+    return true;
+  };
+  if (workflow.nodes.some((node) => !visit(node.id)))
+    issue("Workflow graphs cannot contain cycles.");
+  if (triggers.length === 1) {
+    const reachable = /* @__PURE__ */ new Set();
+    const walk = (id) => {
+      if (reachable.has(id))
+        return;
+      reachable.add(id);
+      for (const next of successors.get(id) ?? [])
+        walk(next);
+    };
+    walk(triggers[0].id);
+    if (workflow.nodes.some((node) => !reachable.has(node.id)))
+      issue("Every node must be reachable from the trigger.");
+  }
+});
+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) };
+}
+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 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.");
+  return json;
+}
+function parseSecurityWorkflowCode(value) {
+  if (typeof value === "string") {
+    if (new TextEncoder().encode(value).byteLength > 65536)
+      throw new Error("Workflow JSON must be at most 64 KiB.");
+    value = JSON.parse(value);
+  }
+  const envelope = codeEnvelope.parse(value);
+  if (!envelope.workflow || typeof envelope.workflow !== "object" || Array.isArray(envelope.workflow))
+    throw new Error("Workflow must be an object.");
+  const { id: _id, revision: _revision, createdAt: _createdAt, updatedAt: _updatedAt, ...draft } = envelope.workflow;
+  if (new TextEncoder().encode(JSON.stringify(envelope)).byteLength > 65536)
+    throw new Error("Workflow JSON must be at most 64 KiB.");
+  return parseSecurityWorkflowInput(draft);
+}
+
+// packages/shared/dist/security-workflow-templates.js
+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 })) }) };
+}
+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"),
+    phase("boundaries", "Trust boundaries", "unknown-vulnerabilities", "Trace authentication, authorization, tenant isolation, and privileged entry points in the authorized repository. Follow input-to-sink paths and report only supported security findings.", "deep"),
+    phase("configuration", "Configuration and secrets", "misconfigurations", "Review repository configuration, credential handling, unsafe defaults, and sensitive debug surfaces. Do not expose secret values in reports.")
+  ]),
+  template("dependency-review", "Dependency and supply-chain review", "Assess an authorized package or repository for advisories and suspicious dependency behavior.", "package", [
+    phase("advisories", "Advisory triage", "known-vulnerabilities", "Review declared and locked dependencies against supported advisory sources. Check affected versions and whether vulnerable functionality is used.", "quick"),
+    phase("lifecycle", "Lifecycle and trust", "unknown-vulnerabilities", "Inspect package installation hooks, dynamic downloads, credential access, and dependency trust changes. Support suspicious behavior with code evidence, without executing untrusted installation scripts.", "deep")
+  ]),
+  template("api-security", "API authorization review", "Review an explicitly authorized API for authorization gaps, unsafe inputs, and exposed configuration.", "web", [
+    phase("surface", "API surface and defaults", "misconfigurations", "Map documented and reachable authorized API endpoints, exposed documentation, error disclosures, and security defaults. Stay within the supplied scope and avoid destructive requests.", "quick"),
+    phase("authorization", "Authorization boundaries", "unknown-vulnerabilities", "Assess object ownership, role boundaries, tenant isolation, and authentication requirements using only identities and targets explicitly authorized for the engagement. Do not invent credentials.", "deep"),
+    phase("inputs", "Input handling", "unknown-vulnerabilities", "Review request parsing, injection boundaries, resource references, and validation. Use bounded non-destructive checks and retain evidence for confirmed impact.")
+  ]),
+  template("web-configuration", "Web configuration review", "Assess an authorized web target's exposure, browser security controls, and session configuration.", "web", [
+    phase("exposure", "Public exposure", "misconfigurations", "Review in-scope publicly reachable files, admin/debug surfaces, transport defaults, and error disclosures using non-destructive checks.", "quick"),
+    phase("sessions", "Browser and session controls", "misconfigurations", "Review observed cookie attributes, cache handling of sensitive responses, cross-origin policy, redirect handling, and browser security headers. Explain practical impact rather than treating every absent header as a vulnerability."),
+    phase("advisories", "Known component exposure", "known-vulnerabilities", "Assess observed components against supported known-vulnerability sources. Separate inferred versions from verified affected versions and avoid unsupported exploit claims.")
+  ]),
+  template("scoped-penetration-test", "Scoped penetration test", "Plan and assess only an explicitly authorized target, with bounded discovery and non-destructive validation.", "security", [
+    phase("discovery", "Scoped discovery", "misconfigurations", "Map only the authorized attack surface and identify exposed configuration and trust boundaries. Honor exclusions and rate limits; do not enumerate unrelated hosts.", "quick"),
+    phase("known", "Known vulnerability triage", "known-vulnerabilities", "Check supported known-vulnerability leads against observed target behavior. Verify applicability with bounded evidence; do not run broad third-party scanners or destructive exploit payloads."),
+    phase("validation", "Targeted validation", "unknown-vulnerabilities", "Investigate authorization, input handling, and sensitive state transitions within explicit scope. Prefer minimal non-destructive proof; stop before destructive actions or accessing unrelated user data.", "deep")
+  ]),
+  template("package-behavior", "Package behavior investigation", "Review an authorized package's security-relevant code paths and suspicious behavior.", "package", [
+    phase("entrypoints", "Entrypoints and advisories", "known-vulnerabilities", "Inspect package metadata, entrypoints, and supported advisories; identify security-sensitive or remotely reachable behavior.", "quick"),
+    phase("behavior", "Suspicious behavior", "unknown-vulnerabilities", "Trace filesystem and credential access, network destinations, obfuscated code, dynamic evaluation, and lifecycle hooks. Distinguish legitimate functionality from suspicious behavior with evidence; do not execute untrusted install scripts.", "deep")
+  ]),
+  template("contract-review", "Smart contract source review", "Review an authorized contract source repository for access control and asset-accounting defects.", "contracts", [
+    phase("access", "Authority and upgrade paths", "unknown-vulnerabilities", "Review contract source for privileged roles, initialization, upgrades, trust in external calls, and missing authorization. Identify the contract ecosystem from source; do not submit transactions or invent specialized verification results.", "deep"),
+    phase("accounting", "Asset and state invariants", "unknown-vulnerabilities", "Trace value transfers, balance accounting, state transitions, rounding, and reentrancy boundaries in the authorized source. Support findings with concrete call sequences; do not move assets or publish exploits.", "deep"),
+    phase("configuration", "Deployment assumptions", "misconfigurations", "Review source-visible deployment and initialization assumptions, privileged configuration, and dependency trust. Clearly distinguish code evidence from unverified deployed state.")
+  ]),
+  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")
+  ])
+];
+function createSecurityWorkflowTemplate(id) {
+  const found = SECURITY_WORKFLOW_TEMPLATES.find((entry) => entry.id === id);
+  if (!found)
+    throw new Error("Unknown security workflow template.");
+  return parseSecurityWorkflowInput(found.definition);
+}
+
+// packages/shared/dist/service-plugins.js
+var token = { key: "token", label: "API token", type: "secret", required: true };
+var SERVICE_PLUGIN_CATALOG = [
+  { id: "github", name: "GitHub", description: "Review repositories, security alerts and pull requests.", category: "Code", docsUrl: "https://github.com/github/github-mcp-server", fields: [{ ...token, label: "Personal access token" }] },
+  { id: "elastic", name: "Elastic", description: "Search security alerts and telemetry.", category: "Security", docsUrl: "https://www.elastic.co/docs/explore-analyze/ai-features/agent-builder/mcp-server-api-keys", fields: [{ key: "url", label: "Kibana URL", type: "url", required: true }, { ...token, label: "Encoded API key" }], credentialNote: "Requires Elastic Agent Builder access." },
+  { id: "semgrep", name: "Semgrep", description: "Investigate code, dependency and secret findings.", category: "Security", docsUrl: "https://semgrep.dev/docs/semgrep-appsec-platform/api", fields: [token, { key: "deploymentId", label: "Deployment ID", type: "text", required: true }] },
+  { id: "snyk", name: "Snyk", description: "Review vulnerable projects and dependencies.", category: "Security", docsUrl: "https://docs.snyk.io/snyk-api", fields: [token, { key: "organizationId", label: "Organization ID", type: "text", required: true }, { key: "url", label: "API URL (optional)", type: "url", required: false }] },
+  { id: "linear", name: "Linear", description: "Create and track remediation issues.", category: "Issues", docsUrl: "https://linear.app/developers/graphql", fields: [token] },
+  { id: "jira", name: "Jira", description: "Turn security findings into assigned issues.", category: "Issues", docsUrl: "https://developer.atlassian.com/cloud/jira/platform/basic-auth-for-rest-apis/", fields: [{ key: "url", label: "Jira Cloud URL", type: "url", required: true }, { key: "email", label: "Account email", type: "text", required: true }, token] },
+  { id: "cloudflare", name: "Cloudflare", description: "Inspect zones, DNS and security configuration.", category: "Cloud", docsUrl: "https://developers.cloudflare.com/fundamentals/api/get-started/create-token/", fields: [token] },
+  { id: "slack", name: "Slack", description: "Read channels and share workflow summaries.", category: "Messaging", docsUrl: "https://docs.slack.dev/authentication/tokens/", fields: [{ ...token, label: "Bot or user token" }] },
+  { 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." }
+];
+
 export {
+  validateScanPlan,
   defaultRoleFor,
   resolveIdentities,
   hasMultipleIdentities,
@@ -1310,5 +1793,17 @@ export {
   DEFAULT_AUTONOMY_MODE,
   DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
   jevConfigFromEnvironment,
-  createJevEvaluator
+  createJevEvaluator,
+  SLASH_COMMANDS,
+  getCommandByName,
+  findCommand,
+  filterCommands,
+  DEFAULT_SECURITY_WORKFLOW_PLAN,
+  SecurityWorkflowInputSchema,
+  parseSecurityWorkflowInput,
+  exportSecurityWorkflowCode,
+  parseSecurityWorkflowCode,
+  SECURITY_WORKFLOW_TEMPLATES,
+  createSecurityWorkflowTemplate,
+  SERVICE_PLUGIN_CATALOG
 };