0sec-cli 0.22.1 → 0.23.0

package/chunks/chunk-LT7BFGXA.js

@@ -0,0 +1,733 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+import {
+  captureObservation,
+  createEvolvedFinder,
+  loadAppsecFinderLenses
+} from "./chunk-4HGGNBKK.js";
+import {
+  loadEvolutionConfigFile
+} from "./chunk-AAA4PRWK.js";
+import {
+  resolveOsecRunStorage,
+  writeOsecRunReport
+} from "./chunk-T7ZEVY5G.js";
+import {
+  ScanCostLedger
+} from "./chunk-CP6HANBE.js";
+import {
+  eventBus
+} from "./chunk-A5QO7N3S.js";
+
+// packages/cli/src/commands/deep-review.ts
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { resolve, join, sep, relative } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+var DEEP_REVIEW_FILE_CAP = 5e3;
+var DEFAULT_MAX_CANDIDATES = 8;
+function defaultMaxCandidates() {
+  const raw = process.env["ZERO_DEEP_REVIEW_MAX_CANDIDATES"];
+  if (!raw) return DEFAULT_MAX_CANDIDATES;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_MAX_CANDIDATES;
+}
+function scaleMaxCandidates(fileCount) {
+  if (fileCount > 2e3) return 20;
+  if (fileCount > 500) return 16;
+  if (fileCount > 200) return 12;
+  return DEFAULT_MAX_CANDIDATES;
+}
+var DEFAULT_ATTEMPTS = 1;
+function defaultAttempts() {
+  const raw = process.env["ZERO_DEEP_REVIEW_ATTEMPTS"];
+  if (!raw) return DEFAULT_ATTEMPTS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_ATTEMPTS;
+}
+function defaultModels() {
+  const raw = process.env["ZERO_DEEP_REVIEW_MODELS"];
+  if (!raw) return void 0;
+  const models = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return models.length > 0 ? models : void 0;
+}
+var DEFAULT_CONCURRENCY = 8;
+var genericFinderLenses = [
+  {
+    id: "memory-safety",
+    challengeHint: "Hunt MEMORY-SAFETY bugs only: out-of-bounds read/write, use-after-free, double-free, uninitialized read, integer overflow feeding an allocation or index, and unchecked length/size arithmetic before a copy. Cite the exact unguarded sink (file:line) and the attacker-controlled path that reaches it."
+  },
+  {
+    id: "input-validation",
+    challengeHint: "Hunt INPUT-VALIDATION and injection bugs only: untrusted input reaching a dangerous sink without validation \u2014 command/SQL/path/template injection, unsafe deserialization, SSRF, unchecked redirects, or a parser that trusts attacker-supplied structure. Trace the taint from the entry point to the sink."
+  },
+  {
+    id: "auth-logic",
+    challengeHint: "Hunt AUTHZ / LOGIC bugs only: a missing or wrong permission/ownership check, a broken state machine, a TOCTOU race, an off-by-one or boundary error in a security-relevant decision, or a check that can be bypassed. Prove the guard is absent or mis-scoped, not merely that the keywords appear."
+  },
+  {
+    id: "secrets-crypto",
+    challengeHint: "Hunt SECRETS / CRYPTO misuse only: hardcoded credentials, a weak/predictable RNG used for security, a broken or misused cryptographic primitive (ECB, static IV/nonce, missing MAC verification, non-constant-time compare), or a signature/token check that can be forged or replayed. Cite the exact misuse."
+  },
+  {
+    id: "cross-component",
+    challengeHint: "Hunt CROSS-COMPONENT bugs only: a bug whose exploit path spans two or more subsystems touching DIFFERENT trust boundaries \u2014 e.g. an API layer that passes unvalidated user input to a kernel driver, a storage layer whose consistency assumptions are violated by a separate async path, or a UX component whose state bleeds into an auth decision in a sibling module. Trace the path ACROSS the boundary and prove the attacker can reach BOTH sides. Ignore bugs fully contained within a single component."
+  }
+];
+function lensSetDigest(lenses) {
+  return createHash("sha256").update(JSON.stringify(lenses.map(({ id, challengeHint }) => ({ id, challengeHint })))).digest("hex");
+}
+function createDefaultFinderLenses() {
+  return [...genericFinderLenses, ...loadAppsecFinderLenses()];
+}
+var defaultFinderLenses = createDefaultFinderLenses();
+var defaultVerifyLenses = [
+  {
+    id: "reachability",
+    challengeHint: "REACHABILITY: is the vulnerable code actually reachable by an attacker from a real entry point (exported/public API, request handler, CLI, parser) with no gate it cannot pass? Trace the concrete path from the entry to the sink. If the path is dead code, disabled, or privileged-only, refute it."
+  },
+  {
+    id: "completeness",
+    challengeHint: "COMPLETENESS: is the 'missing' check actually enforced elsewhere on the path \u2014 a validation earlier in the flow, a guard in the only caller, a wrapper that sanitizes first? Read the whole call path and the full file/module. If the guard is present AND correctly scoped, refute it; keep it only if genuinely absent or mis-scoped."
+  },
+  {
+    id: "novelty-known-issue",
+    challengeHint: "NOVELTY / KNOWN-GUARD: is the standard guard for this class present and correct (a framework escaper, a safe API, a bounds check, a working auth middleware)? Is this a well-known already-mitigated pattern in this codebase or its dependencies? If a correct standard guard covers it, refute it."
+  },
+  {
+    id: "scope",
+    challengeHint: "SCOPE / IMPACT: does exploiting this actually corrupt memory, leak secrets, escalate privilege, execute code, or move value / break a security invariant? A cosmetic missing check with no real impact is info/low, not a high-severity finding \u2014 refute it as such."
+  },
+  {
+    id: "deployment-context",
+    challengeHint: "DEPLOYMENT CONTEXT: is this finding's vulnerable code path actually deployed to a production runtime, or is it restricted to development, test, or build-only surfaces? \n\nYour job is to examine the finding's evidence AND your own reading of the candidate source to decide: can an attacker reach this code from a production entry point? \n\n- If the code is in a test file, a dev-only config (seeds, .dev.vars, dev-server), or build scaffolding (webpack, CI, vendored deps) with NO trust-boundary crossing from prod, refute it as dev/test/build-only.\n- If you find a trust-boundary bypass \u2014 a prod-routed entry point that reaches this code despite it being in a dev/test/build file \u2014 DO NOT refute; the finding is valid per the HackerOne rule.\n- If you are UNCERTAIN (the evidence is ambiguous or you cannot assess the deployment topology), ABSTAIN by returning an error. Never falsely refute a finding with weak evidence.\nPRIORITY: the mechanical path heuristic (file path classification) is the DETERMINISTIC FLOOR and overrides this lens on conflict. If the heuristic already tagged the finding as dev_only/test_only/build_only, the severity cap has already been applied \u2014 this lens exists to catch cases the heuristic misses (ambiguous paths, model-extracted evidence, cross-boundary reachability)."
+  }
+];
+function selectProfileLenses(profile, sets, defaultFinderSnapshot = defaultFinderLenses) {
+  switch ((profile ?? "").trim().toLowerCase()) {
+    case "evm-onchain":
+      return { finderLenses: sets.evmFinderLenses, verifyLenses: sets.evmVerifyLenses, matchedProfile: "evm-onchain" };
+    case "solana-onchain":
+      return { finderLenses: sets.solanaFinderLenses, verifyLenses: sets.solanaVerifyLenses, matchedProfile: "solana-onchain" };
+    case "cardano-onchain":
+      return { finderLenses: sets.cardanoFinderLenses, verifyLenses: sets.cardanoVerifyLenses, matchedProfile: "cardano-onchain" };
+    case "cairo-onchain":
+      return { finderLenses: sets.cairoFinderLenses, verifyLenses: sets.cairoVerifyLenses, matchedProfile: "cairo-onchain" };
+    case "move-onchain":
+      return { finderLenses: sets.moveFinderLenses, verifyLenses: sets.moveVerifyLenses, matchedProfile: "move-onchain" };
+    default:
+      return { finderLenses: defaultFinderSnapshot, verifyLenses: defaultVerifyLenses, matchedProfile: "default" };
+  }
+}
+var NATIVE_SOURCE_EXTS = /* @__PURE__ */ new Set([
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "cxx",
+  "hpp",
+  "hh",
+  "hxx",
+  "rs"
+]);
+var MANAGED_WEB_EXTS = /* @__PURE__ */ new Set([
+  "cs",
+  "csproj",
+  "sln",
+  "vbproj",
+  "fsproj",
+  // .NET / C#
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "vue",
+  "svelte",
+  // JS/TS front+back
+  "java",
+  "kt",
+  "kts",
+  "scala",
+  // JVM
+  "py",
+  "rb",
+  "php",
+  "go",
+  // scripting / Go
+  "html",
+  "htm",
+  "cshtml",
+  "razor",
+  "aspx",
+  "jsp"
+  // web templates
+]);
+function fileExt(path) {
+  const base = path.split(/[/\\]+/).pop() ?? path;
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
+}
+function detectStack(files) {
+  let native = 0;
+  let managed = 0;
+  for (const f of files) {
+    const ext = fileExt(f);
+    if (NATIVE_SOURCE_EXTS.has(ext)) native++;
+    else if (MANAGED_WEB_EXTS.has(ext)) managed++;
+  }
+  if (native === 0 && managed === 0) return "unknown";
+  if (native === 0) return "managed-web";
+  if (managed === 0) return "native";
+  return "mixed";
+}
+var MEMORY_SAFETY_LENS_ID = "memory-safety";
+function selectDefaultFinderLensesForStack(files, defaultFinder) {
+  if (detectStack(files) === "managed-web") {
+    return defaultFinder.filter((l) => l.id !== MEMORY_SAFETY_LENS_ID);
+  }
+  return defaultFinder;
+}
+var EVM_EXCLUDE_DIR_SEGMENTS = /* @__PURE__ */ new Set([
+  "test",
+  "tests",
+  "mock",
+  "mocks",
+  "script",
+  "scripts",
+  // Foundry deploy scripts
+  "lib",
+  // Foundry vendored deps (forge-std / openzeppelin / solmate …)
+  "node_modules"
+  // Hardhat/JS vendored deps (also skipped by the core walker)
+]);
+function isNonProtocolEvmPath(absPath, scopeRoot) {
+  const rel = relative(scopeRoot, absPath);
+  if (rel === "" || rel.startsWith("..")) return false;
+  const segments = rel.split(/[/\\]+/).filter(Boolean);
+  if (segments.length === 0) return false;
+  for (let i = 0; i < segments.length - 1; i++) {
+    if (EVM_EXCLUDE_DIR_SEGMENTS.has(segments[i].toLowerCase())) return true;
+  }
+  const fileName = segments[segments.length - 1].toLowerCase();
+  if (fileName.endsWith(".t.sol")) return true;
+  if (fileName.includes(".test.") || fileName.includes(".spec.")) return true;
+  return false;
+}
+function topLevelModule(absPath, scopeRoot) {
+  const rel = relative(scopeRoot, absPath);
+  if (rel === "" || rel.startsWith("..")) return ".";
+  const segments = rel.split(/[/\\]+/).filter(Boolean);
+  return segments.length > 1 ? segments[0] : ".";
+}
+function selectCandidatesModuleSpread(entries, scopeRoot, maxCandidates) {
+  const cmp = (a, b) => b.size - a.size || a.p.localeCompare(b.p);
+  const byModule = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key = topLevelModule(e.p, scopeRoot);
+    let group = byModule.get(key);
+    if (!group) byModule.set(key, group = []);
+    group.push(e);
+  }
+  const groups = [...byModule.values()];
+  for (const g of groups) g.sort(cmp);
+  groups.sort((a, b) => cmp(a[0], b[0]));
+  const cap = Math.max(1, maxCandidates);
+  const out = [];
+  for (let round = 0; out.length < cap; round++) {
+    let advanced = false;
+    for (const g of groups) {
+      if (round >= g.length) continue;
+      out.push(g[round].p);
+      advanced = true;
+      if (out.length >= cap) break;
+    }
+    if (!advanced) break;
+  }
+  return out;
+}
+function enumerateDeepReviewCandidates(scopeRoot, helpers, opts) {
+  const fileCap = opts.fileCap ?? DEEP_REVIEW_FILE_CAP;
+  const exclude = opts.exclude ?? (() => false);
+  const fileSize = helpers.fileSize ?? ((p) => {
+    try {
+      return statSync(p).size;
+    } catch {
+      return 0;
+    }
+  });
+  const totalFiles = helpers.countScopeFilesUpTo(scopeRoot, fileCap);
+  const overCap = totalFiles > fileCap;
+  const files = helpers.collectScopeFiles(scopeRoot, { maxFiles: fileCap });
+  const entries = files.filter((p) => !exclude(p)).map((p) => ({ p, size: fileSize(p) }));
+  const candidates = selectCandidatesModuleSpread(entries, scopeRoot, opts.maxCandidates);
+  return { candidates, totalFiles, overCap };
+}
+async function runDeepReview(opts) {
+  const defaultFinderSnapshot = createDefaultFinderLenses();
+  const evolvedFinder = opts.evolutionConfig ? await createEvolvedFinder(opts.evolutionConfig, `deep-review-${randomUUID()}`) : void 0;
+  const {
+    runHuntScan,
+    makeMultiLensVerifier,
+    prepare,
+    collectScopeFiles,
+    countScopeFilesUpTo,
+    evmFinderLenses,
+    evmVerifyLenses,
+    solanaFinderLenses,
+    solanaVerifyLenses,
+    cardanoFinderLenses,
+    cardanoVerifyLenses,
+    cairoFinderLenses,
+    cairoVerifyLenses,
+    moveFinderLenses,
+    moveVerifyLenses
+  } = await import("./dist-4LGRIBOC.js");
+  opts.signal?.throwIfAborted();
+  const costLedger = opts.costLedger ?? new ScanCostLedger();
+  const scanStartedAt = Date.now();
+  const log = opts.log ?? (() => {
+  });
+  const runtime = opts.runtime ?? "api";
+  const explicitMaxCandidates = opts.maxCandidates;
+  const hasEnvMaxOverride = !!process.env["ZERO_DEEP_REVIEW_MAX_CANDIDATES"];
+  const baseMaxCandidates = explicitMaxCandidates ?? defaultMaxCandidates();
+  if (evolvedFinder && opts.models?.length) throw new Error("--models selects native finders and cannot be combined with --evolution-config");
+  const models = evolvedFinder ? ["evolved-source"] : opts.models ?? defaultModels();
+  const attemptsPerCandidate = opts.attemptsPerCandidate ?? defaultAttempts();
+  const prepared = await prepare(opts.target, "source-code", { ...opts.timeoutMs ? { timeout: opts.timeoutMs } : {} }, (e) => {
+    if (e.message) log(`[deep-review:source] ${e.message}`);
+  });
+  const sourceRoot = resolve(prepared.resolvedTarget);
+  let scopeRoot = sourceRoot;
+  if (opts.subsystem && opts.subsystem.trim() !== "") {
+    const scoped = resolve(join(sourceRoot, opts.subsystem));
+    if (scoped !== sourceRoot && !scoped.startsWith(sourceRoot + sep)) {
+      prepared.cleanup();
+      throw new Error(`--subsystem '${opts.subsystem}' escapes the source tree`);
+    }
+    try {
+      const realRoot = realpathSync(sourceRoot);
+      const realScoped = realpathSync(scoped);
+      if (realScoped !== realRoot && !realScoped.startsWith(realRoot + sep)) {
+        throw new Error(`--subsystem '${opts.subsystem}' escapes the source tree`);
+      }
+      scopeRoot = scoped;
+    } catch (error) {
+      prepared.cleanup();
+      throw error;
+    }
+  }
+  try {
+    const isEvmProfile = (opts.profile ?? "").trim().toLowerCase() === "evm-onchain";
+    const totalFiles = countScopeFilesUpTo(scopeRoot, DEEP_REVIEW_FILE_CAP);
+    const maxCandidates = explicitMaxCandidates ?? (hasEnvMaxOverride ? baseMaxCandidates : scaleMaxCandidates(totalFiles));
+    const overCap = totalFiles > DEEP_REVIEW_FILE_CAP;
+    if (explicitMaxCandidates === void 0 && maxCandidates !== baseMaxCandidates) {
+      log(`[deep-review] auto-scaled candidate cap from ${baseMaxCandidates} to ${maxCandidates} (${totalFiles} scope files)`);
+    }
+    let lanes = null;
+    let allocateAcrossLanes;
+    if (opts.useThreatModel) {
+      const threatModule = await import("./dist-4LGRIBOC.js");
+      allocateAcrossLanes = threatModule.allocateCandidatesAcrossLanes;
+      const rtType = runtime !== "auto" ? runtime : "api";
+      const plannerRuntime = opts.nativeRuntime ? {
+        type: opts.nativeRuntime.type,
+        isAvailable: () => opts.nativeRuntime.isAvailable(),
+        execute: async (prompt, context) => {
+          const budgeted = threatModule.budgetNativeRuntime(opts.nativeRuntime, costLedger, opts.signal, opts.costCeilingUsd, opts.plan);
+          const started = Date.now();
+          const result = await budgeted.executeNative(context?.systemPrompt ?? "", [{ role: "user", content: [{ type: "text", text: prompt }] }], [], void 0, opts.signal);
+          return { output: result.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("\n"), exitCode: result.stopReason === "error" ? 1 : 0, timedOut: false, durationMs: Date.now() - started };
+        }
+      } : threatModule.createRuntime({
+        type: rtType,
+        timeout: opts.timeoutMs ?? 6e5,
+        model: models?.[0]
+      });
+      const trackedPlanner = !opts.nativeRuntime && opts.plan ? {
+        ...plannerRuntime,
+        type: plannerRuntime.type,
+        isAvailable: () => plannerRuntime.isAvailable(),
+        execute: async (prompt, context) => {
+          opts.signal?.throwIfAborted();
+          const result = await plannerRuntime.execute(prompt, { ...context, signal: opts.signal });
+          if (result.usageByModel?.length) for (const bucket of result.usageByModel) costLedger.add(bucket.usage, bucket.model);
+          else if (result.usage) costLedger.add(result.usage, models?.[0]);
+          else costLedger.markUnpricedUsage();
+          return result;
+        }
+      } : plannerRuntime;
+      lanes = await threatModule.runThreatModelPlanner(sourceRoot, trackedPlanner, log);
+      if (!lanes || lanes.length === 0) {
+        log("[threat-model] no lanes produced \u2014 continuing with default selection");
+      } else {
+        log(`[threat-model] planner returned ${lanes.length} lane(s) \u2014 will allocate candidates across boundaries`);
+      }
+    }
+    if (overCap) {
+      return {
+        exitCode: 2,
+        result: {
+          mode: "deep_review",
+          source: sourceRoot,
+          subsystem: opts.subsystem ?? null,
+          scope_files: totalFiles,
+          note: `scope exceeds the ${DEEP_REVIEW_FILE_CAP}-file review cap \u2014 narrow it with --subsystem <path> to a specific directory.`
+        }
+      };
+    }
+    const { candidates: initialCandidates } = enumerateDeepReviewCandidates(
+      scopeRoot,
+      { collectScopeFiles, countScopeFilesUpTo },
+      {
+        maxCandidates,
+        fileCap: DEEP_REVIEW_FILE_CAP,
+        ...isEvmProfile ? { exclude: (p) => isNonProtocolEvmPath(p, scopeRoot) } : {}
+      }
+    );
+    const candidatePaths = initialCandidates.slice();
+    if (lanes && lanes.length > 0 && allocateAcrossLanes) {
+      const allFiles = collectScopeFiles(scopeRoot, { maxFiles: DEEP_REVIEW_FILE_CAP });
+      const exclude = isEvmProfile ? (p) => isNonProtocolEvmPath(p, scopeRoot) : () => false;
+      const entries = allFiles.filter((p) => !exclude(p)).map((p) => {
+        try {
+          return { p, size: statSync(p).size };
+        } catch {
+          return { p, size: 0 };
+        }
+      });
+      const laneCandidates = allocateAcrossLanes(entries, lanes, scopeRoot, maxCandidates, log);
+      if (laneCandidates.length > 0) {
+        const prevModules = new Set(initialCandidates.map((p) => relative(scopeRoot, p).split(/[/\\]+/)[0]));
+        const laneModules = new Set(laneCandidates.map((p) => relative(scopeRoot, p).split(/[/\\]+/)[0]));
+        log(`[deep-review] threat-model re-allocated ${initialCandidates.length} \u2192 ${laneCandidates.length} candidate(s); modules ${prevModules.size} \u2192 ${laneModules.size}`);
+        candidatePaths.length = 0;
+        candidatePaths.push(...laneCandidates);
+      }
+    }
+    if (candidatePaths.length === 0) {
+      return {
+        exitCode: 2,
+        result: {
+          mode: "deep_review",
+          source: sourceRoot,
+          subsystem: opts.subsystem ?? null,
+          scope_files: totalFiles,
+          candidates: 0,
+          note: "no reviewable source files found under the scope (empty tree or all filtered)."
+        }
+      };
+    }
+    const { finderLenses: selectedFinderLenses, verifyLenses, matchedProfile } = selectProfileLenses(opts.profile, {
+      evmFinderLenses,
+      evmVerifyLenses,
+      solanaFinderLenses,
+      solanaVerifyLenses,
+      cardanoFinderLenses,
+      cardanoVerifyLenses,
+      cairoFinderLenses,
+      cairoVerifyLenses,
+      moveFinderLenses,
+      moveVerifyLenses
+    }, defaultFinderSnapshot);
+    const finderLenses = matchedProfile === "default" ? selectDefaultFinderLensesForStack(candidatePaths, selectedFinderLenses) : selectedFinderLenses;
+    const lensDigest = lensSetDigest(finderLenses);
+    const scanId = randomUUID();
+    let sourceRevisionDigest = null;
+    let sourceFingerprintWarning;
+    try {
+      const files = [...candidatePaths].sort().map((path) => ({
+        path: relative(sourceRoot, path),
+        digest: createHash("sha256").update(readFileSync(path)).digest("hex")
+      }));
+      sourceRevisionDigest = `sha256:${createHash("sha256").update(JSON.stringify(files)).digest("hex")}`;
+    } catch (error) {
+      sourceFingerprintWarning = `learning feedback skipped: reviewed inputs could not be fingerprinted (${error instanceof Error ? error.message : String(error)})`;
+      log(`[deep-review] ${sourceFingerprintWarning}`);
+    }
+    log(
+      `[deep-review] ${candidatePaths.length} candidate file(s) (of ${totalFiles}${overCap ? "+" : ""}) \xD7 ${finderLenses.length} finder-lens(es); verify quorum over ${verifyLenses.length} lens(es); profile=${matchedProfile}; lens-snapshot=${lensDigest.slice(0, 12)}`
+    );
+    const verify = makeMultiLensVerifier(verifyLenses, {
+      sourceRoot,
+      runtime,
+      ...!evolvedFinder && models?.[0] ? { model: models[0] } : {},
+      // Every verify lens is a refute pass on `models[0]` — the same model the
+      // finders ran on. Passing the full finder set lets the cross-family
+      // selector move the refutation off ALL finder families when a second
+      // provider is configured (#661), and `log` records what it decided —
+      // including "it could not", which is the case worth knowing about.
+      ...opts.costCeilingUsd !== void 0 ? { costCeilingUsd: opts.costCeilingUsd } : {},
+      costLedger,
+      ...opts.plan ? { plan: opts.plan } : {},
+      ...opts.signal ? { signal: opts.signal } : {},
+      ...opts.nativeRuntime ? { nativeRuntime: opts.nativeRuntime, crossFamilyRefute: false } : {},
+      ...!evolvedFinder && models && models.length > 0 ? { finderModels: models } : {},
+      ...opts.quorum ? { quorum: opts.quorum } : {},
+      log
+    });
+    const res = await runHuntScan({
+      sourceRoot,
+      candidates: candidatePaths.map((path) => ({ path })),
+      lenses: finderLenses,
+      runtime,
+      ...evolvedFinder ? { finder: (input) => evolvedFinder.find(sourceRoot, input) } : {},
+      concurrency: opts.concurrency ?? DEFAULT_CONCURRENCY,
+      ...opts.costCeilingUsd !== void 0 ? { costCeilingUsd: opts.costCeilingUsd } : {},
+      costLedger,
+      ...opts.plan ? { plan: opts.plan } : {},
+      ...opts.signal ? { signal: opts.signal } : {},
+      ...opts.nativeRuntime ? { nativeRuntime: opts.nativeRuntime } : {},
+      attemptsPerCandidate,
+      ...models ? { models } : {},
+      verify,
+      log
+    });
+    const leads = res.confirmed;
+    if (sourceFingerprintWarning) res.warnings.push(sourceFingerprintWarning);
+    if (sourceRevisionDigest) {
+      try {
+        for (const gap of res.incompleteCoverage ?? []) {
+          captureObservation({
+            classHint: gap.lensId || "generic-finder-timeout",
+            sinkPattern: "",
+            exampleFileLine: gap.file,
+            whyMissed: `finder ${gap.reason}; budget ${gap.budgetMs}ms`,
+            source: "incomplete-coverage",
+            scanId,
+            sourceRevisionDigest,
+            consent: false,
+            detectorLensId: gap.lensId || void 0,
+            detectorLensVersionDigest: gap.lensVersionDigest
+          });
+        }
+        for (const dropped of res.dropped ?? []) {
+          if (dropped.dropReason === "verify_refuted" || dropped.dropReason === "novelty_duplicate" || dropped.dropReason === "judge_truncation" || dropped.dropReason === "late_resolution") continue;
+          captureObservation({
+            classHint: dropped.lensId || "unknown-lens",
+            sinkPattern: "",
+            exampleFileLine: dropped.candidatePath,
+            whyMissed: `dropped: ${dropped.dropReason}`,
+            source: "incomplete-coverage",
+            scanId,
+            sourceRevisionDigest,
+            consent: false,
+            detectorLensId: dropped.lensId || void 0,
+            detectorLensVersionDigest: dropped.lensVersionDigest
+          });
+        }
+      } catch (error) {
+        const warning = `learning feedback was not persisted: ${error instanceof Error ? error.message : String(error)}`;
+        res.warnings.push(warning);
+        log(`[deep-review] ${warning}`);
+      }
+    }
+    const sweptNothing = res.scanned > 0 && typeof res.finderCompleted === "number" && res.finderCompleted === 0;
+    const cost = costLedger.costBreakdown();
+    eventBus.emit("scan_completed", {
+      exit_reason: sweptNothing ? "failed" : res.costCeilingExceeded ? "cost_exceeded" : "completed",
+      findings: res.findings.length,
+      findings_count: res.findings.length,
+      duration_ms: Date.now() - scanStartedAt,
+      summary: res.costCeilingExceeded ? `Deep review stopped at the $${opts.costCeilingUsd?.toFixed(2) ?? "configured"} cost ceiling.` : `Deep review completed: ${res.scanned} finder runs, ${res.findings.length} findings, ${leads.length} leads.`,
+      ...cost ? { cost_usd: cost.costUsd, cost_breakdown: cost.breakdown } : {}
+    });
+    if (sweptNothing) {
+      return {
+        exitCode: 3,
+        result: {
+          mode: "deep_review",
+          profile: matchedProfile,
+          scan_id: scanId,
+          source_revision_digest: sourceRevisionDigest,
+          lens_snapshot_digest: lensDigest,
+          ...evolvedFinder ? { evolution_version_id: evolvedFinder.versionId, evolution_compute_cost_usd: evolvedFinder.computeCostUsd } : {},
+          source: sourceRoot,
+          subsystem: opts.subsystem ?? null,
+          scope_files: totalFiles,
+          candidates: candidatePaths.length,
+          scanned: res.scanned,
+          finder_completed: res.finderCompleted,
+          finder_timed_out: res.finderTimedOut ?? null,
+          finder_errored: res.finderErrored ?? null,
+          error: `every finder run failed (0 of ${res.scanned} completed) \u2014 no coverage was produced; treating as a backend/LLM failure, not a clean 0-finding result.`,
+          warnings: res.warnings.slice(0, 10)
+        }
+      };
+    }
+    const completedAt = /* @__PURE__ */ new Date();
+    const candidateFindings = leads.map((lead) => ({
+      ...lead,
+      status: "discovered"
+    }));
+    const report = {
+      target: opts.target,
+      scanDepth: "deep",
+      startedAt: new Date(scanStartedAt).toISOString(),
+      completedAt: completedAt.toISOString(),
+      durationMs: completedAt.getTime() - scanStartedAt,
+      summary: {
+        totalAttacks: res.scanned,
+        totalFindings: candidateFindings.length,
+        critical: candidateFindings.filter((finding) => finding.severity === "critical").length,
+        high: candidateFindings.filter((finding) => finding.severity === "high").length,
+        medium: candidateFindings.filter((finding) => finding.severity === "medium").length,
+        low: candidateFindings.filter((finding) => finding.severity === "low").length,
+        info: candidateFindings.filter((finding) => finding.severity === "info").length
+      },
+      findings: candidateFindings,
+      warnings: res.warnings.slice(0, 10).map((message) => ({
+        stage: "attack",
+        message
+      })),
+      ...res.costCeilingExceeded ? { costCeilingExceeded: true, exitReason: "cost_ceiling_exceeded" } : {}
+    };
+    return {
+      exitCode: 0,
+      report,
+      result: {
+        mode: "deep_review",
+        profile: matchedProfile,
+        scan_id: scanId,
+        source_revision_digest: sourceRevisionDigest,
+        source: sourceRoot,
+        subsystem: opts.subsystem ?? null,
+        scope_files: totalFiles,
+        lens_snapshot_digest: lensDigest,
+        ...evolvedFinder ? { evolution_version_id: evolvedFinder.versionId, evolution_compute_cost_usd: evolvedFinder.computeCostUsd } : {},
+        candidates: candidatePaths.length,
+        finder_lenses: finderLenses.map((l) => l.id),
+        verify_lenses: verifyLenses.map((l) => l.id),
+        scanned: res.scanned,
+        findings: res.findings.length,
+        confirmed: leads.length,
+        leads: leads.map((f) => ({
+          title: f.title,
+          severity: f.severity,
+          analysis: f.evidence.analysis ?? ""
+        })),
+        dropped: res.dropped.map((d) => ({
+          title: d.finding.title,
+          severity: d.finding.severity,
+          candidatePath: d.candidatePath,
+          lensId: d.lensId,
+          dropReason: d.dropReason,
+          detail: d.detail
+        })),
+        warnings: res.warnings.slice(0, 10),
+        note: "LEADS, not confirmed bugs. Each survived the multi-lens refute quorum; verify the real sink + impact before disclosure."
+      }
+    };
+  } catch (error) {
+    const cost = costLedger.costBreakdown();
+    eventBus.emit("scan_completed", {
+      exit_reason: "failed",
+      findings: 0,
+      findings_count: 0,
+      duration_ms: Date.now() - scanStartedAt,
+      summary: `Deep review failed: ${error instanceof Error ? error.message : String(error)}`,
+      ...cost ? { cost_usd: cost.costUsd, cost_breakdown: cost.breakdown } : {}
+    });
+    throw error;
+  } finally {
+    prepared.cleanup();
+  }
+}
+function parsePositive(flag, raw, dflt) {
+  if (raw === void 0) return dflt;
+  const n = parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) throw new Error(`invalid ${flag} '${raw}' (expected positive integer)`);
+  return n;
+}
+async function deepReviewAction(target, opts) {
+  if (!target || target.trim() === "") throw new Error("missing required argument: <target> (source tree path or git URL)");
+  const ceilingSource = opts.costCeiling ?? process.env["ZERO_COST_CEILING_USD"];
+  let costCeilingUsd;
+  if (ceilingSource !== void 0 && ceilingSource !== "") {
+    const parsed = Number(ceilingSource);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new Error(`invalid --cost-ceiling '${ceilingSource}' (expected positive USD amount)`);
+    }
+    costCeilingUsd = parsed;
+  }
+  const { writeFileSync } = await import("node:fs");
+  const { executeManagedOperation } = await import("./managed-operation-YNQQEA5V.js");
+  const timeoutMs = parsePositive("--timeout", opts.timeout, 6e5);
+  const outcome = await executeManagedOperation({
+    type: "deep-review",
+    name: "Deep source review",
+    target,
+    timeCapMs: timeoutMs,
+    costCapUsd: costCeilingUsd,
+    execute: (context) => runDeepReview({
+      target,
+      signal: context.signal,
+      costLedger: context.costLedger,
+      plan: context.plan,
+      costCeilingUsd: context.plan.costCapUsd,
+      ...opts.profile ? { profile: opts.profile } : {},
+      ...opts.subsystem ? { subsystem: opts.subsystem } : {},
+      // Flag > env > single provider-default model. Only pass `models` when the
+      // flag is set; otherwise let runDeepReview resolve $ZERO_DEEP_REVIEW_MODELS.
+      ...opts.models ? { models: opts.models.split(",").map((s) => s.trim()).filter(Boolean) } : {},
+      ...opts.attempts ? { attemptsPerCandidate: parsePositive("--attempts", opts.attempts, defaultAttempts()) } : {},
+      concurrency: parsePositive("--concurrency", opts.concurrency, DEFAULT_CONCURRENCY),
+      maxCandidates: parsePositive("--max-candidates", opts.maxCandidates, defaultMaxCandidates()),
+      ...opts.quorum ? { quorum: parsePositive("--quorum", opts.quorum, 1) } : {},
+      ...opts.threatModel ? { useThreatModel: true } : {},
+      ...opts.runtime ? { runtime: opts.runtime } : {},
+      ...opts.evolutionConfig ? { evolutionConfig: loadEvolutionConfigFile(opts.evolutionConfig) } : {},
+      timeoutMs: Math.max(1, context.deadline - Date.now()),
+      log: (m) => process.stderr.write(m + "\n")
+    }),
+    status: (outcome2) => outcome2.exitCode === 0 ? "completed" : "failed",
+    reports: (outcome2) => outcome2.report ? [outcome2.report] : []
+  });
+  if (outcome.report) {
+    const storage = resolveOsecRunStorage();
+    writeOsecRunReport(storage, outcome.report);
+  }
+  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 registerDeepReviewCommand(program) {
+  program.command("deep-review").description(
+    "Seedless deep security review of a source tree. Emits leads to verify, not confirmed bugs."
+  ).argument("<target>", "Source tree to review (a local path or a git URL)").option("--profile <p>", "Lens profile: evm-onchain | solana-onchain | cardano-onchain | cairo-onchain | move-onchain (else a generic default lens set)").option("--subsystem <path>", "Narrow the review scope to a subdirectory (respects the 5000-file review cap)").option("--evolution-config <path>", "Use the active source finder with private local execution receipts").option("--models <a,b>", "Comma-separated finder models for diversity (default: single provider model, or $ZERO_DEEP_REVIEW_MODELS)").option("--attempts <N>", `Finder attempts per candidate\xD7lens\xD7model, best-of-N (default ${DEFAULT_ATTEMPTS}, or $ZERO_DEEP_REVIEW_ATTEMPTS)`).option("--concurrency <N>", `Max finders in flight (default ${DEFAULT_CONCURRENCY})`).option("--cost-ceiling <usd>", "Hard scan-wide USD ceiling. Overrides $ZERO_COST_CEILING_USD.").option("--max-candidates <N>", `Cap candidate files hunted, largest-first (default ${DEFAULT_MAX_CANDIDATES}, or $ZERO_DEEP_REVIEW_MAX_CANDIDATES)`).option("--threat-model", "Enable pre-selection threat-model planner pass (trust-boundary lanes); default OFF").option("--quorum <N>", "Multi-lens verify quorum (default: majority of the verify-lens count)").option("--format <fmt>", "Output format (json)", "json").option("--output <path>", "Write the result JSON to this path instead of stdout").option("--runtime <mode>", "Engine runtime (default api)").option("--timeout <ms>", "Cloud agent timeout budget in milliseconds", "600000").action(async (target, opts) => {
+    try {
+      await deepReviewAction(target, opts);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      const json = JSON.stringify({ mode: "deep_review", error: reason }, null, 2);
+      if (opts.output) {
+        const { writeFileSync } = await import("node:fs");
+        try {
+          writeFileSync(resolve(opts.output), json + "\n", "utf8");
+        } catch {
+          process.stderr.write(json + "\n");
+        }
+      } else process.stdout.write(json + "\n");
+      process.exitCode = 3;
+    }
+  });
+}
+
+export {
+  lensSetDigest,
+  createDefaultFinderLenses,
+  defaultFinderLenses,
+  defaultVerifyLenses,
+  selectProfileLenses,
+  detectStack,
+  selectDefaultFinderLensesForStack,
+  isNonProtocolEvmPath,
+  selectCandidatesModuleSpread,
+  enumerateDeepReviewCandidates,
+  runDeepReview,
+  registerDeepReviewCommand
+};