@quantakrypto/core 0.3.0 → 0.4.0

package/src/detectors/source.ts

@@ -29,6 +29,7 @@
 import type { Detector, Finding, RuleMeta } from "../types.js";
 import {
   JS_TS_EXTENSIONS,
+  JWT_HOST_EXTENSIONS,
   eachMatch,
   findingFromRule,
   hasExtension,
@@ -40,31 +41,41 @@ import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION, CWE_WEAK_STRENGTH } from "../cw
 /* Precompiled regexes (module scope — never recreated per file)              */
 /* -------------------------------------------------------------------------- */
 
+// `rsa-pss` is listed before `rsa` so the alternation consumes the full token
+// (ordered alternation would otherwise match `rsa` and reject the `-pss` tail).
 const RE_GENERATE_KEYPAIR =
-  /generateKeyPair(?:Sync)?\s*\(\s*['"`](rsa|ec|dsa|dh|x25519|x448|ed25519|ed448)['"`]/g;
+  /generateKeyPair(?:Sync)?\s*\(\s*['"`](rsa-pss|rsa|ec|dsa|dh|x25519|x448|ed25519|ed448)['"`]/g;
 const RE_CREATE_SIGN_VERIFY = /create(?:Sign|Verify)\s*\(/g;
-// One-shot crypto.sign/verify(algorithm, data, key). Anchored so it doesn't
-// fire inside identifiers like `assign(` or `createSign(` (which the dedicated
-// createSign/createVerify rule handles). The first argument is either a quoted
-// digest-algorithm string (RSA/ECDSA) or `null` — Node's EdDSA one-shot form is
-// `crypto.sign(null, data, edKey)`, which must still be detected.
+// One-shot crypto.sign/verify(algorithm, data, key). A LOOKBEHIND (not a
+// consumed char) anchors it so it doesn't fire inside identifiers like `assign(`
+// or `createSign(` (handled by the dedicated createSign/createVerify rule) —
+// consuming the preceding char used to push the match onto the previous line,
+// corrupting the reported line/snippet and SARIF/baseline fingerprints. The
+// first argument is either a quoted digest-algorithm string (RSA/ECDSA) or
+// `null` — Node's EdDSA one-shot form is `crypto.sign(null, data, edKey)`.
 const RE_ONESHOT_SIGN_VERIFY =
-  /(?:^|[^.\w])(?:crypto\.)?(sign|verify)\s*\(\s*(?:['"`][\w.-]+['"`]|null)\s*,/g;
+  /(?<![.\w])(?:crypto\.)?(sign|verify)\s*\(\s*(?:['"`][\w.-]+['"`]|null)\s*,/g;
 const RE_CREATE_DH = /createDiffieHellman(?:Group)?\s*\(/g;
 const RE_GET_DH = /getDiffieHellman\s*\(\s*['"`](modp\d+)['"`]\s*\)/g;
 const RE_CREATE_ECDH = /createECDH\s*\(/g;
 const RE_RSA_ENCRYPT = /(?:crypto\.)?(?:publicEncrypt|privateDecrypt)\s*\(/g;
 const RE_DH_KEYOBJECT = /(?:crypto\.)?diffieHellman\s*\(\s*\{/g;
 
-// WebCrypto.
-const RE_WEBCRYPTO_ALGO = /\b(RSA-OAEP|RSA-PSS|RSASSA-PKCS1-v1_5|ECDH|ECDSA)\b/gi;
+// WebCrypto. Includes the newer curve algorithms (Ed25519/Ed448 signatures,
+// X25519/X448 key agreement) shipping in modern SubtleCrypto implementations.
+const RE_WEBCRYPTO_ALGO =
+  /\b(RSA-OAEP|RSA-PSS|RSASSA-PKCS1-v1_5|ECDH|ECDSA|Ed25519|Ed448|X25519|X448)\b/gi;
 const RE_SUBTLE_CALL =
   /subtle\s*\.\s*(generateKey|importKey|exportKey|deriveKey|deriveBits|sign|verify|encrypt|decrypt|wrapKey|unwrapKey)\s*\(/g;
 
 // Libraries.
 const RE_FORGE_RSA = /pki\.rsa\.generateKeyPair\s*\(/g;
 const RE_FORGE_ED25519 = /forge\.ed25519\b/g;
-const RE_ELLIPTIC_EC = /new\s+(?:elliptic\.)?ec\s*\(/gi;
+// Require a curve-like first argument so `new EC("request-scope")` (a non-crypto
+// `EC` class) is not flagged; the elliptic library is always constructed with a
+// named curve (`new EC('secp256k1')`, `new EC('p256')`, …).
+const RE_ELLIPTIC_EC =
+  /new\s+(?:elliptic\.)?ec\s*\(\s*['"`](?:sec[pt]|prime|nistp|curve|ed25519|ed448|brainpool|p-?(?:192|224|256|384|521)|x25519|x448)/gi;
 const RE_JSRSASIGN_KEYGEN = /KEYUTIL\.generateKeypair\s*\(/g;
 const RE_JSRSASIGN_SIGN = /KJUR\.crypto\.(?:Signature|ECDSA)\b/g;
 const RE_NODE_RSA = /new\s+NodeRSA\s*\(/g;
@@ -237,6 +248,18 @@ const nodeCryptoDetector: Detector = {
         }
       > = {
         rsa: { algo: "RSA", cat: "kem", sev: "high", hndl: true, label: "RSA" },
+        // RSA-PSS is signature-only, so classify it as a (forgeable) signature
+        // rather than a KEM — no HNDL confidentiality exposure.
+        "rsa-pss": {
+          algo: "RSA",
+          cat: "signature",
+          sev: "high",
+          hndl: false,
+          label: "RSA-PSS",
+          message:
+            "Generates a classical RSA-PSS signing key, which is forgeable by a quantum attacker.",
+          remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+        },
         // EC keys feed BOTH ECDSA (sign) and ECDH (key agreement). ECDH is
         // HNDL-exposed, so classify conservatively as key-exchange-capable and
         // surface both concerns rather than asserting signature-only (P0-4).
@@ -406,15 +429,36 @@ const webCryptoDetector: Detector = {
     eachMatch(RE_WEBCRYPTO_ALGO, content, (m) => {
       if (!nearSortedCall(callIndexes, m.index, 400)) return;
       const name = m[1].toUpperCase();
-      const isKem = name === "RSA-OAEP";
-      const isEcdh = name === "ECDH";
-      const algorithm: Finding["algorithm"] = name.startsWith("RSA")
-        ? "RSA"
-        : isEcdh
-          ? "ECDH"
-          : "ECDSA";
-      const category: Finding["category"] = isEcdh ? "key-exchange" : isKem ? "kem" : "signature";
-      const hndl = isKem || isEcdh;
+      // Classify by algorithm: RSA-OAEP is KEM (HNDL); ECDH/X25519/X448 are key
+      // agreement (HNDL); RSA-PSS/RSASSA/ECDSA/Ed25519/Ed448 are signatures.
+      let algorithm: Finding["algorithm"];
+      let category: Finding["category"];
+      let hndl: boolean;
+      let severity: Finding["severity"] | undefined;
+      if (name.startsWith("RSA")) {
+        algorithm = "RSA";
+        const isKem = name === "RSA-OAEP";
+        category = isKem ? "kem" : "signature";
+        hndl = isKem;
+      } else if (name === "ECDH") {
+        algorithm = "ECDH";
+        category = "key-exchange";
+        hndl = true;
+      } else if (name === "X25519" || name === "X448") {
+        algorithm = name === "X448" ? "X448" : "X25519";
+        category = "key-exchange";
+        hndl = true;
+        severity = "low"; // modern but classical
+      } else if (name === "ED25519" || name === "ED448") {
+        algorithm = "EdDSA";
+        category = "signature";
+        hndl = false;
+        severity = "low";
+      } else {
+        algorithm = "ECDSA";
+        category = "signature";
+        hndl = false;
+      }
       findings.push(
         findingFromRule(
           RULE_WEBCRYPTO,
@@ -424,6 +468,7 @@ const webCryptoDetector: Detector = {
             category,
             algorithm,
             hndl,
+            ...(severity ? { severity } : {}),
             message: `WebCrypto algorithm "${m[1]}" is classical asymmetric crypto and not quantum-safe.`,
           },
         ),
@@ -607,9 +652,12 @@ const jwtDetector: Detector = {
   id: "jwt-jose",
   description: "Classical JWT/JOSE algorithms (RS/PS/ES/EdDSA) and ECDH-ES key agreement",
   scope: "source",
-  language: "js",
+  // Language-agnostic evidence: a quoted "RS256"/"ES256" alg token is the same
+  // signal in JS/TS or Python (e.g. PyJWT `algorithm="RS256"`), so this detector
+  // is un-gated from JS-only to the JWT host surfaces.
+  language: "any",
   rules: [RULE_JWT_ALG, RULE_JOSE_ECDH],
-  appliesTo: (f) => hasExtension(f, JS_TS_EXTENSIONS),
+  appliesTo: (f) => hasExtension(f, JWT_HOST_EXTENSIONS),
   detect({ file, content }): Finding[] {
     const findings: Finding[] = [];
 

package/src/index.ts

@@ -18,6 +18,41 @@ export type { SarifLog } from "./report.js";
 // Core orchestration + built-in detector set.
 export { scan, detectors, detectFile, compareFindings } from "./scan.js";
 
+// Snippet-level fix verification (shared by MCP verify_fix + remediation).
+export { verifyFix, languageToExtension } from "./verify.js";
+export type { VerifyResult } from "./verify.js";
+
+// Agent-plane shared types + the context redactor (offline; reused by MCP).
+export type {
+  ContextLevel,
+  RedactedContext,
+  TriageVerdict,
+  Patch,
+  FixProposal,
+} from "./agent-types.js";
+export { buildContext, renderPreflight } from "./redact.js";
+export { TRIAGE_RUBRIC, TRIAGE_VERDICT_SCHEMA, buildTriageRequest } from "./triage.js";
+export type { TriageRequest } from "./triage.js";
+export {
+  REMEDIATE_RUBRIC,
+  FIX_REQUEST_SCHEMA,
+  buildRemediateRequest,
+} from "./remediate-request.js";
+export type { RemediateRequest } from "./remediate-request.js";
+export { checkPatchPolicy } from "./patch-policy.js";
+export type { PolicyContext, PolicyDecision } from "./patch-policy.js";
+export { withWorktree } from "./worktree.js";
+export { codemodRegistry, codemodFor } from "./codemods/registry.js";
+export type { Codemod } from "./codemods/registry.js";
+export { configToggleCodemod } from "./codemods/config-toggle.js";
+export { remediateFindings } from "./remediate-pipeline.js";
+export type {
+  RemediateOptions,
+  RemediationResult,
+  VerifiedPatch,
+  RejectedPatch,
+} from "./remediate-pipeline.js";
+
 // Scan cancellation / work-budget errors.
 export { AbortError, BudgetExceededError } from "./errors.js";
 
@@ -50,11 +85,20 @@ export type { QuantakryptoFileConfig, LoadConfigResult } from "./config.js";
 // Filesystem walker (relative POSIX paths, default ignores, size/binary filters).
 export { walkFiles, isBinaryPath, isGeneratedPath, looksMinified } from "./walk.js";
 
+// Analyzable-language coverage (which source languages the scanner inspects).
+export {
+  isAnalyzableSource,
+  ANALYZABLE_SOURCE_EXTENSIONS,
+  ANALYZABLE_LANGUAGES_LABEL,
+} from "./detect-utils.js";
+
 // Inventory + readiness score.
 export { buildInventory } from "./inventory.js";
 
 // Vulnerable-dependency database (the manifest scanner is used internally by scan()).
-export { vulnerableDependencies } from "./dependencies.js";
+// `DEP_VULNERABLE_RULE` is the generic catalog entry for dependency findings
+// (which don't come from a Detector, so aren't in the registry's rule catalog).
+export { vulnerableDependencies, DEP_VULNERABLE_RULE, isManifestFile } from "./dependencies.js";
 
 // Severity utilities (ordering, threshold, SARIF level) — shared across tools.
 export { SEVERITY_ORDER, severityRank, meetsThreshold, sarifLevel } from "./severity.js";

package/src/parallel.ts

@@ -18,8 +18,10 @@ import type { Worker as NodeWorker } from "node:worker_threads";
 
 import type { Finding, ParallelScanOptions, ScanResult } from "./types.js";
 import { walkFiles } from "./walk.js";
+import { isAnalyzableSource } from "./detect-utils.js";
 import { buildInventory } from "./inventory.js";
 import { compareFindings, filterExplicitFileList, scan } from "./scan.js";
+import { AbortError, BudgetExceededError } from "./errors.js";
 import { VERSION } from "./version.js";
 
 /** One unit of work dispatched to a worker. */
@@ -31,6 +33,10 @@ export interface ScanChunk {
 export interface ChunkResult {
   findings: Finding[];
   filesScanned: number;
+  /** Files that couldn't be read in this chunk (optional; older workers omit it). */
+  unreadable?: number;
+  /** Files skipped as minified in this chunk (optional; older workers omit it). */
+  skippedMinified?: number;
 }
 
 const DEFAULT_PARALLEL_THRESHOLD_BYTES = 2 * 1024 * 1024;
@@ -74,12 +80,16 @@ export function chunkByBytes(files: readonly SizedFile[], chunkBytes: number): S
 export function mergeChunkResults(results: readonly ChunkResult[]): ChunkResult {
   const findings: Finding[] = [];
   let filesScanned = 0;
+  let unreadable = 0;
+  let skippedMinified = 0;
   for (const r of results) {
     for (const f of r.findings) findings.push(f);
     filesScanned += r.filesScanned;
+    unreadable += r.unreadable ?? 0;
+    skippedMinified += r.skippedMinified ?? 0;
   }
   findings.sort(compareFindings);
-  return { findings, filesScanned };
+  return { findings, filesScanned, unreadable, skippedMinified };
 }
 
 /** Resolve the worker count (>= 1). */
@@ -162,14 +172,29 @@ export async function scanParallel(options: ParallelScanOptions): Promise<ScanRe
   const rootStat = await stat(options.root);
   const baseDir = rootStat.isFile() ? path.dirname(options.root) : options.root;
 
-  // Single-file roots and the override-detectors path always run serially:
-  // detectors may not be structured-cloneable across the worker boundary.
-  if (rootStat.isFile() || options.detectors) {
+  // Single-file roots, the override-detectors path, and the scan cache always
+  // run serially: detectors may not be structured-cloneable across the worker
+  // boundary, and the cache read/write is owned by the in-process `scan()`.
+  if (rootStat.isFile() || options.detectors || options.cacheFile) {
     return scan(options);
   }
 
   const files = await enumerateFiles(options, baseDir);
 
+  // Budget + cancellation parity with the serial path. The parallel path
+  // enumerates upfront, so budgets are enforced against the whole file set
+  // before any worker is dispatched.
+  if (options.signal?.aborted) throw new AbortError();
+  if (typeof options.maxFiles === "number" && files.length > options.maxFiles) {
+    throw new BudgetExceededError(`maxFiles budget exceeded (limit: ${options.maxFiles}).`);
+  }
+  if (typeof options.maxBytes === "number") {
+    const totalBytes = files.reduce((n, f) => n + f.size, 0);
+    if (totalBytes > options.maxBytes) {
+      throw new BudgetExceededError(`maxBytes budget exceeded (limit: ${options.maxBytes}).`);
+    }
+  }
+
   if (!shouldParallelize(options, files)) {
     // In-process: reuse the exact serial path over the same file list.
     return scan({ ...options, files: files.map((f) => f.rel) });
@@ -206,9 +231,12 @@ export async function scanParallel(options: ParallelScanOptions): Promise<ScanRe
       chunks,
       concurrency,
       options.onFile,
+      options.signal,
     );
-  } catch {
-    // Any worker failure → safe fallback to the serial path.
+  } catch (err) {
+    // Cancellation / budget overflow must propagate, not silently degrade.
+    if (err instanceof AbortError || err instanceof BudgetExceededError) throw err;
+    // Any other worker failure → safe fallback to the serial path.
     return scan({ ...options, files: files.map((f) => f.rel) });
   }
 
@@ -216,10 +244,21 @@ export async function scanParallel(options: ParallelScanOptions): Promise<ScanRe
   const inventory = buildInventory(merged.findings);
   const finishedAt = new Date();
 
+  // Coverage: count analyzable-source files in the enumerated set. Computed from
+  // the file list (not per-worker) to avoid worker-boundary plumbing; on the
+  // parallel path this can include a minified analyzable file the workers
+  // skipped, but that is vanishingly rare and never under-reports coverage.
+  const analyzedFiles = files.reduce((n, f) => (isAnalyzableSource(f.rel) ? n + 1 : n), 0);
+
   return {
     root: options.root,
     findings: merged.findings,
     filesScanned: merged.filesScanned,
+    analyzedFiles,
+    diagnostics: {
+      unreadable: merged.unreadable ?? 0,
+      skippedMinified: merged.skippedMinified ?? 0,
+    },
     inventory,
     startedAt: startedAt.toISOString(),
     finishedAt: finishedAt.toISOString(),
@@ -243,6 +282,7 @@ function runPool(
   chunks: ScanChunk[],
   concurrency: number,
   onFile?: (file: string) => void,
+  signal?: AbortSignal,
 ): Promise<ChunkResult[]> {
   return new Promise((resolve, reject) => {
     const results: ChunkResult[] = new Array(chunks.length);
@@ -251,10 +291,27 @@ function runPool(
     let failed = false;
     const workers: Array<NodeWorker> = [];
 
+    const onAbort = (): void => {
+      if (failed) return;
+      failed = true;
+      cleanup();
+      reject(new AbortError());
+    };
+
     const cleanup = () => {
+      if (signal) signal.removeEventListener("abort", onAbort);
       for (const w of workers) void w.terminate();
     };
 
+    // Cooperative cancellation: stop dispatching and tear down on abort.
+    if (signal) {
+      if (signal.aborted) {
+        reject(new AbortError());
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+
     const dispatch = (w: NodeWorker): void => {
       if (failed) return;
       if (next >= chunks.length) {

package/src/patch-policy.ts

@@ -0,0 +1,42 @@
+/**
+ * Patch-policy allowlist. A remediation patch may only edit a file that already
+ * has a finding, or add dependencies to a manifest. Everything else — CI config,
+ * lockfiles, env/secret files, unrelated source — is denied. This is the second
+ * safety gate (the first is `verify_fix`): even a "verified" patch is dropped if
+ * it strays outside the sanctioned surface.
+ */
+import type { Patch } from "./agent-types.js";
+
+/** Files a remediation may write to. */
+export interface PolicyContext {
+  /** Relative paths (posix) that contain at least one finding. */
+  findingFiles: Set<string>;
+  /** Relative manifest paths (package.json, requirements.txt, …). */
+  manifestFiles: Set<string>;
+}
+
+/**
+ * Paths a patch may NEVER touch, regardless of anything else: version control,
+ * CI, dependency lockfiles, and anything that looks like a secret/env file.
+ */
+const DENY_RE =
+  /(^|\/)(\.github|\.git|node_modules)\/|(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|Cargo\.lock|Gemfile\.lock|poetry\.lock)$|(^|\/)\.env(\.[^/]*)?$|\.(pem|key|p12|pfx)$/i;
+
+export interface PolicyDecision {
+  allowed: boolean;
+  reason?: string;
+}
+
+/** Decide whether `patch` may be applied under `ctx`. */
+export function checkPatchPolicy(patch: Patch, ctx: PolicyContext): PolicyDecision {
+  const p = patch.path.replace(/\\/g, "/");
+  if (DENY_RE.test(p)) {
+    return { allowed: false, reason: `patch touches a protected path (${p})` };
+  }
+  if (ctx.findingFiles.has(p)) return { allowed: true };
+  if (ctx.manifestFiles.has(p)) return { allowed: true };
+  return {
+    allowed: false,
+    reason: `patch edits ${p}, which has no finding and is not a dependency manifest`,
+  };
+}

package/src/redact.ts

@@ -0,0 +1,92 @@
+/**
+ * Context redactor: turn a finding + its file into the payload the LLM sees,
+ * bounded to a chosen {@link ContextLevel} and with secrets ALWAYS stripped.
+ *
+ * This is a hard privacy boundary and lives in `@quantakrypto/core` (offline) so
+ * the deterministic MCP plane redacts identically to the networked CLI. A
+ * `sensitive` finding (the match IS key material) never emits code at any level.
+ */
+import type { Finding } from "./types.js";
+import type { ContextLevel, RedactedContext } from "./agent-types.js";
+
+/** Lines of context on each side of the match at `snippet` level. */
+const SNIPPET_RADIUS = 8;
+
+/**
+ * PEM blocks and long unbroken base64 runs (≥120 chars) are treated as secret
+ * material and masked, even inside otherwise-shareable code.
+ */
+const SECRET_RE =
+  /-----BEGIN [A-Z0-9 ]+-----[\s\S]*?-----END [A-Z0-9 ]+-----|[A-Za-z0-9+/]{120,}={0,2}/g;
+
+function stripSecrets(text: string): { text: string; redacted: boolean } {
+  let redacted = false;
+  const out = text.replace(SECRET_RE, () => {
+    redacted = true;
+    return "«redacted-secret»";
+  });
+  return { text: out, redacted };
+}
+
+/** Best-effort enclosing brace/colon block around a 0-based line index. */
+function enclosingBlock(lines: string[], idx: number): string {
+  let start = idx;
+  while (start > 0 && !/[{:]\s*$/.test(lines[start - 1] ?? "")) start--;
+  let end = idx;
+  let depth = 0;
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    depth += (line.match(/{/g) ?? []).length - (line.match(/}/g) ?? []).length;
+    end = i;
+    if (i > idx && depth <= 0) break;
+  }
+  return lines.slice(start, end + 1).join("\n");
+}
+
+/**
+ * Build the redacted context for `finding` at `level`. `fileContent` is the full
+ * text of the file the finding lives in (unused at `metadata` level). Secrets
+ * are always removed; a `sensitive` finding yields `code: null`.
+ */
+export function buildContext(
+  finding: Finding,
+  level: ContextLevel,
+  fileContent: string,
+): RedactedContext {
+  const meta = {
+    ruleId: finding.ruleId,
+    algorithm: finding.algorithm,
+    severity: finding.severity,
+    hndl: finding.hndl,
+    file: finding.location.file,
+    line: finding.location.line,
+    message: finding.message,
+  };
+  // Sensitive findings never emit code, at any level.
+  if (finding.sensitive) return { level, meta, code: null, redactedSecret: true };
+  if (level === "metadata") return { level, meta, code: null, redactedSecret: false };
+
+  const lines = fileContent.split("\n");
+  let code: string;
+  if (level === "file") {
+    code = fileContent;
+  } else if (level === "function") {
+    code = enclosingBlock(lines, finding.location.line - 1);
+  } else {
+    const i = finding.location.line - 1;
+    code = lines.slice(Math.max(0, i - SNIPPET_RADIUS), i + SNIPPET_RADIUS + 1).join("\n");
+  }
+  const { text, redacted } = stripSecrets(code);
+  return { level, meta, code: text, redactedSecret: redacted };
+}
+
+/** Render the exact payload text a `--dry-run` preflight would send. */
+export function renderPreflight(contexts: RedactedContext[]): string {
+  return contexts
+    .map((c) => {
+      const flags = `level=${c.level}${c.redactedSecret ? ", secret-redacted" : ""}`;
+      const head = `[${c.meta.severity}] ${c.meta.ruleId} ${c.meta.file}:${c.meta.line} (${flags})`;
+      return c.code ? `${head}\n${c.code}` : head;
+    })
+    .join("\n\n---\n\n");
+}

package/src/registry.ts

@@ -12,6 +12,13 @@
  */
 import type { Detector, DetectorScope, RuleMeta } from "./types.js";
 import { sourceDetectors } from "./detectors/source.js";
+import { pythonDetector } from "./detectors/python.js";
+import { goDetector } from "./detectors/go.js";
+import { javaDetector } from "./detectors/java.js";
+import { csharpDetector } from "./detectors/csharp.js";
+import { rustDetector } from "./detectors/rust.js";
+import { rubyDetector } from "./detectors/ruby.js";
+import { cDetector } from "./detectors/c.js";
 import { pemDetector } from "./detectors/pem.js";
 
 /** Normalised scope of a detector (defaults to "source" when undeclared). */
@@ -102,8 +109,29 @@ export class DetectorRegistry {
 }
 
 /**
- * The default registry, preloaded with the built-in detectors in run order:
- * the JS/TS source + config detectors, then the language-agnostic PEM detector.
- * The manifest (dependency) scanner is handled separately by `scan()`.
+ * The built-in detectors, in run order: the JS/TS source + config detectors,
+ * then the per-language detectors (Python, Go, Java, C#, Rust, Ruby, C/C++),
+ * then the language-agnostic PEM detector. The manifest (dependency) scanner is
+ * handled separately by `scan()`.
+ *
+ * This is the single source of truth for the default detector set: both
+ * {@link defaultRegistry} and the public `detectors` export (re-exported from
+ * `scan.ts`) are built from it, so the two can never drift out of sync.
+ */
+export const builtinDetectors: Detector[] = [
+  ...sourceDetectors,
+  pythonDetector,
+  goDetector,
+  javaDetector,
+  csharpDetector,
+  rustDetector,
+  rubyDetector,
+  cDetector,
+  pemDetector,
+];
+
+/**
+ * The default registry, preloaded with {@link builtinDetectors}. Used by
+ * `scan()` whenever `options.detectors` is not supplied.
  */
-export const defaultRegistry = new DetectorRegistry([...sourceDetectors, pemDetector]);
+export const defaultRegistry = new DetectorRegistry(builtinDetectors);

package/src/remediate-pipeline.ts

@@ -0,0 +1,81 @@
+/**
+ * The remediation pipeline: turn candidate patches (from codemods or the LLM)
+ * into VERIFIED, in-policy patches. Pure and deterministic — the verify gate
+ * runs `verifyFix` on the patched content in memory, so this needs no
+ * filesystem or git. Callers (the `qremediate` CLI) decide what to DO with the
+ * verified patches (print a diff, write them, or open a PR in a worktree).
+ *
+ * Two gates, both must pass:
+ *   1. patch-policy   — the patch may only touch sanctioned files.
+ *   2. verify_fix     — the patched content clears the target finding, adds no
+ *                       new finding type, and nets fewer findings than before.
+ */
+import type { Finding } from "./types.js";
+import type { Patch } from "./agent-types.js";
+import { checkPatchPolicy } from "./patch-policy.js";
+import type { PolicyContext } from "./patch-policy.js";
+import { verifyFix } from "./verify.js";
+
+export interface VerifiedPatch {
+  finding: Finding;
+  patch: Patch;
+}
+export interface RejectedPatch {
+  finding: Finding;
+  reason: string;
+}
+export interface RemediationResult {
+  applied: VerifiedPatch[];
+  rejected: RejectedPatch[];
+}
+
+export interface RemediateOptions {
+  /** Current content of the file a finding lives in. */
+  readContent: (finding: Finding) => Promise<string> | string;
+  /** Produce a candidate patch for a finding (codemod or LLM), or null. */
+  patchSource: (finding: Finding, content: string) => Promise<Patch | null> | Patch | null;
+  /** Which files a patch is allowed to touch. */
+  policy: PolicyContext;
+}
+
+/** True when `after` is a strict improvement over `before` for `finding`. */
+function passesVerify(before: Finding[], after: Finding[], finding: Finding): boolean {
+  const targetGone = !after.some((x) => x.ruleId === finding.ruleId);
+  const noNewRuleTypes = after.every((x) => before.some((b) => b.ruleId === x.ruleId));
+  return targetGone && noNewRuleTypes && after.length < before.length;
+}
+
+/**
+ * Run each finding through patchSource → policy → verify, collecting the patches
+ * that survive both gates and the reasons the rest were dropped.
+ */
+export async function remediateFindings(
+  findings: readonly Finding[],
+  opts: RemediateOptions,
+): Promise<RemediationResult> {
+  const applied: VerifiedPatch[] = [];
+  const rejected: RejectedPatch[] = [];
+
+  for (const finding of findings) {
+    const content = await opts.readContent(finding);
+    const patch = await opts.patchSource(finding, content);
+    if (!patch) {
+      rejected.push({ finding, reason: "no deterministic fix available" });
+      continue;
+    }
+    const decision = checkPatchPolicy(patch, opts.policy);
+    if (!decision.allowed) {
+      rejected.push({ finding, reason: decision.reason ?? "rejected by patch policy" });
+      continue;
+    }
+    const before = verifyFix(content, { filename: finding.location.file }).findings;
+    const after = verifyFix(patch.newContent, { filename: patch.path }).findings;
+    if (!passesVerify(before, after, finding)) {
+      rejected.push({ finding, reason: "patch did not pass the verify_fix gate" });
+      continue;
+    }
+    applied.push({ finding, patch });
+  }
+
+  return { applied, rejected };
+}