0sec-cli 0.22.4 → 0.23.0

package/chunks/chunk-EWXOG6D3.js

@@ -0,0 +1,1695 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+import {
+  executeManagedOperation
+} from "./chunk-PIR6BNE7.js";
+import {
+  loadFindingFocus
+} from "./chunk-FXR3BT2G.js";
+import {
+  resolveEngagement
+} from "./chunk-R35KKJA4.js";
+import {
+  LinuxBootMatrixImportAdapter,
+  LinuxKernelResearchAdapter,
+  MobileStaticResearchAdapter,
+  UnifiedPipelineResearchAdapter,
+  WorkflowService,
+  createReproductionBundle,
+  executeAssessment,
+  runCliPathTraversalReplayFixture,
+  runPipeline,
+  runReproductionBundle,
+  runResearch
+} from "./chunk-4HGGNBKK.js";
+import {
+  oracleForCategory
+} from "./chunk-62ENS6XO.js";
+import {
+  DockerRunner,
+  LocalShellRunner,
+  QemuRunner,
+  SmolvmRunner,
+  createSmolvmPocTargetRunner,
+  runDeterministicReplay,
+  workflowPolicyRuntime
+} from "./chunk-EH2WTNY7.js";
+import {
+  applySourceFixCandidate,
+  runSourceFix,
+  verifySourceFixCandidate
+} from "./chunk-YYS2H33A.js";
+import {
+  SecurityWorkflowStore
+} from "./chunk-T7ZEVY5G.js";
+import {
+  evidenceKindForFinding
+} from "./chunk-TO35Y326.js";
+import {
+  executePocSteps
+} from "./chunk-IXT64DV5.js";
+import {
+  budgetNativeRuntime
+} from "./chunk-CP6HANBE.js";
+import {
+  LlmApiRuntime
+} from "./chunk-BF5FIK7H.js";
+import {
+  WORKBENCH_BROKER_WORKSPACE,
+  isAdmittedSmolvmWorkbench,
+  runWorkbenchBrokerProgram
+} from "./chunk-NI6QYQSK.js";
+import {
+  getScopeEnforcementState,
+  loadScope,
+  withScopeEnforcement
+} from "./chunk-ITES7BCY.js";
+import {
+  SECURITY_WORKFLOW_TEMPLATES,
+  SecurityWorkflowBindingsSchema,
+  VERSION,
+  VerificationResultSchema,
+  checkSecurityWorkflowTemplateTarget,
+  createSecurityWorkflowTemplate,
+  findingSchema,
+  formatZodError,
+  getSecurityWorkflowTemplate,
+  parseSecurityWorkflowInput
+} from "./chunk-LTEE2JWK.js";
+import {
+  external_exports
+} from "./chunk-VIT5ALXF.js";
+
+// packages/cli/src/workflow-runtime.ts
+import { realpath as realpath3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, relative as relative3, sep as sep4 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+
+// packages/cli/src/finding-workflow-executors.ts
+import { mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { randomUUID } from "node:crypto";
+import { tmpdir as tmpdir2 } from "node:os";
+import { isAbsolute, join as join2, relative, resolve as resolve2, sep as sep2 } from "node:path";
+
+// packages/cli/src/commands/verify.ts
+import { lstatSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join, resolve, posix, sep } from "node:path";
+var EXCERPT_BYTES = 4 * 1024;
+function excerpt(text2, max = EXCERPT_BYTES) {
+  if (!text2) return "";
+  if (text2.length <= max) return text2;
+  return text2.slice(0, max) + "\u2026[truncated]";
+}
+function statusFromVerdict(verdict) {
+  switch (verdict) {
+    case "exploit_still_works":
+      return "reproduced";
+    case "exploit_broken":
+      return "not_reproduced";
+    case "could_not_run":
+      return "skipped";
+    default: {
+      const _exhaustive = verdict;
+      void _exhaustive;
+      return "skipped";
+    }
+  }
+}
+function exitCodeForStatus(status) {
+  switch (status) {
+    case "reproduced":
+      return 0;
+    case "not_reproduced":
+      return 1;
+    case "skipped":
+      return 2;
+    case "error":
+      return 3;
+    default: {
+      const _exhaustive = status;
+      void _exhaustive;
+      return 3;
+    }
+  }
+}
+function argvForStep(step) {
+  switch (step.action.type) {
+    case "shell":
+      return ["/bin/sh", "-c", step.action.cmd];
+    case "docker":
+      return ["docker", "run", "--rm", ...step.action.args, step.action.image];
+    case "http":
+      return [step.action.method, step.action.url];
+    case "note":
+      return ["note", step.id];
+    default: {
+      const _exhaustive = step.action;
+      void _exhaustive;
+      return ["unknown"];
+    }
+  }
+}
+function defaultSummary(status, ran, total) {
+  switch (status) {
+    case "reproduced":
+      return `Replay reproduced the finding (${ran}/${total} steps executed).`;
+    case "not_reproduced":
+      return `Replay completed but the exploit no longer reproduces (${ran}/${total} steps executed).`;
+    case "skipped":
+      return total === 0 ? "No PoC steps to execute" : `Replay was skipped (${ran}/${total} steps executed).`;
+    case "error":
+      return "Verifier failed before reaching a verdict.";
+  }
+}
+function durationMs(startedAt, completedAt) {
+  const started = Date.parse(startedAt);
+  const completed = Date.parse(completedAt);
+  if (!Number.isFinite(started) || !Number.isFinite(completed)) return 0;
+  return Math.max(0, completed - started);
+}
+function engineMetadata() {
+  return {
+    os: process.platform,
+    arch: process.arch,
+    runner: isAdmittedSmolvmWorkbench() ? "smolvm" : "local"
+  };
+}
+function actualOutput(result) {
+  return result.observedStdout ?? result.observedResponseBody ?? "";
+}
+function assertionForStep(result, step) {
+  const expect = step.expect;
+  if (!expect) return null;
+  switch (expect.type) {
+    case "exit-zero":
+      return {
+        kind: "exit_code",
+        target: step.id,
+        expected: 0,
+        actual: result.observedExit ?? null,
+        passed: result.kind === "passed"
+      };
+    case "http-status":
+      return {
+        kind: "http_status",
+        target: step.id,
+        expected: Array.isArray(expect.status) ? expect.status.join(",") : expect.status,
+        actual: result.observedStatus ?? null,
+        passed: result.kind === "passed"
+      };
+    case "body-contains":
+      return {
+        kind: "string_in_output",
+        target: step.id,
+        expected: expect.text,
+        actual: excerpt(actualOutput(result)),
+        passed: result.kind === "passed"
+      };
+    case "body-matches":
+      return {
+        kind: "string_in_output",
+        target: step.id,
+        expected: `/${expect.pattern}/`,
+        actual: excerpt(actualOutput(result)),
+        passed: result.kind === "passed"
+      };
+    case "file-exists":
+      return {
+        kind: "file_exists",
+        target: expect.path,
+        expected: true,
+        actual: result.kind === "passed",
+        passed: result.kind === "passed"
+      };
+    default: {
+      const _exhaustive = expect;
+      void _exhaustive;
+      return null;
+    }
+  }
+}
+function findingOastConfirmed(finding) {
+  if (finding.oastConfirmed === true) return true;
+  if (oracleForCategory(finding.category) !== "oast-callback") return false;
+  return (finding.layerVerdicts ?? []).some(
+    (v) => v?.verdict === "pass" && (v.layer === "pov_gate" || v.layer === "oracle")
+  );
+}
+function oastEvidenceFields(finding) {
+  const oast_confirmed = findingOastConfirmed(finding);
+  const findingKind = evidenceKindForFinding(finding);
+  const evidence_kind = oast_confirmed ? "reproduced-poc" : findingKind === "source-only" ? void 0 : findingKind;
+  return {
+    ...evidence_kind ? { evidence_kind } : {},
+    ...oast_confirmed ? { oast_confirmed: true } : {}
+  };
+}
+function buildVerificationResult(args) {
+  const { finding, report: report2, startedAt, completedAt } = args;
+  const stepsById = new Map(
+    (finding.pocSteps ?? []).map((s) => [s.id, s])
+  );
+  const status = statusFromVerdict(report2.overallVerdict);
+  const commands = report2.steps.filter((r) => r.kind !== "skipped").map((r) => {
+    const step = stepsById.get(r.stepId);
+    const argv = step ? argvForStep(step) : ["unknown", r.stepId];
+    const exit_code = typeof r.observedExit === "number" ? r.observedExit : typeof r.observedStatus === "number" ? r.observedStatus : null;
+    const stdout = r.observedStdout ?? r.observedResponseBody ?? "";
+    const stderr = r.observedStderr ?? r.error ?? "";
+    return {
+      argv,
+      exit_code,
+      stdout_excerpt: excerpt(stdout),
+      stderr_excerpt: excerpt(stderr),
+      duration_ms: r.durationMs
+    };
+  });
+  const assertions = [];
+  for (const r of report2.steps) {
+    const step = stepsById.get(r.stepId);
+    if (!step) continue;
+    const assertion = assertionForStep(r, step);
+    if (assertion) assertions.push(assertion);
+  }
+  const ran = report2.steps.filter((r) => r.kind !== "skipped").length;
+  const total = (finding.pocSteps ?? []).length;
+  return {
+    status,
+    mode: "deterministic_replay",
+    finding_id: finding.id,
+    engine_version: VERSION,
+    started_at: startedAt,
+    completed_at: completedAt,
+    duration_ms: durationMs(startedAt, completedAt),
+    commands,
+    assertions,
+    evidence_artifacts: [],
+    engine_metadata: engineMetadata(),
+    summary: defaultSummary(status, ran, total),
+    error_reason: null,
+    ...oastEvidenceFields(finding)
+  };
+}
+function buildNoStepsResult(args) {
+  return {
+    status: "skipped",
+    mode: "deterministic_replay",
+    finding_id: args.finding.id,
+    engine_version: VERSION,
+    started_at: args.startedAt,
+    completed_at: args.completedAt,
+    duration_ms: durationMs(args.startedAt, args.completedAt),
+    commands: [],
+    assertions: [],
+    evidence_artifacts: [],
+    engine_metadata: engineMetadata(),
+    summary: "No PoC steps to execute",
+    error_reason: null,
+    // A finding proven purely out-of-band (an OAST callback) may carry no
+    // runnable pocSteps — the callback IS the proof. Stamp the provenance so
+    // the cloud still promotes it instead of reading `skipped` as no-evidence.
+    ...oastEvidenceFields(args.finding)
+  };
+}
+function buildErrorResult(args) {
+  const reason = args.error instanceof Error ? args.error.message : String(args.error);
+  return {
+    status: "error",
+    mode: "deterministic_replay",
+    finding_id: args.finding?.id ?? "unknown",
+    engine_version: VERSION,
+    started_at: args.startedAt,
+    completed_at: args.completedAt,
+    duration_ms: durationMs(args.startedAt, args.completedAt),
+    commands: [],
+    assertions: [],
+    evidence_artifacts: [],
+    engine_metadata: engineMetadata(),
+    summary: "Verifier failed before reaching a verdict.",
+    error_reason: reason
+  };
+}
+function legacyFixtureStatus(status) {
+  return status === "reproduced" || status === "not_reproduced" || status === "error" ? status : "skipped";
+}
+function legacyAssertionKind(kind) {
+  if (kind === "command_exit_zero") return "exit_code";
+  if (kind.startsWith("filesystem_")) return "file_exists";
+  return "string_in_output";
+}
+function artifactFromPath(kind, path) {
+  try {
+    const stat = statSync(path);
+    if (!stat.isFile()) return null;
+    const body = readFileSync(path);
+    return {
+      kind: kind.replace(/_ref$/, ""),
+      path,
+      sha256: createHash("sha256").update(body).digest("hex"),
+      bytes: stat.size
+    };
+  } catch {
+    return null;
+  }
+}
+function fixtureResultToShared(result) {
+  return {
+    status: legacyFixtureStatus(result.status),
+    mode: "deterministic_replay",
+    finding_id: result.finding_id,
+    engine_version: result.engine_version,
+    started_at: result.started_at,
+    completed_at: result.completed_at,
+    duration_ms: durationMs(result.started_at, result.completed_at),
+    commands: result.commands.map((command) => ({
+      argv: command.argv,
+      exit_code: command.exit_code,
+      stdout_excerpt: command.stdout_excerpt,
+      stderr_excerpt: command.stderr_excerpt,
+      duration_ms: 0
+    })),
+    assertions: result.assertions.map((assertion) => ({
+      kind: legacyAssertionKind(assertion.kind),
+      target: assertion.kind,
+      expected: true,
+      actual: assertion.passed,
+      passed: assertion.passed
+    })),
+    evidence_artifacts: Object.entries(result.artifacts).map(([kind, path]) => artifactFromPath(kind, path)).filter((artifact) => artifact !== null),
+    engine_metadata: engineMetadata(),
+    summary: result.summary,
+    error_reason: result.error_reason
+  };
+}
+function readJson(path, kind) {
+  const abs = resolve(path);
+  let raw;
+  try {
+    raw = readFileSync(abs, "utf8");
+  } catch (err) {
+    throw new Error(
+      `failed to read ${kind} from ${abs}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `failed to parse ${kind} as JSON (${abs}): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function parseFixtureCommand(raw) {
+  if (!raw) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `failed to parse --fixture-command as JSON argv array: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0 || !parsed.every((item) => typeof item === "string" && item.length > 0)) {
+    throw new Error("--fixture-command must be a non-empty JSON array of strings");
+  }
+  return parsed;
+}
+function parseDurationMs(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") throw new Error("duration is empty");
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/i);
+  if (!match) {
+    throw new Error(`invalid duration '${raw}' (expected e.g. 30m, 90s, 2h)`);
+  }
+  const value = parseFloat(match[1]);
+  const unit = (match[2] ?? "ms").toLowerCase();
+  switch (unit) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    default:
+      throw new Error(`invalid duration unit '${unit}'`);
+  }
+}
+async function runKernelFindingVerify(opts) {
+  const { verifyStaticKernelFinding, applyVerificationToFinding } = await import("./dist-4LGRIBOC.js");
+  const rawFinding = readJson(opts.findingPath, "finding");
+  let finding;
+  try {
+    finding = findingSchema.parse(rawFinding);
+  } catch (err) {
+    if (err instanceof external_exports.ZodError) {
+      throw new Error(formatZodError(err, "finding JSON"));
+    }
+    throw err;
+  }
+  const result = await verifyStaticKernelFinding(finding, {
+    kernelTree: opts.kernelTree,
+    kernelConfig: opts.kernelConfig,
+    attempts: opts.attempts,
+    wallClockMs: opts.wallClockMs
+  });
+  const promotedFinding = applyVerificationToFinding(
+    finding,
+    result
+  );
+  const exitCode = result.status === "confirmed" ? 0 : result.status === "soft_hit" ? 1 : result.status === "error" ? 3 : 2;
+  return {
+    exitCode,
+    result: {
+      mode: "kernel_finding_verify",
+      finding_id: finding.id,
+      status: result.status,
+      new_confidence: result.new_confidence,
+      signature: result.signature,
+      generated_program: result.generated_program,
+      generated_program_lang: result.generated_program_lang,
+      attempts: result.attempts.map((a) => ({
+        index: a.index,
+        program_lang: a.programLang,
+        expected_signature: a.expectedSignature,
+        rejected: a.rejected,
+        duration_ms: a.durationMs,
+        oracle: a.oracle
+      })),
+      reason: result.reason,
+      error: result.errorMessage,
+      finding: promotedFinding
+    }
+  };
+}
+function allocateIsolatedWorkspace() {
+  const cwd = mkdtempSync(join(tmpdir(), "0-verify-"));
+  return {
+    cwd,
+    cleanup: () => {
+      try {
+        rmSync(cwd, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+async function runVerify(opts) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let finding = null;
+  let cleanup;
+  try {
+    if (opts.fixture) {
+      if (opts.fixture !== "cli-path-traversal") {
+        throw new Error(
+          `unsupported fixture '${opts.fixture}', supported fixtures: cli-path-traversal`
+        );
+      }
+      if (opts.fixtureMode && opts.fixtureMode !== "vulnerable" && opts.fixtureMode !== "patched") {
+        throw new Error(
+          `unsupported --fixture-mode '${opts.fixtureMode}', expected 'vulnerable' or 'patched'`
+        );
+      }
+      if (!opts.fixtureCommand || opts.fixtureCommand.length === 0) {
+        throw new Error("--fixture-command is required with --fixture");
+      }
+      if (isAdmittedSmolvmWorkbench()) {
+        const runDir = resolve(opts.artifactDir ?? mkdtempSync(join(tmpdir(), "0-smol-fixture-")));
+        mkdirSync(runDir, { recursive: true });
+        const fixtureArgv = opts.fixtureCommand.map((argument) => argument === runDir ? WORKBENCH_BROKER_WORKSPACE : argument.startsWith(runDir + sep) ? `${WORKBENCH_BROKER_WORKSPACE}/${argument.slice(runDir.length + 1)}` : argument);
+        const execution = await runWorkbenchBrokerProgram({
+          profile: "offline",
+          workspaceRoot: runDir,
+          command: [
+            "0",
+            "verify",
+            "--fixture",
+            "cli-path-traversal",
+            "--fixture-command",
+            JSON.stringify(fixtureArgv),
+            "--fixture-mode",
+            opts.fixtureMode ?? "vulnerable",
+            "--artifact-dir",
+            WORKBENCH_BROKER_WORKSPACE,
+            "--output",
+            `${WORKBENCH_BROKER_WORKSPACE}/result.json`
+          ],
+          timeoutMs: 3e4,
+          memoryMb: 512,
+          cpus: 1,
+          maxOutputBytes: 1024 * 1024
+        }, opts.signal);
+        if (execution.error || execution.timedOut || execution.cleanupFailed) {
+          throw new Error(execution.error ?? (execution.timedOut ? "SmolVM fixture replay timed out" : "SmolVM fixture teardown was not confirmed"));
+        }
+        const result3 = VerificationResultSchema.parse(JSON.parse(readFileSync(join(runDir, "result.json"), "utf8")));
+        if (result3.finding_id !== "fixture:cli-path-traversal" || execution.exitCode !== exitCodeForStatus(result3.status)) {
+          throw new Error("SmolVM fixture result does not match its process outcome");
+        }
+        for (const artifact of result3.evidence_artifacts) {
+          const path = posix.relative(WORKBENCH_BROKER_WORKSPACE, artifact.path);
+          if (!path || path === ".." || path.startsWith("../") || posix.isAbsolute(path)) throw new Error("fixture artifact escaped the replay workspace");
+          const returnedPath = join(runDir, path);
+          const stat = lstatSync(returnedPath);
+          if (!stat.isFile() || stat.size > 4 * 1024 * 1024) throw new Error("invalid returned fixture artifact");
+          const body = readFileSync(returnedPath);
+          if (body.length !== artifact.bytes || createHash("sha256").update(body).digest("hex") !== artifact.sha256) {
+            throw new Error("returned fixture artifact digest mismatch");
+          }
+          artifact.path = returnedPath;
+        }
+        result3.engine_metadata = { os: "linux", arch: process.arch, runner: "smolvm" };
+        return { result: result3, exitCode: exitCodeForStatus(result3.status) };
+      }
+      const legacyResult = await runCliPathTraversalReplayFixture({
+        commandArgv: opts.fixtureCommand,
+        fixtureMode: opts.fixtureMode === "patched" ? "patched" : "vulnerable",
+        retainArtifacts: opts.retainArtifacts,
+        artifactDir: opts.artifactDir,
+        engineVersion: VERSION
+      });
+      const result2 = fixtureResultToShared(legacyResult);
+      VerificationResultSchema.parse(result2);
+      return { result: result2, exitCode: exitCodeForStatus(result2.status) };
+    }
+    if (opts.fixtureMode) {
+      throw new Error("--fixture-mode is only supported with --fixture");
+    }
+    if (!opts.findingPath) {
+      throw new Error("missing required flag: --finding <path>");
+    }
+    const rawFinding = readJson(opts.findingPath, "finding");
+    try {
+      finding = findingSchema.parse(rawFinding);
+    } catch (err) {
+      if (err instanceof external_exports.ZodError) {
+        throw new Error(formatZodError(err, "finding JSON"));
+      }
+      throw err;
+    }
+    const baseTarget = opts.targetPath ? readJson(opts.targetPath, "target") : {};
+    let target = { ...baseTarget, allowProcessActions: false };
+    if (!baseTarget.cwd) {
+      const isolated = allocateIsolatedWorkspace();
+      cleanup = isolated.cleanup;
+      target = { ...target, cwd: isolated.cwd };
+    }
+    if (!finding.pocSteps || finding.pocSteps.length === 0) {
+      const completedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+      const result2 = buildNoStepsResult({ finding, startedAt, completedAt: completedAt2 });
+      return { result: result2, exitCode: exitCodeForStatus(result2.status) };
+    }
+    if (isAdmittedSmolvmWorkbench()) {
+      const runner2 = createSmolvmPocTargetRunner(target);
+      const { result: result2, runDir } = await runDeterministicReplay(finding, {
+        runner: runner2,
+        runDir: target.cwd,
+        stepTimeoutMs: target.timeoutMs,
+        signal: opts.signal,
+        scope: opts.scopeFile ? loadScope(opts.scopeFile) : void 0
+      });
+      cleanup = void 0;
+      for (const artifact of result2.evidence_artifacts) artifact.path = join(runDir, artifact.path);
+      VerificationResultSchema.parse(result2);
+      return { result: result2, exitCode: exitCodeForStatus(result2.status) };
+    }
+    const report2 = await executePocSteps(finding, target);
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const result = buildVerificationResult({
+      finding,
+      report: report2,
+      startedAt,
+      completedAt
+    });
+    return { result, exitCode: exitCodeForStatus(result.status) };
+  } catch (err) {
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const result = buildErrorResult({
+      finding,
+      startedAt,
+      completedAt,
+      error: err
+    });
+    return { result, exitCode: exitCodeForStatus(result.status) };
+  } finally {
+    if (cleanup) cleanup();
+  }
+}
+function parseRunnerKind(raw) {
+  const v = (raw ?? (isAdmittedSmolvmWorkbench() ? "smolvm" : "local")).toLowerCase();
+  if (v === "local" || v === "smolvm" || v === "docker" || v === "qemu") return v;
+  throw new Error(
+    `unsupported --runner '${raw}', expected one of local|smolvm|docker|qemu`
+  );
+}
+async function runDeterministicReplayCli(args) {
+  const runnerKind = args.runner ?? parseRunnerKind(void 0);
+  const rawFinding = readJson(args.findingPath, "finding");
+  let finding;
+  try {
+    finding = findingSchema.parse(rawFinding);
+  } catch (err) {
+    if (err instanceof external_exports.ZodError) {
+      throw new Error(formatZodError(err, "finding JSON"));
+    }
+    throw err;
+  }
+  let runDir;
+  if (args.outDir) {
+    runDir = resolve(args.outDir);
+    mkdirSync(runDir, { recursive: true });
+  }
+  if (args.dockerNetwork && runnerKind !== "docker") {
+    throw new Error("--docker-network is only valid with --runner docker");
+  }
+  if ((args.qemuBinary || args.qemuKernel || args.qemuBusybox) && runnerKind !== "qemu") {
+    throw new Error("--qemu-binary / --qemu-kernel / --qemu-busybox require --runner qemu");
+  }
+  const scope = args.scopeFile ? loadScope(args.scopeFile) : void 0;
+  const runner2 = runnerKind === "local" ? new LocalShellRunner() : runnerKind === "smolvm" ? new SmolvmRunner() : runnerKind === "docker" ? new DockerRunner({ network: args.dockerNetwork }) : new QemuRunner({
+    qemuBinary: args.qemuBinary,
+    kernelImage: args.qemuKernel,
+    busyboxPath: args.qemuBusybox
+  });
+  const { result } = await runDeterministicReplay(finding, {
+    runner: runner2,
+    runDir,
+    scope,
+    signal: args.signal,
+    engineVersion: VERSION
+  });
+  VerificationResultSchema.parse(result);
+  const exitCode = result.status === "reproduced" ? 0 : result.status === "not_reproduced" ? 1 : result.status === "skipped" ? 2 : 3;
+  return { result, exitCode };
+}
+async function verifyAction(opts, positionalFinding) {
+  if ((opts.bundle || opts.createBundle) && (opts.target || opts.fixtureCommand || opts.fixtureMode || opts.retainArtifacts || opts.artifactDir || opts.kernelTree || opts.attempts || opts.wallClock || opts.qemuBinary || opts.qemuKernel || opts.qemuBusybox)) {
+    throw new Error("Bundle modes cannot be combined with target, fixture, or kernel execution options");
+  }
+  if ((opts.bundle || opts.createBundle) && opts.format && opts.format !== "json") {
+    throw new Error("Bundle modes support only JSON output");
+  }
+  if (opts.createBundle) {
+    if (opts.finding || opts.fixture || opts.bundle || opts.runner || opts.kernelFinding || positionalFinding || opts.scope || opts.dockerNetwork) {
+      throw new Error(
+        "--create-bundle cannot be combined with --finding / --fixture / --bundle / --runner / --kernel-finding / <finding> positional"
+      );
+    }
+    if (!opts.out) {
+      throw new Error("--create-bundle requires --out <bundle-dir>");
+    }
+    const { manifest, bundleDir } = await createReproductionBundle(
+      opts.createBundle,
+      opts.out
+    );
+    const result = JSON.stringify(
+      {
+        status: "bundle_created",
+        bundle_dir: bundleDir,
+        finding_id: manifest.finding.id,
+        engine_version: VERSION,
+        created_at: manifest.created_at,
+        runner: manifest.runner_compatibility.runner
+      },
+      null,
+      2
+    );
+    if (opts.output) {
+      writeFileSync(resolve(opts.output), result + "\n", "utf8");
+    } else {
+      process.stdout.write(result + "\n");
+    }
+    process.exitCode = 0;
+    return;
+  }
+  if (opts.kernelFinding) {
+    if (process.env["ZERO_KERNEL_VERIFY"] !== "1") {
+      throw new Error(
+        "--kernel-finding requires ZERO_KERNEL_VERIFY=1 (CI cost gate, #271). Run the command through `env ZERO_KERNEL_VERIFY=1 0 ...` to opt in."
+      );
+    }
+    if (!opts.kernelTree) {
+      throw new Error("--kernel-finding requires --kernel-tree <path>");
+    }
+    if (opts.finding || opts.fixture || opts.bundle || positionalFinding || opts.runner) {
+      throw new Error(
+        "--kernel-finding cannot be combined with --finding / --fixture / --bundle / <finding> positional / --runner"
+      );
+    }
+    const attempts = opts.attempts ? parseInt(opts.attempts, 10) : void 0;
+    if (opts.attempts && (!Number.isFinite(attempts) || attempts <= 0)) {
+      throw new Error(`invalid --attempts '${opts.attempts}' (expected positive integer)`);
+    }
+    const wallClockMs = opts.wallClock ? parseDurationMs(opts.wallClock) : void 0;
+    const kernelOutcome = await executeManagedOperation({
+      type: "verify",
+      name: "Kernel finding verification",
+      target: resolve(opts.kernelTree),
+      timeCapMs: wallClockMs ?? 18e5,
+      inputs: { findingPath: resolve(opts.kernelFinding), kernelTree: resolve(opts.kernelTree), kernelConfig: opts.kernelConfig ?? "kasan" },
+      output: (outcome2) => outcome2.result,
+      status: (outcome2) => outcome2.exitCode === 3 ? "failed" : "completed",
+      execute: () => runKernelFindingVerify({
+        findingPath: opts.kernelFinding,
+        kernelTree: opts.kernelTree,
+        kernelConfig: opts.kernelConfig ?? "kasan",
+        attempts,
+        wallClockMs
+      })
+    });
+    const kernelJson = JSON.stringify(kernelOutcome.result, null, 2);
+    if (opts.output) {
+      writeFileSync(resolve(opts.output), kernelJson + "\n", "utf8");
+    } else {
+      process.stdout.write(kernelJson + "\n");
+    }
+    process.exitCode = kernelOutcome.exitCode;
+    return;
+  }
+  if (!opts.bundle && (positionalFinding || opts.runner || isAdmittedSmolvmWorkbench() && opts.finding && !opts.target)) {
+    if (positionalFinding && opts.finding) {
+      throw new Error(
+        "pass a finding path EITHER as a positional argument OR via --finding, not both"
+      );
+    }
+    const findingPath = positionalFinding ?? opts.finding;
+    if (!findingPath) {
+      throw new Error(
+        "missing finding path. Usage: 0 verify <finding.json> [--runner local|smolvm|docker|qemu]"
+      );
+    }
+    const runner2 = parseRunnerKind(opts.runner);
+    const { result, exitCode } = await executeManagedOperation({
+      type: "verify",
+      name: "Finding replay verification",
+      target: resolve(findingPath),
+      timeCapMs: 36e5,
+      inputs: { findingPath: resolve(findingPath), runner: runner2 },
+      status: (outcome2) => outcome2.result.status === "error" ? "failed" : "completed",
+      output: (outcome2) => outcome2.result,
+      execute: (context) => runDeterministicReplayCli({
+        findingPath,
+        runner: runner2,
+        outDir: opts.out,
+        scopeFile: opts.scope,
+        dockerNetwork: opts.dockerNetwork,
+        qemuBinary: opts.qemuBinary,
+        qemuKernel: opts.qemuKernel,
+        qemuBusybox: opts.qemuBusybox,
+        signal: context.signal
+      })
+    });
+    const json2 = JSON.stringify(result, null, 2);
+    if (opts.output) {
+      writeFileSync(resolve(opts.output), json2 + "\n", "utf8");
+    } else {
+      process.stdout.write(json2 + "\n");
+    }
+    process.exitCode = exitCode;
+    return;
+  }
+  if (opts.bundle) {
+    if (opts.finding || opts.fixture || positionalFinding || opts.kernelFinding) {
+      throw new Error(
+        "--bundle cannot be combined with --finding / --fixture / --kernel-finding / <finding> positional"
+      );
+    }
+    const bundleRunner = opts.runner ?? (isAdmittedSmolvmWorkbench() ? "smolvm" : void 0);
+    if (bundleRunner !== "local" && bundleRunner !== "smolvm" && bundleRunner !== "docker") {
+      throw new Error("--bundle requires --runner local|smolvm|docker (defaults to smolvm in an admitted workbench; qemu is not supported)");
+    }
+    const bundleResult = await executeManagedOperation({
+      type: "verify",
+      name: "Reproduction bundle verification",
+      target: resolve(opts.bundle),
+      timeCapMs: 36e5,
+      inputs: { bundleDir: resolve(opts.bundle), runner: bundleRunner },
+      execute: (context) => runReproductionBundle({
+        bundleDir: opts.bundle,
+        runner: bundleRunner,
+        outDir: opts.out,
+        scope: opts.scope ? loadScope(opts.scope) : void 0,
+        dockerNetwork: opts.dockerNetwork,
+        signal: context.signal
+      })
+    });
+    const json2 = JSON.stringify(bundleResult, null, 2);
+    if (opts.output) {
+      writeFileSync(resolve(opts.output), json2 + "\n", "utf8");
+    } else {
+      process.stdout.write(json2 + "\n");
+    }
+    process.exitCode = bundleResult.exitCode;
+    return;
+  }
+  if (opts.fixture && opts.finding) {
+    throw new Error("--fixture and --finding are mutually exclusive");
+  }
+  if (opts.fixtureCommand && !opts.fixture) {
+    throw new Error("--fixture-command is only supported with --fixture");
+  }
+  if (opts.fixtureMode && !opts.fixture) {
+    throw new Error("--fixture-mode is only supported with --fixture");
+  }
+  if ((opts.retainArtifacts || opts.artifactDir) && !opts.fixture) {
+    throw new Error("--retain-artifacts / --artifact-dir are only supported with --fixture");
+  }
+  if (!opts.finding && !opts.fixture) {
+    throw new Error("missing required flag: --finding <path>");
+  }
+  if (opts.format && opts.format !== "json") {
+    throw new Error(`unsupported --format '${opts.format}', only 'json' is supported`);
+  }
+  const fixtureCommand = parseFixtureCommand(opts.fixtureCommand);
+  const outcome = await executeManagedOperation({
+    type: "verify",
+    name: opts.fixture ? "Verification fixture replay" : "Finding replay verification",
+    target: opts.finding ? resolve(opts.finding) : `fixture:${opts.fixture}`,
+    timeCapMs: 36e5,
+    inputs: { ...opts.finding ? { findingPath: resolve(opts.finding) } : { fixture: opts.fixture } },
+    status: (value) => value.result.status === "error" ? "failed" : "completed",
+    output: (value) => value.result,
+    execute: (context) => runVerify({
+      findingPath: opts.finding,
+      targetPath: opts.target,
+      fixture: opts.fixture,
+      fixtureCommand,
+      fixtureMode: opts.fixtureMode,
+      retainArtifacts: opts.retainArtifacts,
+      artifactDir: opts.artifactDir,
+      scopeFile: opts.scope,
+      signal: context.signal
+    })
+  });
+  const json = JSON.stringify(outcome.result, null, 2);
+  if (opts.output) {
+    writeFileSync(resolve(opts.output), json + "\n", "utf8");
+  } else {
+    process.stdout.write(json + "\n");
+  }
+  process.exitCode = outcome.exitCode;
+}
+function registerVerifyCommand(program) {
+  program.command("verify").description(
+    "Deterministically replay a finding's PoC steps and emit a verification_result JSON."
+  ).argument(
+    "[finding]",
+    "Path to a finding.json (0#193 deterministic-replay path). Equivalent to --finding when --runner is supplied."
+  ).option(
+    "--runner <kind>",
+    "Deterministic replay runner: local|smolvm|docker|qemu (default smolvm in an admitted workbench, local outside)."
+  ).option(
+    "--docker-network <name>",
+    "Docker network for --runner docker. Defaults to none; bridge/custom networks require --scope and only permit HTTP steps."
+  ).option(
+    "--scope <path>",
+    "Engagement scope JSON required for HTTP replay; SmolVM also refuses private/loopback destinations."
+  ).option("--qemu-binary <path>", "QEMU emulator for --runner qemu.").option("--qemu-kernel <path>", "Guest kernel image for --runner qemu.").option(
+    "--qemu-busybox <path>",
+    "Static BusyBox binary used to build the offline QEMU guest."
+  ).option(
+    "--out <dir>",
+    "0#193 run directory (artifacts go under <out>/artifacts/). Defaults to a fresh tmpdir."
+  ).option("--finding <path>", "Path to a finding.json.").option(
+    "--bundle <path>",
+    "Path to a reproduction bundle directory; requires --runner local|smolvm|docker outside an admitted workbench. Replays the bundle's vulnerable and patched snapshots through the configured runner and emits an aggregate ReproductionBundleResult."
+  ).option(
+    "--create-bundle <plan.json>",
+    "Path to a BundlePlan JSON. Creates a reproduction bundle without executing any PoC steps. Requires --out <bundle-dir>."
+  ).option(
+    "--target <path>",
+    "Path to a target.json (PocExecutionTarget: baseUrl, env, cwd, timeoutMs, personas)."
+  ).option(
+    "--fixture <name>",
+    "Run a built-in deterministic replay fixture. Supported: cli-path-traversal."
+  ).option(
+    "--fixture-command <json>",
+    "JSON argv array for the CLI under test. Supports {{apiUrl}}, {{exportDir}}, and {{fixtureMode}} placeholders."
+  ).option(
+    "--fixture-mode <mode>",
+    "Fixture behavior for --fixture: vulnerable or patched."
+  ).option(
+    "--retain-artifacts",
+    "Keep the fixture sandbox, harness metadata, and stdout/stderr logs.",
+    false
+  ).option(
+    "--artifact-dir <path>",
+    "Use this directory as the fixture sandbox root."
+  ).option("--format <fmt>", "Output format. Only 'json' is supported.", "json").option(
+    "--output <path>",
+    "Write the verification_result JSON to this path instead of stdout."
+  ).option(
+    "--kernel-finding <path>",
+    "Path to a kernel-review finding.json. Runs the Tier 2 agent loop to produce a reproducer and promote the finding via the kernel oracle. Requires ZERO_KERNEL_VERIFY=1."
+  ).option(
+    "--kernel-tree <path>",
+    "Linux source tree used by --kernel-finding for Tier 1 kernel build."
+  ).option(
+    "--kernel-config <profile>",
+    "Kernel build config profile for --kernel-finding (only 'kasan' supported).",
+    "kasan"
+  ).option(
+    "--attempts <N>",
+    "Max reproducer attempts for --kernel-finding (default 5)."
+  ).option(
+    "--wall-clock <duration>",
+    "Wall-clock budget for --kernel-finding (e.g. 30m, 90s; default 30m)."
+  ).action(async (positionalFinding, opts) => {
+    try {
+      await verifyAction(opts, positionalFinding);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const result = {
+        status: "error",
+        mode: "deterministic_replay",
+        finding_id: "unknown",
+        engine_version: VERSION,
+        started_at: now,
+        completed_at: now,
+        duration_ms: 0,
+        commands: [],
+        assertions: [],
+        evidence_artifacts: [],
+        engine_metadata: engineMetadata(),
+        summary: "Verifier failed before reaching a verdict.",
+        error_reason: reason
+      };
+      const json = JSON.stringify(result, null, 2);
+      if (opts.output) {
+        try {
+          writeFileSync(resolve(opts.output), json + "\n", "utf8");
+        } catch {
+          process.stderr.write(json + "\n");
+        }
+      } else {
+        process.stdout.write(json + "\n");
+      }
+      process.exitCode = 3;
+    }
+  });
+}
+
+// packages/cli/src/finding-workflow-executors.ts
+var defaults = {
+  propose: runSourceFix,
+  verifyCandidate: verifySourceFixCandidate,
+  applyCandidate: applySourceFixCandidate,
+  replay: runDeterministicReplayCli,
+  finding: loadFindingFocus
+};
+var text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function positive(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer.`);
+  return value;
+}
+function runner(inputs, options) {
+  const selected = text(inputs.runner) ?? options.runner;
+  if (selected !== "local" && selected !== "smolvm" && selected !== "docker" && selected !== "qemu") throw new Error("Verification requires an explicit local, smolvm, docker, or qemu runner.");
+  return selected;
+}
+async function authorizedPath(path, options, explicitlyAllowed) {
+  const resolved = await realpath(resolve2(path));
+  if (explicitlyAllowed && resolved === await realpath(resolve2(explicitlyAllowed))) return resolved;
+  const root = await realpath(options.workspace);
+  const suffix = relative(root, resolved);
+  if (isAbsolute(suffix) || suffix === ".." || suffix.startsWith(`..${sep2}`)) throw new Error("Workflow input is outside the authorized workspace.");
+  return resolved;
+}
+function hasFindingInput(inputs) {
+  return !!(inputs.finding || text(inputs.findingPath) || text(inputs.findingId) || text(inputs.fromStep));
+}
+async function validateFindingWorkflowInputs(workflow, runInputs, options) {
+  for (const node of workflow.nodes.filter((node2) => node2.enabled && (node2.type === "fix" || node2.type === "verify"))) {
+    const inputs = { ...runInputs, ...node.inputs, ...node.input };
+    if (node.inputs?.applyApproval !== void 0 || node.inputs?.allowApply === true) throw new Error("Application approval must be supplied by the host and current run, never stored in a workflow.");
+    if (node.type === "fix") {
+      await authorizedPath(workflow.target, options);
+      if (node.fix?.mode === "apply") {
+        if (!options.allowApply) throw new Error("This host has not authorized repository application.");
+        const approval = runInputs.applyApproval;
+        if (!text(approval?.candidateId) || approval?.approval !== "apply-to-repository") throw new Error("Repository application requires approval of an exact live candidate.");
+      } else if (!text(inputs.testCommand)) throw new Error("Source fix requires an explicit regression testCommand.");
+    }
+    if (!hasFindingInput(inputs) && !text(inputs.candidateId) && !text(inputs.artifactId)) throw new Error("A finding input or connected candidate artifact is required.");
+    const sourceStep = workflow.nodes.find((step) => step.id === text(inputs.fromStep));
+    if (node.type === "verify" && !text(inputs.candidateId) && !text(inputs.artifactId) && sourceStep?.type !== "fix") runner(inputs, options);
+    if (text(inputs.findingId) && !inputs.finding && !text(inputs.findingPath) && !text(inputs.fromStep) && !text(inputs.dbPath) && !options.dbPath) throw new Error("Persisted finding lookup requires an explicitly admitted database path.");
+    if (inputs.finding) findingSchema.parse(inputs.finding);
+    if (text(inputs.findingPath)) findingSchema.parse(JSON.parse(await readFile(await authorizedPath(text(inputs.findingPath), options), "utf8")));
+    if (text(inputs.dbPath)) await authorizedPath(text(inputs.dbPath), options, options.dbPath);
+    if (text(inputs.scopeFile)) await authorizedPath(text(inputs.scopeFile), options, options.scopeFile);
+    positive(inputs.testTimeoutMs, 3e5, "testTimeoutMs");
+    positive(inputs.maxAttempts, 3, "maxAttempts");
+    for (const key of ["qemuBinary", "qemuKernel", "qemuBusybox"]) if (text(inputs[key])) await authorizedPath(text(inputs[key]), options);
+  }
+}
+function createFindingCandidateStore(cleanup = async (repoRoot, worktree) => {
+  await promisify(execFile)("git", ["-C", repoRoot, "worktree", "remove", "--force", worktree]);
+}) {
+  const live = /* @__PURE__ */ new Map();
+  let disposed = false;
+  return {
+    get: (id) => disposed ? void 0 : live.get(id),
+    async put(id, result, repoRoot) {
+      if (disposed || live.size >= 32) {
+        if (result.candidate?.worktree) await cleanup(repoRoot, result.candidate.worktree);
+        throw new Error("Live candidate retention is unavailable; dispose completed candidate worktrees first.");
+      }
+      live.set(id, { result, repoRoot, worktree: result.candidate?.worktree });
+    },
+    async dispose() {
+      disposed = true;
+      const errors = [];
+      for (const [id, candidate] of live) {
+        if (candidate.worktree) {
+          try {
+            await cleanup(candidate.repoRoot, candidate.worktree);
+          } catch (error) {
+            errors.push(`${id}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+      }
+      live.clear();
+      if (errors.length) throw new Error(`Candidate cleanup failed: ${errors.join("; ")}`);
+    }
+  };
+}
+function createFindingWorkflowExecutors(options, dependencies = defaults) {
+  const candidates = options.candidateStore ?? createFindingCandidateStore();
+  const connectedCandidate = (context) => {
+    const explicit = text(context.inputs.candidateId) ?? text(context.inputs.artifactId);
+    const refs = context.priorOutputs.flatMap((output) => output.outputs).filter((output) => output.kind === "source-fix-candidate" || output.kind === "source-fix-verification").map((output) => text(output.value?.candidateId)).filter((id) => !!id);
+    if (explicit) {
+      if (!refs.includes(explicit) && !candidates.get(explicit)) throw new Error("Candidate must belong to a connected predecessor or this owning live host.");
+      return explicit;
+    }
+    return refs.length === 1 ? refs[0] : void 0;
+  };
+  const finding = async (context) => {
+    const inputs = context.inputs;
+    const findingId = text(inputs.findingId);
+    let result;
+    if (inputs.finding) result = findingSchema.parse(inputs.finding);
+    else if (text(inputs.findingPath)) result = findingSchema.parse(JSON.parse(await readFile(await authorizedPath(text(inputs.findingPath), options), "utf8")));
+    else {
+      const prior = context.priorReports.flatMap((report2) => report2.findings).filter((value) => !findingId || value.id === findingId);
+      if (prior.length === 1) result = findingSchema.parse(prior[0]);
+      else if (findingId && !text(inputs.fromStep)) {
+        const path = text(inputs.dbPath);
+        const dbPath = path ? await authorizedPath(path, options, options.dbPath) : options.dbPath;
+        if (!dbPath) throw new Error("Persisted finding lookup requires an explicitly admitted database path.");
+        result = dependencies.finding(findingId, { dbPath }).finding;
+      } else throw new Error("Select exactly one finding from connected assessment results.");
+    }
+    if (findingId && result.id !== findingId) throw new Error("Finding input identity does not match the selected finding.");
+    const verification = context.priorOutputs.flatMap((output) => output.outputs).find((output) => output.kind === "verification-result" && output.value?.finding_id === result.id);
+    return verification ? { ...result, verification_result: verification.value } : result;
+  };
+  const candidateOutput = (id, result) => ({ kind: "source-fix-candidate", value: {
+    candidateId: id,
+    findingId: result.findingId,
+    status: result.status,
+    patch: result.patch,
+    diff: result.diff,
+    sourceFile: result.sourceFile,
+    test: result.test,
+    applied: result.applied
+  }, artifactRefs: [id] });
+  return {
+    fix: async (context) => {
+      context.signal.throwIfAborted();
+      const repoRoot = await authorizedPath(context.target, options);
+      if (context.node.fix?.mode === "apply") {
+        if (!options.allowApply || context.node.inputs?.applyApproval !== void 0) throw new Error("Repository application is not authorized by this host.");
+        const id2 = connectedCandidate(context);
+        const live = id2 ? candidates.get(id2) : void 0;
+        const approval = context.inputs.applyApproval;
+        if (!live || live.repoRoot !== repoRoot || approval?.candidateId !== id2 || approval?.approval !== "apply-to-repository") throw new Error("Application requires approval of the exact process-owned live candidate.");
+        const result2 = await dependencies.applyCandidate(live.result, { approval: "apply-to-repository", signal: context.signal });
+        return { status: result2.status === "applied_and_retested" ? "completed" : "failed", outputs: [candidateOutput(id2, result2)], ...result2.error ? { error: result2.error } : {} };
+      }
+      const testCommand = text(context.inputs.testCommand);
+      if (!testCommand) throw new Error("Source fix requires an explicit regression testCommand.");
+      const runtime = workflowPolicyRuntime(budgetNativeRuntime(options.runtime, context.costLedger, context.signal, context.plan.costCapUsd, context.plan));
+      const result = await dependencies.propose({
+        repoRoot,
+        finding: await finding(context),
+        runtime,
+        testCommand,
+        apply: false,
+        keepWorktree: true,
+        signal: context.signal,
+        onProgress: options.onProgress,
+        maxAttempts: positive(context.inputs.maxAttempts, 3, "maxAttempts"),
+        testTimeoutMs: Math.min(positive(context.inputs.testTimeoutMs, 3e5, "testTimeoutMs"), Math.max(1, context.deadline - Date.now()))
+      });
+      const id = randomUUID();
+      if (result.status === "validated_candidate") await candidates.put(id, result, repoRoot);
+      return {
+        status: result.status === "error" || result.status === "precondition_failed" ? "failed" : "completed",
+        outputs: [{ ...candidateOutput(id, result), kind: result.status === "validated_candidate" ? "source-fix-candidate" : "source-fix-result" }],
+        ...result.error ? { error: result.error } : {}
+      };
+    },
+    verify: async (context) => {
+      context.signal.throwIfAborted();
+      const id = connectedCandidate(context);
+      if (id) {
+        const live = candidates.get(id);
+        if (!live || live.repoRoot !== await authorizedPath(context.target, options)) throw new Error("Verification requires a process-owned live candidate in this repository.");
+        const result = await dependencies.verifyCandidate(live.result, {
+          signal: context.signal,
+          testTimeoutMs: Math.min(positive(context.inputs.testTimeoutMs, 3e5, "testTimeoutMs"), Math.max(1, context.deadline - Date.now()))
+        });
+        return { status: "completed", outputs: [{ kind: "source-fix-verification", value: { ...candidateOutput(id, result).value, error: result.error, precondition: result.precondition, postcondition: result.postcondition } }] };
+      }
+      if (context.priorOutputs.some((output) => output.outputs.some((value) => value.kind === "source-fix-result"))) throw new Error("The connected source-fix step did not produce a validated live candidate.");
+      const selected = await finding(context);
+      const directory = await mkdtemp(join2(tmpdir2(), "0-workflow-finding-"));
+      try {
+        const findingPath = join2(directory, "finding.json");
+        await writeFile(findingPath, JSON.stringify(selected));
+        const scopeFile = text(context.inputs.scopeFile);
+        const replay = await dependencies.replay({
+          findingPath,
+          runner: runner(context.inputs, options),
+          signal: context.signal,
+          scopeFile: scopeFile ? await authorizedPath(scopeFile, options, options.scopeFile) : options.scopeFile,
+          dockerNetwork: text(context.inputs.dockerNetwork),
+          qemuBinary: text(context.inputs.qemuBinary) ? await authorizedPath(text(context.inputs.qemuBinary), options) : void 0,
+          qemuKernel: text(context.inputs.qemuKernel) ? await authorizedPath(text(context.inputs.qemuKernel), options) : void 0,
+          qemuBusybox: text(context.inputs.qemuBusybox) ? await authorizedPath(text(context.inputs.qemuBusybox), options) : void 0
+        });
+        return {
+          status: replay.result.status === "error" ? "failed" : "completed",
+          outputs: [{
+            kind: "verification-result",
+            value: replay.result,
+            artifactRefs: replay.result.evidence_artifacts.map((artifact) => artifact.path)
+          }],
+          ...replay.result.error_reason ? { error: replay.result.error_reason } : {}
+        };
+      } finally {
+        await rm(directory, { recursive: true, force: true });
+      }
+    }
+  };
+}
+
+// packages/cli/src/workflow-research-executors.ts
+import { mkdir, readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
+import { dirname, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3, sep as sep3 } from "node:path";
+var integer = external_exports.number().int().positive();
+var researchInputs = external_exports.object({
+  engine: external_exports.enum(["pipeline", "mobile", "linux-matrix", "linux"]).default("pipeline"),
+  artifactRoot: external_exports.string().min(1).optional(),
+  targetType: external_exports.enum(["url", "web-app", "source-code", "npm-package", "pypi-package", "cargo-package", "oci-image"]).optional(),
+  profile: external_exports.string().min(1).optional(),
+  matrixPath: external_exports.string().min(1).optional(),
+  reproducerPath: external_exports.string().min(1).optional(),
+  expectedSignature: external_exports.string().trim().min(1).optional(),
+  boots: integer.max(16).default(3),
+  minHits: integer.max(16).default(2),
+  findingId: external_exports.string().min(1).optional(),
+  fromStep: external_exports.string().optional(),
+  scanId: external_exports.string().optional(),
+  artifactId: external_exports.string().optional()
+});
+var deepInputs = external_exports.object({
+  profile: external_exports.string().min(1).optional(),
+  subsystem: external_exports.string().min(1).optional(),
+  models: external_exports.array(external_exports.string().min(1)).min(1).max(8).optional(),
+  attemptsPerCandidate: integer.max(16).optional(),
+  concurrency: integer.max(32).optional(),
+  maxCandidates: integer.max(5e3).optional(),
+  quorum: integer.max(32).optional(),
+  useThreatModel: external_exports.boolean().optional(),
+  fromStep: external_exports.string().optional(),
+  findingId: external_exports.string().optional(),
+  scanId: external_exports.string().optional(),
+  artifactId: external_exports.string().optional()
+});
+function contained(root, path) {
+  const suffix = relative2(root, path);
+  return !isAbsolute2(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep3}`);
+}
+async function scopedPath(workspace, input, existing = true) {
+  const root = await realpath2(workspace);
+  const path = resolve3(root, input);
+  let ancestor = path;
+  while (true) {
+    try {
+      const canonical = await realpath2(ancestor);
+      if (!contained(root, canonical)) throw new Error("Research path is outside the workflow workspace.");
+      if (existing && ancestor !== path) throw new Error("Research input path does not exist.");
+      return resolve3(canonical, relative2(ancestor, path));
+    } catch (error) {
+      if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
+      const parent = dirname(ancestor);
+      if (parent === ancestor) throw error;
+      ancestor = parent;
+    }
+  }
+}
+async function validateMatrixPaths(workspace, matrix) {
+  const manifest = JSON.parse(await readFile2(matrix, "utf8"));
+  for (const side of [manifest.vulnerable, manifest.patched]) {
+    if (!side || !Array.isArray(side.boots)) throw new Error("Invalid boot-matrix manifest sides.");
+    for (const boot of side.boots) {
+      if (typeof boot.logPath !== "string" || !boot.logPath) throw new Error("Boot-matrix logs require explicit paths.");
+      await scopedPath(workspace, resolve3(dirname(matrix), boot.logPath));
+    }
+  }
+}
+function report(context, findings, warnings, started) {
+  return {
+    target: context.target,
+    scanDepth: context.plan.depth,
+    startedAt: new Date(started).toISOString(),
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: Date.now() - started,
+    findings,
+    warnings: warnings.map((message) => ({ stage: "source-analysis", message })),
+    summary: {
+      totalAttacks: 0,
+      totalFindings: findings.length,
+      critical: findings.filter((f) => f.severity === "critical").length,
+      high: findings.filter((f) => f.severity === "high").length,
+      medium: findings.filter((f) => f.severity === "medium").length,
+      low: findings.filter((f) => f.severity === "low").length,
+      info: findings.filter((f) => f.severity === "info").length
+    }
+  };
+}
+function boundFinding(context, id, dbPath) {
+  const candidates = context.priorReports.flatMap((report2) => report2.findings);
+  if (id) return candidates.find((finding) => finding.id === id) ?? loadFindingFocus(id, { dbPath }).finding;
+  if (candidates.length === 1) return candidates[0];
+  throw new Error("Kernel research requires an exact findingId or one connected finding.");
+}
+async function validateResearchWorkflowInputs(type, inputs, scope) {
+  if (type === "deep-review") {
+    deepInputs.parse(inputs);
+    if (scope?.target) await scopedPath(scope.workspace, scope.target);
+    return;
+  }
+  const value = researchInputs.parse(inputs);
+  if (value.engine === "linux") throw new Error("Managed Linux reproducer research is unavailable: the kernel VM/build runner does not yet support workflow cancellation and deadlines. Use the explicit research linux command.");
+  if (scope) {
+    if (value.engine === "pipeline" && value.targetType && value.targetType !== "source-code") throw new Error("Managed local research requires targetType source-code.");
+    await scopedPath(scope.workspace, value.artifactRoot ?? ".0/workflow-artifacts", false);
+    if ((value.engine === "mobile" || value.engine === "pipeline") && scope.target) await scopedPath(scope.workspace, scope.target);
+    if (value.engine === "linux-matrix" && (value.matrixPath ?? scope.target)) {
+      const matrix = await scopedPath(scope.workspace, value.matrixPath ?? scope.target);
+      await validateMatrixPaths(scope.workspace, matrix);
+    }
+  }
+}
+function createResearchWorkflowExecutors(options) {
+  return {
+    research: async (context) => {
+      context.signal.throwIfAborted();
+      await validateResearchWorkflowInputs("research", context.inputs, { workspace: options.workspace, target: context.target });
+      const input = researchInputs.parse(context.inputs);
+      const artifactRoot = await scopedPath(options.workspace, input.artifactRoot ?? ".0/workflow-artifacts", false);
+      await mkdir(artifactRoot, { recursive: true });
+      const started = Date.now();
+      let result;
+      if (input.engine === "pipeline") {
+        const sourceTarget = await scopedPath(options.workspace, context.target);
+        const runtime = workflowPolicyRuntime(options.runtime);
+        const adapter = new UnifiedPipelineResearchAdapter((config) => runPipeline({
+          ...config,
+          nativeRuntime: runtime,
+          signal: context.signal,
+          costLedger: context.costLedger,
+          costCeilingUsd: context.plan.costCapUsd,
+          plan: context.plan,
+          timeout: Math.max(1, context.deadline - Date.now()),
+          model: options.model,
+          priorFindings: context.priorFindings
+        }));
+        result = await runResearch(adapter, {
+          kind: "pipeline.unified",
+          id: context.node.id,
+          location: sourceTarget,
+          config: { options: { depth: context.plan.depth, format: "json", runtime: "api", targetType: "source-code", ...input.profile ? { reviewProfile: input.profile } : {} } }
+        }, { artifactRoot, signal: context.signal });
+      } else if (input.engine === "mobile") {
+        const target = await scopedPath(options.workspace, context.target);
+        result = await runResearch(new MobileStaticResearchAdapter(), { kind: "mobile.static-intake", id: context.node.id, location: target, config: {} }, { artifactRoot, signal: context.signal });
+      } else {
+        const finding = boundFinding(context, input.findingId, options.dbPath);
+        if (input.engine === "linux-matrix") {
+          const matrix = await scopedPath(options.workspace, input.matrixPath ?? context.target);
+          result = await runResearch(new LinuxBootMatrixImportAdapter(), { kind: "linux.kernel-boot-matrix-import", id: context.node.id, location: matrix, config: { finding } }, { artifactRoot, signal: context.signal });
+          if (!result.candidates.length) return { status: "failed", error: "External boot-matrix manifest failed validation.", outputs: [{ kind: "research", value: result }] };
+        } else {
+          if (!input.reproducerPath || !input.expectedSignature) throw new Error("Linux research requires reproducerPath and expectedSignature.");
+          if (input.minHits > input.boots) throw new Error("minHits cannot exceed boots.");
+          const tree = await scopedPath(options.workspace, context.target);
+          const reproducer = await scopedPath(options.workspace, input.reproducerPath);
+          const verify = {
+            ...reproducer.endsWith(".syz") ? { syzProgramPath: reproducer } : { reproducerPath: reproducer },
+            boots: input.boots,
+            minHits: input.minHits,
+            expectedSignature: input.expectedSignature,
+            signal: context.signal
+          };
+          result = await runResearch(new LinuxKernelResearchAdapter(), { kind: "linux.kernel-reproducer", id: context.node.id, location: tree, config: { finding, verify } }, { artifactRoot, signal: context.signal });
+        }
+      }
+      return {
+        status: result.completed ? "completed" : "failed",
+        reports: [report(context, result.findings.map((item) => item.finding), result.warnings, started)],
+        outputs: [{ kind: "research", value: result, artifactRefs: result.envelopePath ? [result.envelopePath] : [] }]
+      };
+    },
+    "deep-review": async (context) => {
+      context.signal.throwIfAborted();
+      const input = deepInputs.parse(context.inputs);
+      const target = await scopedPath(options.workspace, context.target);
+      const selected = options.model ?? options.runtime.resolvedModel?.();
+      if (input.models?.some((model) => model !== selected)) throw new Error("Workflow deep review models must match its bound model connection.");
+      const { runDeepReview } = await import("./deep-review-DKED6EN5.js");
+      const result = await runDeepReview({
+        ...input,
+        target,
+        runtime: "api",
+        nativeRuntime: workflowPolicyRuntime(options.runtime),
+        signal: context.signal,
+        costLedger: context.costLedger,
+        plan: context.plan,
+        costCeilingUsd: context.plan.costCapUsd,
+        timeoutMs: Math.max(1, context.deadline - Date.now())
+      });
+      return {
+        status: result.exitCode === 0 ? "completed" : "failed",
+        reports: result.report ? [result.report] : [],
+        ...result.exitCode !== 0 ? { error: `Deep review did not complete (exit ${result.exitCode}).` } : {},
+        outputs: [{ kind: "deep-review", value: result }]
+      };
+    }
+  };
+}
+
+// packages/cli/src/workflow-runtime.ts
+var defaults2 = {
+  createRuntime: (options) => new LlmApiRuntime({ type: "api", ...options }),
+  assess: (options) => executeAssessment(options)
+};
+function bounded(value, fallback, maximum, name) {
+  const selected = value === void 0 ? fallback : fallback === void 0 ? value : Math.min(value, fallback);
+  if (selected !== void 0 && (!Number.isFinite(selected) || selected <= 0 || selected > maximum)) throw new Error(`${name} must be positive and at most ${maximum}.`);
+  return selected;
+}
+function contains(root, path) {
+  const suffix = relative3(root, path);
+  return !isAbsolute3(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep4}`);
+}
+function nodeLinks(run) {
+  const nodes = Object.fromEntries(run.workflow.nodes.map((node) => [node.id, { status: node.enabled ? run.status === "failed" ? "blocked" : run.status === "cancelled" ? "cancelled" : "queued" : "skipped" }]));
+  for (const event of run.events) {
+    if (event.type === "node_started") nodes[event.nodeId] = { status: "running" };
+    if (event.result) {
+      const { status, scanIds, dbPaths, error } = event.result;
+      nodes[event.nodeId] = { status, ...scanIds ? { scanIds } : {}, ...dbPaths ? { dbPaths } : {}, ...error ? { error } : {} };
+    }
+  }
+  if (run.result) for (const [id, result] of Object.entries(run.result.nodeResults)) {
+    const { status, scanIds, dbPaths, error } = result;
+    nodes[id] = { status, ...scanIds ? { scanIds } : {}, ...dbPaths ? { dbPaths } : {}, ...error ? { error } : {} };
+  }
+  return nodes;
+}
+function parseWorkflowRunInputs(value) {
+  return structuredClone(SecurityWorkflowBindingsSchema.parse(value ?? {}));
+}
+async function createCliWorkflowRuntime(options, dependencies = defaults2) {
+  if (!options.ownerId || options.ownerId.length > 128) throw new Error("A workflow runtime requires a valid owner.");
+  if (options.workspace && !isAbsolute3(options.workspace)) throw new Error("The authorized workspace must be an absolute path.");
+  const workspace = options.workspace ? await realpath3(options.workspace) : options.ownerId === "cli" ? await realpath3(process.cwd()) : void 0;
+  const scope = options.scopePath ? loadScope(options.scopePath) : void 0;
+  const scopeState = getScopeEnforcementState(workspace);
+  const store = new SecurityWorkflowStore(options.dbPath);
+  if (options.recoverInterrupted !== false) store.interruptActiveExecutions();
+  const candidateStore = createFindingCandidateStore();
+  const owned = /* @__PURE__ */ new Set();
+  const requests = /* @__PURE__ */ new Map();
+  const launches = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const service = new WorkflowService({ onChange: (run) => {
+    let retentionError;
+    if (run.result) {
+      try {
+        store.saveExecutionResults(run.id, run.result);
+      } catch (error) {
+        retentionError = `Workflow completed with results available in its owning host, but durable result retention failed: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+    const current = store.getExecution(run.id);
+    if (current && ["queued", "running"].includes(current.status)) store.updateExecution(run.id, {
+      status: run.status,
+      nodeResults: nodeLinks(run),
+      ...run.error || retentionError ? { error: (run.error ?? retentionError).slice(0, 16e3) } : {}
+    });
+  } });
+  const read = (id, operatorInspection = false) => {
+    const execution = store.getExecution(id);
+    if (!execution || execution.sessionId !== options.ownerId && !(operatorInspection && options.ownerId === "cli")) throw new Error("Workflow run was not found for this owner.");
+    return execution;
+  };
+  const preflight = async (target) => {
+    if (options.target && target.trim() !== options.target.trim()) throw new Error("Target does not match this workflow server's configured target.");
+    const resolution = resolveEngagement(target);
+    if (!resolution.ok) throw new Error(resolution.message);
+    const resolved = resolution.plan;
+    if (resolved.kind === "source") {
+      if (!workspace) throw new Error("Source workflows require an explicitly authorized --workspace.");
+      if (/^[a-z][a-z0-9+.-]*:\/\//i.test(resolved.target) || resolved.target.startsWith("git@")) {
+        if (options.ownerId !== "cli" && (!options.target || options.target.trim() !== target.trim())) throw new Error("Remote source workflows require a fixed --target and an authorized --workspace.");
+      } else if (!contains(workspace, await realpath3(resolved.target))) throw new Error("Source target is outside the authorized workspace.");
+    } else if (resolved.kind === "web") {
+      if (!scope) throw new Error("Live workflow targets require --scope.");
+      if (!scopeState.enabled) throw new Error("Live workflows require scope enforcement. Enable the scope plugin for this project with `0 plugin enable scope`.");
+      const verdict = scope.match(resolved.target);
+      if (!verdict.allowed) throw new Error(`Workflow target is out of scope: ${verdict.reason}`);
+    }
+    return resolved;
+  };
+  const start = async (request) => {
+    if (disposed) throw new Error("Workflow runtime is shutting down.");
+    if (Boolean(request.templateId) === Boolean(request.workflowId)) throw new Error("Select exactly one template or saved workflow.");
+    const target = request.target?.trim();
+    if (!target) throw new Error("A workflow target is required.");
+    const resolved = await preflight(target);
+    if (disposed) throw new Error("Workflow runtime is shutting down.");
+    const workflow = request.templateId ? createSecurityWorkflowTemplate(request.templateId, { revision: request.revision, target, targetType: resolved.targetType }) : store.get(request.workflowId);
+    if (!workflow) throw new Error("Workflow was not found.");
+    if (request.workflowId && request.revision !== void 0 && workflow.revision !== request.revision) throw new Error("Workflow revision changed; refresh before running.");
+    if (workflow.template) checkSecurityWorkflowTemplateTarget(getSecurityWorkflowTemplate(workflow.template.id, workflow.template.revision), resolved.targetType);
+    if (!workflow.nodes.some((node) => node.enabled && node.type !== "trigger" && node.type !== "report")) throw new Error("Enable at least one executable step before running.");
+    if (request.allowApply && !options.allowApply) throw new Error("This host does not authorize applying fixes.");
+    const inputs = parseWorkflowRunInputs(request.inputs);
+    const { createdAt: _createdAt, updatedAt: _updatedAt, ...portable } = workflow;
+    const definition = parseSecurityWorkflowInput({ ...portable, target });
+    const timeCapMs = bounded(request.timeCapMs, options.timeCapMs, 864e5, "Time cap");
+    const costCapUsd = bounded(request.costCapUsd, options.costCapUsd, 1e3, "Cost cap");
+    const fingerprint = createHash2("sha256").update(JSON.stringify({ definition, inputs, allowApply: request.allowApply === true, model: request.model ?? options.model, timeCapMs, costCapUsd })).digest("hex");
+    if (request.idempotencyKey) {
+      const previous = requests.get(request.idempotencyKey);
+      if (previous) {
+        if (previous.fingerprint !== fingerprint) throw new Error("Idempotency key belongs to a different workflow request.");
+        return read(previous.id);
+      }
+    }
+    const specialized = definition.nodes.filter((node) => node.enabled && !["trigger", "audit", "report"].includes(node.type));
+    if (specialized.length && (!workspace || resolved.kind !== "source" || /^[a-z][a-z0-9+.-]*:\/\//i.test(resolved.target) || resolved.target.startsWith("git@"))) {
+      throw new Error("Specialized workflows require a local source target inside the authorized workspace.");
+    }
+    for (const node of specialized) if (node.type === "research" || node.type === "deep-review") {
+      await validateResearchWorkflowInputs(node.type, { ...inputs, ...node.inputs, ...node.input }, { workspace, target: resolved.target });
+    }
+    const runtime = dependencies.createRuntime({ model: request.model ?? options.model, timeout: timeCapMs ?? 6e5 });
+    const needsModel = definition.nodes.some((node) => {
+      if (!node.enabled) return false;
+      if (node.type === "audit" || node.type === "deep-review") return true;
+      if (node.type === "fix") return node.fix?.mode !== "apply";
+      if (node.type === "research") {
+        const bindings = { ...inputs, ...node.inputs, ...node.input };
+        return bindings.engine === void 0 || bindings.engine === "pipeline";
+      }
+      return false;
+    });
+    if (needsModel && !await runtime.isAvailable()) throw new Error("Configure 0's model provider before starting this workflow.");
+    const findingOptions = { runtime, candidateStore, workspace: workspace ?? "", dbPath: options.dbPath, scopeFile: options.scopePath, allowApply: options.allowApply === true && request.allowApply === true };
+    await validateFindingWorkflowInputs({ ...definition, target: resolved.target }, inputs, findingOptions);
+    const executors = specialized.length ? { ...createFindingWorkflowExecutors(findingOptions), ...createResearchWorkflowExecutors({ runtime, workspace, dbPath: options.dbPath, model: request.model ?? options.model }) } : {};
+    for (const [operation, executor] of Object.entries(executors)) {
+      executors[operation] = (context) => withScopeEnforcement(scopeState, () => executor(context));
+    }
+    if (disposed) throw new Error("Workflow runtime is shutting down.");
+    const execution = store.createExecutionFromSnapshot({ ...definition, id: request.workflowId ?? `template-${request.templateId}`, revision: workflow.revision ?? 1 }, options.ownerId);
+    owned.add(execution.id);
+    if (request.idempotencyKey) requests.set(request.idempotencyKey, { id: execution.id, fingerprint });
+    service.start(options.ownerId, {
+      workflow: definition,
+      target: resolved.target,
+      timeCapMs,
+      costCapUsd,
+      inputs,
+      executors,
+      executeAssessment: async (context) => {
+        const scanIds = [];
+        const { report: report2 } = await withScopeEnforcement(scopeState, () => dependencies.assess({
+          target: resolved.target,
+          targetType: resolved.targetType,
+          reviewPackageEcosystem: resolved.ecosystem,
+          runtime: "api",
+          depth: context.plan.depth,
+          format: "json",
+          timeout: context.plan.timeCapMs,
+          plan: context.plan,
+          costCeilingUsd: context.plan.costCapUsd,
+          costLedger: context.costLedger,
+          nativeRuntime: workflowPolicyRuntime(runtime),
+          model: request.model ?? options.model,
+          scope,
+          scopeFile: options.scopePath,
+          signal: context.signal,
+          dbPath: options.dbPath,
+          priorFindings: context.priorFindings,
+          onEvent: (event) => {
+            const data = event?.data;
+            if (data?.persisted === true && typeof data.scanId === "string" && !scanIds.includes(data.scanId)) scanIds.push(data.scanId);
+          }
+        }));
+        const failed = report2.executionSuccessful === false || report2.costCeilingExceeded || ["failed", "error", "partial", "time_cap_exceeded", "cancelled"].includes(report2.exitReason ?? "");
+        return { status: report2.exitReason === "cancelled" ? "cancelled" : failed ? "failed" : "completed", reports: [report2], scanIds, ...options.dbPath ? { dbPaths: [options.dbPath] } : {}, ...report2.error ? { error: report2.error } : {} };
+      }
+    }, { id: execution.id });
+    return execution;
+  };
+  const getRun = (id) => {
+    const execution = read(id, true);
+    if (!owned.has(id)) return execution;
+    let view;
+    try {
+      view = service.get(options.ownerId, id);
+    } catch (error) {
+      if (!["queued", "running"].includes(execution.status)) return execution;
+      throw error;
+    }
+    return {
+      ...execution,
+      status: view.status,
+      nodeResults: nodeLinks(view),
+      error: view.error ?? execution.error,
+      ...view.cancellationRequestedAt ? { cancellationRequested: true, cancellationAcknowledged: true, cancellationRequestedAt: view.cancellationRequestedAt } : {},
+      events: view.events.map((event) => ({ ...event, result: event.result ? { status: event.result.status, scanIds: event.result.scanIds, dbPaths: event.result.dbPaths, error: event.result.error } : void 0, findings: void 0 })),
+      oldestSequence: view.oldestSequence,
+      eventsTruncated: view.eventsTruncated
+    };
+  };
+  return {
+    listTemplates: () => structuredClone(SECURITY_WORKFLOW_TEMPLATES),
+    getTemplate: (id) => getSecurityWorkflowTemplate(id),
+    listWorkflows: () => store.list(),
+    listRuns: () => store.listExecutions(void 0, options.ownerId).map((execution) => getRun(execution.id)),
+    getWorkflow: (id) => store.get(id),
+    saveWorkflow: (definition, expectedRevision) => {
+      const parsed = parseSecurityWorkflowInput(definition);
+      return store.save({ ...parsed, ...expectedRevision !== void 0 ? { revision: expectedRevision } : {} });
+    },
+    startRun: (request) => {
+      if (!request.idempotencyKey) return start(request);
+      const key = request.idempotencyKey;
+      const signature = JSON.stringify(request);
+      const active = launches.get(key);
+      if (active) {
+        if (active.signature !== signature) return Promise.reject(new Error("Idempotency key belongs to a different workflow request."));
+        return active.promise;
+      }
+      const launch = start(request);
+      launches.set(key, { signature, promise: launch });
+      void launch.finally(() => launches.delete(key)).catch(() => {
+      });
+      return launch;
+    },
+    getRun,
+    getRunResults: (id, page = {}) => {
+      const execution = read(id, true);
+      const cursor = page.cursor ?? 0;
+      const limit = page.limit ?? 100;
+      if (!Number.isSafeInteger(cursor) || cursor < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new Error("Invalid result page; limit must be 1\u2013100 and cursor nonnegative.");
+      let liveResult;
+      if (owned.has(id)) {
+        try {
+          liveResult = service.getResults(options.ownerId, id);
+        } catch (error) {
+          if (["queued", "running"].includes(execution.status)) throw error;
+        }
+      }
+      const result = liveResult ?? store.getExecutionResults(id);
+      if (!result) return { runId: id, findings: [], reports: [], nextCursor: null, retained: false, pending: ["queued", "running"].includes(execution.status), error: execution.error };
+      return {
+        runId: id,
+        status: result.status,
+        retained: true,
+        report: result.report ? { ...result.report, findings: result.findings.slice(cursor, cursor + limit) } : void 0,
+        findings: result.findings.slice(cursor, cursor + limit),
+        reports: result.reports.map((report2) => ({ ...report2, findings: void 0 })),
+        outputs: result.outputs,
+        nodeResults: nodeLinks({ result, workflow: result.workflow, events: [] }),
+        totalFindings: result.findings.length,
+        nextCursor: cursor + limit < result.findings.length ? cursor + limit : null,
+        costUsd: result.costUsd,
+        durationMs: result.durationMs,
+        error: result.error
+      };
+    },
+    cancelRun: (id) => {
+      const execution = read(id);
+      if (!owned.has(id)) {
+        if (["queued", "running"].includes(execution.status)) throw new Error("This run belongs to another host. Cancel it in its owning engine.");
+        return execution;
+      }
+      try {
+        service.cancel(options.ownerId, id);
+      } catch (error) {
+        if (["queued", "running"].includes(execution.status)) throw error;
+      }
+      return getRun(id);
+    },
+    dispose: async () => {
+      if (disposed) return;
+      disposed = true;
+      await Promise.allSettled([...launches.values()].map((launch) => launch.promise));
+      await service.dispose();
+      try {
+        await candidateStore.dispose();
+      } finally {
+        store.close();
+      }
+    }
+  };
+}
+
+export {
+  validateResearchWorkflowInputs,
+  createResearchWorkflowExecutors,
+  registerVerifyCommand,
+  validateFindingWorkflowInputs,
+  createFindingCandidateStore,
+  createFindingWorkflowExecutors,
+  parseWorkflowRunInputs,
+  createCliWorkflowRuntime
+};