fullshield 0.1.1 → 0.1.3

package/dist/mcp.js

@@ -1,12 +1,13 @@
-import { execFile, spawnSync } from 'child_process';
-import { readFileSync, statSync, mkdtempSync, cpSync, writeFileSync, rmSync, existsSync, readdirSync } from 'fs';
-import { homedir, tmpdir } from 'os';
-import { resolve, join, basename, dirname, posix, relative } from 'path';
+import { createHash } from 'crypto';
 import { readFile, mkdir, writeFile, stat, readdir } from 'fs/promises';
+import { resolve, join, basename, dirname, relative, posix } from 'path';
+import { execFile, spawnSync, spawn, execFileSync } from 'child_process';
+import { createInterface } from 'readline';
+import { promisify } from 'util';
+import { existsSync, statSync, readFileSync, readdirSync, mkdtempSync, cpSync, writeFileSync, rmSync } from 'fs';
+import { homedir, tmpdir } from 'os';
 import { performance } from 'perf_hooks';
-import { createHash } from 'crypto';
 import ignoreModule from 'ignore';
-import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 
 var __defProp = Object.defineProperty;
@@ -18,6 +19,521 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+function isSeverity(value) {
+  return SEVERITIES.includes(value);
+}
+function isModuleName(value) {
+  return MODULE_NAMES.includes(value);
+}
+function severityRank(severity) {
+  return SEVERITIES.indexOf(severity);
+}
+function makeFindingId(ruleId, file, snippet) {
+  const normalized = (snippet ?? "").replace(/\s+/g, " ").trim();
+  return createHash("sha256").update(`${ruleId}\0${file ?? ""}\0${normalized}`).digest("hex").slice(0, 16);
+}
+function sortFindings(findings) {
+  return [...findings].sort(
+    (a, b) => severityRank(b.severity) - severityRank(a.severity) || (a.file ?? "").localeCompare(b.file ?? "") || (a.line ?? 0) - (b.line ?? 0) || a.ruleId.localeCompare(b.ruleId)
+  );
+}
+function summarize(findings) {
+  const bySeverity = Object.fromEntries(SEVERITIES.map((s) => [s, 0]));
+  for (const finding4 of findings) {
+    bySeverity[finding4.severity] += 1;
+  }
+  return { total: findings.length, bySeverity };
+}
+var SEVERITIES, MODULE_NAMES;
+var init_finding = __esm({
+  "src/core/finding.ts"() {
+    SEVERITIES = ["info", "low", "medium", "high", "critical"];
+    MODULE_NAMES = ["deps", "secrets", "sast", "config"];
+  }
+});
+
+// src/modules/secrets/mask.ts
+function everyMatch(re, text) {
+  re.lastIndex = 0;
+  return [...text.matchAll(re)];
+}
+function maskSecret(secret) {
+  return `${secret.slice(0, 4)}****`;
+}
+function foldStringConcat(line) {
+  return line.replace(/(["'`])\s*\+\s*(["'`])/g, "");
+}
+function shannonEntropy(value) {
+  if (value.length === 0) return 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const char of value) {
+    counts.set(char, (counts.get(char) ?? 0) + 1);
+  }
+  let entropy = 0;
+  for (const count of counts.values()) {
+    const p = count / value.length;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+var init_mask = __esm({
+  "src/modules/secrets/mask.ts"() {
+  }
+});
+
+// src/modules/secrets/rules/aiKey.ts
+var PATTERN, aiKeyRule;
+var init_aiKey = __esm({
+  "src/modules/secrets/rules/aiKey.ts"() {
+    init_mask();
+    PATTERN = /\bsk-ant-[A-Za-z0-9_-]{16,}\b|\bsk-[A-Za-z0-9_-]{20,}\b/g;
+    aiKeyRule = {
+      meta: {
+        id: "SECRET-AIKEY-001",
+        title: "Hardcoded AI provider API key (OpenAI/Anthropic-style)",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN, line)) {
+            ctx.report({ line: index + 1, secret: match[0] });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/aws.ts
+var PATTERN2, awsRule;
+var init_aws = __esm({
+  "src/modules/secrets/rules/aws.ts"() {
+    init_mask();
+    PATTERN2 = /\bAKIA[0-9A-Z]{16}\b/g;
+    awsRule = {
+      meta: {
+        id: "SECRET-AWS-001",
+        title: "Hardcoded AWS access key ID",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN2, line)) {
+            ctx.report({ line: index + 1, secret: match[0] });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/dbUrl.ts
+function isPlaceholderPassword(password) {
+  if (password.includes("${")) return true;
+  if (/^<[^>]+>$/.test(password)) return true;
+  if (/^\{[^}]+\}$/.test(password)) return true;
+  return false;
+}
+var PATTERN3, dbUrlRule;
+var init_dbUrl = __esm({
+  "src/modules/secrets/rules/dbUrl.ts"() {
+    init_mask();
+    PATTERN3 = /\b(?:postgres(?:ql)?|mysql|mariadb|mongodb(?:\+srv)?|redis|amqp):\/\/([^\s'"@/:]+):([^\s'"@]+)@/g;
+    dbUrlRule = {
+      meta: {
+        id: "SECRET-DBURL-001",
+        title: "Database connection string with inline password",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN3, line)) {
+            const password = match[2];
+            if (password === void 0 || isPlaceholderPassword(password)) continue;
+            ctx.report({ line: index + 1, secret: password });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/entropy.ts
+var ASSIGNMENT, SECRET_NAME2, ENTROPY_THRESHOLD, entropyRule;
+var init_entropy = __esm({
+  "src/modules/secrets/rules/entropy.ts"() {
+    init_mask();
+    ASSIGNMENT = /\b([A-Za-z_$][\w$]*)\s*[:=]\s*["'`]([^"'`]{20,})["'`]/g;
+    SECRET_NAME2 = /(key|secret|token|passw(or)?d|pwd|credential)/i;
+    ENTROPY_THRESHOLD = 4.5;
+    entropyRule = {
+      meta: {
+        id: "SECRET-ENTROPY-001",
+        title: "High-entropy string assigned to a secret-like variable",
+        severity: "medium",
+        confidence: "low",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(ASSIGNMENT, line)) {
+            const [, name, value] = match;
+            if (name === void 0 || value === void 0) continue;
+            if (!SECRET_NAME2.test(name)) continue;
+            if (value.includes(" ") || value.includes("${")) continue;
+            if (shannonEntropy(value) <= ENTROPY_THRESHOLD) continue;
+            ctx.report({ line: index + 1, secret: value });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/envFile.ts
+var ENV_FILE, envFileRule;
+var init_envFile = __esm({
+  "src/modules/secrets/rules/envFile.ts"() {
+    ENV_FILE = /^\.env(\..+)?$/;
+    envFileRule = {
+      meta: {
+        id: "SECRET-ENVFILE-001",
+        title: "Committed .env file",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-312"
+      },
+      check(ctx) {
+        const base = ctx.path.split("/").pop() ?? ctx.path;
+        ENV_FILE.lastIndex = 0;
+        if (ENV_FILE.test(base) && base !== ".env.example" && base !== ".env.backup") {
+          ctx.report({
+            line: 1,
+            message: `${ctx.path} is tracked in the repository. .env files hold live credentials and must never be committed.`
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/github.ts
+var PATTERN4, githubRule;
+var init_github = __esm({
+  "src/modules/secrets/rules/github.ts"() {
+    init_mask();
+    PATTERN4 = /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36}\b/g;
+    githubRule = {
+      meta: {
+        id: "SECRET-GITHUB-001",
+        title: "Hardcoded GitHub token",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN4, line)) {
+            ctx.report({ line: index + 1, secret: match[0] });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/google.ts
+var PATTERN5, googleRule;
+var init_google = __esm({
+  "src/modules/secrets/rules/google.ts"() {
+    init_mask();
+    PATTERN5 = /\bAIza[0-9A-Za-z_-]{35}\b/g;
+    googleRule = {
+      meta: {
+        id: "SECRET-GOOGLE-001",
+        title: "Hardcoded Google API key",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN5, line)) {
+            ctx.report({ line: index + 1, secret: match[0] });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/jwtSecret.ts
+var PATTERN6, jwtSecretRule;
+var init_jwtSecret = __esm({
+  "src/modules/secrets/rules/jwtSecret.ts"() {
+    init_mask();
+    PATTERN6 = /\b(?:jwt[_-]?secret|jwt[_-]?key|token[_-]?secret|signing[_-]?key)\b\s*[:=]\s*["'`]([^"'`]{8,})["'`]/gi;
+    jwtSecretRule = {
+      meta: {
+        id: "SECRET-JWT-001",
+        title: "JWT secret assigned from a string literal",
+        severity: "medium",
+        confidence: "medium",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN6, line)) {
+            const secret = match[1];
+            if (secret !== void 0) {
+              ctx.report({ line: index + 1, secret });
+            }
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/privateKey.ts
+var PATTERN7, privateKeyRule;
+var init_privateKey = __esm({
+  "src/modules/secrets/rules/privateKey.ts"() {
+    PATTERN7 = /-----BEGIN (?:[A-Z]+ )*PRIVATE KEY-----/;
+    privateKeyRule = {
+      meta: {
+        id: "SECRET-PRIVKEY-001",
+        title: "Private key material committed to the repository",
+        severity: "critical",
+        confidence: "high",
+        cwe: "CWE-321"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          if (line.match(PATTERN7) !== null) {
+            ctx.report({
+              line: index + 1,
+              message: "A PEM private key block is committed to the repository."
+            });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/sessionSecret.ts
+var SECRET_PROP, sessionSecretRule;
+var init_sessionSecret = __esm({
+  "src/modules/secrets/rules/sessionSecret.ts"() {
+    init_mask();
+    SECRET_PROP = /\bsecret\s*:\s*['"`]([^'"`]{3,})['"`]/g;
+    sessionSecretRule = {
+      meta: {
+        id: "SECRET-SESSION-001",
+        title: "Hardcoded express-session secret",
+        severity: "medium",
+        confidence: "medium",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        let pending = 0;
+        ctx.lines.forEach((line, index) => {
+          if (/\bsession\s*\(/.test(line)) pending = 8;
+          if (pending <= 0) return;
+          pending -= 1;
+          for (const match of everyMatch(SECRET_PROP, line)) {
+            const secret = match[1];
+            if (secret !== void 0) {
+              ctx.report({ line: index + 1, secret });
+            }
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/slack.ts
+var PATTERN8, slackRule;
+var init_slack = __esm({
+  "src/modules/secrets/rules/slack.ts"() {
+    init_mask();
+    PATTERN8 = /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g;
+    slackRule = {
+      meta: {
+        id: "SECRET-SLACK-001",
+        title: "Hardcoded Slack token",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN8, line)) {
+            ctx.report({ line: index + 1, secret: match[0] });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/rules/stripe.ts
+var PATTERN9, stripeRule;
+var init_stripe = __esm({
+  "src/modules/secrets/rules/stripe.ts"() {
+    init_mask();
+    PATTERN9 = /\bsk_(?:live|test)_[A-Za-z0-9]{16,}\b/g;
+    stripeRule = {
+      meta: {
+        id: "SECRET-STRIPE-001",
+        title: "Hardcoded Stripe secret key",
+        severity: "high",
+        confidence: "high",
+        cwe: "CWE-798"
+      },
+      check(ctx) {
+        ctx.lines.forEach((line, index) => {
+          for (const match of everyMatch(PATTERN9, line)) {
+            ctx.report({ line: index + 1, secret: match[0] });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/modules/secrets/index.ts
+var secrets_exports = {};
+__export(secrets_exports, {
+  scanTextForSecretHits: () => scanTextForSecretHits,
+  scanTextForSecrets: () => scanTextForSecrets,
+  secretsModule: () => secretsModule,
+  secretsRules: () => secretsRules
+});
+function scanTextForSecretHits(path, text) {
+  const rawLines = text.split(/\r?\n/);
+  const lines = rawLines.map(foldStringConcat);
+  const hits = [];
+  for (const rule of secretsRules) {
+    rule.check({
+      path,
+      lines,
+      rawLines,
+      report: ({ line, secret, message }) => {
+        const masked = secret !== void 0 ? maskSecret(secret) : void 0;
+        hits.push({
+          finding: {
+            id: makeFindingId(rule.meta.id, path, `${line}|${masked ?? "file"}`),
+            ruleId: rule.meta.id,
+            module: "secrets",
+            title: rule.meta.title,
+            severity: rule.meta.severity,
+            confidence: rule.meta.confidence,
+            cwe: rule.meta.cwe,
+            file: path,
+            line,
+            snippet: masked,
+            message: message ?? `${rule.meta.title}${masked !== void 0 ? ` (${masked})` : ""}.`,
+            remediation: REMEDIATION
+          },
+          secret
+        });
+      }
+    });
+  }
+  return hits;
+}
+function scanTextForSecrets(path, text) {
+  return scanTextForSecretHits(path, text).map((hit) => hit.finding);
+}
+var secretsRules, REMEDIATION, MAX_FILE_SIZE, secretsModule;
+var init_secrets = __esm({
+  "src/modules/secrets/index.ts"() {
+    init_finding();
+    init_mask();
+    init_aiKey();
+    init_aws();
+    init_dbUrl();
+    init_entropy();
+    init_envFile();
+    init_github();
+    init_google();
+    init_jwtSecret();
+    init_privateKey();
+    init_sessionSecret();
+    init_slack();
+    init_stripe();
+    secretsRules = [
+      awsRule,
+      stripeRule,
+      githubRule,
+      slackRule,
+      googleRule,
+      aiKeyRule,
+      privateKeyRule,
+      dbUrlRule,
+      jwtSecretRule,
+      sessionSecretRule,
+      entropyRule,
+      envFileRule
+    ];
+    REMEDIATION = "Rotate this credential immediately, then load it from an environment variable or a secret manager. Removing it from the code is NOT enough: it remains visible in git history.";
+    MAX_FILE_SIZE = 1024 * 1024;
+    secretsModule = {
+      name: "secrets",
+      async run(ctx) {
+        const findings = [];
+        for (const rel of ctx.files) {
+          let text;
+          try {
+            text = await readFile(join(ctx.cwd, rel), "utf8");
+          } catch {
+            continue;
+          }
+          if (text.length > MAX_FILE_SIZE || text.includes("\0")) continue;
+          findings.push(...scanTextForSecrets(rel, text));
+        }
+        return findings;
+      }
+    };
+  }
+});
+
+// src/core/suppression.ts
+function parseIgnore(line) {
+  const match = IGNORE.exec(line);
+  if (match?.[1] === void 0 || match[2] === void 0) return void 0;
+  return { ruleId: match[1], reason: match[2] };
+}
+function applyInlineSuppressions(findings, sources) {
+  return findings.filter((finding4) => {
+    if (finding4.file === void 0 || finding4.line === void 0) return true;
+    const text = sources[finding4.file];
+    if (text === void 0) return true;
+    const lines = text.split(/\r?\n/);
+    const current = lines[finding4.line - 1] ?? "";
+    const previous = finding4.line >= 2 ? lines[finding4.line - 2] ?? "" : "";
+    for (const line of [current, previous]) {
+      const ignore = parseIgnore(line);
+      if (ignore !== void 0 && ignore.ruleId === finding4.ruleId) return false;
+    }
+    return true;
+  });
+}
+var IGNORE;
+var init_suppression = __esm({
+  "src/core/suppression.ts"() {
+    IGNORE = /fullshield-ignore\s+([A-Z0-9-]+)\s*:\s*(\S+)/;
+  }
+});
 
 // src/incremental/index.ts
 var incremental_exports = {};
@@ -37,6 +553,435 @@ var init_incremental = __esm({
   }
 });
 
+// src/modules/secrets/history.ts
+var history_exports = {};
+__export(history_exports, {
+  scanGitHistory: () => scanGitHistory
+});
+function gitError(error) {
+  const detail = error instanceof Error ? error.message.split("\n")[0] ?? "git failed" : String(error);
+  return new Error(`--history requires a git repository and the git CLI (${detail})`);
+}
+async function gitOk(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      maxBuffer: MAX_BLOB + 16384
+    });
+    return stdout;
+  } catch (error) {
+    throw gitError(error);
+  }
+}
+async function readBlob(cwd, hash) {
+  if (ZERO_HASH.test(hash)) return void 0;
+  try {
+    const sizeRaw = await gitOk(cwd, ["cat-file", "-s", hash]);
+    const size = Number(sizeRaw.trim());
+    if (!Number.isFinite(size) || size <= 0 || size > MAX_BLOB) return void 0;
+    const { stdout } = await execFileAsync2("git", ["-C", cwd, "cat-file", "blob", hash], {
+      encoding: "utf8",
+      maxBuffer: MAX_BLOB + 16384
+    });
+    if (stdout.includes("\0")) return void 0;
+    return stdout;
+  } catch {
+    return void 0;
+  }
+}
+function remapHit(hit, file) {
+  const snippet = hit.finding.snippet;
+  const line = hit.finding.line ?? 0;
+  const id = makeFindingId(hit.finding.ruleId, file, `${line}|${snippet ?? "file"}`);
+  return {
+    finding: { ...hit.finding, id, file },
+    secret: hit.secret
+  };
+}
+async function streamLogChanges(cwd) {
+  const changes = [];
+  await gitOk(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  const child = spawn(
+    "git",
+    [
+      "-C",
+      cwd,
+      "log",
+      "--reverse",
+      "--raw",
+      "-p",
+      "--no-abbrev",
+      "--full-index",
+      "--format=FSCOMMIT:%H",
+      "--no-textconv",
+      "--no-ext-diff",
+      "HEAD"
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] }
+  );
+  const stderrChunks = [];
+  child.stderr.on("data", (chunk) => {
+    stderrChunks.push(chunk);
+  });
+  const closed = new Promise((resolve5, reject) => {
+    child.on("error", reject);
+    child.on("close", (c) => resolve5(c));
+  });
+  let current = "";
+  const rl = createInterface({ input: child.stdout });
+  for await (const line of rl) {
+    if (line.startsWith("FSCOMMIT:")) {
+      current = line.slice("FSCOMMIT:".length).trim();
+      continue;
+    }
+    const match = RAW_LINE.exec(line);
+    if (match?.[3] !== void 0 && match[4] !== void 0 && match[6] !== void 0) {
+      const newHash = match[4];
+      const status = match[5] ?? "";
+      if (status.startsWith("D") || ZERO_HASH.test(newHash) || current.length === 0) continue;
+      const pathField = match[6];
+      const path = pathField.includes("	") ? pathField.split("	").pop() ?? pathField : pathField;
+      changes.push({ commit: current, hash: newHash, path });
+    }
+  }
+  let code;
+  try {
+    code = await closed;
+  } catch (error) {
+    throw gitError(error);
+  }
+  if (code !== 0) {
+    const err = Buffer.concat(stderrChunks).toString("utf8").trim();
+    throw gitError(new Error(err.length > 0 ? err : `git log exited ${code}`));
+  }
+  return changes;
+}
+async function headSecretKeys(cwd) {
+  const keys = /* @__PURE__ */ new Set();
+  let ls;
+  try {
+    ls = await gitOk(cwd, ["ls-tree", "-r", "--full-tree", "HEAD"]);
+  } catch {
+    return keys;
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const line of ls.split("\n")) {
+    const match = /^(\d{6}) blob ([0-9a-f]{40})\t(.+)$/.exec(line);
+    if (match?.[2] === void 0 || match[3] === void 0) continue;
+    const hash = match[2];
+    const path = match[3];
+    let hits = seen.get(hash);
+    if (hits === void 0) {
+      const text = await readBlob(cwd, hash);
+      if (text === void 0) continue;
+      hits = scanTextForSecretHits(path, text);
+      seen.set(hash, hits);
+    }
+    for (const hit of hits) {
+      keys.add(`${hit.finding.ruleId}\0${hit.finding.snippet ?? ""}`);
+    }
+  }
+  return keys;
+}
+async function scanGitHistory(cwd) {
+  const changes = await streamLogChanges(cwd);
+  const blobHits = /* @__PURE__ */ new Map();
+  const first = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    let hits2 = blobHits.get(change.hash);
+    if (hits2 === void 0) {
+      const text = await readBlob(cwd, change.hash);
+      if (text === void 0) {
+        blobHits.set(change.hash, []);
+        continue;
+      }
+      const rawHits = scanTextForSecretHits(change.path, text);
+      const allowed = new Set(
+        applyInlineSuppressions(
+          rawHits.map((h) => h.finding),
+          { [change.path]: text }
+        ).map((f) => f.id)
+      );
+      hits2 = rawHits.filter((h) => allowed.has(h.finding.id));
+      blobHits.set(change.hash, hits2);
+    }
+    for (const hit of hits2) {
+      const mapped = remapHit(hit, change.path);
+      if (!first.has(mapped.finding.id)) {
+        first.set(mapped.finding.id, { hit: mapped, commit: change.commit });
+      }
+    }
+  }
+  const atHead = await headSecretKeys(cwd);
+  const hits = [];
+  for (const { hit, commit } of first.values()) {
+    const stillAtHead = atHead.has(`${hit.finding.ruleId}\0${hit.finding.snippet ?? ""}`);
+    hits.push({
+      finding: { ...hit.finding, introducedIn: commit, stillAtHead },
+      secret: hit.secret
+    });
+  }
+  return { findings: hits.map((h) => h.finding), hits };
+}
+var execFileAsync2, ZERO_HASH, MAX_BLOB, RAW_LINE;
+var init_history = __esm({
+  "src/modules/secrets/history.ts"() {
+    init_suppression();
+    init_finding();
+    init_secrets();
+    execFileAsync2 = promisify(execFile);
+    ZERO_HASH = /^0+$/;
+    MAX_BLOB = 1024 * 1024;
+    RAW_LINE = /^:(\d{6}) (\d{6}) ([0-9a-f]{40}) ([0-9a-f]{40}) ([A-Z][0-9]*)\t(.+)$/;
+  }
+});
+
+// src/modules/secrets/bundle.ts
+var bundle_exports = {};
+__export(bundle_exports, {
+  scanBundle: () => scanBundle
+});
+function posixRel(root, full) {
+  return relative(root, full).split("\\").join("/");
+}
+async function listFiles(root) {
+  const files = [];
+  async function walk3(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS2.has(entry.name)) continue;
+        await walk3(full);
+      } else if (entry.isFile()) {
+        const base = entry.name;
+        if (FILE_OK.test(base) || ENV_NAME.test(base)) files.push(full);
+      }
+    }
+  }
+  const roots = /* @__PURE__ */ new Set([root]);
+  for (const sub of BUNDLE_SUBDIRS) roots.add(join(root, sub));
+  for (const dir of roots) {
+    try {
+      const s = await stat(dir);
+      if (s.isDirectory()) await walk3(dir);
+      else if (s.isFile()) files.push(dir);
+    } catch {
+    }
+  }
+  return files;
+}
+function isSecretShaped(name, value) {
+  if (value.startsWith("pk_live_") || value.startsWith("pk_test_")) return false;
+  if (/^https?:\/\//i.test(value)) return false;
+  if (value.includes(" ") || value.includes("${")) return false;
+  const probe = `const ${name} = "${value}";
+`;
+  if (scanTextForSecretHits("bundle.js", probe).some((h) => h.secret !== void 0)) return true;
+  if (!SECRETISH_NAME.test(name)) return false;
+  return value.length >= 16 && shannonEntropy(value) > 4.5;
+}
+function publicEnvHits(rel, text) {
+  const hits = [];
+  const folded = text.split(/\r?\n/).map((line) => line.replace(/(["'`])\s*\+\s*(["'`])/g, ""));
+  folded.forEach((line, index) => {
+    for (const match of everyMatch(PUBLIC_ENV, line)) {
+      const name = match[1];
+      const value = match[2] ?? match[3];
+      if (name === void 0 || value === void 0) continue;
+      if (!isSecretShaped(name, value)) continue;
+      const masked = maskSecret(value);
+      const lineNo = index + 1;
+      hits.push({
+        finding: {
+          id: makeFindingId("SECRET-BUNDLE-001", rel, `${lineNo}|${masked}`),
+          ruleId: "SECRET-BUNDLE-001",
+          module: "secrets",
+          title: "Secret-shaped value exposed to the browser",
+          severity: "high",
+          confidence: "medium",
+          cwe: "CWE-798",
+          file: rel,
+          line: lineNo,
+          snippet: masked,
+          message: `${name} is inlined into a client bundle (NEXT_PUBLIC_/VITE_* values are browser-visible).`,
+          remediation: BUNDLE_REMEDIATION
+        },
+        secret: value
+      });
+    }
+  });
+  return hits;
+}
+async function scanBundle(root) {
+  const hits = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const full of await listFiles(root)) {
+    if (seen.has(full)) continue;
+    seen.add(full);
+    let text;
+    try {
+      text = await readFile(full, "utf8");
+    } catch {
+      continue;
+    }
+    if (text.length > MAX_FILE || text.includes("\0")) continue;
+    const rel = posixRel(root, full) || full;
+    hits.push(...scanTextForSecretHits(rel, text), ...publicEnvHits(rel, text));
+  }
+  return { findings: hits.map((h) => h.finding), hits };
+}
+var BUNDLE_SUBDIRS, SKIP_DIRS2, FILE_OK, ENV_NAME, PUBLIC_ENV, SECRETISH_NAME, MAX_FILE, BUNDLE_REMEDIATION;
+var init_bundle = __esm({
+  "src/modules/secrets/bundle.ts"() {
+    init_finding();
+    init_mask();
+    init_secrets();
+    BUNDLE_SUBDIRS = ["dist", ".next/static", "build"];
+    SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", ".fullshield"]);
+    FILE_OK = /\.(?:[cm]?[jt]sx?|json|html?|css|map|env)(?:\..*)?$/i;
+    ENV_NAME = /^\.env(?:\..+)?$/;
+    PUBLIC_ENV = /\b((?:NEXT_PUBLIC_|VITE_)[A-Z0-9_]+)\s*[:=]\s*(?:["']([^"']{8,})["']|([^\s"'`,}]{8,}))/g;
+    SECRETISH_NAME = /(SECRET|TOKEN|PASSWORD|PASSWD|PWD|KEY)/i;
+    MAX_FILE = 1024 * 1024;
+    BUNDLE_REMEDIATION = "Remove this value from client code. NEXT_PUBLIC_ and VITE_ names are inlined into the browser bundle. Rotate the credential; shipping a secret to clients cannot be undone by deleting the source line.";
+  }
+});
+
+// src/modules/secrets/verify.ts
+var verify_exports = {};
+__export(verify_exports, {
+  applyVerification: () => applyVerification,
+  verifySecretHits: () => verifySecretHits
+});
+function classifyHttp(status) {
+  if (status === 200) return "live";
+  if (status === 401 || status === 403) return "revoked";
+  return "unknown";
+}
+async function call(fetchImpl, url, init) {
+  const res = await fetchImpl(url, {
+    ...init,
+    redirect: "error",
+    signal: init.signal ?? AbortSignal.timeout(8e3)
+  });
+  let json;
+  try {
+    json = await res.json();
+  } catch {
+    try {
+      await res.text();
+    } catch {
+    }
+  }
+  return { status: res.status, json };
+}
+async function verifyAws(secret, fetchImpl) {
+  try {
+    const { status } = await call(fetchImpl, AWS_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "X-Amz-Access-Key-Id": secret
+      },
+      body: "Action=GetCallerIdentity&Version=2011-06-15"
+    });
+    if (status === 200) return "live";
+    if (status === 401) return "revoked";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function verifyGithub(secret, fetchImpl) {
+  try {
+    const { status } = await call(fetchImpl, GITHUB_URL, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${secret}`,
+        Accept: "application/vnd.github+json",
+        "User-Agent": "fullshield"
+      }
+    });
+    return classifyHttp(status);
+  } catch {
+    return "unknown";
+  }
+}
+async function verifyStripe(secret, fetchImpl) {
+  try {
+    const { status } = await call(fetchImpl, STRIPE_URL, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${secret}` }
+    });
+    return classifyHttp(status);
+  } catch {
+    return "unknown";
+  }
+}
+async function verifySlack(secret, fetchImpl) {
+  try {
+    const { status, json } = await call(fetchImpl, SLACK_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${secret}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: ""
+    });
+    if (status !== 200) return classifyHttp(status);
+    if (typeof json === "object" && json !== null && "ok" in json) {
+      return json.ok === true ? "live" : "revoked";
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function providerFor(ruleId, secret) {
+  if (ruleId === "SECRET-AWS-001" || secret.startsWith("AKIA")) return verifyAws;
+  if (ruleId === "SECRET-GITHUB-001" || /^(?:ghp|gho|ghu|ghs|ghr)_/.test(secret)) return verifyGithub;
+  if (ruleId === "SECRET-STRIPE-001" || /^sk_(?:live|test)_/.test(secret)) return verifyStripe;
+  if (ruleId === "SECRET-SLACK-001" || /^xox[baprs]-/.test(secret)) return verifySlack;
+  return void 0;
+}
+async function verifySecretHits(hits, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const out = [];
+  for (const hit of hits) {
+    const secret = hit.secret;
+    if (secret === void 0 || secret.length === 0) {
+      out.push({ finding: { ...hit.finding, verification: "unknown" }, secret: hit.secret });
+      continue;
+    }
+    const run = providerFor(hit.finding.ruleId, secret);
+    const verification = run === void 0 ? "unknown" : await run(secret, fetchImpl);
+    out.push({ finding: { ...hit.finding, verification }, secret: hit.secret });
+  }
+  return out;
+}
+async function applyVerification(findings, secretById, options = {}) {
+  const hits = findings.filter((f) => f.module === "secrets").map((finding4) => ({ finding: finding4, secret: secretById.get(finding4.id) }));
+  const verified = await verifySecretHits(hits, options);
+  const byId = new Map(verified.map((h) => [h.finding.id, h.finding]));
+  return findings.map((f) => byId.get(f.id) ?? f);
+}
+var AWS_URL, GITHUB_URL, STRIPE_URL, SLACK_URL;
+var init_verify = __esm({
+  "src/modules/secrets/verify.ts"() {
+    AWS_URL = "https://sts.amazonaws.com/";
+    GITHUB_URL = "https://api.github.com/user";
+    STRIPE_URL = "https://api.stripe.com/v1/balance";
+    SLACK_URL = "https://slack.com/api/auth.test";
+  }
+});
+
 // src/modules/sast/ast.ts
 var SKIP_KEYS = /* @__PURE__ */ new Set(["loc", "range", "type", "parent"]);
 function propName(node) {
@@ -51,6 +996,24 @@ function calleeName(node) {
   if (node.callee.type === "MemberExpression") return propName(node.callee);
   return void 0;
 }
+function calleeChainHas(node, method) {
+  let current = node.callee;
+  for (let i = 0; i < 16 && current !== void 0; i += 1) {
+    if (current.type === "CallExpression") {
+      if (calleeName(current) === method) return true;
+      current = current.callee;
+      continue;
+    }
+    if (current.type === "MemberExpression") {
+      if (propName(current) === method) return true;
+      current = current.object;
+      continue;
+    }
+    if (current.type === "Identifier") return current.name === method;
+    break;
+  }
+  return false;
+}
 function literalString(node) {
   if (node === void 0) return void 0;
   if (node.type === "Literal" && typeof node.value === "string") return node.value;
@@ -121,17 +1084,19 @@ function attachParents(node, parent) {
     }
   }
 }
-var SOURCE_PROPS = /* @__PURE__ */ new Set(["query", "body", "params", "headers"]);
+var REQUEST_SOURCE_PROPS = /* @__PURE__ */ new Set(["query", "body", "params", "headers", "files"]);
+var SOURCE_PROPS = REQUEST_SOURCE_PROPS;
 function isTaintSource(node) {
-  if (node.type !== "MemberExpression") return false;
-  const name = propName(node);
-  if (node.object.type === "Identifier" && node.object.name === "req" && name !== void 0 && SOURCE_PROPS.has(name)) {
-    return true;
-  }
-  if (node.object.type === "Identifier" && node.object.name === "process" && name === "argv") {
-    return true;
+  if (node.type === "MemberExpression") {
+    const name = propName(node);
+    if (node.object.type === "Identifier" && node.object.name === "req" && name !== void 0 && SOURCE_PROPS.has(name)) {
+      return true;
+    }
+    if (node.object.type === "Identifier" && node.object.name === "process" && name === "argv") {
+      return true;
+    }
+    if (node.object.type === "MemberExpression" && isTaintSource(node.object)) return true;
   }
-  if (node.object.type === "MemberExpression" && isTaintSource(node.object)) return true;
   return false;
 }
 function isRequestObjectNode(node) {
@@ -151,6 +1116,7 @@ function assignedNameOf(node) {
     return parent.id.name;
   }
   if (parent.type === "AssignmentExpression" && parent.right === node) {
+    if (parent.left.type === "MemberExpression") return propName(parent.left);
     const names = boundNames(parent.left);
     return names[0];
   }
@@ -159,35 +1125,23 @@ function assignedNameOf(node) {
   }
   return void 0;
 }
-var SEVERITIES = ["info", "low", "medium", "high", "critical"];
-var MODULE_NAMES = ["deps", "secrets", "sast", "config"];
-function isSeverity(value) {
-  return SEVERITIES.includes(value);
-}
-function isModuleName(value) {
-  return MODULE_NAMES.includes(value);
-}
-function severityRank(severity) {
-  return SEVERITIES.indexOf(severity);
+
+// src/modules/sast/experimental.ts
+function sastGapsEnabled() {
+  return process.env.FULLSHIELD_EXPERIMENTAL_SAST_GAPS === "1";
 }
-function makeFindingId(ruleId, file, snippet) {
-  const normalized = (snippet ?? "").replace(/\s+/g, " ").trim();
-  return createHash("sha256").update(`${ruleId}\0${file ?? ""}\0${normalized}`).digest("hex").slice(0, 16);
+function frameworksEnabled() {
+  return process.env.FULLSHIELD_EXPERIMENTAL_FRAMEWORKS === "1";
 }
-function sortFindings(findings) {
-  return [...findings].sort(
-    (a, b) => severityRank(b.severity) - severityRank(a.severity) || (a.file ?? "").localeCompare(b.file ?? "") || (a.line ?? 0) - (b.line ?? 0) || a.ruleId.localeCompare(b.ruleId)
-  );
+function classesEnabled() {
+  return process.env.FULLSHIELD_EXPERIMENTAL_CLASSES === "1";
 }
-function summarize(findings) {
-  const bySeverity = Object.fromEntries(SEVERITIES.map((s) => [s, 0]));
-  for (const finding2 of findings) {
-    bySeverity[finding2.severity] += 1;
-  }
-  return { total: findings.length, bySeverity };
+function mcpCfgEnabled() {
+  return process.env.FULLSHIELD_EXPERIMENTAL_MCPCFG === "1";
 }
 
 // src/modules/config/finding.ts
+init_finding();
 function configFinding(ruleId, title, severity, file, message, remediation, line) {
   return {
     id: makeFindingId(ruleId, file, `${line ?? 0}|${title}`),
@@ -204,6 +1158,13 @@ function configFinding(ruleId, title, severity, file, message, remediation, line
 }
 
 // src/modules/config/astChecks.ts
+function lineAt(source, index) {
+  let line = 1;
+  for (let i = 0; i < index; i += 1) {
+    if (source[i] === "\n") line += 1;
+  }
+  return line;
+}
 function objectProp(node, name) {
   if (node.type !== "ObjectExpression") return void 0;
   for (const prop of node.properties) {
@@ -225,12 +1186,16 @@ async function runConfigAstChecks(file, source) {
   });
   const findings = [];
   let createsApp = false;
+  let createsAppLine;
   let usesHelmet = false;
   walk(ast, (node) => {
     if (node.type === "CallExpression") {
       const name = calleeName(node);
       if (name === "helmet") usesHelmet = true;
-      if (name === "express" && node.callee.type === "Identifier") createsApp = true;
+      if (name === "express" && node.callee.type === "Identifier") {
+        createsApp = true;
+        createsAppLine = node.loc?.start.line;
+      }
       if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "express" && name === "json") {
         const opts = node.arguments[0];
         const hasLimit = opts !== void 0 && opts.type !== "SpreadElement" && objectProp(opts, "limit") !== void 0;
@@ -248,6 +1213,19 @@ async function runConfigAstChecks(file, source) {
           );
         }
       }
+      if (name === "serveIndex") {
+        findings.push(
+          configFinding(
+            "CONFIG-DIRLIST-001",
+            "Directory listing enabled",
+            "medium",
+            file,
+            "serveIndex() exposes directory contents over HTTP.",
+            "Remove serve-index or restrict it behind auth; do not list ftp/logs/keys.",
+            node.loc?.start.line
+          )
+        );
+      }
       if (name === "cors") {
         const opts = node.arguments[0];
         if (opts !== void 0 && opts.type === "ObjectExpression") {
@@ -306,6 +1284,26 @@ async function runConfigAstChecks(file, source) {
       );
     }
   });
+  const commentedLines = [];
+  if (!usesHelmet) {
+    const commented = /^\s*\/\/\s*(?:(?:const|let|var)\s+helmet\b|app\.use\(\s*helmet\b|.*require\(\s*['"]helmet['"]\s*\))/gim;
+    for (const match of source.matchAll(commented)) {
+      const index = match.index ?? 0;
+      const line = lineAt(source, index);
+      commentedLines.push(line);
+      findings.push(
+        configFinding(
+          "CONFIG-HELMET-001",
+          "Express app does not use helmet",
+          "medium",
+          file,
+          "helmet is commented out; security headers are not applied.",
+          "Uncomment or add app.use(helmet()) to set standard security headers.",
+          line
+        )
+      );
+    }
+  }
   if (createsApp && !usesHelmet) {
     findings.push(
       configFinding(
@@ -314,10 +1312,52 @@ async function runConfigAstChecks(file, source) {
         "medium",
         file,
         "An Express app is created but helmet() is never applied.",
-        "Add app.use(helmet()) to set standard security headers."
+        "Add app.use(helmet()) to set standard security headers.",
+        // Keep a file-level finding when a comment already carries the line so
+        // scoring treats that as line-attribution, not a new detection.
+        commentedLines.length > 0 ? void 0 : createsAppLine
       )
     );
   }
+  if (classesEnabled()) {
+    let trustProxyTrue = false;
+    let ipRateLimit = false;
+    let trustLine;
+    walk(ast, (node) => {
+      if (node.type !== "CallExpression") return;
+      const name = calleeName(node);
+      if (name === "set" && literalString(node.arguments[0]) === "trust proxy") {
+        const value = node.arguments[1];
+        if (value !== void 0 && value.type === "Literal" && value.value === true) {
+          trustProxyTrue = true;
+          trustLine = node.loc?.start.line;
+        }
+      }
+      if (name === "enable" && literalString(node.arguments[0]) === "trust proxy") {
+        trustProxyTrue = true;
+        trustLine = node.loc?.start.line;
+      }
+      if (name === "rateLimit" || name === "slowDown") {
+        const opts = node.arguments[0];
+        const keyGen = opts !== void 0 && opts.type !== "SpreadElement" ? objectProp(opts, "keyGenerator") : void 0;
+        const keyedByIp = keyGen === void 0 || keyGen.type !== "SpreadElement" && /ip/i.test(source.slice(keyGen.range?.[0] ?? 0, keyGen.range?.[1] ?? 0));
+        if (keyedByIp) ipRateLimit = true;
+      }
+    });
+    if (trustProxyTrue && ipRateLimit) {
+      findings.push(
+        configFinding(
+          "CONFIG-TRUSTPROXY-001",
+          "trust proxy true with IP-based rate limiting",
+          "high",
+          file,
+          "app.set('trust proxy', true) makes X-Forwarded-For spoofable while rate limits key on IP.",
+          "Set trust proxy to a hop count or subnet, and key rate limits on a verified identity\u2014not the raw client IP.",
+          trustLine
+        )
+      );
+    }
+  }
   return findings;
 }
 
@@ -471,6 +1511,9 @@ var configModule = {
   }
 };
 
+// src/modules/deps/index.ts
+init_finding();
+
 // src/modules/deps/lockfile.ts
 function basename2(filename) {
   const parts = filename.replace(/\\/g, "/").split("/");
@@ -862,6 +1905,30 @@ function isExactNpmVersion(spec) {
   if (/[~^><*xX|]/.test(bare)) return false;
   return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(bare);
 }
+var MANIFEST_DEP_FIELDS = /"(dependencies|devDependencies|optionalDependencies)"\s*:/;
+function lineOfManifestDep(raw, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const depLine = new RegExp(`^\\s*"${escaped}"\\s*:`);
+  let inBlock = false;
+  let depth = 0;
+  const lines = raw.split(/\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const startsBlock = MANIFEST_DEP_FIELDS.test(line);
+    if (startsBlock) {
+      inBlock = true;
+      depth = 0;
+    }
+    if (!inBlock) continue;
+    for (const ch of line) {
+      if (ch === "{") depth += 1;
+      if (ch === "}") depth -= 1;
+    }
+    if (depLine.test(line) && depth >= 1) return i + 1;
+    if (depth <= 0 && !startsBlock) inBlock = false;
+  }
+  return void 0;
+}
 function exactPinsFromManifest(pkg) {
   const out = [];
   for (const field of MANIFEST_FIELDS) {
@@ -877,6 +1944,7 @@ function exactPinsFromManifest(pkg) {
 }
 
 // src/modules/deps/reachability.ts
+init_finding();
 function packageNameFromSnippet(snippet) {
   if (snippet.startsWith("@")) {
     const second = snippet.indexOf("@", 1);
@@ -1016,26 +2084,26 @@ function isDevOnly(pkgName, ctx) {
   return directDev.has(pkgName) || reachableFrom(pkgName, directDev, edges);
 }
 function applyReachability(findings, ctx) {
-  return findings.map((finding2) => {
-    if (finding2.ruleId === "DEPS-MALICIOUS-001") {
-      if (finding2.snippet === void 0) return finding2;
-      const pkg2 = packageNameFromSnippet(finding2.snippet);
-      if (pkg2 === void 0 || pkg2.length === 0) return finding2;
+  return findings.map((finding4) => {
+    if (finding4.ruleId === "DEPS-MALICIOUS-001") {
+      if (finding4.snippet === void 0) return finding4;
+      const pkg2 = packageNameFromSnippet(finding4.snippet);
+      if (pkg2 === void 0 || pkg2.length === 0) return finding4;
       const classified2 = classifyReachability(pkg2, ctx.productionUsage, ctx.graph);
       return {
-        ...finding2,
+        ...finding4,
         severity: "critical",
         reachability: classified2.reachability,
         ...classified2.path !== void 0 ? { dependencyPath: classified2.path } : {}
       };
     }
-    if (finding2.ruleId !== "DEPS-VULN-001" || finding2.snippet === void 0) return finding2;
-    const pkg = packageNameFromSnippet(finding2.snippet);
-    if (pkg === void 0 || pkg.length === 0) return finding2;
+    if (finding4.ruleId !== "DEPS-VULN-001" || finding4.snippet === void 0) return finding4;
+    const pkg = packageNameFromSnippet(finding4.snippet);
+    if (pkg === void 0 || pkg.length === 0) return finding4;
     const classified = classifyReachability(pkg, ctx.productionUsage, ctx.graph);
     const steps = reachabilitySteps(classified.reachability);
-    let severity = steps === 0 ? finding2.severity : downgradeSeverity(finding2.severity, steps);
-    let message = finding2.message;
+    let severity = steps === 0 ? finding4.severity : downgradeSeverity(finding4.severity, steps);
+    let message = finding4.message;
     if (classified.path !== void 0) {
       const shown = classified.path.join(" > ");
       message = `${message} Reachable via ${shown}.`;
@@ -1046,7 +2114,7 @@ function applyReachability(findings, ctx) {
       message = `${message} (dev-only)`;
     }
     return {
-      ...finding2,
+      ...finding4,
       reachability: classified.reachability,
       ...classified.path !== void 0 ? { dependencyPath: classified.path } : {},
       severity,
@@ -2949,6 +4017,250 @@ function findTyposquats(packages, options = {}) {
   return hits;
 }
 
+// src/supply/experimental.ts
+function experimentalVex() {
+  return process.env.FULLSHIELD_EXPERIMENTAL_VEX === "1";
+}
+
+// src/fixer/eol.ts
+function detectEol(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function applyEol(text, eol) {
+  const normalized = normalizeNewlines(text);
+  return eol === "\n" ? normalized : normalized.replace(/\n/g, "\r\n");
+}
+
+// src/fixer/diff.ts
+function unifiedDiff(filename, before, after) {
+  const oldNorm = normalizeNewlines(before);
+  const newNorm = normalizeNewlines(after);
+  if (oldNorm === newNorm) return "";
+  const oldLines = oldNorm.split("\n");
+  const newLines = newNorm.split("\n");
+  const hunks = [`--- a/${filename}`, `+++ b/${filename}`];
+  hunks.push(`@@ -1,${oldLines.length} +1,${newLines.length} @@`);
+  for (const line of oldLines) hunks.push(`-${line}`);
+  for (const line of newLines) hunks.push(`+${line}`);
+  return hunks.join("\n");
+}
+
+// src/fixer/override.ts
+function lockfileKind(filename) {
+  const base = filename.replace(/\\/g, "/").split("/").pop() ?? filename;
+  if (base === "package-lock.json") return "npm";
+  if (base === "yarn.lock") return "yarn";
+  if (base === "pnpm-lock.yaml") return "pnpm";
+  return void 0;
+}
+function stringMap(value) {
+  if (value === void 0 || value === null || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") out[key] = entry;
+  }
+  return out;
+}
+function objectMap(value) {
+  if (value === void 0 || value === null || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+function withManifestOverride(manifestRaw, kind, name, version) {
+  let pkg;
+  try {
+    pkg = JSON.parse(manifestRaw);
+  } catch {
+    return manifestRaw;
+  }
+  if (kind === "yarn") {
+    pkg.resolutions = { ...stringMap(pkg.resolutions), [name]: version };
+  } else if (kind === "pnpm") {
+    const pnpm = objectMap(pkg.pnpm);
+    pnpm.overrides = { ...stringMap(pnpm.overrides), [name]: version };
+    pkg.pnpm = pnpm;
+  } else {
+    pkg.overrides = { ...stringMap(pkg.overrides), [name]: version };
+  }
+  return `${JSON.stringify(pkg, null, 2)}
+`;
+}
+
+// src/supply/index.ts
+init_finding();
+function finding(ruleId, title, message, file, severity = "high") {
+  return {
+    id: makeFindingId(ruleId, file, message),
+    ruleId,
+    module: "deps",
+    title,
+    severity,
+    confidence: "high",
+    file,
+    message,
+    remediation: "Do not install this package until the behavior is reviewed. Use --ignore-scripts."
+  };
+}
+function walkJs(dir, out = []) {
+  if (!existsSync(dir)) return out;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules") continue;
+      walkJs(full, out);
+    } else if (entry.isFile() && /\.(js|cjs|mjs|ts)$/.test(entry.name)) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+var TOKEN_RE = /(?:~\/)?\.npmrc\b|\bNPM_TOKEN\b|\bGITHUB_TOKEN\b/;
+var PUBLISH_RE = /\bnpm\s+publish\b|\bnpmPublish\b|\blibnpmpublish\b/;
+var REGISTRY_PUT_RE = /registry\.npmjs\.org[\s\S]{0,800}\bPUT\b|\bmethod\s*:\s*['"]PUT['"][\s\S]{0,400}registry\.npmjs\.org/;
+var GITHUB_CREATE_RE = /api\.github\.com\/(?:user\/repos|repos\/)|\/actions\/workflows/;
+var WORKFLOW_PATH_RE = /\.github\/workflows/;
+var CI_WRITE_RE = /\.github\/|\.git\/hooks\/|\.gitlab-ci\.yml|\.travis\.yml|azure-pipelines(?:\.yml)?|Jenkinsfile|\.circleci\//;
+function packageSources(dir) {
+  const manifestPath = join(dir, "package.json");
+  let scripts = "";
+  if (existsSync(manifestPath) && statSync(manifestPath).isFile()) {
+    try {
+      const pkg = readJson(manifestPath);
+      const block = pkg.scripts ?? {};
+      scripts = Object.values(block).join("\n");
+    } catch {
+      scripts = "";
+    }
+  }
+  const sources = walkJs(dir).map((file) => ({
+    file: relative(dir, file) || file,
+    text: readFileSync(file, "utf8")
+  }));
+  return { sources, scripts };
+}
+function analyzeWormIndicators(dir) {
+  const { sources, scripts } = packageSources(dir);
+  if (sources.length === 0 && scripts.length === 0) return [];
+  const text = `${sources.map((s) => s.text).join("\n")}
+${scripts}`;
+  if (!TOKEN_RE.test(text)) return [];
+  const replicates = PUBLISH_RE.test(text) || REGISTRY_PUT_RE.test(text) || GITHUB_CREATE_RE.test(text) || WORKFLOW_PATH_RE.test(text);
+  if (!replicates) return [];
+  const hit = sources.find(
+    (s) => TOKEN_RE.test(s.text) && (PUBLISH_RE.test(s.text) || REGISTRY_PUT_RE.test(s.text) || GITHUB_CREATE_RE.test(s.text) || WORKFLOW_PATH_RE.test(s.text))
+  ) ?? sources.find((s) => TOKEN_RE.test(s.text));
+  return [
+    finding(
+      "SUPPLY-WORM-001",
+      "Self-replicating worm indicators in dependency code",
+      "static: npm/GitHub token read combined with publish, registry PUT, GitHub repo/workflow creation, or writing .github/workflows",
+      hit?.file,
+      "critical"
+    )
+  ];
+}
+function analyzeWorkflowTampering(dir) {
+  const { sources, scripts } = packageSources(dir);
+  const text = `${sources.map((s) => s.text).join("\n")}
+${scripts}`;
+  if (!CI_WRITE_RE.test(text)) return [];
+  const hit = sources.find((s) => CI_WRITE_RE.test(s.text));
+  return [
+    finding(
+      "SUPPLY-WORKFLOW-001",
+      "Dependency writes GitHub workflow, git hooks, or CI config",
+      "static: install script or package code writes .github/, .git/hooks/, or CI configuration",
+      hit?.file ?? (CI_WRITE_RE.test(scripts) ? "package.json" : void 0),
+      "critical"
+    )
+  ];
+}
+
+// src/modules/deps/phase31.ts
+function packageNameFromSnippet2(snippet) {
+  if (snippet.startsWith("@")) {
+    const second = snippet.indexOf("@", 1);
+    return second === -1 ? snippet : snippet.slice(0, second);
+  }
+  const at = snippet.indexOf("@");
+  return at <= 0 ? snippet : snippet.slice(0, at);
+}
+function parentsOf(name, edges) {
+  const out = [];
+  for (const [from, tos] of edges) {
+    if (tos.has(name)) out.push(from);
+  }
+  return out;
+}
+function isDirect(name, graph) {
+  return graph.directProd.has(name) || graph.directDev.has(name);
+}
+function packagesWithAFixedRelease(findings) {
+  const names = /* @__PURE__ */ new Set();
+  for (const finding4 of findings) {
+    if (finding4.ruleId !== "DEPS-VULN-001" || finding4.snippet === void 0) continue;
+    if (!/Upgrade \S+ to \S+ or later/.test(finding4.remediation)) continue;
+    names.add(packageNameFromSnippet2(finding4.snippet));
+  }
+  return names;
+}
+function targetVersion(finding4) {
+  const match = /Upgrade \S+ to (\S+) or later/.exec(finding4.remediation);
+  return match?.[1];
+}
+function kindFromLockfile(lockFile) {
+  return lockfileKind(lockFile) ?? "npm";
+}
+function attachOverrideProposals(findings, graph, lockFile, manifestRaw) {
+  if (!graph.edgesKnown || manifestRaw === void 0) return findings;
+  const withFix = packagesWithAFixedRelease(findings);
+  const kind = kindFromLockfile(lockFile);
+  return findings.map((finding4) => {
+    if (finding4.ruleId !== "DEPS-VULN-001" || finding4.snippet === void 0) return finding4;
+    const name = packageNameFromSnippet2(finding4.snippet);
+    if (name.length === 0 || isDirect(name, graph)) return finding4;
+    const version = targetVersion(finding4);
+    if (version === void 0) return finding4;
+    const parentFixed = parentsOf(name, graph.edges).some((parent) => withFix.has(parent));
+    if (parentFixed) return finding4;
+    const after = withManifestOverride(manifestRaw, kind, name, version);
+    const diff = unifiedDiff("package.json", manifestRaw, after);
+    if (diff.length === 0) return finding4;
+    return {
+      ...finding4,
+      fix: { kind: "dependency-override", safe: false, diff }
+    };
+  });
+}
+function packageDir(cwd, pkg) {
+  const candidates = [join(cwd, pkg.path), join(cwd, "node_modules", pkg.name)];
+  return candidates.find((dir) => existsSync(dir));
+}
+function scanInstalledPackages(cwd, packages) {
+  const out = [];
+  for (const pkg of packages) {
+    const dir = packageDir(cwd, pkg);
+    if (dir === void 0) continue;
+    const prefix = pkg.path.startsWith("node_modules/") ? pkg.path : `node_modules/${pkg.name}`;
+    for (const hit of [...analyzeWormIndicators(dir), ...analyzeWorkflowTampering(dir)]) {
+      out.push({
+        ...hit,
+        file: hit.file !== void 0 && hit.file.length > 0 ? `${prefix}/${hit.file}` : prefix
+      });
+    }
+  }
+  return out;
+}
+
 // src/modules/deps/index.ts
 var LOCKFILE_NAMES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"];
 function defaultCacheDir() {
@@ -2971,27 +4283,29 @@ async function readDirectDependencyNames(cwd) {
     return void 0;
   }
 }
-function vulnFinding(lockFile, pkg, vuln) {
+function vulnFinding(lockFile, pkg, vuln, loc) {
   const snippet = `${pkg.name}@${pkg.version}`;
   const aliases = (vuln.aliases ?? []).filter((a) => a.startsWith("CVE-"));
   const references = [vuln.id, ...aliases];
   const summary = vuln.summary ?? "known vulnerability";
   const fixed = minFixedVersion(vuln.affected ?? []);
-  const finding2 = {
-    id: makeFindingId("DEPS-VULN-001", lockFile, `${snippet}|${vuln.id}`),
+  const file = loc?.file ?? lockFile;
+  const finding4 = {
+    id: makeFindingId("DEPS-VULN-001", file, `${snippet}|${vuln.id}`),
     ruleId: "DEPS-VULN-001",
     module: "deps",
     title: `Vulnerable dependency ${snippet}`,
     severity: osvSeverity(vuln),
     confidence: "high",
-    file: lockFile,
+    file,
+    line: loc?.line,
     snippet,
     message: `${snippet} is affected by ${vuln.id} (${summary}).`,
     remediation: fixed ? `Upgrade ${pkg.name} to ${fixed} or later (data from OSV).` : `Upgrade ${pkg.name} to a version that OSV does not mark as affected.`,
     references
   };
   if (fixed !== void 0) {
-    finding2.fix = {
+    finding4.fix = {
       kind: "dependency-bump",
       safe: sameMajor(pkg.version, fixed),
       diff: `--- a/package.json
@@ -3000,7 +4314,7 @@ function vulnFinding(lockFile, pkg, vuln) {
 `
     };
   }
-  return finding2;
+  return finding4;
 }
 var MALICIOUS_REMEDIATION = "Remove the package from package.json and the lockfile, delete node_modules, reinstall, and rotate any credentials on machines that installed it. Install scripts run at npm install regardless of whether application code imports the package.";
 function maliciousFinding(lockFile, pkg, vuln) {
@@ -3068,12 +4382,23 @@ var depsModule = {
     const lockFile = LOCKFILE_NAMES.find((name) => ctx.files.includes(name));
     const cacheDir = ctx.config.deps.cacheDir !== void 0 ? resolve(ctx.cwd, ctx.config.deps.cacheDir) : defaultCacheDir();
     const osvOpts = { cacheDir, offline: ctx.config.deps.offline };
+    let manifestRaw;
+    try {
+      manifestRaw = await readFile(join(ctx.cwd, "package.json"), "utf8");
+    } catch {
+      manifestRaw = void 0;
+    }
+    const depLoc = (name) => {
+      if (manifestRaw === void 0) return void 0;
+      const line = lineOfManifestDep(manifestRaw, name);
+      return line === void 0 ? void 0 : { file: "package.json", line };
+    };
     if (lockFile === void 0) {
       if (!ctx.files.includes("package.json")) return [];
       const findings2 = [noLockFinding()];
       let manifest = {};
       try {
-        manifest = JSON.parse(await readFile(join(ctx.cwd, "package.json"), "utf8"));
+        manifest = JSON.parse(manifestRaw ?? "{}");
       } catch {
         return findings2;
       }
@@ -3086,7 +4411,7 @@ var depsModule = {
       for (const hit of osvHits2) {
         for (const vuln of hit.vulns) {
           findings2.push(
-            isMaliciousAdvisory(vuln) ? maliciousFinding("package.json", hit.pkg, vuln) : vulnFinding("package.json", hit.pkg, vuln)
+            isMaliciousAdvisory(vuln) ? maliciousFinding("package.json", hit.pkg, vuln) : vulnFinding("package.json", hit.pkg, vuln, depLoc(hit.pkg.name))
           );
         }
       }
@@ -3110,44 +4435,532 @@ var depsModule = {
         findings.push(deprecatedFinding(lockFile, pkg));
       }
     }
-    const osvHits = await queryOsv(packages, osvOpts);
-    for (const hit of osvHits) {
-      for (const vuln of hit.vulns) {
+    const osvHits = await queryOsv(packages, osvOpts);
+    for (const hit of osvHits) {
+      for (const vuln of hit.vulns) {
+        findings.push(
+          isMaliciousAdvisory(vuln) ? maliciousFinding(lockFile, hit.pkg, vuln) : vulnFinding(lockFile, hit.pkg, vuln, depLoc(hit.pkg.name))
+        );
+      }
+    }
+    let reached = applyReachability(findings, await reachabilityCtx(ctx.cwd, ctx.files, graph));
+    if (experimentalVex()) {
+      reached = attachOverrideProposals(reached, graph, lockFile, manifestRaw);
+      reached.push(...scanInstalledPackages(ctx.cwd, packages));
+    }
+    return reached;
+  }
+};
+function graphFromManifest(manifest) {
+  const keys = (field) => {
+    const block = manifest[field];
+    if (block !== null && typeof block === "object" && !Array.isArray(block)) {
+      return new Set(Object.keys(block));
+    }
+    return /* @__PURE__ */ new Set();
+  };
+  return {
+    packages: [],
+    edges: /* @__PURE__ */ new Map(),
+    directProd: keys("dependencies"),
+    directDev: keys("devDependencies"),
+    edgesKnown: false
+  };
+}
+async function reachabilityCtx(cwd, files, graph) {
+  const prodSources = /* @__PURE__ */ new Map();
+  for (const rel of files) {
+    if (!/\.[cm]?[jt]sx?$/.test(rel)) continue;
+    if (!isProductionSource(rel)) continue;
+    try {
+      prodSources.set(rel, await readFile(join(cwd, rel), "utf8"));
+    } catch {
+    }
+  }
+  return { productionUsage: indexPackageUsage(prodSources), graph };
+}
+
+// src/modules/mcp/index.ts
+init_finding();
+init_mask();
+var FLAG = "FULLSHIELD_EXPERIMENTAL_MCPCFG";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage"]);
+var SECRET_NAME = /(key|secret|token|passw(or)?d|pwd|credential|auth)/i;
+var ENV_REF = /^\s*(?:\$\{[A-Za-z_][\w]*\}|\$[A-Za-z_][\w]*|%[A-Za-z_][\w]*%)\s*$/;
+var INJECT_PHRASE = /ignore previous|ignore all previous|hidden instruction|do not tell (?:the )?user|you are now|system prompt/i;
+var ZERO_WIDTH = /[\u200B\u200C\u200D\uFEFF\u2060\u202E\u2066\u2067\u2068\u2069]|\\u(?:200b|200c|200d|feff|2060|202e|206[6-9])/i;
+var DANGEROUS_TOOL = /\.(?:tool|registerTool|addTool)\(\s*['"`](shell|exec|bash|cmd|run_command|execute|write_file|writeFile|fs_write)['"`]/i;
+var ALLOWLIST = /allowed(?:Directories|Paths|Commands|Roots)|allowlist/;
+var FS_PKG = /server-filesystem|mcp-filesystem/i;
+var SHELL_PKG = /server-shell|mcp-server-commands|mcp-shell|server-everything/i;
+var NPX = /^(npx|bunx|pnpx)(?:\.cmd)?$/i;
+var DLX_CMD = /^(pnpm|yarn|npm)(?:\.cmd)?$/i;
+function mcpCfgEnabled2() {
+  return process.env[FLAG] === "1";
+}
+function finding2(ruleId, title, message, file, severity, extra) {
+  return {
+    id: makeFindingId(ruleId, file, `${extra.line ?? 0}|${extra.snippet ?? message}`),
+    ruleId,
+    module: "config",
+    title,
+    severity,
+    confidence: "medium",
+    cwe: extra.cwe,
+    file,
+    line: extra.line,
+    snippet: extra.snippet,
+    message,
+    remediation: extra.remediation
+  };
+}
+function lineOf(text, needle) {
+  const idx = text.indexOf(needle);
+  if (idx < 0) return 1;
+  return text.slice(0, idx).split(/\r?\n/).length;
+}
+function stripJsonc(text) {
+  return text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(stripJsonc(text));
+  } catch {
+    return void 0;
+  }
+}
+function commandBase(command) {
+  if (typeof command !== "string") return "";
+  const norm = command.replaceAll("\\", "/");
+  return norm.split("/").pop() ?? command;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string");
+}
+function isNpmSpec(spec) {
+  if (spec.startsWith("-") || spec.startsWith(".") || spec.startsWith("/") || spec.includes("\\")) return false;
+  if (spec.includes("://") || /\.[cm]?[jt]sx?$/.test(spec)) return false;
+  return true;
+}
+function specUnpinned(spec) {
+  if (!isNpmSpec(spec)) return false;
+  if (/@latest(?:[/]|$)/i.test(spec) || spec.endsWith("@*")) return true;
+  const rest = spec.startsWith("@") ? spec.slice(1) : spec;
+  const at = rest.lastIndexOf("@");
+  if (at > 0) {
+    const ver = rest.slice(at + 1);
+    if (/^\d/.test(ver)) return false;
+    if (ver === "latest" || ver === "*") return true;
+  }
+  return /^(@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/.test(spec);
+}
+function looksSecretValue(value) {
+  if (ENV_REF.test(value)) return false;
+  if (/\b(?:AKIA[0-9A-Z]{16}|sk-[A-Za-z0-9_-]{20,}|ghp_[A-Za-z0-9]{36})\b/.test(value)) return true;
+  if (value.length >= 20 && shannonEntropy(value) > 4.5) return true;
+  return value.length >= 12;
+}
+function unrestrictedPath(path) {
+  const n = path.replaceAll("\\", "/").trim();
+  return n === "/" || n === "/*" || n === "*" || n === "~" || /^[A-Za-z]:\/?$/.test(path);
+}
+function pathAllowArgs(args) {
+  const out = [];
+  for (const arg of args) {
+    if (arg.startsWith("-") || specUnpinned(arg) || /^(@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+@/.test(arg)) continue;
+    if (arg.startsWith(".") || arg.startsWith("/") || arg.includes("\\") || arg === "~" || arg === "*") {
+      out.push(arg);
+    }
+  }
+  return out;
+}
+function hasAllowlist(server, text) {
+  for (const key of ["allowedDirectories", "allowedPaths", "allowedCommands", "roots", "allowlist", "allow"]) {
+    const v = server[key];
+    if (Array.isArray(v) && v.length > 0 && !v.every((p) => typeof p === "string" && unrestrictedPath(p))) {
+      return true;
+    }
+  }
+  return ALLOWLIST.test(text);
+}
+function serverEntries(root) {
+  if (root === null || typeof root !== "object" || Array.isArray(root)) return [];
+  const obj = root;
+  const block = obj.mcpServers ?? obj.servers;
+  if (block === null || typeof block !== "object" || Array.isArray(block)) return [];
+  const out = [];
+  for (const [name, value] of Object.entries(block)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      out.push({ name, server: value });
+    }
+  }
+  return out;
+}
+function visitStrings(value, visit, key = "") {
+  if (typeof value === "string") {
+    visit(key, value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) visitStrings(item, visit, key);
+    return;
+  }
+  if (value !== null && typeof value === "object") {
+    for (const [k, v] of Object.entries(value)) visitStrings(v, visit, k);
+  }
+}
+function isMcpConfigRel(rel, name) {
+  const n = rel.replaceAll("\\", "/");
+  if (name === ".mcp.json" || n.endsWith("/.mcp.json")) return true;
+  if (name === "claude_desktop_config.json") return true;
+  if (name === "mcp.json" && (n === ".cursor/mcp.json" || n.endsWith("/.cursor/mcp.json"))) return true;
+  if (name === "mcp.json" && (n === ".vscode/mcp.json" || n.endsWith("/.vscode/mcp.json"))) return true;
+  return false;
+}
+function isSourceName(name) {
+  return /\.[cm]?[jt]sx?$/.test(name);
+}
+function collectRepoFiles(dir, out = [], rel = "") {
+  if (!existsSync(dir)) return out;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const childRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      collectRepoFiles(abs, out, childRel);
+    } else if (entry.isFile()) {
+      if (isMcpConfigRel(childRel, entry.name) || isSourceName(entry.name)) {
+        out.push({ abs, rel: childRel });
+      }
+    }
+  }
+  return out;
+}
+function mcpHomeConfigPaths(home) {
+  const paths = [join(home, ".cursor", "mcp.json"), join(home, ".vscode", "mcp.json"), join(home, ".mcp.json")];
+  if (process.platform === "darwin") {
+    paths.push(join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"));
+  } else if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+    paths.push(join(appData, "Claude", "claude_desktop_config.json"));
+  } else {
+    paths.push(join(home, ".config", "Claude", "claude_desktop_config.json"));
+  }
+  return paths;
+}
+function scanJsonConfig(file, text, findings) {
+  const parsed = parseJson(text);
+  for (const { server } of serverEntries(parsed)) {
+    const args = asStringArray(server.args);
+    const cmd = commandBase(server.command);
+    const env = server.env;
+    if (env !== null && typeof env === "object" && !Array.isArray(env)) {
+      for (const [key, value] of Object.entries(env)) {
+        if (typeof value !== "string" || ENV_REF.test(value)) continue;
+        if (!SECRET_NAME.test(key) && !looksSecretValue(value)) continue;
         findings.push(
-          isMaliciousAdvisory(vuln) ? maliciousFinding(lockFile, hit.pkg, vuln) : vulnFinding(lockFile, hit.pkg, vuln)
+          finding2(
+            "MCP-001",
+            "Secret inlined in MCP config",
+            "MCP server env has an inline secret; use an environment-variable reference instead.",
+            file,
+            "high",
+            {
+              line: lineOf(text, key),
+              snippet: maskSecret(value),
+              remediation: "Replace inline secrets with env refs such as ${GITHUB_TOKEN} and rotate the exposed value.",
+              cwe: "CWE-798"
+            }
+          )
         );
       }
     }
-    return applyReachability(findings, await reachabilityCtx(ctx.cwd, ctx.files, graph));
+    const npxish = NPX.test(cmd) || DLX_CMD.test(cmd) && args.some((a) => a === "dlx" || a === "exec");
+    if (npxish && args.some((a) => specUnpinned(a))) {
+      findings.push(
+        finding2(
+          "MCP-002",
+          "Unpinned npx MCP server",
+          "MCP server is launched via unpinned npx / @latest (supply-chain risk).",
+          file,
+          "medium",
+          {
+            line: lineOf(text, "npx") || lineOf(text, "@latest"),
+            snippet: args.find((a) => specUnpinned(a))?.slice(0, 80),
+            remediation: "Pin the MCP server package to an exact version (pkg@1.2.3), not @latest or a bare name.",
+            cwe: "CWE-494"
+          }
+        )
+      );
+    }
+    const joinedArgs = args.join(" ");
+    const commandText = typeof server.command === "string" ? server.command : "";
+    const fsServer = FS_PKG.test(joinedArgs) || FS_PKG.test(commandText);
+    const shellServer = SHELL_PKG.test(joinedArgs) || SHELL_PKG.test(commandText);
+    const paths = pathAllowArgs(args);
+    const unrestrictedFs = fsServer && (paths.length === 0 || paths.some(unrestrictedPath));
+    if ((unrestrictedFs || shellServer) && !hasAllowlist(server, text)) {
+      findings.push(
+        finding2(
+          "MCP-003",
+          "MCP shell/exec or unrestricted filesystem tool",
+          "MCP server exposes shell/exec or unrestricted filesystem writes without an allowlist.",
+          file,
+          "medium",
+          {
+            line: lineOf(text, args[0] ?? "mcp"),
+            remediation: "Restrict filesystem roots to project directories and deny shell/exec tools unless an allowlist is enforced.",
+            cwe: "CWE-250"
+          }
+        )
+      );
+    }
   }
-};
-function graphFromManifest(manifest) {
-  const keys = (field) => {
-    const block = manifest[field];
-    if (block !== null && typeof block === "object" && !Array.isArray(block)) {
-      return new Set(Object.keys(block));
+  visitStrings(parsed, (key, val) => {
+    if (key === "description" && (INJECT_PHRASE.test(val) || ZERO_WIDTH.test(val) || val.includes("<!--"))) {
+      findings.push(
+        finding2(
+          "MCP-004",
+          "MCP tool description instruction injection",
+          "Tool description contains instruction-injection text, hidden markup, or zero-width characters.",
+          file,
+          "high",
+          {
+            line: lineOf(text, val.slice(0, 24)) || lineOf(text, "description"),
+            snippet: val.replace(ZERO_WIDTH, "").slice(0, 80),
+            remediation: "Keep tool descriptions literal and user-facing; strip hidden/zero-width characters and model-directed instructions.",
+            cwe: "CWE-74"
+          }
+        )
+      );
     }
-    return /* @__PURE__ */ new Set();
-  };
-  return {
-    packages: [],
-    edges: /* @__PURE__ */ new Map(),
-    directProd: keys("dependencies"),
-    directDev: keys("devDependencies"),
-    edgesKnown: false
-  };
+    if ((key === "url" || key === "serverUrl" || key === "href" || key === "endpoint") && /^http:\/\//i.test(val.trim())) {
+      findings.push(
+        finding2(
+          "MCP-005",
+          "Remote MCP over plaintext HTTP",
+          "Remote MCP server is configured with http:// instead of https://.",
+          file,
+          "medium",
+          {
+            line: lineOf(text, val),
+            snippet: val.slice(0, 80),
+            remediation: "Use https:// for remote MCP servers so tokens and tool traffic are not sent in the clear.",
+            cwe: "CWE-319"
+          }
+        )
+      );
+    }
+  });
 }
-async function reachabilityCtx(cwd, files, graph) {
-  const prodSources = /* @__PURE__ */ new Map();
-  for (const rel of files) {
-    if (!/\.[cm]?[jt]sx?$/.test(rel)) continue;
-    if (!isProductionSource(rel)) continue;
-    try {
-      prodSources.set(rel, await readFile(join(cwd, rel), "utf8"));
-    } catch {
+function scanServerSource(file, text, findings) {
+  if (!/\.(?:tool|registerTool|addTool)\s*\(/.test(text) && !/@modelcontextprotocol/.test(text)) return;
+  if (DANGEROUS_TOOL.test(text) && !ALLOWLIST.test(text)) {
+    findings.push(
+      finding2(
+        "MCP-003",
+        "MCP shell/exec or unrestricted filesystem tool",
+        "MCP server code registers shell/exec or filesystem-write tools without an allowlist.",
+        file,
+        "medium",
+        {
+          line: lineOf(text, "tool("),
+          remediation: "Do not expose shell/exec or unrestricted writes; gate them with an allowlist and a confirm step (see guardTools).",
+          cwe: "CWE-250"
+        }
+      )
+    );
+  }
+  if (INJECT_PHRASE.test(text) || ZERO_WIDTH.test(text)) {
+    findings.push(
+      finding2(
+        "MCP-004",
+        "MCP tool description instruction injection",
+        "MCP tool description contains instruction-injection text, hidden markup, or zero-width characters.",
+        file,
+        "high",
+        {
+          line: lineOf(text, "Ignore previous") || lineOf(text, "ignore previous"),
+          remediation: "Keep tool descriptions literal and user-facing; strip hidden/zero-width characters and model-directed instructions.",
+          cwe: "CWE-74"
+        }
+      )
+    );
+  }
+}
+function scanOne(abs, file, findings) {
+  let text;
+  try {
+    text = readFileSync(abs, "utf8");
+  } catch {
+    return;
+  }
+  if (text.length > 1024 * 1024 || text.includes("\0")) return;
+  if (file.endsWith(".json") || file.endsWith(".mcp.json")) scanJsonConfig(file, text, findings);
+  else scanServerSource(file, text, findings);
+}
+function scanMcpConfig(dir, opts = {}) {
+  if (!opts.experimental && !mcpCfgEnabled2()) return [];
+  if (!existsSync(dir) || !statSync(dir).isDirectory()) return [];
+  const findings = [];
+  for (const file of collectRepoFiles(dir)) {
+    scanOne(file.abs, file.rel, findings);
+  }
+  if (opts.includeHome === true) {
+    for (const abs of mcpHomeConfigPaths(homedir())) {
+      if (!existsSync(abs) || !statSync(abs).isFile()) continue;
+      scanOne(abs, abs, findings);
     }
   }
-  return { productionUsage: indexPackageUsage(prodSources), graph };
+  return findings;
+}
+
+// src/modules/sast/engine.ts
+init_finding();
+
+// src/modules/sast/interproc.ts
+init_finding();
+
+// src/modules/sast/frameworks.ts
+var NEXT_HANDLERS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var NEST_HTTP = /^(Get|Post|Put|Patch|Delete|All|Head|Options)$/;
+var NEST_INPUT = /^(Body|Query|Param|Headers)$/;
+var REQ_READERS = /* @__PURE__ */ new Set(["json", "formData", "text", "arrayBuffer"]);
+var HONO_READERS = /* @__PURE__ */ new Set(["query", "param", "header", "json", "parseBody", "text"]);
+function decoratorExpr(dec) {
+  if (dec.type !== "Decorator") return void 0;
+  return dec.expression;
+}
+function decoratorName(dec) {
+  const expr = decoratorExpr(dec);
+  if (expr === void 0) return void 0;
+  if (expr.type === "Identifier") return expr.name;
+  if (expr.type === "CallExpression") return calleeName(expr);
+  return void 0;
+}
+function nodeDecorators(node) {
+  const decs = node.decorators;
+  return Array.isArray(decs) ? decs : [];
+}
+function nestInputDecorator(param) {
+  if (!frameworksEnabled()) return void 0;
+  for (const dec of nodeDecorators(param)) {
+    const name = decoratorName(dec);
+    if (name !== void 0 && NEST_INPUT.test(name)) return name;
+  }
+  return void 0;
+}
+function nestDecoratorArgCount(param, name) {
+  for (const dec of nodeDecorators(param)) {
+    if (decoratorName(dec) !== name) continue;
+    const expr = decoratorExpr(dec);
+    if (expr?.type === "CallExpression") return expr.arguments.length;
+    return 0;
+  }
+  return 0;
+}
+function isCtxIdent(node) {
+  return node.type === "Identifier" && node.name === "ctx";
+}
+function isCReq(node) {
+  return node.type === "MemberExpression" && node.object.type === "Identifier" && node.object.name === "c" && propName(node) === "req";
+}
+function isCtxRequest(node) {
+  return node.type === "MemberExpression" && isCtxIdent(node.object) && propName(node) === "request";
+}
+function isFrameworkMemberTaint(node) {
+  if (!frameworksEnabled() || node.type !== "MemberExpression") return false;
+  const name = propName(node);
+  if (name === void 0) return false;
+  if (isCtxIdent(node.object) && (REQUEST_SOURCE_PROPS.has(name) || name === "query")) return true;
+  if (isCtxRequest(node.object) && REQUEST_SOURCE_PROPS.has(name)) return true;
+  return false;
+}
+function isFrameworkTaintCall(node) {
+  if (!frameworksEnabled() || node.type !== "CallExpression") return false;
+  const name = calleeName(node);
+  if (name === void 0 || node.callee.type !== "MemberExpression") return false;
+  const obj = node.callee.object;
+  if (obj.type === "Identifier" && obj.name === "request" && REQ_READERS.has(name)) return true;
+  if (obj.type === "Identifier" && (obj.name === "formData" || obj.name === "searchParams") && name === "get") {
+    return true;
+  }
+  if (obj.type === "MemberExpression" && propName(obj) === "searchParams" && name === "get") return true;
+  if (isCReq(obj) && HONO_READERS.has(name)) return true;
+  return false;
+}
+function isFrameworkRequestObject(node) {
+  if (!frameworksEnabled()) return false;
+  if (node.type === "AwaitExpression") return isFrameworkRequestObject(node.argument);
+  if (node.type === "CallExpression") {
+    const name = calleeName(node);
+    if (name !== "json" && name !== "formData") return false;
+    if (node.callee.type !== "MemberExpression") return false;
+    const obj = node.callee.object;
+    if (obj.type === "Identifier" && obj.name === "request") return true;
+    return isCReq(obj);
+  }
+  if (node.type === "MemberExpression") {
+    const name = propName(node);
+    if (name !== "body" && name !== "query" && name !== "params") return false;
+    return isCtxRequest(node.object) || isCtxIdent(node.object);
+  }
+  return false;
+}
+function isNextHandler(node) {
+  if (!frameworksEnabled() || node.type !== "FunctionDeclaration" || node.id === null) return false;
+  if (!NEXT_HANDLERS.has(node.id.name)) return false;
+  const parent = node.parent;
+  return parent?.type === "ExportNamedDeclaration";
+}
+function isNestHttpMethod(node) {
+  if (!frameworksEnabled() || node.type !== "MethodDefinition") return false;
+  return nodeDecorators(node).some((d) => {
+    const n = decoratorName(d);
+    return n !== void 0 && NEST_HTTP.test(n);
+  });
+}
+function nestMethodHasGuard(node) {
+  if (nodeDecorators(node).some((d) => decoratorName(d) === "UseGuards")) return true;
+  const cls = node.parent?.parent;
+  if (cls) return nodeDecorators(cls).some((d) => decoratorName(d) === "UseGuards");
+  return false;
+}
+function handlerHasFrameworkAuth(handler) {
+  let yes = false;
+  walk(handler, (child) => {
+    if (child.type !== "CallExpression") return;
+    const name = calleeName(child);
+    if (name !== void 0 && /^(auth|cookies|getServerSession|getToken|requireAuth|authenticate)$/i.test(name)) {
+      yes = true;
+    }
+  });
+  return yes;
+}
+
+// src/modules/sast/mcp.ts
+function isMcpToolHandler(fn) {
+  if (!mcpCfgEnabled()) return false;
+  const parent = fn.parent;
+  if (parent === void 0 || parent.type !== "CallExpression") return false;
+  const name = calleeName(parent);
+  if (name !== "tool" && name !== "registerTool" && name !== "addTool") return false;
+  const args = parent.arguments;
+  return args[args.length - 1] === fn;
+}
+function isMcpArgsTaintSource(node) {
+  if (!mcpCfgEnabled() || node.type !== "MemberExpression") return false;
+  if (propName(node) !== "arguments") return false;
+  const obj = node.object;
+  return obj.type === "MemberExpression" && propName(obj) === "params";
 }
 
 // src/modules/sast/taint.ts
@@ -3183,6 +4996,15 @@ function isUrlSanitizerCall(node) {
   const name = calleeName(node);
   return name === "encodeURIComponent" || name === "encodeURI";
 }
+function isCoercionCall(node) {
+  if (node === void 0 || node.type !== "CallExpression") return false;
+  return node.callee.type === "Identifier" && (node.callee.name === "String" || node.callee.name === "Number" || node.callee.name === "Boolean");
+}
+function isMongoSanitizeCall(node) {
+  if (node === void 0 || node.type !== "CallExpression") return false;
+  const name = calleeName(node);
+  return name === "mongoSanitize" || name === "mongo_sanitize";
+}
 function isXssSanitizerCall(node) {
   if (node === void 0 || node.type !== "CallExpression") return false;
   const name = calleeName(node);
@@ -3192,44 +5014,60 @@ function isXssSanitizerCall(node) {
   }
   return false;
 }
-function exprIsTainted(node, tainted) {
+var NO_RETURNERS = /* @__PURE__ */ new Set();
+function exprIsTainted(node, tainted, returners = NO_RETURNERS) {
   if (node === void 0) return false;
-  if (isTaintSource(node)) return true;
+  if (isTaintSource(node) || isFrameworkMemberTaint(node) || isFrameworkTaintCall(node) || isMcpArgsTaintSource(node)) {
+    return true;
+  }
   switch (node.type) {
+    case "AwaitExpression":
+      return exprIsTainted(node.argument, tainted, returners);
     case "Identifier":
       return tainted.has(node.name);
     case "MemberExpression":
-      return exprIsTainted(node.object, tainted);
+      return exprIsTainted(node.object, tainted, returners);
     case "CallExpression":
       if (isSchemaValidatorCall(node)) return false;
-      return node.arguments.some((arg) => arg.type !== "SpreadElement" && exprIsTainted(arg, tainted));
+      if (node.callee.type === "Identifier" && returners.has(node.callee.name)) return true;
+      if (node.callee.type === "MemberExpression" && exprIsTainted(node.callee.object, tainted, returners)) {
+        return true;
+      }
+      return node.arguments.some(
+        (arg) => arg.type !== "SpreadElement" && exprIsTainted(arg, tainted, returners)
+      );
     case "NewExpression":
-      return node.arguments.some((arg) => arg.type !== "SpreadElement" && exprIsTainted(arg, tainted));
+      if (exprIsTainted(node.callee, tainted, returners)) return true;
+      return node.arguments.some(
+        (arg) => arg.type !== "SpreadElement" && exprIsTainted(arg, tainted, returners)
+      );
     case "TemplateLiteral":
-      return node.expressions.some((expr) => exprIsTainted(expr, tainted));
+      return node.expressions.some((expr) => exprIsTainted(expr, tainted, returners));
+    case "TaggedTemplateExpression":
+      return exprIsTainted(node.quasi, tainted, returners);
     case "BinaryExpression":
-      return node.operator === "+" && (exprIsTainted(node.left, tainted) || exprIsTainted(node.right, tainted));
+      return node.operator === "+" && (exprIsTainted(node.left, tainted, returners) || exprIsTainted(node.right, tainted, returners));
     case "AssignmentExpression":
-      return exprIsTainted(node.right, tainted);
+      return exprIsTainted(node.right, tainted, returners);
     case "LogicalExpression":
-      return exprIsTainted(node.left, tainted) || exprIsTainted(node.right, tainted);
+      return exprIsTainted(node.left, tainted, returners) || exprIsTainted(node.right, tainted, returners);
     case "ConditionalExpression":
-      return exprIsTainted(node.consequent, tainted) || exprIsTainted(node.alternate, tainted);
+      return exprIsTainted(node.consequent, tainted, returners) || exprIsTainted(node.alternate, tainted, returners);
     case "ChainExpression":
-      return exprIsTainted(node.expression, tainted);
+      return exprIsTainted(node.expression, tainted, returners);
     case "TSAsExpression":
     case "TSNonNullExpression":
     case "TSTypeAssertion":
-      return exprIsTainted(node.expression, tainted);
+      return exprIsTainted(node.expression, tainted, returners);
     default:
       return false;
   }
 }
-function exprIsSanitized(node, tainted, names, isCall) {
+function exprIsSanitized(node, tainted, names, isCall, returners = NO_RETURNERS) {
   if (node === void 0) return true;
   if (isCall(node)) return true;
   if (node.type === "Identifier") return names.has(node.name) || !tainted.has(node.name);
-  if (!exprIsTainted(node, tainted)) return true;
+  if (!exprIsTainted(node, tainted, returners)) return true;
   if (node.type === "BinaryExpression" && node.operator === "+") {
     return exprIsSanitized(node.left, tainted, names, isCall) && exprIsSanitized(node.right, tainted, names, isCall);
   }
@@ -3261,16 +5099,50 @@ function walkScope(scope, visit) {
   }
   inner(scope);
 }
-function analyzeScope(scope, seed = []) {
+function seedDestructuredRequestParams(scope, tainted) {
+  if (!isFunctionNode(scope)) return;
+  for (const param of scope.params) {
+    if (param.type !== "ObjectPattern") continue;
+    for (const prop of param.properties) {
+      if (prop.type !== "Property") continue;
+      const key = prop.key.type === "Identifier" ? prop.key.name : void 0;
+      if (key === void 0 || !REQUEST_SOURCE_PROPS.has(key)) continue;
+      for (const name of boundNames(prop.value)) tainted.add(name);
+    }
+  }
+}
+function seedFrameworkParams(scope, tainted) {
+  if (!frameworksEnabled() || !isFunctionNode(scope)) return;
+  for (const param of scope.params) {
+    if (param.type === "Identifier" && param.name === "formData") tainted.add("formData");
+    const nest = nestInputDecorator(param);
+    if (nest === void 0) continue;
+    for (const name of boundNames(param)) tainted.add(name);
+  }
+}
+function seedMcpToolParams(scope, tainted) {
+  if (!isFunctionNode(scope) || !isMcpToolHandler(scope)) return;
+  for (const param of scope.params) {
+    for (const name of boundNames(param)) tainted.add(name);
+  }
+}
+function analyzeScope(scope, seed = [], returners = NO_RETURNERS) {
   const tainted = new Set(seed);
+  seedDestructuredRequestParams(scope, tainted);
+  seedFrameworkParams(scope, tainted);
+  seedMcpToolParams(scope, tainted);
   const urlSanitized = /* @__PURE__ */ new Set();
   const xssSanitized = /* @__PURE__ */ new Set();
+  const nosqlSanitized = /* @__PURE__ */ new Set();
   let changed = true;
   while (changed) {
     changed = false;
     walkScope(scope, (node) => {
       if (node.type === "VariableDeclarator") {
         const init = node.init ?? void 0;
+        if (isSchemaValidatorCall(init) || isCoercionCall(init) || isMongoSanitizeCall(init)) {
+          for (const name of boundNames(node.id)) nosqlSanitized.add(name);
+        }
         if (isSchemaValidatorCall(init)) return;
         if (isUrlSanitizerCall(init)) {
           for (const name of boundNames(node.id)) urlSanitized.add(name);
@@ -3278,7 +5150,7 @@ function analyzeScope(scope, seed = []) {
         if (isXssSanitizerCall(init)) {
           for (const name of boundNames(node.id)) xssSanitized.add(name);
         }
-        if (exprIsTainted(init, tainted)) {
+        if (exprIsTainted(init, tainted, returners)) {
           for (const name of boundNames(node.id)) {
             if (!tainted.has(name)) {
               tainted.add(name);
@@ -3288,6 +5160,9 @@ function analyzeScope(scope, seed = []) {
         }
       }
       if (node.type === "AssignmentExpression") {
+        if (isSchemaValidatorCall(node.right) || isCoercionCall(node.right) || isMongoSanitizeCall(node.right)) {
+          for (const name of boundNames(node.left)) nosqlSanitized.add(name);
+        }
         if (isSchemaValidatorCall(node.right)) return;
         if (isUrlSanitizerCall(node.right)) {
           for (const name of boundNames(node.left)) urlSanitized.add(name);
@@ -3295,7 +5170,7 @@ function analyzeScope(scope, seed = []) {
         if (isXssSanitizerCall(node.right)) {
           for (const name of boundNames(node.left)) xssSanitized.add(name);
         }
-        if (exprIsTainted(node.right, tainted)) {
+        if (exprIsTainted(node.right, tainted, returners)) {
           for (const name of boundNames(node.left)) {
             if (!tainted.has(name)) {
               tainted.add(name);
@@ -3333,6 +5208,16 @@ function analyzeScope(scope, seed = []) {
     hasPasswordName = true;
   }
   const requestObjects = /* @__PURE__ */ new Set();
+  if (frameworksEnabled() && isFunctionNode(scope)) {
+    for (const param of scope.params) {
+      const nest = nestInputDecorator(param);
+      if (nest === "Body" || nest === "Query" || nest === "Param") {
+        if (nestDecoratorArgCount(param, nest) === 0) {
+          for (const name of boundNames(param)) requestObjects.add(name);
+        }
+      }
+    }
+  }
   walkScope(scope, (node) => {
     if (node.type === "VariableDeclarator" && node.init !== null && isRequestObjectNode(node.init)) {
       for (const name of boundNames(node.id)) requestObjects.add(name);
@@ -3340,18 +5225,110 @@ function analyzeScope(scope, seed = []) {
     if (node.type === "AssignmentExpression" && isRequestObjectNode(node.right)) {
       for (const name of boundNames(node.left)) requestObjects.add(name);
     }
+    if (node.type === "VariableDeclarator" && node.init !== null && isFrameworkRequestObject(node.init)) {
+      for (const name of boundNames(node.id)) requestObjects.add(name);
+    }
+    if (node.type === "AssignmentExpression" && isFrameworkRequestObject(node.right)) {
+      for (const name of boundNames(node.left)) requestObjects.add(name);
+    }
   });
-  return { tainted, pathSanitized, urlSanitized, xssSanitized, hasPasswordName, requestObjects };
+  return {
+    tainted,
+    pathSanitized,
+    urlSanitized,
+    xssSanitized,
+    nosqlSanitized,
+    hasPasswordName,
+    requestObjects,
+    returners: new Set(returners)
+  };
+}
+function functionName(fn) {
+  if (fn.type === "FunctionDeclaration" && fn.id !== null) return fn.id.name;
+  if (isFunctionNode(fn) && fn.id !== null && fn.id.type === "Identifier") return fn.id.name;
+  return assignedNameOf(fn);
+}
+function scopeReturnsTaint(scope, tainted, returners) {
+  let yes = false;
+  walkScope(scope, (node) => {
+    if (node.type === "ReturnStatement" && node.argument !== null) {
+      if (exprIsTainted(node.argument, tainted, returners)) yes = true;
+    }
+  });
+  return yes;
 }
-function analyzeFile(ast) {
+var MAX_TAINT_HOPS = 5;
+function analyzeFile(ast, extraReturners = NO_RETURNERS) {
   attachParents(ast);
   const facts = /* @__PURE__ */ new WeakMap();
-  facts.set(ast, analyzeScope(ast));
+  const functions = [];
   walk(ast, (node) => {
-    if (isFunctionNode(node)) facts.set(node, analyzeScope(node));
+    if (isFunctionNode(node)) functions.push(node);
   });
+  const nameToFn = /* @__PURE__ */ new Map();
+  for (const fn of functions) {
+    const name = functionName(fn);
+    if (name !== void 0) nameToFn.set(name, fn);
+  }
+  const seeds = /* @__PURE__ */ new Map();
+  for (const fn of functions) seeds.set(fn, /* @__PURE__ */ new Set());
+  const returners = new Set(extraReturners);
+  for (let hop = 0; hop < MAX_TAINT_HOPS; hop += 1) {
+    let changed = false;
+    facts.set(ast, analyzeScope(ast, [], returners));
+    for (const fn of functions) {
+      facts.set(fn, analyzeScope(fn, seeds.get(fn) ?? [], returners));
+    }
+    for (const fn of functions) {
+      const name = functionName(fn);
+      const f = facts.get(fn);
+      if (name === void 0 || f === void 0) continue;
+      if (scopeReturnsTaint(fn, f.tainted, returners) && !returners.has(name)) {
+        returners.add(name);
+        changed = true;
+      }
+    }
+    for (const fn of functions) {
+      const f = facts.get(fn);
+      if (f === void 0) continue;
+      walkScope(fn, (node) => {
+        if (node.type !== "CallExpression") return;
+        if (node.callee.type !== "Identifier") return;
+        const callee = nameToFn.get(node.callee.name);
+        if (callee === void 0 || !isFunctionNode(callee)) return;
+        node.arguments.forEach((arg, i) => {
+          if (arg.type === "SpreadElement") return;
+          if (!exprIsTainted(arg, f.tainted, returners)) return;
+          const param = callee.params[i];
+          if (param === void 0) return;
+          const pname = boundNames(param)[0];
+          if (pname === void 0) return;
+          const set = seeds.get(callee) ?? /* @__PURE__ */ new Set();
+          if (!set.has(pname)) {
+            set.add(pname);
+            seeds.set(callee, set);
+            changed = true;
+          }
+        });
+      });
+    }
+    if (!changed) break;
+  }
   return facts;
 }
+function functionsThatReturnTaint(ast) {
+  attachParents(ast);
+  const names = /* @__PURE__ */ new Set();
+  const facts = analyzeFile(ast);
+  walk(ast, (node) => {
+    if (!isFunctionNode(node)) return;
+    const name = functionName(node);
+    const f = facts.get(node);
+    if (name === void 0 || f === void 0) return;
+    if (scopeReturnsTaint(node, f.tainted, f.returners)) names.add(name);
+  });
+  return names;
+}
 function analyzeFunctionWithSeed(fn, seed) {
   attachParents(fn);
   return analyzeScope(fn, seed);
@@ -3362,12 +5339,15 @@ function factsFor(node, map) {
     pathSanitized: /* @__PURE__ */ new Set(),
     urlSanitized: /* @__PURE__ */ new Set(),
     xssSanitized: /* @__PURE__ */ new Set(),
+    nosqlSanitized: /* @__PURE__ */ new Set(),
     hasPasswordName: false,
-    requestObjects: /* @__PURE__ */ new Set()
+    requestObjects: /* @__PURE__ */ new Set(),
+    returners: /* @__PURE__ */ new Set()
   };
 }
 function nodeIsTainted(node, map) {
-  return exprIsTainted(node, factsFor(node, map).tainted);
+  const facts = factsFor(node, map);
+  return exprIsTainted(node, facts.tainted, facts.returners);
 }
 function nodeIsPathSanitized(node, map) {
   if (node.type !== "Identifier") return false;
@@ -3375,14 +5355,21 @@ function nodeIsPathSanitized(node, map) {
 }
 function nodeIsSanitizedFor(node, map, kind) {
   const facts = factsFor(node, map);
-  if (kind === "url") return exprIsSanitized(node, facts.tainted, facts.urlSanitized, isUrlSanitizerCall);
-  return exprIsSanitized(node, facts.tainted, facts.xssSanitized, isXssSanitizerCall);
+  if (kind === "url") {
+    return exprIsSanitized(node, facts.tainted, facts.urlSanitized, isUrlSanitizerCall, facts.returners);
+  }
+  return exprIsSanitized(node, facts.tainted, facts.xssSanitized, isXssSanitizerCall, facts.returners);
 }
 function nodeIsRequestObject(node, map) {
-  if (isRequestObjectNode(node)) return true;
+  if (isRequestObjectNode(node) || isFrameworkRequestObject(node)) return true;
   if (node.type === "Identifier") return factsFor(node, map).requestObjects.has(node.name);
   return false;
 }
+function nodeIsNosqlSanitized(node, map) {
+  if (isCoercionCall(node) || isSchemaValidatorCall(node) || isMongoSanitizeCall(node)) return true;
+  if (node.type === "Identifier") return factsFor(node, map).nosqlSanitized.has(node.name);
+  return false;
+}
 
 // src/modules/sast/interproc.ts
 var MAX_HOPS = 5;
@@ -3722,6 +5709,22 @@ var authRule = {
           node,
           message: `Route ${path ?? "(dynamic)"} touches database/user data with no auth middleware in the chain.`
         });
+      },
+      FunctionDeclaration(node) {
+        if (!isNextHandler(node) || !handlerTouchesDb(node) || handlerHasFrameworkAuth(node)) return;
+        ctx.report({
+          node,
+          message: `Next.js handler ${node.type === "FunctionDeclaration" && node.id ? node.id.name : ""} touches database/user data with no auth() / session check.`
+        });
+      },
+      MethodDefinition(node) {
+        if (node.type !== "MethodDefinition" || !isNestHttpMethod(node)) return;
+        if (nestMethodHasGuard(node)) return;
+        if (!handlerTouchesDb(node.value)) return;
+        ctx.report({
+          node,
+          message: "NestJS handler touches database/user data with no UseGuards / AuthGuard."
+        });
       }
     };
   }
@@ -3730,6 +5733,8 @@ var authRule = {
 // src/modules/sast/rules/cmdi.ts
 var ALWAYS_SHELL = /* @__PURE__ */ new Set(["exec", "execSync"]);
 var OPTIONAL_SHELL = /* @__PURE__ */ new Set(["spawn", "spawnSync", "execFile", "execFileSync"]);
+var INTERPRETERS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "cmd", "cmd.exe", "powershell", "pwsh"]);
+var DASH_C_CALLEES = /* @__PURE__ */ new Set(["spawn", "spawnSync", "execFile", "execFileSync", "execa"]);
 function optionsObject(node) {
   for (const arg of node.arguments) {
     if (arg.type === "ObjectExpression") return arg;
@@ -3760,6 +5765,45 @@ function argumentTainted(node, isTainted) {
   }
   return false;
 }
+function interpreterBase(node) {
+  const cmd = literalString(node.arguments[0]);
+  if (cmd === void 0) return void 0;
+  return cmd.replace(/^.*[/\\]/, "").toLowerCase();
+}
+function isInterpreterDashC(node, isTainted) {
+  const name = calleeName(node);
+  if (name === void 0 || !DASH_C_CALLEES.has(name)) return false;
+  const base = interpreterBase(node);
+  if (base === void 0 || !INTERPRETERS.has(base)) return false;
+  const args = node.arguments[1];
+  if (args === void 0 || args.type !== "ArrayExpression") return false;
+  for (let i = 0; i < args.elements.length; i += 1) {
+    const el = args.elements[i];
+    if (el == null || el.type === "SpreadElement") continue;
+    if (literalString(el) !== "-c") continue;
+    const next = args.elements[i + 1];
+    return next !== null && next !== void 0 && next.type !== "SpreadElement" && isTainted(next);
+  }
+  return false;
+}
+function isUnsafeZxTag(tag) {
+  if (tag.type === "MemberExpression" && propName(tag) === "raw") {
+    return tag.object.type === "Identifier" && tag.object.name === "$";
+  }
+  if (tag.type === "CallExpression" && tag.callee.type === "Identifier" && tag.callee.name === "$") {
+    const opts = tag.arguments[0];
+    if (opts === void 0 || opts.type !== "ObjectExpression") return false;
+    for (const prop of opts.properties) {
+      if (prop.type !== "Property") continue;
+      const key = prop.key.type === "Identifier" ? prop.key.name : literalString(prop.key);
+      if (key === "quote" && prop.value.type === "Literal" && prop.value.value === false) return true;
+    }
+  }
+  return false;
+}
+function isExecaShellTag(tag) {
+  return tag.type === "CallExpression" && calleeName(tag) === "execa" && hasShellTrue(tag);
+}
 var cmdiRule = {
   meta: {
     id: "SAST-CMDI-001",
@@ -3769,23 +5813,37 @@ var cmdiRule = {
     docs: "https://cwe.mitre.org/data/definitions/78.html"
   },
   create(ctx) {
+    const tainted = (n) => ctx.isTainted(n);
     return {
       CallExpression(node) {
         if (node.type !== "CallExpression") return;
         const name = calleeName(node);
         if (name === void 0) return;
-        const shell = ALWAYS_SHELL.has(name) || OPTIONAL_SHELL.has(name) && hasShellTrue(node);
+        const dashC = sastGapsEnabled() && isInterpreterDashC(node, tainted);
+        const execaCall = sastGapsEnabled() && name === "execa" && hasShellTrue(node);
+        const shell = ALWAYS_SHELL.has(name) || OPTIONAL_SHELL.has(name) && hasShellTrue(node) || dashC || execaCall;
         if (!shell) return;
         if (node.callee.type === "MemberExpression") {
           const obj = node.callee.object;
           const fromChild = obj.type === "Identifier" && (obj.name === "child_process" || obj.name === "cp") || propName(node.callee) !== void 0;
-          if (!fromChild && !ALWAYS_SHELL.has(name) && !OPTIONAL_SHELL.has(name)) return;
+          if (!fromChild && !ALWAYS_SHELL.has(name) && !OPTIONAL_SHELL.has(name) && !dashC && !execaCall) {
+            return;
+          }
         }
-        if (!argumentTainted(node, (n) => ctx.isTainted(n))) return;
+        if (!argumentTainted(node, tainted) && !dashC) return;
         ctx.report({
           node,
           message: "Tainted input reaches a shell command (exec/execSync/spawn with shell: true)."
         });
+      },
+      TaggedTemplateExpression(node) {
+        if (node.type !== "TaggedTemplateExpression" || !sastGapsEnabled()) return;
+        if (!isUnsafeZxTag(node.tag) && !isExecaShellTag(node.tag)) return;
+        if (!tainted(node.quasi)) return;
+        ctx.report({
+          node,
+          message: "Tainted input reaches a shell tagged template that does not auto-escape interpolations."
+        });
       }
     };
   }
@@ -3816,7 +5874,18 @@ var cryptoRule = {
           }
           return;
         }
-        if (calleeName(node) !== "createHash") return;
+        const name = calleeName(node);
+        if (name === "md5") {
+          const arg = node.arguments[0];
+          if (arg !== void 0 && arg.type !== "SpreadElement" && ctx.isTainted(arg)) {
+            ctx.report({
+              node,
+              message: "The md5 helper is used as a token or identifier over tainted input."
+            });
+          }
+          return;
+        }
+        if (name !== "createHash") return;
         const algo = literalString(node.arguments[0]);
         if (algo === void 0 || !WEAK_HASH.has(algo.toLowerCase())) return;
         if (!ctx.functionHasPasswordName(node)) return;
@@ -3926,21 +5995,105 @@ var jwtRule = {
       }
     };
   }
-};
-
-// src/modules/sast/rules/nosqli.ts
-var MONGO_SINKS = /* @__PURE__ */ new Set([
-  "find",
-  "findOne",
-  "findOneAndUpdate",
-  "update",
-  "updateOne",
-  "updateMany",
-  "deleteOne",
-  "deleteMany",
-  "remove",
-  "aggregate"
-]);
+};
+
+// src/modules/sast/rules/nosqli.ts
+var MONGO_SINKS = /* @__PURE__ */ new Set([
+  "find",
+  "findOne",
+  "findOneAndUpdate",
+  "update",
+  "updateOne",
+  "updateMany",
+  "deleteOne",
+  "deleteMany",
+  "remove",
+  "aggregate"
+]);
+var SQL_ONLY_METHODS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findMany",
+  "findFirst",
+  "findAll",
+  "findAndCountAll",
+  "findByPk",
+  "findById"
+]);
+var SQL_ORM_IMPORT = /(?:from|require\s*\(\s*)['"](?:sequelize|@prisma\/client|typeorm|knex|drizzle-orm)['"]/;
+var MONGO_IMPORT = /(?:from|require\s*\(\s*)['"](?:mongodb|mongoose)['"]/;
+function objectKey(prop) {
+  if (prop.type !== "Property" || prop.key === void 0) return void 0;
+  const key = prop.key;
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal") return String(key.value);
+  return literalString(key);
+}
+function objectHasKey(node, name) {
+  if (node.type !== "ObjectExpression") return false;
+  return node.properties.some((prop) => objectKey(prop) === name);
+}
+function isPascalModel(name) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(name);
+}
+function isCollectionName(name) {
+  return /^(collection|col)$/i.test(name) || /Collection$/i.test(name);
+}
+function isMongoReceiver(node, source) {
+  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") return false;
+  const fileHasMongo = MONGO_IMPORT.test(source);
+  const fileHasSqlOrm = SQL_ORM_IMPORT.test(source) && !fileHasMongo;
+  if (fileHasSqlOrm) return false;
+  const obj = node.callee.object;
+  if (obj.type === "Identifier") {
+    if (isCollectionName(obj.name)) return true;
+    if (isPascalModel(obj.name)) return !fileHasSqlOrm;
+    return fileHasMongo;
+  }
+  if (obj.type === "MemberExpression") {
+    const prop = propName(obj);
+    if (prop !== void 0 && (prop === "collection" || isCollectionName(prop))) return true;
+    if (prop !== void 0 && isPascalModel(prop)) return fileHasMongo;
+    if (obj.object.type === "Identifier" && obj.object.name === "mongoose") return true;
+  }
+  return fileHasMongo;
+}
+function objectHasTaintedWhere(node, isTainted) {
+  if (node.type !== "ObjectExpression") return false;
+  for (const prop of node.properties) {
+    if (prop.type !== "Property") continue;
+    const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" ? String(prop.key.value) : literalString(prop.key);
+    if (key === "$where" && isTainted(prop.value)) return true;
+  }
+  return false;
+}
+function fileHasMongoSanitizeMiddleware(source) {
+  return /(?:express-)?mongo-sanitize/.test(source) && /(?:app|router)\.use\(\s*(?:mongoSanitize|sanitize)\s*\(/.test(source);
+}
+function isSanitizeWrap(node, source) {
+  if (node.type !== "CallExpression") return false;
+  const name = calleeName(node);
+  return name === "sanitize" && /(?:express-)?mongo-sanitize/.test(source);
+}
+function isNosqlSafeValue(node, source, isNosqlSanitized) {
+  if (isNosqlSanitized(node) || isCoercionCall(node) || isSchemaValidatorCall(node) || isMongoSanitizeCall(node)) {
+    return true;
+  }
+  return isSanitizeWrap(node, source);
+}
+function objectHasUnsafeTaintedValue(node, isTainted, isSafe) {
+  if (node.type === "ArrayExpression") {
+    return node.elements.some((el) => el !== null && el.type !== "SpreadElement" && objectHasUnsafeTaintedValue(el, isTainted, isSafe));
+  }
+  if (node.type !== "ObjectExpression") return false;
+  for (const prop of node.properties) {
+    if (prop.type !== "Property") continue;
+    const value = prop.value;
+    if (isSafe(value)) continue;
+    if (isTainted(value)) return true;
+    if (objectHasUnsafeTaintedValue(value, isTainted, isSafe)) return true;
+  }
+  return false;
+}
 var nosqliRule = {
   meta: {
     id: "SAST-NOSQLI-001",
@@ -3950,24 +6103,58 @@ var nosqliRule = {
     docs: "https://cwe.mitre.org/data/definitions/943.html"
   },
   create(ctx) {
+    const middleware = fileHasMongoSanitizeMiddleware(ctx.source);
+    const isSafe = (n) => isNosqlSafeValue(n, ctx.source, (x) => ctx.isNosqlSanitized(x));
     return {
       CallExpression(node) {
         if (node.type !== "CallExpression") return;
         const name = calleeName(node);
+        if (name === "$where") {
+          if (!MONGO_IMPORT.test(ctx.source) && !isMongoReceiver(node, ctx.source)) return;
+          const expr = node.arguments[0];
+          if (expr !== void 0 && expr.type !== "SpreadElement" && ctx.isTainted(expr)) {
+            ctx.report({
+              node,
+              message: "Tainted input is passed to mongoose $where (server-side JS)."
+            });
+          }
+          return;
+        }
+        if (name !== void 0 && SQL_ONLY_METHODS.has(name)) return;
         if (name === void 0 || !MONGO_SINKS.has(name)) return;
+        if (!isMongoReceiver(node, ctx.source)) return;
         const filter = node.arguments[0];
         if (filter === void 0 || filter.type === "SpreadElement") return;
-        if (!ctx.isRequestObject(filter)) return;
-        ctx.report({
-          node,
-          message: "req.body/req.query is passed directly into a Mongo-style filter."
-        });
+        if (objectHasKey(filter, "where")) return;
+        if (ctx.isRequestObject(filter)) {
+          ctx.report({
+            node,
+            message: "req.body/req.query is passed directly into a Mongo-style filter."
+          });
+          return;
+        }
+        if (objectHasTaintedWhere(filter, (n) => ctx.isTainted(n))) {
+          ctx.report({
+            node,
+            message: "Tainted input is passed to a Mongo $where filter."
+          });
+          return;
+        }
+        if (middleware) return;
+        if (objectHasUnsafeTaintedValue(filter, (n) => ctx.isTainted(n), isSafe)) {
+          ctx.report({
+            node,
+            message: "Request input is used as a Mongo filter value without coercion, schema validation, or mongo-sanitize.",
+            confidence: "medium"
+          });
+        }
       }
     };
   }
 };
 
 // src/modules/sast/rules/path.ts
+var EXTRACT_SINKS = /* @__PURE__ */ new Set(["extractAllTo", "extractAll", "extract"]);
 var PATH_SINKS = /* @__PURE__ */ new Set([
   "sendFile",
   "readFile",
@@ -4009,7 +6196,15 @@ var pathRule = {
       CallExpression(node) {
         if (node.type !== "CallExpression") return;
         const name = calleeName(node);
-        if (name === void 0 || !PATH_SINKS.has(name)) return;
+        if (name === void 0) return;
+        if (EXTRACT_SINKS.has(name) && node.callee.type === "MemberExpression" && ctx.isTainted(node.callee.object)) {
+          ctx.report({
+            node,
+            message: "A tainted archive is extracted to the filesystem (zip-slip)."
+          });
+          return;
+        }
+        if (!PATH_SINKS.has(name) && !EXTRACT_SINKS.has(name)) return;
         const pathArg = node.arguments[0];
         if (pathArg === void 0 || pathArg.type === "SpreadElement") return;
         if (!ctx.isTainted(pathArg)) return;
@@ -4080,10 +6275,34 @@ var redirectRule = {
 };
 
 // src/modules/sast/rules/sqli.ts
+var STABLE_SQL_SINKS = /* @__PURE__ */ new Set(["query", "execute"]);
+var GAP_SQL_SINKS = /* @__PURE__ */ new Set([
+  "$queryRawUnsafe",
+  "$executeRawUnsafe",
+  "raw",
+  "literal",
+  "whereRaw",
+  "orderByRaw"
+]);
+function hasBindings(node) {
+  const second = node.arguments[1];
+  if (second === void 0 || second.type === "SpreadElement") return false;
+  return second.type === "ArrayExpression" || second.type === "ObjectExpression";
+}
 function isSqlSink2(node) {
-  if (node.type !== "CallExpression") return false;
   const name = calleeName(node);
-  return name === "query" || name === "execute";
+  if (name === void 0) return false;
+  if (STABLE_SQL_SINKS.has(name)) return true;
+  if (!sastGapsEnabled()) return false;
+  if (GAP_SQL_SINKS.has(name)) {
+    if ((name === "whereRaw" || name === "orderByRaw") && hasBindings(node)) return false;
+    return true;
+  }
+  if (name === "where" && calleeChainHas(node, "createQueryBuilder")) {
+    const first = node.arguments[0];
+    return first !== void 0 && first.type !== "ObjectExpression";
+  }
+  return false;
 }
 var sqliRule = {
   meta: {
@@ -4192,6 +6411,19 @@ var xssRule = {
     return {
       CallExpression(node) {
         if (node.type !== "CallExpression") return;
+        for (const arg2 of node.arguments) {
+          if (arg2.type !== "ObjectExpression") continue;
+          for (const prop of arg2.properties) {
+            if (prop.type !== "Property") continue;
+            const key = prop.key.type === "Identifier" ? prop.key.name : literalString(prop.key);
+            if (key === "autoescape" && prop.value.type === "Literal" && prop.value.value === false) {
+              ctx.report({
+                node,
+                message: "Template engine autoescape is disabled; interpolations are XSS sinks."
+              });
+            }
+          }
+        }
         const name = calleeName(node);
         if (name !== "send" && name !== "write") return;
         const arg = node.arguments[0];
@@ -4207,497 +6439,845 @@ var xssRule = {
   }
 };
 
-// src/ai/injection.ts
-var PHRASES = [/ignore previous/i, /mark as safe/i, /ai reviewer/i];
-function isCommentLine(line) {
-  const trimmed = line.trim();
-  return trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*");
+// src/modules/sast/rules/phase29.ts
+function gated(rule) {
+  return {
+    meta: rule.meta,
+    create(ctx) {
+      if (!classesEnabled()) return {};
+      return rule.create(ctx);
+    }
+  };
 }
-function scanPromptInjection(file, source) {
-  const findings = [];
-  const lines = source.split(/\r?\n/);
-  lines.forEach((line, index) => {
-    if (!isCommentLine(line)) return;
-    if (!PHRASES.some((p) => p.test(line))) return;
-    findings.push({
-      id: makeFindingId("AI-INJECT-001", file, `${index + 1}|${line.trim()}`),
-      ruleId: "AI-INJECT-001",
-      module: "sast",
-      title: "Prompt-injection comment aimed at AI reviewers",
-      severity: "medium",
-      confidence: "high",
-      file,
-      line: index + 1,
-      snippet: line.trim().slice(0, 120),
-      message: "Code contains text attempting to manipulate AI reviewers.",
-      remediation: "Remove comments that try to instruct an AI reviewer.",
-      references: ["AI-INJECT-001"],
-      source: "deterministic"
-    });
+function objectProp2(node, name) {
+  if (node === void 0 || node.type !== "ObjectExpression") return void 0;
+  for (const prop of node.properties) {
+    if (prop.type !== "Property") continue;
+    const key = prop.key.type === "Identifier" ? prop.key.name : literalString(prop.key);
+    if (key === name) return prop.value;
+  }
+  return void 0;
+}
+function boolLiteral(node) {
+  if (node === void 0 || node.type !== "Literal" || typeof node.value !== "boolean") return void 0;
+  return node.value;
+}
+function numberLiteral(node) {
+  if (node === void 0 || node.type !== "Literal" || typeof node.value !== "number") return void 0;
+  return node.value;
+}
+function containsIdentMember(node, objectName) {
+  let hit = false;
+  walk(node, (child) => {
+    if (child.type === "MemberExpression" && child.object.type === "Identifier" && child.object.name === objectName) {
+      hit = true;
+    }
   });
-  return findings;
+  return hit;
 }
-
-// src/modules/sast/engine.ts
-var sastRules = [
-  sqliRule,
-  cmdiRule,
-  pathRule,
-  evalRule,
-  jwtRule,
-  cryptoRule,
-  nosqliRule,
-  ssrfRule,
-  redirectRule,
-  protoRule,
-  xssRule,
-  authRule
-];
-var SOURCE_EXT = /\.[cm]?[jt]sx?$/;
-async function parseSource(code) {
-  const { parse } = await import('@typescript-eslint/typescript-estree');
-  return parse(code, {
-    loc: true,
-    range: true,
-    comment: false,
-    jsx: true,
-    errorOnUnknownASTType: false,
-    errorOnTypeScriptSyntacticAndSemanticIssues: false
+function containsCallNamed(node, name) {
+  let hit = false;
+  walk(node, (child) => {
+    if (child.type === "CallExpression" && calleeName(child) === name) hit = true;
   });
+  return hit;
 }
-function snippetOf(source, node) {
-  if (node.range === void 0) return "";
-  return source.slice(node.range[0], node.range[1]).replace(/\s+/g, " ").trim().slice(0, 120);
+function containsOriginalName(node) {
+  let hit = false;
+  walk(node, (child) => {
+    if (child.type === "MemberExpression" && propName(child) === "originalname") hit = true;
+  });
+  return hit;
 }
-function findingsFromAst(filename, source, ast) {
-  const facts = analyzeFile(ast);
-  const findings = [];
-  for (const rule of sastRules) {
-    const ctx = {
-      filename,
-      source,
-      report: ({ node, message }) => {
-        const snippet = snippetOf(source, node);
-        findings.push({
-          id: makeFindingId(rule.meta.id, filename, `${node.loc?.start.line ?? 0}|${snippet}`),
-          ruleId: rule.meta.id,
-          module: "sast",
-          title: rule.meta.title,
-          severity: rule.meta.severity,
-          confidence: "high",
-          cwe: rule.meta.cwe,
-          file: filename,
-          line: node.loc?.start.line,
-          column: node.loc?.start.column,
-          snippet,
-          message,
-          remediation: `${rule.meta.title}. See ${rule.meta.docs}`,
-          references: [rule.meta.docs, rule.meta.cwe]
-        });
-      },
-      isTainted: (node) => nodeIsTainted(node, facts),
-      isPathSanitized: (node) => nodeIsPathSanitized(node, facts),
-      isSanitizedFor: (node, kind) => nodeIsSanitizedFor(node, facts, kind),
-      isRequestObject: (node) => nodeIsRequestObject(node, facts),
-      functionHasPasswordName: (node) => factsFor(node, facts).hasPasswordName,
-      assignedName: (node) => assignedNameOf(node)
-    };
-    const visitors = rule.create(ctx);
-    walk(ast, (node) => {
-      visitors[node.type]?.(node);
-    });
+function schemaLooksSafe(schema) {
+  if (schema === void 0) return false;
+  const name = schema.type === "Identifier" ? schema.name : schema.type === "MemberExpression" ? propName(schema) : void 0;
+  return name !== void 0 && /^(JSON_SCHEMA|CORE_SCHEMA|FAILSAFE_SCHEMA|SAFE_SCHEMA)$/.test(name);
+}
+function firstsOverlap(a, b) {
+  if (a.kind === "none" || b.kind === "none") return false;
+  if (a.kind === "any" || b.kind === "any") return true;
+  return a.c === b.c;
+}
+function patternHasRedos(pattern) {
+  if (pattern.length > 2e3) return false;
+  const st = { i: 0 };
+  try {
+    const frag = parseAlts(pattern, st);
+    return frag.nested || frag.overlap;
+  } catch {
+    return false;
   }
-  findings.push(...scanPromptInjection(filename, source));
-  return findings;
 }
-function findingsFromTemplate(filename, source) {
-  const findings = [];
-  const ctx = {
-    filename,
-    source,
-    report: ({ node, message }) => {
-      const snippet = source.split(/\r?\n/)[(node.loc?.start.line ?? 1) - 1]?.trim().slice(0, 120) ?? "";
-      findings.push({
-        id: makeFindingId(xssRule.meta.id, filename, `${node.loc?.start.line ?? 0}|${snippet}`),
-        ruleId: xssRule.meta.id,
-        module: "sast",
-        title: xssRule.meta.title,
-        severity: xssRule.meta.severity,
-        confidence: "high",
-        cwe: xssRule.meta.cwe,
-        file: filename,
-        line: node.loc?.start.line,
-        column: node.loc?.start.column,
-        snippet,
-        message,
-        remediation: `${xssRule.meta.title}. See ${xssRule.meta.docs}`,
-        references: [xssRule.meta.docs, xssRule.meta.cwe]
-      });
-    },
-    isTainted: () => false,
-    isPathSanitized: () => false,
-    isSanitizedFor: () => false,
-    isRequestObject: () => false,
-    functionHasPasswordName: () => false,
-    assignedName: () => void 0
+function parseAlts(s, st) {
+  const parts = [parseSeq(s, st)];
+  while (s[st.i] === "|") {
+    st.i += 1;
+    parts.push(parseSeq(s, st));
+  }
+  let altOverlap = false;
+  for (let i = 0; i < parts.length; i += 1) {
+    for (let j = i + 1; j < parts.length; j += 1) {
+      if (firstsOverlap(parts[i]?.first ?? { kind: "none" }, parts[j]?.first ?? { kind: "none" })) {
+        altOverlap = true;
+      }
+    }
+  }
+  return {
+    nested: parts.some((p) => p.nested),
+    overlap: parts.some((p) => p.overlap),
+    canRepeatInner: parts.some((p) => p.canRepeatInner),
+    altOverlap: altOverlap || parts.some((p) => p.altOverlap),
+    first: parts[0]?.first ?? { kind: "none" }
   };
-  xssRule.create(ctx);
-  return findings;
 }
-var sastModule = {
-  name: "sast",
-  async run(ctx) {
-    const findings = [];
-    const parsed = [];
-    for (const rel of ctx.files) {
-      const isSource = SOURCE_EXT.test(rel);
-      const isTemplate = TEMPLATE_EXT.test(rel);
-      if (!isSource && !isTemplate) continue;
-      let source;
-      try {
-        source = await readFile(join(ctx.cwd, rel), "utf8");
-      } catch {
-        continue;
-      }
-      if (source.length > 1024 * 1024 || source.includes("\0")) continue;
-      if (isTemplate) {
-        findings.push(...findingsFromTemplate(rel, source));
-        continue;
-      }
-      try {
-        const ast = await parseSource(source);
-        parsed.push({ file: rel, source, ast });
-        findings.push(...findingsFromAst(rel, source, ast));
-      } catch {
-      }
+function parseSeq(s, st) {
+  const parts = [];
+  while (st.i < s.length && s[st.i] !== "|" && s[st.i] !== ")") {
+    parts.push(parseAtom(s, st));
+  }
+  if (parts.length === 0) {
+    return { nested: false, overlap: false, canRepeatInner: false, altOverlap: false, first: { kind: "none" } };
+  }
+  return {
+    nested: parts.some((p) => p.nested),
+    overlap: parts.some((p) => p.overlap),
+    canRepeatInner: parts.some((p) => p.canRepeatInner),
+    altOverlap: false,
+    first: parts.find((p) => p.first.kind !== "none")?.first ?? { kind: "none" }
+  };
+}
+function parseAtom(s, st) {
+  let frag;
+  const c = s[st.i];
+  if (c === void 0) {
+    return { nested: false, overlap: false, canRepeatInner: false, altOverlap: false, first: { kind: "none" } };
+  }
+  if (c === "(") {
+    st.i += 1;
+    if (s.startsWith("?:", st.i) || s.startsWith("?=", st.i) || s.startsWith("?!", st.i)) st.i += 2;
+    frag = parseAlts(s, st);
+    if (s[st.i] === ")") st.i += 1;
+  } else if (c === "[") {
+    st.i += 1;
+    if (s[st.i] === "^") st.i += 1;
+    while (st.i < s.length && s[st.i] !== "]") {
+      if (s[st.i] === "\\") st.i += 2;
+      else st.i += 1;
     }
-    findings.push(...runInterproc(parsed));
-    return findings;
+    if (s[st.i] === "]") st.i += 1;
+    frag = { nested: false, overlap: false, canRepeatInner: false, altOverlap: false, first: { kind: "any" } };
+  } else if (c === "\\") {
+    st.i += 1;
+    const esc = s[st.i];
+    st.i += 1;
+    const any = esc !== void 0 && /[dDwWsS]/.test(esc);
+    frag = {
+      nested: false,
+      overlap: false,
+      canRepeatInner: false,
+      altOverlap: false,
+      first: any ? { kind: "any" } : { kind: "char", c: esc ?? "" }
+    };
+  } else if (c === ".") {
+    st.i += 1;
+    frag = { nested: false, overlap: false, canRepeatInner: false, altOverlap: false, first: { kind: "any" } };
+  } else if (c === "^" || c === "$") {
+    st.i += 1;
+    frag = { nested: false, overlap: false, canRepeatInner: false, altOverlap: false, first: { kind: "none" } };
+  } else {
+    st.i += 1;
+    frag = { nested: false, overlap: false, canRepeatInner: false, altOverlap: false, first: { kind: "char", c } };
+  }
+  const q = parseQuantifier(s, st);
+  if (q === void 0) return frag;
+  if (!q.repeating) return frag;
+  return {
+    nested: frag.nested || frag.canRepeatInner,
+    overlap: frag.overlap || frag.altOverlap,
+    canRepeatInner: true,
+    altOverlap: false,
+    first: frag.first
+  };
+}
+function parseQuantifier(s, st) {
+  const c = s[st.i];
+  if (c === "*" || c === "+") {
+    st.i += 1;
+    if (s[st.i] === "?") st.i += 1;
+    return { repeating: true };
+  }
+  if (c === "?") {
+    st.i += 1;
+    return { repeating: false };
+  }
+  if (c !== "{") return void 0;
+  const rest = s.slice(st.i);
+  const m = rest.match(/^\{(\d+)(,(\d+)?)?\}/);
+  if (m === null) return void 0;
+  st.i += m[0].length;
+  if (s[st.i] === "?") st.i += 1;
+  const min = Number(m[1]);
+  const hasComma = m[2] !== void 0;
+  const max = m[3] !== void 0 ? Number(m[3]) : hasComma ? Number.POSITIVE_INFINITY : min;
+  return { repeating: max > 1 };
+}
+function regexPatternOf(node) {
+  if (node === void 0) return void 0;
+  if (node.type === "Literal" && "regex" in node && node.regex !== null) {
+    return node.regex.pattern;
   }
-};
-
-// src/modules/secrets/mask.ts
-function everyMatch(re, text) {
-  re.lastIndex = 0;
-  return [...text.matchAll(re)];
+  if ((node.type === "NewExpression" || node.type === "CallExpression") && node.callee.type === "Identifier" && node.callee.name === "RegExp") {
+    return literalString(node.arguments[0]);
+  }
+  return void 0;
+}
+function secretishName(name) {
+  if (name === void 0) return false;
+  return /secret|token|password|passwd|pwd|hmac|signature|hash|apikey|api_key|credential/i.test(name);
+}
+function secretish(node) {
+  if (node.type === "Identifier") return secretishName(node.name);
+  if (node.type === "MemberExpression") return secretishName(propName(node));
+  return false;
 }
-function maskSecret(secret) {
-  return `${secret.slice(0, 4)}****`;
+function isTimingSafeEqual(node) {
+  return node.type === "CallExpression" && calleeName(node) === "timingSafeEqual";
 }
-function foldStringConcat(line) {
-  return line.replace(/(["'`])\s*\+\s*(["'`])/g, "");
+function cookieFlagsComplete(opts) {
+  if (opts === void 0 || opts.type !== "ObjectExpression") return false;
+  const httpOnly = boolLiteral(objectProp2(opts, "httpOnly")) === true;
+  const secure = boolLiteral(objectProp2(opts, "secure")) === true;
+  const sameSite = objectProp2(opts, "sameSite");
+  const hasSameSite = sameSite !== void 0 && (sameSite.type === "Literal" && typeof sameSite.value === "string" || sameSite.type === "Identifier");
+  return httpOnly && secure && hasSameSite;
 }
-function shannonEntropy(value) {
-  if (value.length === 0) return 0;
-  const counts = /* @__PURE__ */ new Map();
-  for (const char of value) {
-    counts.set(char, (counts.get(char) ?? 0) + 1);
-  }
-  let entropy = 0;
-  for (const count of counts.values()) {
-    const p = count / value.length;
-    entropy -= p * Math.log2(p);
+var PATH_CALLS = /* @__PURE__ */ new Set([
+  "writeFile",
+  "writeFileSync",
+  "appendFile",
+  "appendFileSync",
+  "createWriteStream",
+  "rename",
+  "copyFile",
+  "join",
+  "resolve",
+  "sendFile",
+  "open",
+  "openSync"
+]);
+var redosRule = {
+  meta: {
+    id: "SAST-REDOS-001",
+    title: "Regular expression with nested or overlapping quantifiers on tainted input",
+    severity: "medium",
+    cwe: "CWE-1333",
+    docs: "https://cwe.mitre.org/data/definitions/1333.html"
+  },
+  create(ctx) {
+    const redosNames = /* @__PURE__ */ new Set();
+    return {
+      VariableDeclarator(node) {
+        if (node.type !== "VariableDeclarator" || node.id.type !== "Identifier" || node.init === null) return;
+        const pattern = regexPatternOf(node.init);
+        if (pattern !== void 0 && patternHasRedos(pattern)) redosNames.add(node.id.name);
+      },
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        if (name === "test" || name === "exec") {
+          const arg = node.arguments[0];
+          if (arg === void 0 || arg.type === "SpreadElement" || !ctx.isTainted(arg)) return;
+          if (node.callee.type !== "MemberExpression") return;
+          const pattern = regexPatternOf(node.callee.object);
+          const named = node.callee.object.type === "Identifier" && redosNames.has(node.callee.object.name);
+          if (pattern !== void 0 && patternHasRedos(pattern) || named) {
+            ctx.report({ node, message: "Tainted input is matched against a regex with nested or overlapping quantifiers." });
+          }
+          return;
+        }
+        if (name === "match" || name === "search") {
+          if (node.callee.type !== "MemberExpression" || !ctx.isTainted(node.callee.object)) return;
+          const arg = node.arguments[0];
+          if (arg === void 0 || arg.type === "SpreadElement") return;
+          const pattern = regexPatternOf(arg);
+          if (pattern !== void 0 && patternHasRedos(pattern)) {
+            ctx.report({ node, message: "Tainted input is matched against a regex with nested or overlapping quantifiers." });
+          }
+        }
+      }
+    };
   }
-  return entropy;
-}
-
-// src/modules/secrets/rules/aiKey.ts
-var PATTERN = /\bsk-ant-[A-Za-z0-9_-]{16,}\b|\bsk-[A-Za-z0-9_-]{20,}\b/g;
-var aiKeyRule = {
+};
+var deserRule = {
   meta: {
-    id: "SECRET-AIKEY-001",
-    title: "Hardcoded AI provider API key (OpenAI/Anthropic-style)",
+    id: "SAST-DESER-001",
+    title: "Insecure deserialization of untrusted data",
     severity: "high",
-    confidence: "high",
-    cwe: "CWE-798"
+    cwe: "CWE-502",
+    docs: "https://cwe.mitre.org/data/definitions/502.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN, line)) {
-        ctx.report({ line: index + 1, secret: match[0] });
+  create(ctx) {
+    return {
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        const arg0 = node.arguments[0];
+        const taintedFirst = arg0 !== void 0 && arg0.type !== "SpreadElement" && ctx.isTainted(arg0);
+        if ((name === "unserialize" || name === "deserialize" || name === "deepDeserialize" || name === "unsafeLoad") && taintedFirst) {
+          ctx.report({ node, message: "Tainted input is deserialized with an unsafe API (node-serialize, funcster, or yaml.unsafeLoad)." });
+          return;
+        }
+        if (name === "load" && taintedFirst) {
+          const opts = node.arguments[1];
+          const schema = opts !== void 0 && opts.type !== "SpreadElement" ? objectProp2(opts, "schema") : void 0;
+          if (!schemaLooksSafe(schema)) {
+            ctx.report({ node, message: "js-yaml load() of tainted input uses an unsafe schema or default types." });
+          }
+          return;
+        }
+        if (name === "serialize") {
+          const opts = node.arguments[1];
+          const unsafe = opts !== void 0 && opts.type !== "SpreadElement" && boolLiteral(objectProp2(opts, "unsafe")) === true;
+          if (unsafe) {
+            ctx.report({ node, message: "serialize-javascript is called with unsafe: true (eval path)." });
+          }
+          return;
+        }
+        if (name === "eval" || name === "runInNewContext") {
+          const arg = node.arguments[0];
+          if (arg !== void 0 && arg.type !== "SpreadElement" && containsCallNamed(arg, "serialize")) {
+            ctx.report({ node, message: "serialize-javascript output is passed to eval / vm (insecure deserialize)." });
+          }
+        }
       }
-    });
+    };
   }
 };
-
-// src/modules/secrets/rules/aws.ts
-var PATTERN2 = /\bAKIA[0-9A-Z]{16}\b/g;
-var awsRule = {
+var xxeRule = {
   meta: {
-    id: "SECRET-AWS-001",
-    title: "Hardcoded AWS access key ID",
+    id: "SAST-XXE-001",
+    title: "XML parser with external entities enabled on tainted input",
     severity: "high",
-    confidence: "high",
-    cwe: "CWE-798"
+    cwe: "CWE-611",
+    docs: "https://cwe.mitre.org/data/definitions/611.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN2, line)) {
-        ctx.report({ line: index + 1, secret: match[0] });
+  create(ctx) {
+    const customEntities = /ENTITIES/.test(ctx.source);
+    return {
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        const arg0 = node.arguments[0];
+        const taintedFirst = arg0 !== void 0 && arg0.type !== "SpreadElement" && ctx.isTainted(arg0);
+        if (!taintedFirst) return;
+        if (name === "parseXml" || name === "parseXmlString") {
+          const opts = node.arguments[1];
+          if (opts !== void 0 && opts.type !== "SpreadElement" && boolLiteral(objectProp2(opts, "noent")) === true) {
+            ctx.report({ node, message: "libxmljs parses tainted XML with noent: true (external entities)." });
+          }
+          return;
+        }
+        if (name === "parseString" || name === "Parser") {
+          const opts = node.arguments[1];
+          const customOpt = opts !== void 0 && opts.type !== "SpreadElement" && (objectProp2(opts, "xmlns") !== void 0 || objectProp2(opts, "entities") !== void 0);
+          if (customEntities || customOpt) {
+            ctx.report({ node, message: "xml2js parses tainted XML with custom entity handling." });
+          }
+        }
       }
-    });
+    };
   }
 };
-
-// src/modules/secrets/rules/dbUrl.ts
-var PATTERN3 = /\b(?:postgres(?:ql)?|mysql|mariadb|mongodb(?:\+srv)?|redis|amqp):\/\/([^\s'"@/:]+):([^\s'"@]+)@/g;
-function isPlaceholderPassword(password) {
-  if (password.includes("${")) return true;
-  if (/^<[^>]+>$/.test(password)) return true;
-  if (/^\{[^}]+\}$/.test(password)) return true;
-  return false;
-}
-var dbUrlRule = {
+var uploadRule = {
   meta: {
-    id: "SECRET-DBURL-001",
-    title: "Database connection string with inline password",
+    id: "SAST-UPLOAD-001",
+    title: "Unrestricted file upload or originalname used as a path",
     severity: "high",
-    confidence: "high",
-    cwe: "CWE-798"
+    cwe: "CWE-434",
+    docs: "https://cwe.mitre.org/data/definitions/434.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN3, line)) {
-        const password = match[2];
-        if (password === void 0 || isPlaceholderPassword(password)) continue;
-        ctx.report({ line: index + 1, secret: password });
+  create(ctx) {
+    return {
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        if (name === "multer" || name === "busboy" || name === "formidable" || name === "IncomingForm") {
+          const opts = node.arguments[0];
+          const obj = opts !== void 0 && opts.type !== "SpreadElement" ? opts : void 0;
+          const hasSize = objectProp2(obj, "limits") !== void 0 || objectProp2(obj, "maxFileSize") !== void 0 || objectProp2(obj, "fileSize") !== void 0;
+          const hasType = objectProp2(obj, "fileFilter") !== void 0 || objectProp2(obj, "filter") !== void 0;
+          if (!hasSize || !hasType) {
+            ctx.report({ node, message: `${name} is configured without a file size limit or type filter.` });
+          }
+          return;
+        }
+        if (name !== void 0 && PATH_CALLS.has(name)) {
+          const usesName = node.arguments.some(
+            (arg) => arg.type !== "SpreadElement" && containsOriginalName(arg)
+          );
+          if (usesName) {
+            ctx.report({ node, message: "Uploaded originalname is used in a filesystem path." });
+          }
+        }
+      },
+      NewExpression(node) {
+        if (node.type !== "NewExpression") return;
+        const name = calleeName(node);
+        if (name !== "IncomingForm" && name !== "Formidable") return;
+        const opts = node.arguments[0];
+        const obj = opts !== void 0 && opts.type !== "SpreadElement" ? opts : void 0;
+        if (objectProp2(obj, "maxFileSize") === void 0 || objectProp2(obj, "filter") === void 0) {
+          ctx.report({ node, message: `${name} is configured without a file size limit or type filter.` });
+        }
       }
-    });
+    };
   }
 };
-
-// src/modules/secrets/rules/entropy.ts
-var ASSIGNMENT = /\b([A-Za-z_$][\w$]*)\s*[:=]\s*["'`]([^"'`]{20,})["'`]/g;
-var SECRET_NAME = /(key|secret|token|passw(or)?d|pwd|credential)/i;
-var ENTROPY_THRESHOLD = 4.5;
-var entropyRule = {
+var CSRF_GUARD = /csrf-csrf|csrf-sync|csrfProtection|doubleCsrf|@fastify\/csrf-protection|\blusca\b|\bcsurf\b/;
+function sourceHasCsrfGuard(source) {
+  return CSRF_GUARD.test(source);
+}
+var cookieRule = {
   meta: {
-    id: "SECRET-ENTROPY-001",
-    title: "High-entropy string assigned to a secret-like variable",
+    id: "SAST-COOKIE-001",
+    title: "Cookie missing httpOnly, secure, or sameSite",
     severity: "medium",
-    confidence: "low",
-    cwe: "CWE-798"
+    cwe: "CWE-614",
+    docs: "https://cwe.mitre.org/data/definitions/614.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(ASSIGNMENT, line)) {
-        const [, name, value] = match;
-        if (name === void 0 || value === void 0) continue;
-        if (!SECRET_NAME.test(name)) continue;
-        if (value.includes(" ") || value.includes("${")) continue;
-        if (shannonEntropy(value) <= ENTROPY_THRESHOLD) continue;
-        ctx.report({ line: index + 1, secret: value });
+  create(ctx) {
+    return {
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        if (name === "cookie") {
+          const opts = node.arguments[2];
+          const optNode = opts !== void 0 && opts.type !== "SpreadElement" ? opts : void 0;
+          if (!cookieFlagsComplete(optNode)) {
+            ctx.report({ node, message: "Cookie is set without httpOnly, secure, and sameSite." });
+          }
+          return;
+        }
+        if (name === "session") {
+          const opts = node.arguments[0];
+          const optNode = opts !== void 0 && opts.type !== "SpreadElement" ? opts : void 0;
+          const secret = objectProp2(optNode, "secret");
+          const cookie = objectProp2(optNode, "cookie");
+          if (literalString(secret) !== void 0) return;
+          if (!cookieFlagsComplete(cookie)) {
+            ctx.report({
+              node,
+              message: "express-session cookie is missing httpOnly, secure, and sameSite."
+            });
+          }
+        }
       }
-    });
+    };
   }
 };
-
-// src/modules/secrets/rules/envFile.ts
-var ENV_FILE = /^\.env(\..+)?$/;
-var envFileRule = {
+var csrfRule = {
   meta: {
-    id: "SECRET-ENVFILE-001",
-    title: "Committed .env file",
+    id: "SAST-CSRF-001",
+    title: "Cookie-authenticated state-changing route without CSRF protection",
     severity: "high",
-    confidence: "high",
-    cwe: "CWE-312"
+    cwe: "CWE-352",
+    docs: "https://cwe.mitre.org/data/definitions/352.html"
   },
-  check(ctx) {
-    const base = ctx.path.split("/").pop() ?? ctx.path;
-    ENV_FILE.lastIndex = 0;
-    if (ENV_FILE.test(base) && base !== ".env.example" && base !== ".env.backup") {
-      ctx.report({
-        line: 1,
-        message: `${ctx.path} is tracked in the repository. .env files hold live credentials and must never be committed.`
-      });
-    }
+  create(ctx) {
+    const cookieAuth = /express-session|cookie-session|cookieParser|req\.cookies|\.cookie\s*\(/.test(ctx.source);
+    const csrfProtect = ctx.projectCsrfProtected === true || sourceHasCsrfGuard(ctx.source);
+    const sameSiteOk = /sameSite\s*:\s*['"](strict|lax)['"]/.test(ctx.source);
+    return {
+      CallExpression(node) {
+        if (node.type !== "CallExpression" || !cookieAuth || csrfProtect || sameSiteOk) return;
+        if (node.callee.type !== "MemberExpression") return;
+        const name = calleeName(node);
+        if (name === void 0 || !/^(post|put|patch|delete)$/.test(name)) return;
+        const obj = node.callee.object;
+        if (obj.type !== "Identifier" || !/^(app|router)$/i.test(obj.name)) return;
+        ctx.report({
+          node,
+          message: "Cookie-authenticated POST/PUT/PATCH/DELETE has no CSRF protection and sameSite is not strict/lax."
+        });
+      }
+    };
   }
 };
-
-// src/modules/secrets/rules/github.ts
-var PATTERN4 = /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36}\b/g;
-var githubRule = {
+var massAssignRule = {
   meta: {
-    id: "SECRET-GITHUB-001",
-    title: "Hardcoded GitHub token",
+    id: "SAST-MASSASSIGN-001",
+    title: "Mass assignment of req.body without an allowlist or schema",
     severity: "high",
-    confidence: "high",
-    cwe: "CWE-798"
+    cwe: "CWE-915",
+    docs: "https://cwe.mitre.org/data/definitions/915.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN4, line)) {
-        ctx.report({ line: index + 1, secret: match[0] });
+  create(ctx) {
+    return {
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        if (name === "assign") {
+          const src = node.arguments[1];
+          if (src !== void 0 && src.type !== "SpreadElement" && ctx.isRequestObject(src)) {
+            ctx.report({ node, message: "Object.assign copies req.body onto an object without an allowlist." });
+          }
+          return;
+        }
+        if (name !== "create" && name !== "update" && name !== "upsert") return;
+        const body = node.arguments.find((arg) => arg.type !== "SpreadElement" && ctx.isRequestObject(arg));
+        if (body === void 0) return;
+        const opts = node.arguments[1];
+        if (opts !== void 0 && opts.type !== "SpreadElement" && (objectProp2(opts, "fields") !== void 0 || objectProp2(opts, "whitelist") !== void 0)) {
+          return;
+        }
+        ctx.report({ node, message: `Model.${name}(req.body) assigns untrusted fields without an allowlist or schema.` });
       }
-    });
+    };
   }
 };
-
-// src/modules/secrets/rules/google.ts
-var PATTERN5 = /\bAIza[0-9A-Za-z_-]{35}\b/g;
-var googleRule = {
+var timingRule = {
   meta: {
-    id: "SECRET-GOOGLE-001",
-    title: "Hardcoded Google API key",
-    severity: "high",
-    confidence: "high",
-    cwe: "CWE-798"
+    id: "SAST-TIMING-001",
+    title: "Secret compared with === instead of timingSafeEqual",
+    severity: "medium",
+    cwe: "CWE-208",
+    docs: "https://cwe.mitre.org/data/definitions/208.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN5, line)) {
-        ctx.report({ line: index + 1, secret: match[0] });
+  create(ctx) {
+    return {
+      BinaryExpression(node) {
+        if (node.type !== "BinaryExpression") return;
+        if (node.operator !== "===" && node.operator !== "==") return;
+        if (isTimingSafeEqual(node.left) || isTimingSafeEqual(node.right)) return;
+        if (!secretish(node.left) && !secretish(node.right)) return;
+        ctx.report({
+          node,
+          message: "A secret/token/HMAC is compared with ===/== instead of crypto.timingSafeEqual."
+        });
       }
-    });
+    };
   }
 };
-
-// src/modules/secrets/rules/jwtSecret.ts
-var PATTERN6 = /\b(?:jwt[_-]?secret|jwt[_-]?key|token[_-]?secret|signing[_-]?key)\b\s*[:=]\s*["'`]([^"'`]{8,})["'`]/gi;
-var jwtSecretRule = {
+function argon2BelowOwasp(opts) {
+  if (opts === void 0 || opts.type !== "ObjectExpression") return false;
+  const memory = numberLiteral(objectProp2(opts, "memoryCost"));
+  const time = numberLiteral(objectProp2(opts, "timeCost"));
+  if (memory !== void 0 && memory < 12288) return true;
+  if (time !== void 0 && time < 2) return true;
+  if (memory !== void 0 && time !== void 0 && memory < 19456 && time < 3) return true;
+  return false;
+}
+function pbkdf2BelowOwasp(iterations, digest) {
+  const algo = (digest ?? "sha256").toLowerCase();
+  if (algo === "sha512") return iterations < 21e4;
+  if (algo === "sha1") return iterations < 13e5;
+  return iterations < 6e5;
+}
+var hashRule = {
   meta: {
-    id: "SECRET-JWT-001",
-    title: "JWT secret assigned from a string literal",
+    id: "SAST-HASH-001",
+    title: "Password hash below OWASP minimum cost",
     severity: "medium",
-    confidence: "medium",
-    cwe: "CWE-798"
+    cwe: "CWE-916",
+    docs: "https://cwe.mitre.org/data/definitions/916.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN6, line)) {
-        const secret = match[1];
-        if (secret !== void 0) {
-          ctx.report({ line: index + 1, secret });
+  create(ctx) {
+    return {
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        if (name === "hash" || name === "hashSync" || name === "genSalt" || name === "genSaltSync") {
+          const costArg = name === "genSalt" || name === "genSaltSync" ? node.arguments[0] : node.arguments[1];
+          const cost = numberLiteral(costArg);
+          if (cost !== void 0 && cost < 10) {
+            ctx.report({ node, message: `bcrypt cost ${cost} is below the minimum of 10.` });
+            return;
+          }
+          if (name === "hash" || name === "hashSync") {
+            const opts = node.arguments[1];
+            if (opts !== void 0 && opts.type !== "SpreadElement" && argon2BelowOwasp(opts)) {
+              ctx.report({ node, message: "argon2 options are below OWASP minimum memory/time cost." });
+            }
+          }
+          return;
+        }
+        if (name === "pbkdf2" || name === "pbkdf2Sync") {
+          const iterations = numberLiteral(node.arguments[2]);
+          const digest = literalString(node.arguments[4]);
+          if (iterations !== void 0 && pbkdf2BelowOwasp(iterations, digest)) {
+            ctx.report({ node, message: `pbkdf2 iterations ${iterations} are below the OWASP minimum for ${digest ?? "sha256"}.` });
+          }
         }
       }
-    });
+    };
   }
 };
-
-// src/modules/secrets/rules/privateKey.ts
-var PATTERN7 = /-----BEGIN (?:[A-Z]+ )*PRIVATE KEY-----/;
-var privateKeyRule = {
+var GQL_SERVERS = /* @__PURE__ */ new Set(["ApolloServer", "GraphQLServer", "YogaServer", "graphqlHTTP"]);
+var gqlRule = {
   meta: {
-    id: "SECRET-PRIVKEY-001",
-    title: "Private key material committed to the repository",
-    severity: "critical",
-    confidence: "high",
-    cwe: "CWE-321"
+    id: "SAST-GQL-001",
+    title: "GraphQL introspection, unbounded depth, or tainted resolver args",
+    severity: "medium",
+    cwe: "CWE-770",
+    docs: "https://cwe.mitre.org/data/definitions/770.html"
   },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      if (line.match(PATTERN7) !== null) {
+  create(ctx) {
+    const mentionsProduction = /NODE_ENV/.test(ctx.source) && /production/.test(ctx.source);
+    return {
+      NewExpression(node) {
+        if (node.type !== "NewExpression") return;
+        const name = calleeName(node);
+        if (name === void 0 || !GQL_SERVERS.has(name)) return;
+        reportGqlServer(ctx, node, node.arguments[0], mentionsProduction);
+      },
+      CallExpression(node) {
+        if (node.type !== "CallExpression") return;
+        const name = calleeName(node);
+        if (name !== void 0 && GQL_SERVERS.has(name)) {
+          reportGqlServer(ctx, node, node.arguments[0], mentionsProduction);
+          return;
+        }
+        if (name !== "query" && name !== "execute" && name !== "exec" && name !== "eval") return;
+        const sql = node.arguments[0];
+        if (sql === void 0 || sql.type === "SpreadElement") return;
+        if (!containsIdentMember(sql, "args")) return;
         ctx.report({
-          line: index + 1,
-          message: "A PEM private key block is committed to the repository."
+          node,
+          message: "GraphQL resolver args reach a sink without validation (tainted resolver argument)."
         });
       }
-    });
-  }
-};
-
-// src/modules/secrets/rules/slack.ts
-var PATTERN8 = /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g;
-var slackRule = {
-  meta: {
-    id: "SECRET-SLACK-001",
-    title: "Hardcoded Slack token",
-    severity: "high",
-    confidence: "high",
-    cwe: "CWE-798"
-  },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN8, line)) {
-        ctx.report({ line: index + 1, secret: match[0] });
-      }
-    });
+    };
   }
 };
+function reportGqlServer(ctx, node, optsArg, mentionsProduction) {
+  const opts = optsArg !== void 0 && optsArg.type !== "SpreadElement" ? optsArg : void 0;
+  const introspection = objectProp2(opts, "introspection");
+  const rules = objectProp2(opts, "validationRules");
+  const hasDepth = rules !== void 0 && containsCallNamed(rules, "depthLimit") || objectProp2(opts, "depthLimit") !== void 0 || /depthLimit|createComplexity|queryComplexity|costAnalysis/.test(ctx.source);
+  const introOn = boolLiteral(introspection) === true;
+  if (introOn && mentionsProduction) {
+    ctx.report({ node, message: "GraphQL introspection is enabled in production." });
+  }
+  if (!hasDepth) {
+    ctx.report({ node, message: "GraphQL server has no depth or complexity limit." });
+  }
+}
+var phase29Rules = [
+  gated(redosRule),
+  gated(deserRule),
+  gated(xxeRule),
+  gated(uploadRule),
+  gated(cookieRule),
+  gated(csrfRule),
+  gated(massAssignRule),
+  gated(timingRule),
+  gated(hashRule),
+  gated(gqlRule)
+];
 
-// src/modules/secrets/rules/stripe.ts
-var PATTERN9 = /\bsk_(?:live|test)_[A-Za-z0-9]{16,}\b/g;
-var stripeRule = {
-  meta: {
-    id: "SECRET-STRIPE-001",
-    title: "Hardcoded Stripe secret key",
-    severity: "high",
-    confidence: "high",
-    cwe: "CWE-798"
-  },
-  check(ctx) {
-    ctx.lines.forEach((line, index) => {
-      for (const match of everyMatch(PATTERN9, line)) {
-        ctx.report({ line: index + 1, secret: match[0] });
-      }
+// src/ai/injection.ts
+init_finding();
+var PHRASES = [/ignore previous/i, /mark as safe/i, /ai reviewer/i];
+function isCommentLine(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*");
+}
+function scanPromptInjection(file, source) {
+  const findings = [];
+  const lines = source.split(/\r?\n/);
+  lines.forEach((line, index) => {
+    if (!isCommentLine(line)) return;
+    if (!PHRASES.some((p) => p.test(line))) return;
+    findings.push({
+      id: makeFindingId("AI-INJECT-001", file, `${index + 1}|${line.trim()}`),
+      ruleId: "AI-INJECT-001",
+      module: "sast",
+      title: "Prompt-injection comment aimed at AI reviewers",
+      severity: "medium",
+      confidence: "high",
+      file,
+      line: index + 1,
+      snippet: line.trim().slice(0, 120),
+      message: "Code contains text attempting to manipulate AI reviewers.",
+      remediation: "Remove comments that try to instruct an AI reviewer.",
+      references: ["AI-INJECT-001"],
+      source: "deterministic"
     });
-  }
-};
+  });
+  return findings;
+}
 
-// src/modules/secrets/index.ts
-var secretsRules = [
-  awsRule,
-  stripeRule,
-  githubRule,
-  slackRule,
-  googleRule,
-  aiKeyRule,
-  privateKeyRule,
-  dbUrlRule,
-  jwtSecretRule,
-  entropyRule,
-  envFileRule
+// src/modules/sast/engine.ts
+var sastRules = [
+  sqliRule,
+  cmdiRule,
+  pathRule,
+  evalRule,
+  jwtRule,
+  cryptoRule,
+  nosqliRule,
+  ssrfRule,
+  redirectRule,
+  protoRule,
+  xssRule,
+  authRule,
+  ...phase29Rules
 ];
-var REMEDIATION = "Rotate this credential immediately, then load it from an environment variable or a secret manager. Removing it from the code is NOT enough: it remains visible in git history.";
-function scanTextForSecrets(path, text) {
-  const rawLines = text.split(/\r?\n/);
-  const lines = rawLines.map(foldStringConcat);
+var SOURCE_EXT = /\.[cm]?[jt]sx?$/;
+async function parseSource(code) {
+  const { parse } = await import('@typescript-eslint/typescript-estree');
+  return parse(code, {
+    loc: true,
+    range: true,
+    comment: false,
+    jsx: true,
+    errorOnUnknownASTType: false,
+    errorOnTypeScriptSyntacticAndSemanticIssues: false
+  });
+}
+function snippetOf(source, node) {
+  if (node.range === void 0) return "";
+  return source.slice(node.range[0], node.range[1]).replace(/\s+/g, " ").trim().slice(0, 120);
+}
+function findingsFromAst(filename, source, ast, extraReturners = /* @__PURE__ */ new Set(), projectCsrfProtected = false) {
+  const facts = analyzeFile(ast, extraReturners);
   const findings = [];
-  for (const rule of secretsRules) {
-    rule.check({
-      path,
-      lines,
-      rawLines,
-      report: ({ line, secret, message }) => {
-        const masked = secret !== void 0 ? maskSecret(secret) : void 0;
+  for (const rule of sastRules) {
+    const ctx = {
+      filename,
+      source,
+      report: ({ node, message, confidence }) => {
+        const snippet = snippetOf(source, node);
         findings.push({
-          id: makeFindingId(rule.meta.id, path, `${line}|${masked ?? "file"}`),
+          id: makeFindingId(rule.meta.id, filename, `${node.loc?.start.line ?? 0}|${snippet}`),
           ruleId: rule.meta.id,
-          module: "secrets",
+          module: "sast",
           title: rule.meta.title,
           severity: rule.meta.severity,
-          confidence: rule.meta.confidence,
+          confidence: confidence ?? "high",
           cwe: rule.meta.cwe,
-          file: path,
-          line,
-          snippet: masked,
-          message: message ?? `${rule.meta.title}${masked !== void 0 ? ` (${masked})` : ""}.`,
-          remediation: REMEDIATION
+          file: filename,
+          line: node.loc?.start.line,
+          column: node.loc?.start.column,
+          snippet,
+          message,
+          remediation: `${rule.meta.title}. See ${rule.meta.docs}`,
+          references: [rule.meta.docs, rule.meta.cwe]
         });
-      }
+      },
+      isTainted: (node) => nodeIsTainted(node, facts),
+      isPathSanitized: (node) => nodeIsPathSanitized(node, facts),
+      isSanitizedFor: (node, kind) => nodeIsSanitizedFor(node, facts, kind),
+      isNosqlSanitized: (node) => nodeIsNosqlSanitized(node, facts),
+      isRequestObject: (node) => nodeIsRequestObject(node, facts),
+      functionHasPasswordName: (node) => factsFor(node, facts).hasPasswordName,
+      assignedName: (node) => assignedNameOf(node),
+      projectCsrfProtected
+    };
+    const visitors = rule.create(ctx);
+    walk(ast, (node) => {
+      visitors[node.type]?.(node);
     });
   }
+  findings.push(...scanPromptInjection(filename, source));
+  return findings;
+}
+function findingsFromTemplate(filename, source) {
+  const findings = [];
+  const ctx = {
+    filename,
+    source,
+    report: ({ node, message }) => {
+      const snippet = source.split(/\r?\n/)[(node.loc?.start.line ?? 1) - 1]?.trim().slice(0, 120) ?? "";
+      findings.push({
+        id: makeFindingId(xssRule.meta.id, filename, `${node.loc?.start.line ?? 0}|${snippet}`),
+        ruleId: xssRule.meta.id,
+        module: "sast",
+        title: xssRule.meta.title,
+        severity: xssRule.meta.severity,
+        confidence: "high",
+        cwe: xssRule.meta.cwe,
+        file: filename,
+        line: node.loc?.start.line,
+        column: node.loc?.start.column,
+        snippet,
+        message,
+        remediation: `${xssRule.meta.title}. See ${xssRule.meta.docs}`,
+        references: [xssRule.meta.docs, xssRule.meta.cwe]
+      });
+    },
+    isTainted: () => false,
+    isPathSanitized: () => false,
+    isSanitizedFor: () => false,
+    isNosqlSanitized: () => false,
+    isRequestObject: () => false,
+    functionHasPasswordName: () => false,
+    assignedName: () => void 0,
+    projectCsrfProtected: false
+  };
+  xssRule.create(ctx);
   return findings;
 }
-var MAX_FILE_SIZE = 1024 * 1024;
-var secretsModule = {
-  name: "secrets",
+var sastModule = {
+  name: "sast",
   async run(ctx) {
     const findings = [];
+    const parsed = [];
     for (const rel of ctx.files) {
-      let text;
+      const isSource = SOURCE_EXT.test(rel);
+      const isTemplate = TEMPLATE_EXT.test(rel);
+      if (!isSource && !isTemplate) continue;
+      let source;
       try {
-        text = await readFile(join(ctx.cwd, rel), "utf8");
+        source = await readFile(join(ctx.cwd, rel), "utf8");
       } catch {
         continue;
       }
-      if (text.length > MAX_FILE_SIZE || text.includes("\0")) continue;
-      findings.push(...scanTextForSecrets(rel, text));
+      if (source.length > 1024 * 1024 || source.includes("\0")) continue;
+      if (isTemplate) {
+        findings.push(...findingsFromTemplate(rel, source));
+        continue;
+      }
+      try {
+        const ast = await parseSource(source);
+        parsed.push({ file: rel, source, ast });
+      } catch {
+      }
     }
+    const files = new Set(parsed.map((p) => p.file));
+    const projectCsrf = parsed.some((p) => sourceHasCsrfGuard(p.source));
+    const returning = /* @__PURE__ */ new Map();
+    for (const p of parsed) {
+      returning.set(p.file, functionsThatReturnTaint(p.ast));
+    }
+    for (const p of parsed) {
+      const ns = collectRequires(p.file, p.ast, files);
+      const extra = new Set(returning.get(p.file));
+      for (const [local, spec] of ns) {
+        const hash = spec.indexOf("#");
+        const file = hash >= 0 ? spec.slice(0, hash) : spec;
+        const exp = hash >= 0 ? spec.slice(hash + 1) : local;
+        if (returning.get(file)?.has(exp)) extra.add(local);
+      }
+      findings.push(...findingsFromAst(p.file, p.source, p.ast, extra, projectCsrf));
+    }
+    findings.push(...runInterproc(parsed));
     return findings;
   }
 };
 
+// src/core/engine.ts
+init_secrets();
+
+// src/modules/secrets/experimental.ts
+function secretsAdvEnabled() {
+  return process.env.FULLSHIELD_EXPERIMENTAL_SECRETS_ADV === "1";
+}
+
+// src/ai/triage.ts
+init_finding();
+
 // src/ai/fixtures.ts
 var RECORDED_FIXTURES = {
   triage: {
@@ -4849,58 +7429,61 @@ function cap(findings, max) {
 }
 async function applyTriage(findings, client, config, snippets) {
   const budget = cap(findings, config.maxFindings);
-  for (const finding2 of budget) {
-    const snippet = snippets[finding2.file ?? ""] ?? finding2.snippet ?? finding2.message;
+  for (const finding4 of budget) {
+    const snippet = snippets[finding4.file ?? ""] ?? finding4.snippet ?? finding4.message;
     const res = await client.complete({
       mode: "triage",
-      prompt: `${finding2.ruleId}
+      prompt: `${finding4.ruleId}
 ${snippet}`
     });
     if (res === null) continue;
     if (client.useFixtures) {
-      const label = fixtureTriage(finding2.ruleId);
-      finding2.aiVerdict = label.verdict;
-      finding2.aiReasoning = label.reasoning;
-      finding2.exploitScenario = label.exploitScenario;
+      const label = fixtureTriage(finding4.ruleId);
+      finding4.aiVerdict = label.verdict;
+      finding4.aiReasoning = label.reasoning;
+      finding4.exploitScenario = label.exploitScenario;
       continue;
     }
     const live = asTriage(res.json);
     if (live === void 0) continue;
-    finding2.aiVerdict = live.verdict;
-    finding2.aiReasoning = live.reasoning;
-    finding2.exploitScenario = live.exploitScenario;
+    finding4.aiVerdict = live.verdict;
+    finding4.aiReasoning = live.reasoning;
+    finding4.exploitScenario = live.exploitScenario;
   }
   return findings;
 }
 async function applyExplain(findings, client, config, snippets) {
   const budget = cap(findings, config.maxFindings);
-  for (const finding2 of budget) {
-    const snippet = snippets[finding2.file ?? ""] ?? finding2.snippet ?? finding2.message;
+  for (const finding4 of budget) {
+    const snippet = snippets[finding4.file ?? ""] ?? finding4.snippet ?? finding4.message;
     const res = await client.complete({
       mode: "explain",
-      prompt: `${finding2.ruleId}
+      prompt: `${finding4.ruleId}
 ${snippet}`
     });
     if (res === null) continue;
     if (client.useFixtures) {
-      finding2.explanation = fixtureExplain(finding2.ruleId);
+      finding4.explanation = fixtureExplain(finding4.ruleId);
       continue;
     }
     const text = asExplanation(res.json);
-    if (text !== void 0) finding2.explanation = text;
-    delete finding2.aiVerdict;
-    delete finding2.exploitScenario;
-    delete finding2.aiReasoning;
+    if (text !== void 0) finding4.explanation = text;
+    delete finding4.aiVerdict;
+    delete finding4.exploitScenario;
+    delete finding4.aiReasoning;
   }
   return findings;
 }
+
+// src/ai/logic.ts
+init_finding();
 var ROUTE_FILE = /(^|\/)(routes?|handlers?|controllers?)\//;
-function clampAiFinding(finding2) {
+function clampAiFinding(finding4) {
   return {
-    ...finding2,
+    ...finding4,
     source: "ai",
     confidence: "medium",
-    severity: finding2.severity === "low" ? "low" : "medium"
+    severity: finding4.severity === "low" ? "low" : "medium"
   };
 }
 async function runLogicHunt(cwd, files, client) {
@@ -4968,6 +7551,8 @@ ${text}`);
 }
 
 // src/ai/redact.ts
+init_mask();
+init_secrets();
 var REDACTED = "<REDACTED>";
 function redactSecrets(text) {
   const rawLines = text.split(/\r?\n/);
@@ -5149,6 +7734,9 @@ function applyBaseline(findings, baseline) {
   const known = new Set(baseline.findings.map((f) => f.id));
   return findings.filter((f) => !known.has(f.id));
 }
+
+// src/core/config.ts
+init_finding();
 var CONFIG_FILE_NAME = "fullshield.config.json";
 var DEFAULT_CONFIG = {
   modules: [...MODULE_NAMES],
@@ -5338,28 +7926,9 @@ async function listStagedFiles(cwd) {
   }
 }
 
-// src/core/suppression.ts
-var IGNORE = /fullshield-ignore\s+([A-Z0-9-]+)\s*:\s*(\S+)/;
-function parseIgnore(line) {
-  const match = IGNORE.exec(line);
-  if (match?.[1] === void 0 || match[2] === void 0) return void 0;
-  return { ruleId: match[1], reason: match[2] };
-}
-function applyInlineSuppressions(findings, sources) {
-  return findings.filter((finding2) => {
-    if (finding2.file === void 0 || finding2.line === void 0) return true;
-    const text = sources[finding2.file];
-    if (text === void 0) return true;
-    const lines = text.split(/\r?\n/);
-    const current = lines[finding2.line - 1] ?? "";
-    const previous = finding2.line >= 2 ? lines[finding2.line - 2] ?? "" : "";
-    for (const line of [current, previous]) {
-      const ignore = parseIgnore(line);
-      if (ignore !== void 0 && ignore.ruleId === finding2.ruleId) return false;
-    }
-    return true;
-  });
-}
+// src/core/engine.ts
+init_suppression();
+init_finding();
 function packageVersion() {
   let dir = dirname(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < 6; depth += 1) {
@@ -5378,16 +7947,201 @@ function packageVersion() {
   throw new Error("fullshield package.json not found");
 }
 
+// src/policy/index.ts
+init_finding();
+
+// src/policy/prSummary.ts
+init_finding();
+
+// src/policy/index.ts
+var POLICY_FILE_NAME = "fullshield.policy.json";
+var POLICY_FLAG = "FULLSHIELD_EXPERIMENTAL_POLICY";
+var POLICY_PEER_ERROR = "fullshield policy requires optional peer zod. Install with: npm i -D zod";
+var PolicyError = class extends Error {
+};
+var defaultLoadZod = async () => {
+  const zodMod = await import('zod');
+  const z = zodMod.z ?? zodMod;
+  return { z };
+};
+function isPolicyEnabled(opts = {}) {
+  return opts.experimental === true || process.env[POLICY_FLAG] === "1";
+}
+function formatZodIssues(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.map(String).join(".");
+    return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+  }).join("; ");
+}
+function isIsoTimestamp(value) {
+  if (!/^\d{4}-\d{2}-\d{2}(T[\d:.+-Z]+)?$/.test(value)) return false;
+  return Number.isFinite(Date.parse(value));
+}
+function policySchema(z) {
+  const severity = z.enum(SEVERITIES);
+  const moduleName = z.enum(MODULE_NAMES);
+  const isoExpires = z.string().min(1).refine(isIsoTimestamp, { message: "expires must be an ISO date" });
+  return z.object({
+    requiredModules: z.array(moduleName).optional(),
+    severityOverrides: z.record(z.string(), severity).optional(),
+    failOn: z.record(z.string(), severity).optional(),
+    exceptions: z.array(
+      z.object({
+        ruleId: z.string().min(1),
+        file: z.string().min(1).optional(),
+        id: z.string().min(1).optional(),
+        owner: z.string().min(1, "exceptions require owner"),
+        reason: z.string().min(1, "exceptions require reason"),
+        expires: isoExpires
+      })
+    ).optional()
+  }).strict();
+}
+async function parsePolicy(raw, source = POLICY_FILE_NAME, loadZod = defaultLoadZod) {
+  let z;
+  try {
+    ({ z } = await loadZod());
+  } catch {
+    throw new PolicyError(POLICY_PEER_ERROR);
+  }
+  const parsed = policySchema(z).safeParse(raw);
+  if (!parsed.success) {
+    throw new PolicyError(`${source}: ${formatZodIssues(parsed.error)}`);
+  }
+  const data = parsed.data;
+  const requiredModules = data.requiredModules?.filter(isModuleName);
+  const severityOverrides = {};
+  if (data.severityOverrides !== void 0) {
+    for (const [ruleId, severity] of Object.entries(data.severityOverrides)) {
+      if (isSeverity(severity)) severityOverrides[ruleId] = severity;
+    }
+  }
+  const failOn = {};
+  if (data.failOn !== void 0) {
+    for (const [branch, severity] of Object.entries(data.failOn)) {
+      if (isSeverity(severity)) failOn[branch] = severity;
+    }
+  }
+  return {
+    requiredModules,
+    severityOverrides: Object.keys(severityOverrides).length > 0 ? severityOverrides : void 0,
+    failOn: Object.keys(failOn).length > 0 ? failOn : void 0,
+    exceptions: data.exceptions
+  };
+}
+async function loadPolicy(cwd, opts = {}, loadZod = defaultLoadZod) {
+  if (!isPolicyEnabled(opts)) return void 0;
+  const file = join(cwd, POLICY_FILE_NAME);
+  let contents;
+  try {
+    contents = await readFile(file, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") return void 0;
+    throw new PolicyError(`cannot read policy file ${file}: ${code ?? String(error)}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(contents);
+  } catch (error) {
+    throw new PolicyError(
+      `${file}: invalid JSON (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+  return parsePolicy(raw, file, loadZod);
+}
+function globMatch(pattern, value) {
+  if (pattern === "*") return true;
+  if (!pattern.includes("*")) return pattern === value;
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+function failOnForBranch(map, branch) {
+  if (map === void 0) return void 0;
+  if (Object.prototype.hasOwnProperty.call(map, branch)) return map[branch];
+  for (const [key, severity] of Object.entries(map)) {
+    if (key === "*") continue;
+    if (globMatch(key, branch)) return severity;
+  }
+  return map["*"];
+}
+function resolvePolicyBranch(cwd, env = process.env) {
+  const fromEnv = env.FULLSHIELD_POLICY_BRANCH ?? env.GITHUB_HEAD_REF ?? env.GITHUB_REF_NAME ?? env.CI_COMMIT_BRANCH;
+  if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv;
+  try {
+    const stdout = execFileSync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const branch = stdout.trim();
+    return branch.length > 0 ? branch : "*";
+  } catch {
+    return "*";
+  }
+}
+function expiresAtMs(expires) {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(expires)) {
+    return Date.parse(`${expires}T23:59:59.999Z`);
+  }
+  return Date.parse(expires);
+}
+function exceptionMatches(exception, finding4) {
+  if (exception.ruleId !== finding4.ruleId) return false;
+  if (exception.id !== void 0 && exception.id !== finding4.id) return false;
+  if (exception.file !== void 0 && exception.file !== finding4.file) return false;
+  return true;
+}
+function applyPolicy(findings, policy, ctx = {}) {
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const errors = [];
+  const overrides = policy.severityOverrides ?? {};
+  let next = findings.map((finding4) => {
+    const severity = overrides[finding4.ruleId];
+    return severity !== void 0 && severity !== finding4.severity ? { ...finding4, severity } : finding4;
+  });
+  const suppressed = /* @__PURE__ */ new Set();
+  for (const exception of policy.exceptions ?? []) {
+    if (expiresAtMs(exception.expires) < now.getTime()) {
+      errors.push(
+        `policy exception for ${exception.ruleId} expired on ${exception.expires} (owner: ${exception.owner}); renew or remove it`
+      );
+      continue;
+    }
+    for (const finding4 of next) {
+      if (exceptionMatches(exception, finding4)) suppressed.add(finding4.id);
+    }
+  }
+  next = next.filter((finding4) => !suppressed.has(finding4.id));
+  for (const required of policy.requiredModules ?? []) {
+    if (!(ctx.modulesRun ?? []).includes(required)) {
+      errors.push(`policy required module "${required}" did not run`);
+    }
+  }
+  return {
+    findings: sortFindings(next),
+    failOn: failOnForBranch(policy.failOn, ctx.branch ?? "*"),
+    errors
+  };
+}
+function mergeRequiredModules(requested, required) {
+  if (required === void 0 || required.length === 0) return [...requested];
+  const out = [...requested];
+  for (const name of required) {
+    if (!out.includes(name)) out.push(name);
+  }
+  return out;
+}
+
 // src/core/engine.ts
 var builtinModules = [depsModule, secretsModule, sastModule, configModule];
 builtinModules.map((m) => m.name);
 function dedupe2(findings) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const finding2 of findings) {
-    if (!seen.has(finding2.id)) {
-      seen.add(finding2.id);
-      out.push(finding2);
+  for (const finding4 of findings) {
+    if (!seen.has(finding4.id)) {
+      seen.add(finding4.id);
+      out.push(finding4);
     }
   }
   return out;
@@ -5411,7 +8165,11 @@ async function runScan(options = {}, modules = builtinModules) {
       config = { ...config, ai: { ...config.ai, maxFindings } };
     }
   }
-  const modulesRequested = options.modules ?? config.modules;
+  const loadedPolicy = await loadPolicy(cwd, { experimental: options.experimentalPolicy });
+  const modulesRequested = mergeRequiredModules(
+    options.modules ?? config.modules,
+    loadedPolicy?.requiredModules
+  );
   let files = await walkFiles({ cwd, ignore: config.ignore });
   if (options.staged === true) {
     const staged = new Set(await listStagedFiles(cwd));
@@ -5440,6 +8198,27 @@ async function runScan(options = {}, modules = builtinModules) {
       collected.push(...await module.run(ctx));
     }
   }
+  if (process.env.FULLSHIELD_EXPERIMENTAL_MCPCFG === "1") {
+    collected.push(
+      ...scanMcpConfig(cwd, { experimental: true, includeHome: options.includeHome === true })
+    );
+  }
+  const extraHits = [];
+  const secretsWanted = modulesRequested.includes("secrets");
+  if (secretsAdvEnabled() && secretsWanted) {
+    if (options.history === true) {
+      const { scanGitHistory: scanGitHistory2 } = await Promise.resolve().then(() => (init_history(), history_exports));
+      const hist = await scanGitHistory2(cwd);
+      extraHits.push(...hist.hits);
+      collected.push(...hist.findings);
+    }
+    if (options.bundle !== void 0 && options.bundle.length > 0) {
+      const { scanBundle: scanBundle2 } = await Promise.resolve().then(() => (init_bundle(), bundle_exports));
+      const bun = await scanBundle2(options.bundle);
+      extraHits.push(...bun.hits);
+      collected.push(...bun.findings);
+    }
+  }
   const sources = {};
   for (const file of new Set(collected.map((f) => f.file).filter((f) => f !== void 0))) {
     try {
@@ -5453,6 +8232,50 @@ async function runScan(options = {}, modules = builtinModules) {
     await writeBaseline(baselinePath, unsuppressed);
   }
   let findings = sortFindings(applyBaseline(unsuppressed, await readBaseline(baselinePath)));
+  if (secretsAdvEnabled() && secretsWanted && options.verifySecrets === true && options.iOwnTheseCredentials === true) {
+    const { applyVerification: applyVerification2 } = await Promise.resolve().then(() => (init_verify(), verify_exports));
+    const { scanTextForSecretHits: scanTextForSecretHits2 } = await Promise.resolve().then(() => (init_secrets(), secrets_exports));
+    const secretById = /* @__PURE__ */ new Map();
+    for (const hit of extraHits) {
+      if (hit.secret !== void 0) secretById.set(hit.finding.id, hit.secret);
+    }
+    for (const finding4 of findings) {
+      if (finding4.module !== "secrets" || finding4.file === void 0 || secretById.has(finding4.id)) {
+        continue;
+      }
+      let text = sources[finding4.file];
+      if (text === void 0) {
+        try {
+          text = await readFile(join(cwd, finding4.file), "utf8");
+        } catch {
+          continue;
+        }
+      }
+      for (const hit of scanTextForSecretHits2(finding4.file, text)) {
+        if (hit.secret !== void 0) secretById.set(hit.finding.id, hit.secret);
+      }
+    }
+    findings = sortFindings(
+      await applyVerification2(findings, secretById, {
+        fetchImpl: options.verifyFetch
+      })
+    );
+  }
+  let policyResult;
+  if (loadedPolicy !== void 0) {
+    const applied = applyPolicy(findings, loadedPolicy, {
+      branch: options.policyBranch ?? resolvePolicyBranch(cwd),
+      modulesRun
+    });
+    findings = applied.findings;
+    policyResult = {
+      enabled: true,
+      file: join(cwd, POLICY_FILE_NAME),
+      failOn: applied.failOn,
+      errors: applied.errors,
+      policy: loadedPolicy
+    };
+  }
   const aiMode = options.ai;
   const aiEnabled = aiMode === true || aiMode === "triage" || aiMode === "explain" || aiMode === "logic" || config.ai.enabled;
   if (aiEnabled) {
@@ -5482,49 +8305,24 @@ async function runScan(options = {}, modules = builtinModules) {
       modulesRequested: [...modulesRequested],
       modulesRun
     },
-    config
+    config,
+    policy: policyResult
   };
 }
 function scan(options = {}) {
   return runScan(options);
 }
 
-// src/fixer/eol.ts
-function detectEol(text) {
-  return text.includes("\r\n") ? "\r\n" : "\n";
-}
-function normalizeNewlines(text) {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-function applyEol(text, eol) {
-  const normalized = normalizeNewlines(text);
-  return eol === "\n" ? normalized : normalized.replace(/\n/g, "\r\n");
-}
-
-// src/fixer/diff.ts
-function unifiedDiff(filename, before, after) {
-  const oldNorm = normalizeNewlines(before);
-  const newNorm = normalizeNewlines(after);
-  if (oldNorm === newNorm) return "";
-  const oldLines = oldNorm.split("\n");
-  const newLines = newNorm.split("\n");
-  const hunks = [`--- a/${filename}`, `+++ b/${filename}`];
-  hunks.push(`@@ -1,${oldLines.length} +1,${newLines.length} @@`);
-  for (const line of oldLines) hunks.push(`-${line}`);
-  for (const line of newLines) hunks.push(`+${line}`);
-  return hunks.join("\n");
-}
-
 // src/fixer/patches.ts
-function proposeFix(finding2, source) {
-  const file = finding2.file ?? "";
-  if (finding2.ruleId === "CONFIG-HELMET-001") return helmetFix(file, source);
-  if (finding2.ruleId === "CONFIG-BODYLIMIT-001") return bodyLimitFix(file, source);
-  if (finding2.ruleId === "SAST-CRYPTO-001") return cryptoFix(file, source);
-  if (finding2.ruleId === "SECRET-ENVFILE-001") return gitignoreFix(file, source);
-  if (finding2.fix !== void 0) return finding2.fix;
-  if (finding2.ruleId.startsWith("SECRET-") && finding2.ruleId !== "SECRET-ENVFILE-001") {
-    return secretEnvFix(file, source, finding2);
+function proposeFix(finding4, source) {
+  const file = finding4.file ?? "";
+  if (finding4.ruleId === "CONFIG-HELMET-001") return helmetFix(file, source);
+  if (finding4.ruleId === "CONFIG-BODYLIMIT-001") return bodyLimitFix(file, source);
+  if (finding4.ruleId === "SAST-CRYPTO-001") return cryptoFix(file, source);
+  if (finding4.ruleId === "SECRET-ENVFILE-001") return gitignoreFix(file, source);
+  if (finding4.fix !== void 0) return finding4.fix;
+  if (finding4.ruleId.startsWith("SECRET-") && finding4.ruleId !== "SECRET-ENVFILE-001") {
+    return secretEnvFix(file, source, finding4);
   }
   return void 0;
 }
@@ -5574,11 +8372,11 @@ function gitignoreFix(file, source) {
 `;
   return { kind: "config-add", safe: true, diff: unifiedDiff(target, normalized, after) };
 }
-function secretEnvFix(file, source, finding2) {
-  const envName = envNameFor(finding2.ruleId);
+function secretEnvFix(file, source, finding4) {
+  const envName = envNameFor(finding4.ruleId);
   const normalized = normalizeNewlines(source);
   const lines = normalized.split("\n");
-  const idx = (finding2.line ?? 1) - 1;
+  const idx = (finding4.line ?? 1) - 1;
   const line = lines[idx];
   if (line === void 0) return void 0;
   const replaced = line.replace(
@@ -5606,7 +8404,10 @@ function applyUnifiedDiff(source, diff) {
   if (plus.length === 0) return source;
   return applyEol(plus.join("\n"), detectEol(source));
 }
-function finding(ruleId, title, message, file, severity = "high") {
+
+// src/llm/index.ts
+init_finding();
+function finding3(ruleId, title, message, file, severity = "high") {
   return {
     id: makeFindingId(ruleId, file, message),
     ruleId,
@@ -5642,7 +8443,7 @@ function scanLlmApp(dir, opts = {}) {
     const text = readFileSync(file, "utf8");
     if (/role\s*:\s*['"]system['"]/.test(text) && /content\s*:\s*['"][^'"]*['"]\s*\+|content\s*:\s*.*\+\s*req\.(body|query|params)/.test(text)) {
       findings.push(
-        finding(
+        finding3(
           "LLM-001",
           "User input concatenated into an LLM system prompt",
           "User-controlled data is concatenated into a system-role message (OWASP LLM01).",
@@ -5654,7 +8455,7 @@ function scanLlmApp(dir, opts = {}) {
       text
     ) || /\.innerHTML\s*=\s*.*(completion|choices\[)/.test(text)) {
       findings.push(
-        finding(
+        finding3(
           "LLM-002",
           "LLM output passed into a dangerous sink",
           "Model output reaches exec/eval/SQL/HTML without validation (OWASP LLM02).",
@@ -5664,7 +8465,7 @@ function scanLlmApp(dir, opts = {}) {
     }
     if (/name\s*:\s*['"](run_shell|shell|exec|write_file|send_payment)['"]/.test(text) && !/require(Confirmation|Approval)|confirm(ation)?\s*:/.test(text)) {
       findings.push(
-        finding(
+        finding3(
           "LLM-003",
           "Dangerous LLM tool without confirmation",
           "Function-calling exposes shell/file/payment tools without a confirmation step (OWASP LLM06).",
@@ -5675,7 +8476,7 @@ function scanLlmApp(dir, opts = {}) {
     const browserish = /(^|\/)(public|client|browser|static)\//.test(rel.replaceAll("\\", "/"));
     if (browserish && /OPENAI_API_KEY|ANTHROPIC_API_KEY|sk-[a-zA-Z0-9]{8,}/.test(text)) {
       findings.push(
-        finding(
+        finding3(
           "LLM-004",
           "LLM API key exposed to a browser bundle",
           "An OpenAI/Anthropic-style key is present in a public/client file (OWASP LLM06/sensitive info).",
@@ -5686,7 +8487,7 @@ function scanLlmApp(dir, opts = {}) {
     }
     if (/chat\.completions\.create|messages\.create|anthropic\.messages/.test(text) && !/max_tokens|max_completion_tokens|maxTokens/.test(text)) {
       findings.push(
-        finding(
+        finding3(
           "LLM-005",
           "LLM call has no output length or cost limit",
           "chat/completions call does not set max_tokens (OWASP LLM10 unbounded consumption).",