@vibekiln/cutline-mcp-cli 0.13.0 → 0.15.0

package/dist/servers/chunk-Q5V4VTF5.js

@@ -0,0 +1,3180 @@
+import {
+  computeGenericGraphMetrics
+} from "./chunk-IDSVMCGM.js";
+
+// ../mcp/dist/mcp/src/context-graph/codebase-scanner.js
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, relative, basename, extname } from "node:path";
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".next",
+  ".nuxt",
+  "dist",
+  "build",
+  "out",
+  ".git",
+  ".svn",
+  ".hg",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".tox",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  "vendor",
+  "target",
+  ".gradle",
+  ".idea",
+  ".vscode",
+  ".cursor",
+  "coverage",
+  ".turbo",
+  ".vercel",
+  ".firebase",
+  ".serverless",
+  "tmp",
+  "temp",
+  ".cache",
+  ".parcel-cache"
+]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".lock"
+]);
+async function walkFileTree(options) {
+  const { root, maxDepth = 12, maxFiles = 5e3, extraIgnoreDirs = [] } = options;
+  const ignoreDirs = /* @__PURE__ */ new Set([...DEFAULT_IGNORE_DIRS, ...extraIgnoreDirs]);
+  const gitignorePatterns = await loadGitignore(root);
+  const files = [];
+  async function walk(dir, depth) {
+    if (depth > maxDepth || files.length >= maxFiles)
+      return;
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (files.length >= maxFiles)
+        break;
+      if (name.startsWith(".") && name !== ".env.example")
+        continue;
+      const fullPath = join(dir, name);
+      const relPath = relative(root, fullPath).replace(/\\/g, "/");
+      let stats;
+      try {
+        stats = await stat(fullPath);
+      } catch {
+        continue;
+      }
+      if (stats.isDirectory()) {
+        if (ignoreDirs.has(name))
+          continue;
+        if (matchesGitignore(relPath + "/", gitignorePatterns))
+          continue;
+        await walk(fullPath, depth + 1);
+      } else if (stats.isFile()) {
+        const ext = extname(name).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext))
+          continue;
+        if (matchesGitignore(relPath, gitignorePatterns))
+          continue;
+        files.push({ path: relPath, size: stats.size, ext });
+      }
+    }
+  }
+  await walk(root, 0);
+  return files;
+}
+var DEP_CLASSIFIERS = [
+  // Frameworks
+  { pattern: /^next$/i, category: "frameworks", label: "next.js" },
+  { pattern: /^nuxt$/i, category: "frameworks", label: "nuxt" },
+  { pattern: /^react$/i, category: "frameworks", label: "react" },
+  { pattern: /^vue$/i, category: "frameworks", label: "vue" },
+  { pattern: /^svelte$/i, category: "frameworks", label: "svelte" },
+  { pattern: /^angular/i, category: "frameworks", label: "angular" },
+  { pattern: /^express$/i, category: "frameworks", label: "express" },
+  { pattern: /^fastify$/i, category: "frameworks", label: "fastify" },
+  { pattern: /^hono$/i, category: "frameworks", label: "hono" },
+  { pattern: /^django$/i, category: "frameworks", label: "django" },
+  { pattern: /^flask$/i, category: "frameworks", label: "flask" },
+  { pattern: /^fastapi$/i, category: "frameworks", label: "fastapi" },
+  { pattern: /^spring/i, category: "frameworks", label: "spring-boot" },
+  { pattern: /^rails$/i, category: "frameworks", label: "rails" },
+  { pattern: /^remix$/i, category: "frameworks", label: "remix" },
+  { pattern: /^astro$/i, category: "frameworks", label: "astro" },
+  { pattern: /^gatsby$/i, category: "frameworks", label: "gatsby" },
+  { pattern: /^electron$/i, category: "frameworks", label: "electron" },
+  { pattern: /^react-native$/i, category: "frameworks", label: "react-native" },
+  { pattern: /^expo$/i, category: "frameworks", label: "expo" },
+  // ORMs / DB
+  { pattern: /^prisma$|^@prisma/i, category: "orms", label: "prisma" },
+  { pattern: /^typeorm$/i, category: "orms", label: "typeorm" },
+  { pattern: /^drizzle-orm$/i, category: "orms", label: "drizzle" },
+  { pattern: /^sequelize$/i, category: "orms", label: "sequelize" },
+  { pattern: /^mongoose$/i, category: "orms", label: "mongoose" },
+  { pattern: /^knex$/i, category: "orms", label: "knex" },
+  { pattern: /^sqlalchemy$/i, category: "orms", label: "sqlalchemy" },
+  { pattern: /^pg$|^postgres$/i, category: "orms", label: "postgresql" },
+  { pattern: /^mysql2?$/i, category: "orms", label: "mysql" },
+  { pattern: /^better-sqlite3$/i, category: "orms", label: "sqlite" },
+  // Infrastructure
+  { pattern: /^firebase-admin$|^@firebase/i, category: "infrastructure", label: "firebase" },
+  { pattern: /^@google-cloud/i, category: "infrastructure", label: "gcp" },
+  { pattern: /^@?aws-sdk/i, category: "infrastructure", label: "aws" },
+  { pattern: /^@azure/i, category: "infrastructure", label: "azure" },
+  { pattern: /^redis$|^ioredis$/i, category: "infrastructure", label: "redis" },
+  { pattern: /^kafkajs$|^kafka-node$/i, category: "infrastructure", label: "kafka" },
+  { pattern: /^amqplib$/i, category: "infrastructure", label: "rabbitmq" },
+  { pattern: /^stripe$/i, category: "infrastructure", label: "stripe" },
+  { pattern: /^@sendgrid/i, category: "infrastructure", label: "sendgrid" },
+  { pattern: /^nodemailer$/i, category: "infrastructure", label: "nodemailer" },
+  { pattern: /^@supabase/i, category: "infrastructure", label: "supabase" },
+  { pattern: /^@vercel/i, category: "infrastructure", label: "vercel" },
+  { pattern: /^docker/i, category: "infrastructure", label: "docker" },
+  // Security
+  { pattern: /^helmet$/i, category: "security_libs", label: "helmet" },
+  { pattern: /^bcrypt$|^bcryptjs$/i, category: "security_libs", label: "bcrypt" },
+  { pattern: /^jsonwebtoken$/i, category: "security_libs", label: "jwt" },
+  { pattern: /^passport$/i, category: "security_libs", label: "passport" },
+  { pattern: /^cors$/i, category: "security_libs", label: "cors" },
+  { pattern: /^csurf$/i, category: "security_libs", label: "csrf" },
+  { pattern: /^rate-limiter-flexible$/i, category: "security_libs", label: "rate-limiter" },
+  { pattern: /^zod$/i, category: "security_libs", label: "zod" },
+  { pattern: /^joi$/i, category: "security_libs", label: "joi" },
+  { pattern: /^express-validator$/i, category: "security_libs", label: "express-validator" },
+  // AI/LLM
+  { pattern: /^openai$/i, category: "ai_libs", label: "openai" },
+  { pattern: /^@anthropic-ai/i, category: "ai_libs", label: "anthropic" },
+  { pattern: /^@google-cloud\/vertexai$|^@google\/generative-ai$/i, category: "ai_libs", label: "vertex-ai" },
+  { pattern: /^langchain$|^@langchain/i, category: "ai_libs", label: "langchain" },
+  { pattern: /^llamaindex$/i, category: "ai_libs", label: "llamaindex" },
+  { pattern: /^ai$|^@ai-sdk/i, category: "ai_libs", label: "vercel-ai-sdk" },
+  { pattern: /^replicate$/i, category: "ai_libs", label: "replicate" },
+  { pattern: /^cohere-ai$/i, category: "ai_libs", label: "cohere" },
+  // Testing
+  { pattern: /^jest$/i, category: "testing", label: "jest" },
+  { pattern: /^vitest$/i, category: "testing", label: "vitest" },
+  { pattern: /^mocha$/i, category: "testing", label: "mocha" },
+  { pattern: /^cypress$/i, category: "testing", label: "cypress" },
+  { pattern: /^playwright$/i, category: "testing", label: "playwright" },
+  { pattern: /^@testing-library/i, category: "testing", label: "testing-library" },
+  { pattern: /^pytest$/i, category: "testing", label: "pytest" },
+  { pattern: /^supertest$/i, category: "testing", label: "supertest" }
+];
+async function fingerprint(root, files) {
+  const result = {
+    languages: [],
+    frameworks: [],
+    orms: [],
+    infrastructure: [],
+    security_libs: [],
+    ai_libs: [],
+    testing: [],
+    all_dependencies: [],
+    iac_tools: []
+  };
+  const extCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const ext = f.ext.toLowerCase();
+    extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
+  }
+  result.languages = detectLanguages(extCounts);
+  const deps = /* @__PURE__ */ new Set();
+  const pkgJson = await readJsonSafe(join(root, "package.json"));
+  if (pkgJson) {
+    result.package_manager = detectNodePackageManager(root, files);
+    for (const name of Object.keys(pkgJson.dependencies ?? {}))
+      deps.add(name);
+    for (const name of Object.keys(pkgJson.devDependencies ?? {}))
+      deps.add(name);
+  }
+  const reqTxt = await readTextSafe(join(root, "requirements.txt"));
+  if (reqTxt) {
+    result.package_manager = result.package_manager ?? "pip";
+    for (const line of reqTxt.split("\n")) {
+      const pkg = line.trim().split(/[=<>!~\[]/)[0].trim();
+      if (pkg && !pkg.startsWith("#") && !pkg.startsWith("-"))
+        deps.add(pkg);
+    }
+  }
+  const pyproject = await readTextSafe(join(root, "pyproject.toml"));
+  if (pyproject) {
+    result.package_manager = result.package_manager ?? "pip";
+    const depSection = pyproject.match(/\[(?:tool\.poetry\.)?dependencies\]([\s\S]*?)(?:\[|$)/);
+    if (depSection) {
+      for (const line of depSection[1].split("\n")) {
+        const match = line.match(/^(\w[\w-]*)\s*=/);
+        if (match)
+          deps.add(match[1]);
+      }
+    }
+  }
+  const gomod = await readTextSafe(join(root, "go.mod"));
+  if (gomod) {
+    result.package_manager = "go";
+    for (const line of gomod.split("\n")) {
+      const match = line.match(/^\s+([\w./\-@]+)\s+v/);
+      if (match)
+        deps.add(match[1].split("/").pop());
+    }
+  }
+  const gemfile = await readTextSafe(join(root, "Gemfile"));
+  if (gemfile) {
+    result.package_manager = result.package_manager ?? "bundler";
+    for (const line of gemfile.split("\n")) {
+      const match = line.match(/gem\s+['"]([^'"]+)['"]/);
+      if (match)
+        deps.add(match[1]);
+    }
+  }
+  result.all_dependencies = [...deps];
+  const seen = /* @__PURE__ */ new Map();
+  for (const depName of deps) {
+    for (const classifier of DEP_CLASSIFIERS) {
+      if (classifier.pattern.test(depName)) {
+        if (!seen.has(classifier.category))
+          seen.set(classifier.category, /* @__PURE__ */ new Set());
+        const catSet = seen.get(classifier.category);
+        if (!catSet.has(classifier.label)) {
+          catSet.add(classifier.label);
+          result[classifier.category].push(classifier.label);
+        }
+      }
+    }
+  }
+  const fileNames = new Set(files.map((f) => basename(f.path).toLowerCase()));
+  const filePaths = files.map((f) => f.path.toLowerCase());
+  const iacSet = /* @__PURE__ */ new Set();
+  if (filePaths.some((p) => p.endsWith(".tf")))
+    iacSet.add("terraform");
+  if (fileNames.has("dockerfile") || filePaths.some((p) => /docker-compose/i.test(p)))
+    iacSet.add("docker");
+  if (filePaths.some((p) => /pulumi\.(yaml|yml)$/i.test(p)))
+    iacSet.add("pulumi");
+  if (filePaths.some((p) => /\/k8s\/|\/kubernetes\/|\/helm\//i.test(p)))
+    iacSet.add("kubernetes");
+  if (filePaths.some((p) => /cloudformation/i.test(p)))
+    iacSet.add("cloudformation");
+  result.iac_tools = [...iacSet];
+  return result;
+}
+async function parseLockfiles(root, files, packageManager) {
+  const entries = [];
+  const seenKey = /* @__PURE__ */ new Set();
+  function add(name, version, ecosystem, dev) {
+    if (!name || !version)
+      return;
+    const key = `${ecosystem}:${name}@${version}`;
+    if (seenKey.has(key))
+      return;
+    seenKey.add(key);
+    entries.push({ name, version, ecosystem, dev });
+  }
+  const pkgLock = await readJsonSafe(join(root, "package-lock.json"));
+  if (pkgLock) {
+    if (pkgLock.packages) {
+      for (const [key, val] of Object.entries(pkgLock.packages)) {
+        if (key === "")
+          continue;
+        const name = key.replace(/^node_modules\//, "");
+        if (name.includes("node_modules/"))
+          continue;
+        if (val.version)
+          add(name, val.version, "npm", val.dev ?? false);
+      }
+    } else if (pkgLock.dependencies) {
+      for (const [name, val] of Object.entries(pkgLock.dependencies)) {
+        if (val.version)
+          add(name, val.version, "npm", val.dev ?? false);
+      }
+    }
+  }
+  if (!pkgLock || packageManager === "yarn") {
+    const yarnLock = await readTextSafe(join(root, "yarn.lock"));
+    if (yarnLock) {
+      const blocks = yarnLock.split(/\n(?=\S)/);
+      for (const block of blocks) {
+        const headerMatch = block.match(/^"?(@?[^@\s"]+)@/);
+        const versionMatch = block.match(/^\s+version\s+"([^"]+)"/m);
+        if (headerMatch && versionMatch) {
+          add(headerMatch[1], versionMatch[1], "npm", false);
+        }
+      }
+    }
+  }
+  if (packageManager === "pnpm") {
+    const pnpmLock = await readTextSafe(join(root, "pnpm-lock.yaml"));
+    if (pnpmLock) {
+      const pkgRegex = /^\s+'?\/?(@?[^@\s']+)@(\d[^':\s]*)[':]?/;
+      for (const line of pnpmLock.split("\n")) {
+        const m = line.match(pkgRegex);
+        if (m)
+          add(m[1], m[2], "npm", false);
+      }
+    }
+  }
+  const reqTxt = await readTextSafe(join(root, "requirements.txt"));
+  if (reqTxt) {
+    for (const line of reqTxt.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-"))
+        continue;
+      const m = trimmed.match(/^([a-zA-Z0-9_.-]+)\s*[=~!<>]=\s*([0-9][^\s;,#]*)/);
+      if (m)
+        add(m[1], m[2], "PyPI", false);
+    }
+  }
+  const poetryLock = await readTextSafe(join(root, "poetry.lock"));
+  if (poetryLock) {
+    const blocks = poetryLock.split(/\n\[\[package\]\]/);
+    for (const block of blocks) {
+      const nameMatch = block.match(/^name\s*=\s*"([^"]+)"/m);
+      const versionMatch = block.match(/^version\s*=\s*"([^"]+)"/m);
+      if (nameMatch && versionMatch) {
+        add(nameMatch[1], versionMatch[1], "PyPI", false);
+      }
+    }
+  }
+  const goSum = await readTextSafe(join(root, "go.sum"));
+  if (goSum) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of goSum.split("\n")) {
+      const m = line.match(/^(\S+)\s+v(\d[^\s/]*)/);
+      if (m) {
+        const key = `${m[1]}@${m[2]}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          add(m[1], m[2], "Go", false);
+        }
+      }
+    }
+  }
+  const gemfileLock = await readTextSafe(join(root, "Gemfile.lock"));
+  if (gemfileLock) {
+    const specSection = gemfileLock.match(/GEM[\s\S]*?specs:\n([\s\S]*?)(?:\n\S|\n$)/);
+    if (specSection) {
+      for (const line of specSection[1].split("\n")) {
+        const m = line.match(/^\s{4}(\S+)\s+\(([^)]+)\)/);
+        if (m)
+          add(m[1], m[2], "RubyGems", false);
+      }
+    }
+  }
+  return entries;
+}
+function detectLanguages(extCounts) {
+  const langMap = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".rb": "ruby",
+    ".cs": "csharp",
+    ".swift": "swift",
+    ".php": "php",
+    ".dart": "dart",
+    ".ex": "elixir",
+    ".exs": "elixir"
+  };
+  const langCounts = /* @__PURE__ */ new Map();
+  for (const [ext, count] of extCounts) {
+    const lang = langMap[ext];
+    if (lang)
+      langCounts.set(lang, (langCounts.get(lang) ?? 0) + count);
+  }
+  return [...langCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4).map(([lang]) => lang);
+}
+function detectNodePackageManager(root, files) {
+  const names = new Set(files.map((f) => basename(f.path)));
+  if (names.has("pnpm-lock.yaml"))
+    return "pnpm";
+  if (names.has("yarn.lock"))
+    return "yarn";
+  if (names.has("bun.lockb"))
+    return "bun";
+  return "npm";
+}
+var SENSITIVE_PATTERNS = [
+  // PII
+  { pattern: /\b(email|e_mail|emailAddress|user_email)\b/i, classification: "pii" },
+  { pattern: /\b(phone|phoneNumber|phone_number|mobile|cellPhone)\b/i, classification: "pii" },
+  { pattern: /\b(firstName|first_name|lastName|last_name|fullName|full_name|displayName)\b/i, classification: "pii" },
+  { pattern: /\b(dateOfBirth|date_of_birth|dob|birthDate|birth_date)\b/i, classification: "pii" },
+  { pattern: /\b(address|streetAddress|street_address|homeAddress|mailingAddress)\b/i, classification: "pii" },
+  { pattern: /\b(city|state|zipCode|zip_code|postalCode|postal_code|country)\b/i, classification: "pii" },
+  { pattern: /\b(ipAddress|ip_address|userAgent|user_agent)\b/i, classification: "pii" },
+  { pattern: /\b(avatar|profilePhoto|profile_photo|profileImage)\b/i, classification: "pii" },
+  // Financial
+  { pattern: /\b(creditCard|credit_card|cardNumber|card_number)\b/i, classification: "financial" },
+  { pattern: /\b(bankAccount|bank_account|accountNumber|account_number|routingNumber)\b/i, classification: "financial" },
+  { pattern: /\b(stripeId|stripe_id|stripeCustomerId|stripe_customer_id|paymentMethod)\b/i, classification: "financial" },
+  { pattern: /\b(balance|amount|price|salary|income|revenue)\b/i, classification: "financial" },
+  { pattern: /\b(invoice|billing|subscription|plan|tier)\b/i, classification: "financial" },
+  // Credentials
+  { pattern: /\b(password|passwordHash|password_hash|hashedPassword)\b/i, classification: "credential" },
+  { pattern: /\b(secret|apiKey|api_key|apiSecret|api_secret)\b/i, classification: "credential" },
+  { pattern: /\b(token|accessToken|access_token|refreshToken|refresh_token)\b/i, classification: "credential" },
+  { pattern: /\b(sessionId|session_id|authToken|auth_token)\b/i, classification: "credential" },
+  { pattern: /\b(privateKey|private_key|publicKey|encryptionKey)\b/i, classification: "credential" },
+  // Health
+  { pattern: /\b(diagnosis|medication|prescription|medicalRecord|medical_record)\b/i, classification: "health" },
+  { pattern: /\b(healthData|health_data|bloodType|blood_type|allergy|allergies)\b/i, classification: "health" },
+  { pattern: /\b(insuranceId|insurance_id|patientId|patient_id)\b/i, classification: "health" },
+  // Government ID
+  { pattern: /\b(ssn|socialSecurity|social_security|socialSecurityNumber)\b/i, classification: "government_id" },
+  { pattern: /\b(taxId|tax_id|ein|nationalId|national_id|passport|passportNumber)\b/i, classification: "government_id" },
+  { pattern: /\b(driversLicense|drivers_license|licenseNumber|license_number)\b/i, classification: "government_id" }
+];
+var MODEL_FILE_PATTERNS = [
+  /\bmodels?\b/i,
+  /\bschemas?\b/i,
+  /\btypes?\b/i,
+  /\bentit(y|ies)\b/i,
+  /\binterfaces?\b/i,
+  /\bdb\b/i,
+  /\bdatabase\b/i,
+  /\bmigrations?\b/i
+];
+var MODEL_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".rb",
+  ".prisma",
+  ".graphql",
+  ".gql",
+  ".proto",
+  ".sql"
+]);
+async function discoverSensitiveData(root, files, extraModelExts = []) {
+  const allowedExts = /* @__PURE__ */ new Set([...MODEL_EXTENSIONS, ...extraModelExts]);
+  const fields = [];
+  let filesScanned = 0;
+  const candidates = files.filter((f) => {
+    if (!allowedExts.has(f.ext.toLowerCase()))
+      return false;
+    if (f.size > 2e5)
+      return false;
+    return MODEL_FILE_PATTERNS.some((p) => p.test(f.path));
+  });
+  for (const f of files) {
+    const ext = f.ext.toLowerCase();
+    if ([".prisma", ".graphql", ".gql", ".proto", ".sql"].includes(ext)) {
+      if (!candidates.some((c) => c.path === f.path)) {
+        candidates.push(f);
+      }
+    }
+  }
+  const toScan = candidates.slice(0, 200);
+  for (const file of toScan) {
+    let content;
+    try {
+      content = await readFile(join(root, file.path), "utf-8");
+    } catch {
+      continue;
+    }
+    filesScanned++;
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      for (const sp of SENSITIVE_PATTERNS) {
+        const match = sp.pattern.exec(line);
+        if (match) {
+          fields.push({
+            file: file.path,
+            line: i + 1,
+            field: match[1] || match[0],
+            classification: sp.classification
+          });
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = fields.filter((f) => {
+    const key = `${f.file}:${f.field}:${f.classification}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+  const byClass = {
+    pii: 0,
+    financial: 0,
+    credential: 0,
+    health: 0,
+    government_id: 0
+  };
+  for (const f of deduped) {
+    byClass[f.classification]++;
+  }
+  return { fields: deduped, by_class: byClass, files_scanned: filesScanned };
+}
+async function scanCodebase(options) {
+  const t0 = Date.now();
+  const files = await walkFileTree(options);
+  const ecosystem = await fingerprint(options.root, files);
+  const [sensitive_data, dependencies] = await Promise.all([
+    discoverSensitiveData(options.root, files, options.extraModelExts),
+    parseLockfiles(options.root, files, ecosystem.package_manager)
+  ]);
+  return {
+    root: options.root,
+    files,
+    ecosystem,
+    sensitive_data,
+    dependencies,
+    elapsed_ms: Date.now() - t0
+  };
+}
+async function readJsonSafe(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readTextSafe(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function loadGitignore(root) {
+  const content = await readTextSafe(join(root, ".gitignore"));
+  if (!content)
+    return [];
+  return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!")).map(gitignoreToRegex).filter(Boolean);
+}
+function gitignoreToRegex(pattern) {
+  try {
+    let p = pattern;
+    const dirOnly = p.endsWith("/");
+    if (dirOnly)
+      p = p.slice(0, -1);
+    p = p.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    p = p.replace(/\*\*/g, "{{GLOBSTAR}}");
+    p = p.replace(/\*/g, "[^/]*");
+    p = p.replace(/\?/g, "[^/]");
+    p = p.replace(/\{\{GLOBSTAR\}\}/g, ".*");
+    if (!pattern.startsWith("/")) {
+      p = `(^|.*/?)${p}`;
+    } else {
+      p = `^${p.slice(1)}`;
+    }
+    return new RegExp(`${p}(/.*)?$`, "i");
+  } catch {
+    return null;
+  }
+}
+function matchesGitignore(relPath, patterns) {
+  for (const re of patterns) {
+    if (re.test(relPath))
+      return true;
+  }
+  return false;
+}
+
+// ../mcp/dist/mcp/src/tools/code-audit-prompts.js
+var UNIVERSAL_CONSTRAINTS = [
+  {
+    id_suffix: "auth_middleware",
+    category: "security",
+    summary: "All API endpoints MUST be protected by authentication middleware. No public data-mutation routes.",
+    keywords: ["auth", "middleware", "api", "endpoint", "protection"],
+    severity: "critical",
+    action: "Add auth middleware to every API route. Verify no unprotected state-changing endpoints exist.",
+    checklist_ref: "A1",
+    file_patterns: ["**/api/**", "**/routes/**", "**/handlers/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "authz_per_resource",
+    category: "security",
+    summary: "Authorization checks MUST be per-resource, not just per-route. User A must not access User B's data.",
+    keywords: ["authorization", "rbac", "access-control", "isolation", "multi-tenant"],
+    severity: "critical",
+    action: "Implement per-resource authorization checks. Verify data isolation in queries.",
+    checklist_ref: "A2",
+    file_patterns: ["**/api/**", "**/middleware/**", "**/auth/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "input_validation",
+    category: "security",
+    summary: "All user inputs MUST be validated and sanitized before use in queries, commands, or rendered output.",
+    keywords: ["validation", "sanitization", "injection", "xss", "input"],
+    severity: "critical",
+    action: "Add input validation on all API routes. Use parameterized queries. Sanitize rendered content.",
+    checklist_ref: "B1",
+    file_patterns: ["**/api/**", "**/routes/**", "**/components/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "secrets_management",
+    category: "security",
+    summary: "Secrets, API keys, and credentials MUST NOT be committed to version control or exposed client-side.",
+    keywords: ["secrets", "env", "api-key", "credentials", "config"],
+    severity: "critical",
+    action: "Use environment variables for secrets. Verify .gitignore covers .env. Audit client bundles for leaked keys.",
+    checklist_ref: "C4",
+    file_patterns: ["**/.env*", "**/config/**", "**/.gitignore"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "rate_limiting",
+    category: "security",
+    summary: "Rate limiting MUST be applied to authentication endpoints, payment endpoints, and data export routes.",
+    keywords: ["rate-limit", "throttle", "brute-force", "dos"],
+    severity: "warning",
+    action: "Add rate limiting middleware to sensitive endpoints (login, signup, payment, export).",
+    checklist_ref: "D1",
+    file_patterns: ["**/api/auth/**", "**/api/login*", "**/api/payment*", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "csrf_protection",
+    category: "security",
+    summary: "CSRF protection MUST be enabled on all state-changing endpoints.",
+    keywords: ["csrf", "cross-site", "token", "form"],
+    severity: "warning",
+    action: "Enable CSRF tokens on POST/PUT/DELETE routes. Verify SameSite cookie attributes.",
+    checklist_ref: "D2",
+    file_patterns: ["**/api/**", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "error_leakage",
+    category: "security",
+    summary: "Error responses MUST NOT leak stack traces, internal paths, or database error details to clients.",
+    keywords: ["error", "stack-trace", "leak", "debug", "internal"],
+    severity: "warning",
+    action: "Use generic error responses in production. Strip internal details from API error payloads.",
+    checklist_ref: "D3",
+    file_patterns: ["**/api/**", "**/middleware/**", "**/error*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "cors_explicit_origins",
+    category: "security",
+    summary: "CORS origins MUST be explicitly whitelisted. Wildcard (*) origins are forbidden on authenticated or state-changing endpoints.",
+    keywords: ["cors", "origin", "wildcard", "cross-origin", "headers"],
+    severity: "warning",
+    action: "Replace wildcard CORS with an explicit allowlist of trusted origins. Verify credentials mode is not combined with wildcard.",
+    checklist_ref: "D5",
+    file_patterns: ["**/api/**", "**/middleware/**", "**/config/**", "**/server.*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "dependency_scanning",
+    category: "security",
+    summary: "Dependencies MUST be scanned for known vulnerabilities. Lockfiles must be committed and integrity-checked.",
+    keywords: ["dependency", "vulnerability", "npm-audit", "lockfile", "supply-chain", "cve"],
+    severity: "warning",
+    action: "Run `npm audit` or equivalent in CI. Commit lockfiles. Enable Dependabot or similar automated scanning.",
+    checklist_ref: "F1",
+    file_patterns: ["**/package*.json", "**/requirements*.txt", "**/*lock*", "**/.github/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "file_upload_validation",
+    category: "security",
+    summary: "File uploads MUST be validated for type, size, and content. Untrusted files must not be served inline or executed.",
+    keywords: ["upload", "file", "mime", "size-limit", "content-type", "malware"],
+    severity: "warning",
+    action: "Validate MIME type and file extension server-side. Enforce size limits. Store uploads outside webroot. Serve with Content-Disposition: attachment.",
+    checklist_ref: "B3",
+    file_patterns: ["**/api/upload*", "**/api/file*", "**/storage/**", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "no_default_credentials",
+    category: "security",
+    summary: "Default credentials, example configs with real-looking values, and scaffolding secrets MUST be removed before deployment.",
+    keywords: ["default-credentials", "example-config", "scaffold", "boilerplate", "seed-data"],
+    severity: "critical",
+    action: "Audit for default passwords, example API keys, and seed data in config files. Verify .env.example contains only placeholders, not real values.",
+    checklist_ref: "C6",
+    file_patterns: ["**/.env*", "**/config/**", "**/seed*", "**/fixtures/**", "**/docker-compose*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "no_debug_production",
+    category: "security",
+    summary: "Debug mode, verbose logging, and dev tools MUST be disabled in production builds. No DEBUG=*, React DevTools, or source maps in prod.",
+    keywords: ["debug", "devtools", "source-map", "verbose", "production", "NODE_ENV"],
+    severity: "warning",
+    action: "Ensure NODE_ENV=production in deployment. Disable source maps in prod builds. Remove debug middleware and verbose logging.",
+    checklist_ref: "C7",
+    file_patterns: ["**/config/**", "**/next.config*", "**/webpack*", "**/.env*", "**/Dockerfile*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "secure_token_storage",
+    category: "security",
+    summary: "Auth tokens MUST be stored in httpOnly secure cookies, NOT in localStorage or sessionStorage. Client-side JS must not access tokens.",
+    keywords: ["token", "localStorage", "sessionStorage", "cookie", "httpOnly", "secure"],
+    severity: "critical",
+    action: "Move tokens from localStorage/sessionStorage to httpOnly, Secure, SameSite=Strict cookies. Verify no client JS reads auth tokens.",
+    checklist_ref: "A7",
+    file_patterns: ["**/auth/**", "**/api/login*", "**/api/session*", "**/lib/auth*", "**/hooks/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "user_enumeration_prevention",
+    category: "security",
+    summary: "Login, signup, and password reset flows MUST NOT reveal whether an account exists. Use identical responses and consistent timing.",
+    keywords: ["enumeration", "user-exists", "timing", "login", "reset", "signup"],
+    severity: "warning",
+    action: "Return identical error messages for valid/invalid accounts on login and reset. Add constant-time comparison. Avoid 'email already registered' on signup.",
+    checklist_ref: "A8",
+    file_patterns: ["**/api/auth/**", "**/api/login*", "**/api/signup*", "**/api/reset*", "**/api/forgot*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "minimal_data_exposure",
+    category: "security",
+    summary: "API endpoints MUST return only the fields the client needs. No over-fetching of user records, internal IDs, or other users' data.",
+    keywords: ["over-fetch", "data-exposure", "select", "projection", "field-filtering"],
+    severity: "warning",
+    action: "Use explicit field selection in queries. Strip internal fields (createdBy, internalId, etc.) from API responses. Never return full DB documents.",
+    checklist_ref: "D6",
+    file_patterns: ["**/api/**", "**/models/**", "**/queries/**", "**/serializers/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "destructive_action_confirmation",
+    category: "security",
+    summary: "Sensitive actions (account deletion, email change, role escalation) MUST require re-authentication or a confirmation step.",
+    keywords: ["re-auth", "confirmation", "delete", "email-change", "destructive", "step-up"],
+    severity: "warning",
+    action: "Require password re-entry or MFA step-up for destructive operations. Add confirmation tokens with short TTL for irreversible actions.",
+    checklist_ref: "D7",
+    file_patterns: ["**/api/user*", "**/api/account*", "**/api/admin*", "**/api/delete*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "server_side_payment_validation",
+    category: "security",
+    summary: "Payment amounts, prices, and billing logic MUST be validated server-side. Client-submitted prices or quantities must never be trusted.",
+    keywords: ["payment", "price", "billing", "server-side", "validation", "tamper"],
+    severity: "critical",
+    action: "Validate all prices/quantities against server-side catalog. Never trust client-submitted amounts. Use Stripe Checkout or server-created PaymentIntents.",
+    checklist_ref: "D8",
+    file_patterns: ["**/api/payment*", "**/api/checkout*", "**/api/stripe*", "**/billing/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "insecure_deserialization",
+    category: "security",
+    summary: "Untrusted data MUST NOT be deserialized using unsafe functions (pickle.load, yaml.load, eval, Function constructor). Use safe parsers with schema validation.",
+    keywords: ["deserialization", "pickle", "yaml", "eval", "prototype-pollution", "unsafe"],
+    severity: "critical",
+    action: "Replace unsafe deserialization with schema-validated parsers (zod, joi). Ban eval/Function constructor on user input. Use yaml.safeLoad instead of yaml.load.",
+    checklist_ref: "B5",
+    file_patterns: ["**/api/**", "**/utils/**", "**/lib/**", "**/parsers/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "path_traversal_prevention",
+    category: "security",
+    summary: "File paths from user input MUST be sanitized and restricted to an allowed base directory. Reject `..` traversal sequences.",
+    keywords: ["path-traversal", "directory-traversal", "file-access", "sanitize", "realpath"],
+    severity: "critical",
+    action: "Resolve paths with path.resolve and verify they stay within the allowed base directory. Reject inputs containing '..' or absolute paths. Use path.basename for filenames.",
+    checklist_ref: "B6",
+    file_patterns: ["**/api/file*", "**/api/download*", "**/api/upload*", "**/storage/**", "**/static/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "password_hashing",
+    category: "security",
+    summary: "Passwords MUST be hashed with bcrypt, scrypt, or argon2. MD5, SHA-1, and SHA-256 without salt are forbidden. Never store plaintext passwords.",
+    keywords: ["password", "hash", "bcrypt", "argon2", "scrypt", "md5", "plaintext"],
+    severity: "critical",
+    action: "Use bcrypt (cost >= 10) or argon2id for password hashing. Remove any MD5/SHA usage for passwords. Verify no plaintext password storage in DB schemas.",
+    checklist_ref: "A4",
+    file_patterns: ["**/auth/**", "**/api/auth/**", "**/api/signup*", "**/api/login*", "**/models/user*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "transport_security",
+    category: "security",
+    summary: "All traffic MUST use HTTPS/TLS 1.2+. HTTP MUST redirect to HTTPS. HSTS headers MUST be enabled with a minimum max-age of 1 year.",
+    keywords: ["https", "tls", "ssl", "hsts", "http-redirect", "transport", "encryption-in-transit"],
+    severity: "critical",
+    action: "Enforce HTTPS on all endpoints. Add HSTS header (Strict-Transport-Security: max-age=31536000; includeSubDomains). Redirect HTTP to HTTPS at load balancer or app level.",
+    checklist_ref: "C5",
+    file_patterns: ["**/server.*", "**/app.*", "**/config/**", "**/middleware/**", "**/*.tf", "**/nginx*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "origin_header_validation",
+    category: "security",
+    summary: "State-changing endpoints MUST verify the Origin or Referer header in addition to CSRF tokens. Reject requests from unexpected origins.",
+    keywords: ["origin", "referer", "csrf", "cross-site", "request-forgery", "samesite"],
+    severity: "warning",
+    action: "Check Origin/Referer header on POST/PUT/DELETE requests. Combine with CSRF tokens and SameSite=Strict cookies for defense in depth.",
+    checklist_ref: "D2",
+    file_patterns: ["**/middleware/**", "**/api/**", "**/config/cors*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "secret_rotation",
+    category: "security",
+    summary: "Secrets and API keys MUST have a defined rotation schedule (90 days max). Long-lived credentials without rotation are forbidden in production.",
+    keywords: ["secret-rotation", "api-key", "credentials", "lifecycle", "expiration", "rotate"],
+    severity: "warning",
+    action: "Implement secret rotation via your cloud provider's secret manager (GCP Secret Manager, AWS Secrets Manager). Flag any API key older than 90 days. Use short-lived tokens where possible.",
+    checklist_ref: "C8",
+    file_patterns: ["**/.env*", "**/config/**", "**/secrets/**", "**/*.tf", "**/ci/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "redirect_url_allowlist",
+    category: "security",
+    summary: "All redirect URLs (OAuth callbacks, post-login, post-payment) MUST be validated against an explicit allowlist. Open redirects are forbidden.",
+    keywords: ["redirect", "open-redirect", "allowlist", "callback", "oauth", "return-url", "phishing"],
+    severity: "critical",
+    action: "Validate every redirect target against a hardcoded allowlist of trusted domains/paths. Reject absolute URLs to unknown hosts. Never pass user-controlled redirect targets without validation.",
+    checklist_ref: "D9",
+    file_patterns: ["**/api/auth/**", "**/api/login*", "**/api/callback*", "**/api/checkout*", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "sensitive_tokens_not_in_urls",
+    category: "security",
+    summary: "Auth/session/API tokens MUST NOT be passed in URL query parameters during redirects. Sensitive tokens in URLs leak via logs, browser history, and referrers.",
+    keywords: ["token", "query-param", "callback", "returnUrl", "redirect", "referrer", "url-leakage"],
+    severity: "critical",
+    action: "Use Authorization headers or httpOnly cookies for token transport. Validate callback/return URLs against an allowlist and never append bearer/session tokens to redirected URLs.",
+    checklist_ref: "D11",
+    file_patterns: ["**/auth/**", "**/api/auth/**", "**/api/**/checkout*", "**/mcp-auth*", "**/session/**", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "no_secrets_in_query_params",
+    category: "security",
+    summary: "Secrets (revalidation secrets, API secrets, webhook secrets) MUST NOT be transported via URL query parameters. Query-string secrets are leaked through logs, referrers, and browser history.",
+    keywords: ["secret", "query-param", "url", "revalidate", "webhook", "referrer", "leakage"],
+    severity: "critical",
+    action: "Accept secrets only via headers or signed request bodies. Reject secret-bearing query params in production endpoints. Rotate any secret previously sent in URLs.",
+    checklist_ref: "D12",
+    file_patterns: ["**/api/**", "**/webhooks/**", "**/revalidate/**", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "no_state_change_get_cookie_auth",
+    category: "security",
+    summary: "State-changing operations MUST NOT be reachable via GET when cookie authentication is accepted. GET + cookie auth creates CSRF risk.",
+    keywords: ["csrf", "get", "state-change", "cookie-auth", "origin-check", "referer", "method-safety"],
+    severity: "critical",
+    action: "Use POST/PUT/DELETE for side effects. If GET fallback is unavoidable, enforce strict same-origin checks (Origin/Referer/sec-fetch-site) and avoid cookie-based auth fallback where possible.",
+    checklist_ref: "D13",
+    file_patterns: ["**/api/**", "**/auth/**", "**/checkout/**", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "ai_cost_caps",
+    category: "security",
+    summary: "AI/LLM API usage MUST have cost caps enforced in code (token limits, request budgets) and in provider dashboards (spending alerts, hard limits).",
+    keywords: ["ai", "llm", "cost-cap", "budget", "token-limit", "spending", "billing-alert"],
+    severity: "warning",
+    action: "Set max_tokens on every LLM call. Implement per-user and per-request budget limits. Configure spending alerts and hard caps in provider dashboards (OpenAI, Vertex AI, Anthropic).",
+    checklist_ref: "F4",
+    file_patterns: ["**/ai/**", "**/llm/**", "**/agents/**", "**/orchestrator/**", "**/config/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "webhook_signature_verification",
+    category: "security",
+    summary: "Inbound webhooks (Stripe, payment providers, third-party events) MUST verify the request signature before processing. Unverified webhooks are a fraud vector.",
+    keywords: ["webhook", "signature", "stripe", "hmac", "verify", "payment", "event"],
+    severity: "critical",
+    action: "Verify webhook signatures using the provider's SDK (e.g., stripe.webhooks.constructEvent). Reject requests with missing or invalid signatures. Use raw body for signature verification.",
+    checklist_ref: "D10",
+    file_patterns: ["**/api/webhook*", "**/api/stripe*", "**/api/payment*", "**/webhooks/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "critical_action_audit_logging",
+    category: "security",
+    summary: "Critical actions (account deletion, role changes, payment events, data exports, permission escalation) MUST be logged with actor, timestamp, and affected resource.",
+    keywords: ["audit-log", "deletion", "role-change", "payment", "export", "logging", "accountability"],
+    severity: "critical",
+    action: "Log all destructive and sensitive operations with structured data (who, what, when, which resource). Store audit logs in append-only / tamper-evident storage. Set up alerts for anomalous patterns.",
+    checklist_ref: "E5",
+    file_patterns: ["**/api/**", "**/admin/**", "**/auth/**", "**/logger/**", "**/middleware/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "session_lifetime_limits",
+    category: "security",
+    summary: "Session and JWT lifetimes MUST be bounded. JWTs should not exceed 7 days. Refresh token rotation MUST be implemented to limit the blast radius of stolen tokens.",
+    keywords: ["session", "jwt", "lifetime", "expiry", "refresh-token", "rotation", "max-age"],
+    severity: "warning",
+    action: "Set JWT maxAge <= 7 days. Implement refresh token rotation (one-time-use refresh tokens). Expire idle sessions. Invalidate all tokens on password change.",
+    checklist_ref: "A9",
+    file_patterns: ["**/auth/**", "**/api/session*", "**/api/login*", "**/middleware/**", "**/config/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "password_reset_token_expiry",
+    category: "security",
+    summary: "Password reset tokens/links MUST be single-use and time-limited. Expired or reused reset tokens must fail closed.",
+    keywords: ["password-reset", "token", "expiry", "single-use", "account-takeover"],
+    severity: "critical",
+    action: "Enforce reset token TTL and one-time use semantics. Invalidate outstanding reset tokens after successful password change.",
+    checklist_ref: "A10",
+    file_patterns: ["**/auth/**", "**/api/reset*", "**/api/forgot*", "**/api/password*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "backup_testing",
+    category: "stability",
+    summary: "Backups MUST be automated and periodically tested with a restore verification process. An untested backup is equivalent to no backup.",
+    keywords: ["backup", "restore", "disaster-recovery", "test", "verification", "snapshot"],
+    severity: "warning",
+    action: "Automate database and storage backups on a schedule. Test restores at least quarterly. Document and verify the restore procedure. Alert on backup failures.",
+    checklist_ref: "E6",
+    file_patterns: ["**/*.tf", "**/backup*", "**/config/**", "**/ci/**", "**/scripts/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "environment_separation",
+    category: "infrastructure",
+    summary: "Test and production environments MUST be fully separated (distinct credentials, databases, and API keys). Webhooks in test MUST NOT trigger production systems.",
+    keywords: ["environment", "staging", "production", "separation", "isolation", "test", "webhook"],
+    severity: "warning",
+    action: "Use distinct GCP/AWS projects or accounts for test vs production. Never share database instances, API keys, or webhook endpoints across environments. Verify webhook URLs are environment-scoped.",
+    checklist_ref: "E7",
+    file_patterns: ["**/.env*", "**/config/**", "**/*.tf", "**/docker-compose*", "**/ci/**"],
+    framework: "baseline"
+  }
+];
+var SCALABILITY_CONSTRAINTS = [
+  {
+    id_suffix: "n_plus_one_queries",
+    category: "performance",
+    summary: "Data fetching MUST use JOINs, eager loading, or batch queries. Avoid fetching related records in loops (N+1 pattern).",
+    keywords: ["n+1", "query", "loop", "eager-loading", "join", "batch", "dataloader"],
+    severity: "warning",
+    action: "Replace loop-based DB fetches with JOINs, includes/eager-loading, or DataLoader-style batching. Profile query counts per request.",
+    checklist_ref: "I1",
+    file_patterns: ["**/api/**", "**/models/**", "**/repositories/**", "**/services/**", "**/db/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "database_indexing",
+    category: "scalability",
+    summary: "Columns used in WHERE, ORDER BY, and JOIN clauses MUST have database indexes. Use composite indexes for multi-column filters.",
+    keywords: ["index", "database", "query-performance", "composite-index", "explain"],
+    severity: "warning",
+    action: "Add indexes on all filtered/sorted columns. Use EXPLAIN to verify index usage. Add composite indexes for compound queries.",
+    checklist_ref: "I2",
+    file_patterns: ["**/migrations/**", "**/schema*", "**/models/**", "**/*.prisma", "**/*.sql"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "algorithmic_complexity",
+    category: "performance",
+    summary: "Nested loops over large datasets MUST be reviewed. Prefer O(n) or O(log n) lookups (Maps, Sets, binary search) over O(n^2) scans.",
+    keywords: ["complexity", "O(n^2)", "nested-loop", "performance", "map", "set", "algorithm"],
+    severity: "warning",
+    action: "Replace nested array scans with Map/Set lookups. Use indexing or sorting + binary search for large collections. Profile hot paths.",
+    checklist_ref: "I3",
+    file_patterns: ["**/utils/**", "**/lib/**", "**/services/**", "**/api/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "memory_leak_prevention",
+    category: "stability",
+    summary: "Database connections, event listeners, timers, and streams MUST be explicitly cleaned up. Use dispose/close patterns and AbortControllers.",
+    keywords: ["memory-leak", "listener", "timer", "connection", "dispose", "cleanup", "abort"],
+    severity: "warning",
+    action: "Add cleanup in useEffect returns, finally blocks, and process signal handlers. Use AbortController for cancellable operations. Close DB connections in pool.",
+    checklist_ref: "I4",
+    file_patterns: ["**/hooks/**", "**/services/**", "**/db/**", "**/workers/**", "**/lib/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "pagination_required",
+    category: "scalability",
+    summary: "Queries returning unbounded result sets MUST use cursor or offset pagination. Never load entire tables into memory.",
+    keywords: ["pagination", "cursor", "offset", "limit", "unbounded", "streaming"],
+    severity: "critical",
+    action: "Add LIMIT/offset or cursor-based pagination to all list endpoints. Stream large exports instead of buffering. Enforce max page size.",
+    checklist_ref: "I5",
+    file_patterns: ["**/api/**", "**/queries/**", "**/repositories/**", "**/db/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "async_io_offloading",
+    category: "performance",
+    summary: "CPU-intensive or blocking I/O operations MUST be offloaded from the main thread/event loop. Use worker threads, queues, or background jobs.",
+    keywords: ["blocking", "sync", "worker", "thread", "event-loop", "offload", "queue"],
+    severity: "warning",
+    action: "Move image processing, PDF generation, and heavy computation to worker threads or background queues. Never use sync file/network I/O on request path.",
+    checklist_ref: "I6",
+    file_patterns: ["**/api/**", "**/workers/**", "**/jobs/**", "**/services/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "connection_pooling",
+    category: "scalability",
+    summary: "Database and HTTP clients MUST use connection pooling. One-connection-per-request patterns are forbidden at scale.",
+    keywords: ["connection-pool", "pool", "database", "http-client", "keep-alive"],
+    severity: "warning",
+    action: "Configure connection pools for all DB clients. Reuse HTTP agents with keep-alive. Set pool size limits matching expected concurrency.",
+    checklist_ref: "I7",
+    file_patterns: ["**/db/**", "**/config/**", "**/lib/**", "**/services/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "concurrency_bounds",
+    category: "scalability",
+    summary: "Worker threads, parallel API calls, and queue consumers MUST have bounded concurrency. Use semaphores or rate-limiting queues.",
+    keywords: ["concurrency", "semaphore", "rate-limit", "worker", "parallel", "queue", "throttle"],
+    severity: "warning",
+    action: "Use p-limit, Bull queue concurrency settings, or semaphores for parallel operations. Never Promise.all on unbounded arrays of async work.",
+    checklist_ref: "I8",
+    file_patterns: ["**/workers/**", "**/jobs/**", "**/services/**", "**/api/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "stateless_backend",
+    category: "scalability",
+    summary: "Application state MUST NOT be stored in process memory. Use external stores (Redis, DB) for sessions, caches, and shared state to enable horizontal scaling.",
+    keywords: ["stateless", "session", "cache", "redis", "horizontal-scaling", "in-memory"],
+    severity: "warning",
+    action: "Move sessions to Redis/DB. Replace in-memory caches with Redis or Memcached. Ensure any instance can handle any request.",
+    checklist_ref: "I9",
+    file_patterns: ["**/server.*", "**/app.*", "**/config/**", "**/session/**", "**/cache/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "single_source_schema",
+    category: "stability",
+    summary: "Data models and schemas MUST be defined once and shared (via codegen, shared types, or a schema registry). No redundant redefinition across layers.",
+    keywords: ["schema", "single-source", "codegen", "data-drift", "duplication", "types"],
+    severity: "warning",
+    action: "Define schemas once (Prisma, Zod, protobuf, JSON Schema) and generate types for all layers. Remove duplicated type definitions across frontend/backend.",
+    checklist_ref: "I10",
+    file_patterns: ["**/models/**", "**/types/**", "**/schema*", "**/shared/**", "**/*.prisma"],
+    framework: "baseline"
+  }
+];
+var RELIABILITY_CONSTRAINTS = [
+  {
+    id_suffix: "verified_dependencies",
+    category: "stability",
+    summary: "All imported packages MUST exist in the registry and resolve correctly. Lock files must be committed. Flag phantom/hallucinated imports.",
+    keywords: ["dependency", "phantom", "hallucinated", "import", "lockfile", "registry"],
+    severity: "warning",
+    action: "Run npm ls / pip check to verify all imports resolve. Commit lockfiles. Audit for AI-generated imports of non-existent packages.",
+    checklist_ref: "J1",
+    file_patterns: ["**/package*.json", "**/requirements*.txt", "**/*lock*", "**/imports/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "no_silent_failures",
+    category: "stability",
+    summary: "Catch blocks MUST log or re-throw errors. Empty catch blocks and swallowed promises are forbidden.",
+    keywords: ["silent-failure", "empty-catch", "error-handling", "swallowed", "promise"],
+    severity: "critical",
+    action: "Audit all catch blocks for empty bodies. Add logging or re-throw. Add .catch() or try/catch to all async paths. Enable unhandledRejection handler.",
+    checklist_ref: "J2",
+    file_patterns: ["**/api/**", "**/services/**", "**/lib/**", "**/utils/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "state_sync_discipline",
+    category: "stability",
+    summary: "Shared state MUST have a single source of truth. Derived/component state must sync via subscriptions or reactivity, not manual copies.",
+    keywords: ["state", "sync", "source-of-truth", "stale", "derived", "store", "reactivity"],
+    severity: "warning",
+    action: "Consolidate state into stores (Redux, Zustand, context). Remove manual state copies. Use derived/computed values instead of duplicated state.",
+    checklist_ref: "J3",
+    file_patterns: ["**/store/**", "**/state/**", "**/context/**", "**/hooks/**", "**/components/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "boundary_correctness",
+    category: "stability",
+    summary: "Array/collection operations MUST handle empty collections, off-by-one indexes, and boundary conditions. Use safe access patterns.",
+    keywords: ["off-by-one", "boundary", "empty-array", "index", "optional-chaining", "bounds"],
+    severity: "warning",
+    action: "Use .at(), optional chaining, and nullish coalescing for array access. Add explicit length checks before index operations. Test with empty inputs.",
+    checklist_ref: "J4",
+    file_patterns: ["**/utils/**", "**/lib/**", "**/services/**", "**/api/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "api_contract_validation",
+    category: "stability",
+    summary: "External API responses MUST be validated against a schema (zod, joi, type guard) before use. Do not assume response shape matches documentation.",
+    keywords: ["api-contract", "validation", "schema", "response", "type-guard", "external"],
+    severity: "warning",
+    action: "Add runtime validation (zod.parse, joi.validate) on all external API responses. Handle validation failures gracefully with fallbacks or retries.",
+    checklist_ref: "J5",
+    file_patterns: ["**/services/**", "**/integrations/**", "**/api/**", "**/lib/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "defensive_edge_cases",
+    category: "stability",
+    summary: "Functions MUST handle null, undefined, empty arrays, unauthenticated users, network timeouts, and malformed input. Fail gracefully with meaningful errors.",
+    keywords: ["edge-case", "null", "undefined", "timeout", "defensive", "graceful-degradation"],
+    severity: "warning",
+    action: "Add null/undefined guards at function boundaries. Set timeouts on network requests. Return meaningful error objects instead of crashing.",
+    checklist_ref: "J6",
+    file_patterns: ["**/api/**", "**/services/**", "**/utils/**", "**/lib/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "function_size_limit",
+    category: "stability",
+    summary: "Functions exceeding ~100 lines SHOULD be decomposed. God functions that mix concerns are a testability and maintainability risk.",
+    keywords: ["god-function", "decomposition", "single-responsibility", "testability", "complexity"],
+    severity: "info",
+    action: "Break functions over 100 lines into focused helpers. Extract validation, transformation, and I/O into separate functions. Aim for single responsibility.",
+    checklist_ref: "J7",
+    file_patterns: ["**/api/**", "**/services/**", "**/utils/**", "**/lib/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "idiomatic_patterns",
+    category: "stability",
+    summary: "Code SHOULD follow language-specific idioms and current best practices. Avoid legacy patterns (var, callbacks where async/await is available, class components where hooks exist).",
+    keywords: ["idiomatic", "best-practice", "legacy", "var", "callback", "modernize"],
+    severity: "info",
+    action: "Replace var with const/let. Convert callbacks to async/await. Use hooks instead of class components. Follow framework-specific conventions.",
+    checklist_ref: "J8",
+    file_patterns: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "refactor_safety",
+    category: "stability",
+    summary: "Changes to shared modules MUST account for all call sites. Renaming, removing, or changing function signatures without updating consumers is a regression vector.",
+    keywords: ["refactor", "regression", "call-site", "breaking-change", "rename", "shared-module"],
+    severity: "warning",
+    action: "Use IDE-assisted rename refactoring. Run TypeScript compiler and tests after signature changes. Search for all usages before modifying exported functions.",
+    checklist_ref: "J9",
+    file_patterns: ["**/lib/**", "**/shared/**", "**/utils/**", "**/types/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "inline_documentation",
+    category: "stability",
+    summary: "Complex business logic, regex, algorithms, and non-obvious code paths SHOULD include explanatory comments. AI-generated code without context creates maintenance debt.",
+    keywords: ["documentation", "comments", "regex", "algorithm", "maintenance", "readability"],
+    severity: "info",
+    action: "Add JSDoc/docstrings to complex functions. Comment non-obvious regex patterns. Document business rules and trade-offs. Flag AI-generated code without explanation.",
+    checklist_ref: "J10",
+    file_patterns: ["**/utils/**", "**/lib/**", "**/services/**", "**/api/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "startup_env_schema_validation",
+    category: "stability",
+    summary: "Runtime environment variables MUST be validated against an explicit schema at startup, and app boot must fail fast on invalid critical config.",
+    keywords: ["env", "startup", "schema", "validation", "fail-fast", "configuration"],
+    severity: "critical",
+    action: "Create startup env schema checks for server and public runtime variables. Crash startup when required production config is missing or malformed.",
+    checklist_ref: "J11",
+    file_patterns: ["**/config/**", "**/env/**", "**/server/**", "**/.env*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "ui_error_boundaries",
+    category: "stability",
+    summary: "Critical user-facing UI surfaces MUST be wrapped in error boundaries to prevent full-app white screens during component crashes.",
+    keywords: ["error-boundary", "react", "ui", "crash", "fallback", "reliability"],
+    severity: "warning",
+    action: "Add error boundaries around major routes/layouts and high-risk widgets. Provide fallback UI and telemetry when boundaries catch errors.",
+    checklist_ref: "J12",
+    file_patterns: ["**/components/**", "**/pages/**", "**/app/**", "**/*error*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "health_readiness_endpoints",
+    category: "stability",
+    summary: "Services MUST expose dedicated liveness and readiness endpoints (e.g., /api/health and /api/readyz) for monitoring and deployment safety checks.",
+    keywords: ["health", "readyz", "liveness", "readiness", "monitoring", "probe"],
+    severity: "critical",
+    action: "Implement lightweight health/readiness endpoints with no sensitive payload data. Integrate endpoints into uptime monitoring and deployment probes.",
+    checklist_ref: "J13",
+    file_patterns: ["**/api/health*", "**/api/ready*", "**/monitoring/**", "**/deploy/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "structured_production_logging",
+    category: "stability",
+    summary: "Production logging MUST be structured and include correlation/request IDs, with automatic redaction of tokens, API keys, and credentials.",
+    keywords: ["logging", "structured", "correlation-id", "request-id", "redaction", "observability"],
+    severity: "critical",
+    action: "Emit JSON logs in production and propagate request/correlation IDs across handlers and background jobs. Apply secret-redaction middleware before log emission.",
+    checklist_ref: "J14",
+    file_patterns: ["**/logger/**", "**/api/**", "**/middleware/**", "**/monitoring/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "typed_ai_generated_code",
+    category: "stability",
+    summary: "AI-generated production code MUST use TypeScript (or equivalent static typing) and pass strict type-check gates before merge.",
+    keywords: ["ai-generated", "typescript", "typing", "typecheck", "ci-gate", "quality"],
+    severity: "warning",
+    action: "Require strict type-check in CI for generated code changes and block merges on type errors. Prefer typed templates for agent-generated modules.",
+    checklist_ref: "J15",
+    file_patterns: ["**/*.ts", "**/*.tsx", "**/ai/**", "**/agents/**", "**/.github/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "async_email_dispatch",
+    category: "performance",
+    summary: "Transactional emails SHOULD be dispatched asynchronously (queue/background workers) so request handlers do not block on provider latency.",
+    keywords: ["email", "async", "queue", "worker", "latency", "smtp", "request-path"],
+    severity: "warning",
+    action: "Move email delivery to async jobs/queues and return request responses before provider completion. Add retry/backoff for transient send failures.",
+    checklist_ref: "J16",
+    file_patterns: ["**/api/**", "**/jobs/**", "**/workers/**", "**/email/**", "**/notifications/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "cdn_media_delivery",
+    category: "performance",
+    summary: "User-uploaded media MUST be stored in object storage and delivered through CDN caching, not served directly from app servers.",
+    keywords: ["cdn", "media", "uploads", "object-storage", "cache", "bandwidth"],
+    severity: "warning",
+    action: "Store uploads in object storage (S3/GCS/etc.) and serve via CDN URLs with cache headers. Keep app servers out of large media delivery paths.",
+    checklist_ref: "J17",
+    file_patterns: ["**/api/upload*", "**/storage/**", "**/media/**", "**/cdn/**", "**/config/**"],
+    framework: "baseline"
+  }
+];
+var IAC_CONSTRAINTS = [
+  {
+    id_suffix: "iac_least_privilege_iam",
+    category: "infrastructure",
+    summary: 'IAM policies MUST follow least privilege. No wildcard actions (Action: "*") or wildcard resources (Resource: "*") in production.',
+    keywords: ["iam", "least-privilege", "terraform", "cloudformation", "policy", "wildcard"],
+    severity: "critical",
+    action: "Audit all IAM policy documents. Replace wildcard actions/resources with specific service:action and ARN scoping. Use condition keys where possible.",
+    checklist_ref: "K1",
+    file_patterns: ["**/*.tf", "**/iam/**", "**/policies/**", "**/cloudformation/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "iac_no_public_storage",
+    category: "infrastructure",
+    summary: "Storage buckets and blobs MUST NOT be publicly accessible unless explicitly required and documented. No public-read ACLs without business justification.",
+    keywords: ["s3", "gcs", "storage", "public-read", "acl", "bucket", "blob"],
+    severity: "critical",
+    action: "Remove public ACLs from all storage resources. Enable bucket-level public access prevention. Document any intentional public assets with approval.",
+    checklist_ref: "K2",
+    file_patterns: ["**/*.tf", "**/storage/**", "**/s3/**", "**/gcs/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "iac_restricted_ingress",
+    category: "infrastructure",
+    summary: "Network security groups MUST restrict ingress to specific ports and source CIDRs. No 0.0.0.0/0 on non-443 ports.",
+    keywords: ["security-group", "firewall", "ingress", "cidr", "network", "port"],
+    severity: "critical",
+    action: "Review all security group / firewall rules. Restrict SSH (22) to VPN/bastion CIDRs. Close all non-essential ports. Allow 0.0.0.0/0 only for 443 (HTTPS).",
+    checklist_ref: "K3",
+    file_patterns: ["**/*.tf", "**/security-groups/**", "**/firewall/**", "**/network/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "iac_encryption_at_rest",
+    category: "infrastructure",
+    summary: "Databases and storage MUST have encryption at rest explicitly enabled in IaC configuration.",
+    keywords: ["encryption", "at-rest", "kms", "aes", "database", "storage", "rds"],
+    severity: "warning",
+    action: "Explicitly set encryption_at_rest or kms_key_id on all database and storage resources. Do not rely on provider defaults.",
+    checklist_ref: "K4",
+    file_patterns: ["**/*.tf", "**/database/**", "**/rds/**", "**/storage/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "iac_docker_nonroot",
+    category: "infrastructure",
+    summary: "Dockerfiles MUST specify a non-root USER. Running containers as root is forbidden in production.",
+    keywords: ["docker", "dockerfile", "user", "root", "container", "nonroot"],
+    severity: "warning",
+    action: "Add a USER directive to all Dockerfiles. Create a dedicated app user. Set file ownership appropriately for the non-root user.",
+    checklist_ref: "K5",
+    file_patterns: ["**/Dockerfile*", "**/docker/**"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "iac_docker_pinned_tags",
+    category: "infrastructure",
+    summary: "Docker images MUST use pinned version tags (e.g., node:20.11-slim), not :latest or untagged references.",
+    keywords: ["docker", "image", "tag", "latest", "pinned", "version", "reproducible"],
+    severity: "warning",
+    action: "Replace all :latest tags with specific version tags. Pin base images to digest hashes for maximum reproducibility in CI.",
+    checklist_ref: "K6",
+    file_patterns: ["**/Dockerfile*", "**/docker-compose*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "iac_no_secrets_in_build",
+    category: "infrastructure",
+    summary: "Secrets MUST NOT be passed via Docker build args, ENV directives, or docker-compose environment variables. Use secret managers or mounted secrets.",
+    keywords: ["docker", "secret", "build-arg", "env", "credential", "compose"],
+    severity: "critical",
+    action: "Remove all secrets from Dockerfiles and docker-compose.yml. Use Docker BuildKit secrets, mounted volume secrets, or external secret managers.",
+    checklist_ref: "K7",
+    file_patterns: ["**/Dockerfile*", "**/docker-compose*", "**/.env*"],
+    framework: "baseline"
+  },
+  {
+    id_suffix: "iac_k8s_resource_limits",
+    category: "infrastructure",
+    summary: "Kubernetes pods MUST have CPU and memory resource limits defined. Pods MUST NOT run with privileged: true.",
+    keywords: ["kubernetes", "k8s", "resources", "limits", "privileged", "pod", "container"],
+    severity: "warning",
+    action: "Add resources.limits.cpu and resources.limits.memory to all pod specs. Remove privileged: true. Set securityContext.runAsNonRoot: true.",
+    checklist_ref: "K8",
+    file_patterns: ["**/k8s/**", "**/kubernetes/**", "**/helm/**", "**/manifests/**"],
+    framework: "baseline"
+  }
+];
+var SOC2_CONSTRAINTS = [
+  {
+    id_suffix: "soc2_cc6_access_control",
+    category: "compliance",
+    summary: "[SOC 2 CC6.1] Logical access to systems and data MUST be restricted to authorized individuals using unique credentials.",
+    keywords: ["soc2", "access-control", "unique-credentials", "identity"],
+    severity: "critical",
+    action: "Ensure every user has unique credentials. No shared accounts. Enforce MFA for administrative access.",
+    checklist_ref: "SOC2-CC6.1",
+    file_patterns: ["**/auth/**", "**/api/session/**", "**/middleware/**"],
+    framework: "soc2"
+  },
+  {
+    id_suffix: "soc2_cc6_least_privilege",
+    category: "compliance",
+    summary: "[SOC 2 CC6.3] Access MUST follow least-privilege principle. Users receive only the permissions needed for their role.",
+    keywords: ["soc2", "least-privilege", "rbac", "permissions", "roles"],
+    severity: "critical",
+    action: "Implement RBAC. Audit that admin endpoints check role. Verify no default-admin patterns.",
+    checklist_ref: "SOC2-CC6.3",
+    file_patterns: ["**/api/admin/**", "**/middleware/**", "**/auth/**", "**/organizations/**"],
+    framework: "soc2"
+  },
+  {
+    id_suffix: "soc2_cc7_monitoring",
+    category: "compliance",
+    summary: "[SOC 2 CC7.2] Security events (failed logins, permission changes, data exports) MUST be logged and monitored.",
+    keywords: ["soc2", "monitoring", "security-events", "alerting", "siem"],
+    severity: "critical",
+    action: "Log all auth events, admin actions, and data exports. Set up alerts for anomalous patterns.",
+    checklist_ref: "SOC2-CC7.2",
+    file_patterns: ["**/api/**", "**/auth/**", "**/admin/**", "**/logger/**"],
+    framework: "soc2"
+  },
+  {
+    id_suffix: "soc2_cc7_incident_response",
+    category: "compliance",
+    summary: "[SOC 2 CC7.3] An incident response plan MUST exist. Security incidents must be detected, reported, and remediated.",
+    keywords: ["soc2", "incident-response", "breach", "notification", "remediation"],
+    severity: "warning",
+    action: "Document incident response procedures. Implement error alerting. Define escalation paths.",
+    checklist_ref: "SOC2-CC7.3",
+    file_patterns: ["**/error*", "**/sentry/**", "**/monitoring/**"],
+    framework: "soc2"
+  },
+  {
+    id_suffix: "soc2_cc8_change_management",
+    category: "compliance",
+    summary: "[SOC 2 CC8.1] Changes to production MUST follow a documented change management process with review and approval.",
+    keywords: ["soc2", "change-management", "ci-cd", "deployment", "review"],
+    severity: "warning",
+    action: "Enforce PR reviews. Use CI/CD with gated deployments. Log all production changes.",
+    checklist_ref: "SOC2-CC8.1",
+    file_patterns: ["**/.github/**", "**/ci/**", "**/deploy*"],
+    framework: "soc2"
+  },
+  {
+    id_suffix: "soc2_cc6_encryption",
+    category: "compliance",
+    summary: "[SOC 2 CC6.7] Data MUST be encrypted in transit (TLS 1.2+) and sensitive data encrypted at rest.",
+    keywords: ["soc2", "encryption", "tls", "at-rest", "transit"],
+    severity: "critical",
+    action: "Enforce HTTPS everywhere. Encrypt PII/sensitive fields at rest. Verify TLS configuration.",
+    checklist_ref: "SOC2-CC6.7",
+    file_patterns: ["**/config/**", "**/security/**", "**/crypto/**"],
+    framework: "soc2"
+  },
+  {
+    id_suffix: "soc2_cc9_vendor_risk",
+    category: "compliance",
+    summary: "[SOC 2 CC9.2] Third-party vendor risks MUST be assessed. AI providers must have data processing agreements.",
+    keywords: ["soc2", "vendor", "third-party", "dpa", "subprocessor"],
+    severity: "warning",
+    action: "Maintain vendor inventory. Verify DPAs with AI/cloud providers. Review data retention policies.",
+    checklist_ref: "SOC2-CC9.2",
+    file_patterns: ["**/ai/**", "**/llm/**", "**/integrations/**"],
+    framework: "soc2"
+  },
+  {
+    id_suffix: "soc2_audit_logging",
+    category: "compliance",
+    summary: "[SOC 2 CC7.1] Audit logs MUST capture who did what, when, and to which resource. Logs must be tamper-evident.",
+    keywords: ["soc2", "audit", "logging", "compliance", "immutable"],
+    severity: "critical",
+    action: "Structured audit logging for auth, data access, and admin actions. Store logs immutably.",
+    checklist_ref: "SOC2-CC7.1",
+    file_patterns: ["**/api/**", "**/auth/**", "**/admin/**", "**/logger/**"],
+    framework: "soc2"
+  }
+];
+var BLUEPRINT_RULES = [
+  {
+    trigger: (eco) => eco.frameworks.some((f) => /next/i.test(f)),
+    constraints: [
+      {
+        id_suffix: "nextjs_ssr_secrets",
+        category: "security",
+        summary: "Server-only secrets MUST NOT leak into client bundles via getStaticProps/getServerSideProps return values.",
+        keywords: ["next.js", "ssr", "secrets", "props", "client-bundle"],
+        severity: "critical",
+        action: "Audit getStaticProps/getServerSideProps for secrets in returned props. Use server-only modules.",
+        checklist_ref: "G-nextjs",
+        file_patterns: ["**/pages/**", "**/app/**"],
+        framework: "baseline"
+      }
+    ]
+  },
+  {
+    trigger: (eco) => eco.infrastructure.some((i) => /firebase/i.test(i)),
+    constraints: [
+      {
+        id_suffix: "firestore_rules",
+        category: "security",
+        summary: "Firestore security rules MUST enforce per-user data isolation. Admin SDK must only be used server-side.",
+        keywords: ["firestore", "rules", "firebase", "admin-sdk", "security-rules"],
+        severity: "critical",
+        action: "Write and test Firestore rules for per-user/per-org isolation. Never import firebase-admin in client code.",
+        checklist_ref: "E1",
+        file_patterns: ["**/*.rules", "**/firestore.rules", "**/firebase/**"],
+        framework: "baseline"
+      }
+    ]
+  },
+  {
+    trigger: (eco) => eco.security_libs.some((l) => /jsonwebtoken|jose|jwt/i.test(l)),
+    constraints: [
+      {
+        id_suffix: "jwt_validation",
+        category: "security",
+        summary: "JWTs MUST be validated on every request (signature, expiry, audience). Do not trust unverified tokens.",
+        keywords: ["jwt", "token", "validation", "expiry", "signature"],
+        severity: "critical",
+        action: "Verify JWT signature, expiration, and audience on every authenticated request.",
+        checklist_ref: "A3",
+        file_patterns: ["**/auth/**", "**/middleware/**", "**/api/**"],
+        framework: "baseline"
+      }
+    ]
+  },
+  {
+    trigger: (eco) => eco.frameworks.some((f) => /express/i.test(f)),
+    constraints: [
+      {
+        id_suffix: "express_helmet",
+        category: "security",
+        summary: "Express apps MUST use helmet for security headers and configure cookies with httpOnly, secure, sameSite.",
+        keywords: ["helmet", "headers", "cookies", "express", "hsts", "csp"],
+        severity: "warning",
+        action: "Add helmet middleware. Set cookies to httpOnly, secure, sameSite=strict.",
+        checklist_ref: "G-express",
+        file_patterns: ["**/server.*", "**/app.*", "**/index.*"],
+        framework: "baseline"
+      }
+    ]
+  },
+  {
+    trigger: (eco) => eco.ai_libs.length > 0,
+    constraints: [
+      {
+        id_suffix: "ai_key_scoping",
+        category: "security",
+        summary: "AI/LLM API keys MUST have minimal permissions and be scoped per-environment. Monitor usage for anomalies.",
+        keywords: ["ai", "llm", "api-key", "openai", "vertex", "scoping"],
+        severity: "warning",
+        action: "Use per-environment API keys with minimal scopes. Add usage monitoring and spending alerts.",
+        checklist_ref: "F3",
+        file_patterns: ["**/ai/**", "**/llm/**", "**/agents/**", "**/orchestrator/**"],
+        framework: "baseline"
+      }
+    ]
+  },
+  {
+    trigger: (eco) => eco.orms.some((o) => /prisma|typeorm|sequelize|drizzle/i.test(o)),
+    constraints: [
+      {
+        id_suffix: "orm_parameterized",
+        category: "security",
+        summary: "All database queries MUST use the ORM's parameterized query API. No raw string concatenation for SQL.",
+        keywords: ["orm", "sql", "injection", "parameterized", "query"],
+        severity: "critical",
+        action: "Audit raw SQL usage. Replace string concatenation with parameterized queries.",
+        checklist_ref: "B2",
+        file_patterns: ["**/db/**", "**/models/**", "**/repositories/**", "**/api/**"],
+        framework: "baseline"
+      }
+    ]
+  },
+  // ── PCI-DSS (triggered by payment/billing infrastructure) ───────────────
+  {
+    trigger: (eco, ctx) => {
+      const paymentLibs = /stripe|braintree|adyen|square|paypal|chargebee|recurly|paddle/i;
+      const hasDep = eco.all_dependencies.some((d) => paymentLibs.test(d));
+      const hasInfra = eco.infrastructure.some((i) => paymentLibs.test(i));
+      const descMatch = ctx?.productDescription ? /payment|billing|checkout|subscript|invoice|credit.?card|cardholder/i.test(ctx.productDescription) : false;
+      return hasDep || hasInfra || descMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "pci_no_raw_card_data",
+        category: "compliance",
+        summary: "[PCI-DSS Req 3] Raw cardholder data (PAN, CVV, PIN) MUST NOT be stored, logged, or rendered anywhere in the application.",
+        keywords: ["pci", "cardholder", "pan", "cvv", "card-data", "tokenization"],
+        severity: "critical",
+        action: "Use tokenized payment methods (Stripe Elements, etc.). Audit logs and DB for raw card numbers.",
+        checklist_ref: "PCI-R3",
+        file_patterns: ["**/api/stripe/**", "**/api/payment*", "**/billing/**", "**/checkout/**"],
+        framework: "pci_dss"
+      },
+      {
+        id_suffix: "pci_tls_transmission",
+        category: "compliance",
+        summary: "[PCI-DSS Req 4] All transmission of cardholder data MUST use TLS 1.2+. No fallback to plaintext.",
+        keywords: ["pci", "tls", "encryption", "transit", "https"],
+        severity: "critical",
+        action: "Enforce TLS 1.2+ on all endpoints. Disable legacy protocols. Verify CSP and HSTS headers.",
+        checklist_ref: "PCI-R4",
+        file_patterns: ["**/config/**", "**/middleware/**", "**/security/**"],
+        framework: "pci_dss"
+      },
+      {
+        id_suffix: "pci_secure_systems",
+        category: "compliance",
+        summary: "[PCI-DSS Req 6] Applications handling payment data MUST address known vulnerabilities and follow secure coding practices.",
+        keywords: ["pci", "secure-coding", "vulnerability", "patching", "code-review"],
+        severity: "critical",
+        action: "Run dependency vulnerability scans. Enforce code reviews on payment-related changes. Apply patches promptly.",
+        checklist_ref: "PCI-R6",
+        file_patterns: ["**/api/stripe/**", "**/api/payment*", "**/billing/**"],
+        framework: "pci_dss"
+      },
+      {
+        id_suffix: "pci_access_restrict",
+        category: "compliance",
+        summary: "[PCI-DSS Req 7] Access to payment systems MUST be restricted by business need-to-know. Admin-only for billing config.",
+        keywords: ["pci", "access-control", "need-to-know", "billing-admin"],
+        severity: "critical",
+        action: "Restrict billing/subscription admin endpoints to billing-role users. Audit access logs.",
+        checklist_ref: "PCI-R7",
+        file_patterns: ["**/api/stripe/**", "**/api/subscription/**", "**/admin/**"],
+        framework: "pci_dss"
+      },
+      {
+        id_suffix: "pci_audit_trail",
+        category: "compliance",
+        summary: "[PCI-DSS Req 10] All access to payment resources MUST generate audit trail entries with user, action, timestamp, and outcome.",
+        keywords: ["pci", "audit-trail", "logging", "payment-events"],
+        severity: "critical",
+        action: "Log all payment-related API calls with user ID, action, and result. Retain logs for 12 months.",
+        checklist_ref: "PCI-R10",
+        file_patterns: ["**/api/stripe/**", "**/api/payment*", "**/logger/**"],
+        framework: "pci_dss"
+      }
+    ]
+  },
+  // ── HIPAA (triggered by health data patterns) ─────────────────────────────
+  {
+    trigger: (eco, ctx) => {
+      const healthLibs = /fhir|hl7|dicom|health|medical|epic-sdk|cerner|athena/i;
+      const hasDep = eco.all_dependencies.some((d) => healthLibs.test(d));
+      const descMatch = ctx?.productDescription ? /\b(hipaa|phi|protected.health|patient.data|medical.record|ehr|electronic.health|healthcare|telehealth|telemedicine)\b/i.test(ctx.productDescription) : false;
+      const entityMatch = ctx?.existingEntityNames?.some((n) => /health|patient|medical|clinical|hipaa|phi|diagnosis|prescription/i.test(n)) ?? false;
+      return hasDep || descMatch || entityMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "hipaa_phi_encryption",
+        category: "compliance",
+        summary: "[HIPAA \xA7164.312(a)] PHI MUST be encrypted at rest (AES-256) and in transit (TLS 1.2+). Access requires unique user identification.",
+        keywords: ["hipaa", "phi", "encryption", "at-rest", "transit", "aes"],
+        severity: "critical",
+        action: "Encrypt all PHI fields at rest. Enforce TLS. Implement unique user authentication for PHI access.",
+        checklist_ref: "HIPAA-312a",
+        file_patterns: ["**/api/**", "**/models/**", "**/db/**", "**/crypto/**"],
+        framework: "hipaa"
+      },
+      {
+        id_suffix: "hipaa_access_controls",
+        category: "compliance",
+        summary: "[HIPAA \xA7164.312(d)] Access to PHI MUST be controlled by role. Emergency access procedure must exist.",
+        keywords: ["hipaa", "access-control", "role", "phi", "emergency-access"],
+        severity: "critical",
+        action: "Implement role-based PHI access. Document break-glass procedure. Log all PHI access.",
+        checklist_ref: "HIPAA-312d",
+        file_patterns: ["**/api/**", "**/auth/**", "**/middleware/**"],
+        framework: "hipaa"
+      },
+      {
+        id_suffix: "hipaa_audit_controls",
+        category: "compliance",
+        summary: "[HIPAA \xA7164.312(b)] All PHI access, modification, and deletion MUST be logged with immutable audit trails.",
+        keywords: ["hipaa", "audit", "phi-access", "immutable-log", "tracking"],
+        severity: "critical",
+        action: "Log every PHI read, write, and delete with user, timestamp, and resource ID. Logs must be tamper-evident.",
+        checklist_ref: "HIPAA-312b",
+        file_patterns: ["**/api/**", "**/logger/**", "**/audit/**"],
+        framework: "hipaa"
+      },
+      {
+        id_suffix: "hipaa_minimum_necessary",
+        category: "compliance",
+        summary: "[HIPAA \xA7164.502(b)] Applications MUST apply the minimum necessary standard \u2014 only access/disclose the PHI required for the task.",
+        keywords: ["hipaa", "minimum-necessary", "data-minimization", "phi", "scope"],
+        severity: "critical",
+        action: "API responses must return only needed PHI fields. No bulk PHI dumps. Filter by purpose of use.",
+        checklist_ref: "HIPAA-502b",
+        file_patterns: ["**/api/**", "**/models/**", "**/queries/**"],
+        framework: "hipaa"
+      },
+      {
+        id_suffix: "hipaa_baa_required",
+        category: "compliance",
+        summary: "[HIPAA \xA7164.502(e)] Business Associate Agreements MUST be in place with all third-party services that process PHI.",
+        keywords: ["hipaa", "baa", "business-associate", "vendor", "subprocessor"],
+        severity: "critical",
+        action: "Verify BAAs exist with cloud providers, AI services, and any SaaS that touches PHI. Maintain BAA inventory.",
+        checklist_ref: "HIPAA-502e",
+        file_patterns: ["**/integrations/**", "**/ai/**", "**/config/**"],
+        framework: "hipaa"
+      }
+    ]
+  },
+  // ── FedRAMP (triggered by government/federal indicators) ──────────────────
+  {
+    trigger: (eco, ctx) => {
+      const govLibs = /govcloud|fedramp|fips|nist|cac-auth|piv/i;
+      const hasDep = eco.all_dependencies.some((d) => govLibs.test(d));
+      const hasGovInfra = eco.infrastructure.some((i) => /govcloud|gov-/i.test(i));
+      const descMatch = ctx?.productDescription ? /\b(fedramp|federal|government|gov.?cloud|fips|nist.800|ato|fisma|stateramp|dod.?il[2-6])\b/i.test(ctx.productDescription) : false;
+      const entityMatch = ctx?.existingEntityNames?.some((n) => /federal|government|fedramp|fips|nist|fisma/i.test(n)) ?? false;
+      return hasDep || hasGovInfra || descMatch || entityMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "fedramp_fips_crypto",
+        category: "compliance",
+        summary: "[FedRAMP/FIPS 140-2] All cryptographic operations MUST use FIPS 140-2 validated modules. No custom or non-validated crypto.",
+        keywords: ["fedramp", "fips", "fips-140", "cryptography", "validated"],
+        severity: "critical",
+        action: "Use FIPS-validated crypto libraries. Enable FIPS mode in Node.js/OpenSSL. Verify no custom crypto implementations.",
+        checklist_ref: "FEDRAMP-SC13",
+        file_patterns: ["**/crypto/**", "**/auth/**", "**/security/**"],
+        framework: "fedramp"
+      },
+      {
+        id_suffix: "fedramp_continuous_monitoring",
+        category: "compliance",
+        summary: "[FedRAMP CA-7] Continuous monitoring MUST be implemented: vulnerability scans, config drift detection, and incident alerting.",
+        keywords: ["fedramp", "continuous-monitoring", "conmon", "vulnerability-scan", "drift"],
+        severity: "critical",
+        action: "Implement automated vulnerability scanning, configuration drift detection, and monthly security reporting.",
+        checklist_ref: "FEDRAMP-CA7",
+        file_patterns: ["**/.github/**", "**/ci/**", "**/monitoring/**", "**/security/**"],
+        framework: "fedramp"
+      },
+      {
+        id_suffix: "fedramp_incident_response",
+        category: "compliance",
+        summary: "[FedRAMP IR-6] Security incidents MUST be reported to US-CERT within required timeframes. Incident handling plan required.",
+        keywords: ["fedramp", "incident-response", "us-cert", "reporting", "breach"],
+        severity: "critical",
+        action: "Document incident response plan with US-CERT reporting procedures. Implement automated incident detection.",
+        checklist_ref: "FEDRAMP-IR6",
+        file_patterns: ["**/error*", "**/monitoring/**", "**/sentry/**"],
+        framework: "fedramp"
+      },
+      {
+        id_suffix: "fedramp_supply_chain",
+        category: "compliance",
+        summary: "[FedRAMP SA-12] Supply chain risks MUST be assessed. All dependencies must be vetted and integrity-verified.",
+        keywords: ["fedramp", "supply-chain", "sbom", "integrity", "provenance"],
+        severity: "critical",
+        action: "Generate and maintain SBOM. Verify lockfile integrity. Vet all third-party dependencies for provenance.",
+        checklist_ref: "FEDRAMP-SA12",
+        file_patterns: ["**/package*.json", "**/requirements*.txt", "**/*lock*"],
+        framework: "fedramp"
+      },
+      {
+        id_suffix: "fedramp_boundary_protection",
+        category: "compliance",
+        summary: "[FedRAMP SC-7] System boundary MUST be defined and enforced. All data flows must be documented and authorized.",
+        keywords: ["fedramp", "boundary", "network", "data-flow", "authorization"],
+        severity: "critical",
+        action: "Document system boundary diagram. Restrict egress to authorized endpoints. Log all cross-boundary data flows.",
+        checklist_ref: "FEDRAMP-SC7",
+        file_patterns: ["**/api/**", "**/proxy/**", "**/integrations/**", "**/config/**"],
+        framework: "fedramp"
+      }
+    ]
+  },
+  // ── GDPR & CCPA (Privacy by Design) ───────────────────────────────────────
+  {
+    trigger: (eco, ctx) => {
+      const privacyLibs = /posthog|segment|analytics|gtag|google-analytics|mixpanel|amplitude|auth0|clerk|next-auth|passport|cookie-consent|cookiebot/i;
+      const hasDep = eco.all_dependencies.some((d) => privacyLibs.test(d));
+      const descMatch = ctx?.productDescription ? /\b(gdpr|ccpa|cpra|privacy|user.?data|tracking|cookie|consent|eu|california|data.?subject|right.to.erasure|data.?portability)\b/i.test(ctx.productDescription) : false;
+      const entityMatch = ctx?.existingEntityNames?.some((n) => /privacy|gdpr|ccpa|consent|tracking|analytics|cookie/i.test(n)) ?? false;
+      return hasDep || descMatch || entityMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "gdpr_right_to_erasure",
+        category: "compliance",
+        summary: "[GDPR Art. 17] Users MUST be able to request complete deletion of their data. Erasure must cascade across all services and backups.",
+        keywords: ["gdpr", "right-to-erasure", "deletion", "cascade", "data-subject"],
+        severity: "critical",
+        action: "Implement automated hard-delete cascading across Firestore, storage, analytics, and third-party services. Verify no orphaned references.",
+        checklist_ref: "GDPR-A17",
+        file_patterns: ["**/api/user*", "**/api/account*", "**/api/delete*", "**/models/**"],
+        framework: "gdpr_ccpa"
+      },
+      {
+        id_suffix: "gdpr_data_portability",
+        category: "compliance",
+        summary: "[GDPR Art. 20] Users MUST be able to export their data in a structured, machine-readable format (JSON/CSV).",
+        keywords: ["gdpr", "data-portability", "export", "machine-readable", "data-subject"],
+        severity: "critical",
+        action: "Build automated data export endpoints returning user data as JSON/CSV. Include all PII and user-generated content.",
+        checklist_ref: "GDPR-A20",
+        file_patterns: ["**/api/export*", "**/api/user*", "**/api/account*"],
+        framework: "gdpr_ccpa"
+      },
+      {
+        id_suffix: "gdpr_consent_gating",
+        category: "compliance",
+        summary: "[GDPR Art. 7 / CCPA \xA71798.120] Cookie and session tracking MUST be gated behind explicit user consent. No pre-checked boxes.",
+        keywords: ["gdpr", "ccpa", "consent", "cookie", "tracking", "opt-in"],
+        severity: "critical",
+        action: "Implement consent banner with granular opt-in. Block analytics/tracking scripts until consent. Record consent timestamps.",
+        checklist_ref: "GDPR-A7",
+        file_patterns: ["**/components/**cookie*", "**/analytics/**", "**/tracking/**", "**/middleware/**"],
+        framework: "gdpr_ccpa"
+      },
+      {
+        id_suffix: "gdpr_data_residency",
+        category: "compliance",
+        summary: "[GDPR Art. 44-49] EU user data MUST be stored in EU regions unless adequate safeguards (SCCs/DPF) are documented.",
+        keywords: ["gdpr", "data-residency", "eu", "transfer", "scc", "adequacy"],
+        severity: "warning",
+        action: "Configure cloud regions for EU data. Document cross-border transfer mechanisms (SCCs or DPF certification).",
+        checklist_ref: "GDPR-A44",
+        file_patterns: ["**/config/**", "**/firebase/**", "**/infrastructure/**"],
+        framework: "gdpr_ccpa"
+      },
+      {
+        id_suffix: "gdpr_pii_log_anonymization",
+        category: "compliance",
+        summary: "[GDPR Art. 25] PII MUST be anonymized or pseudonymized in all logs, error reports, and analytics pipelines.",
+        keywords: ["gdpr", "anonymization", "pseudonymization", "pii", "logs", "masking"],
+        severity: "critical",
+        action: "Strip or hash PII from log outputs, error payloads (Sentry, etc.), and analytics events. Audit existing log statements.",
+        checklist_ref: "GDPR-A25",
+        file_patterns: ["**/logger/**", "**/api/**", "**/sentry/**", "**/monitoring/**"],
+        framework: "gdpr_ccpa"
+      }
+    ]
+  },
+  // ── OWASP LLM Top 10 & AI Safety ─────────────────────────────────────────
+  {
+    trigger: (eco, ctx) => {
+      const aiLibs = /openai|anthropic|langchain|llamaindex|llama.?index|pinecone|weaviate|chroma|qdrant|milvus|@google-cloud\/vertexai|@google\/generative/i;
+      const hasDep = eco.all_dependencies.some((d) => aiLibs.test(d));
+      const hasAiLib = eco.ai_libs.length > 0;
+      const descMatch = ctx?.productDescription ? /\b(rag|agent|llm|prompt|embedding|vector.?db|retrieval|generative.?ai|chatbot|copilot)\b/i.test(ctx.productDescription) : false;
+      return hasDep || hasAiLib || descMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "owasp_llm01_prompt_injection",
+        category: "security",
+        summary: "[OWASP LLM01] Prompt injection defenses MUST be implemented. Strict input sanitization boundaries between user content and system prompts.",
+        keywords: ["owasp-llm", "prompt-injection", "sanitization", "boundary", "jailbreak"],
+        severity: "critical",
+        action: "Separate user input from system prompts. Sanitize special characters. Implement prompt firewalls. Test with known injection payloads.",
+        checklist_ref: "LLM01",
+        file_patterns: ["**/ai/**", "**/llm/**", "**/agents/**", "**/orchestrator/**", "**/prompts/**"],
+        framework: "owasp_llm"
+      },
+      {
+        id_suffix: "owasp_llm02_insecure_output",
+        category: "security",
+        summary: "[OWASP LLM02] LLM outputs MUST be treated as untrusted. Apply XSS prevention, output encoding, and content filtering before rendering.",
+        keywords: ["owasp-llm", "output-handling", "xss", "encoding", "content-filter"],
+        severity: "critical",
+        action: "Sanitize all LLM outputs before rendering in HTML. Apply Content-Security-Policy. Never use dangerouslySetInnerHTML with raw model output.",
+        checklist_ref: "LLM02",
+        file_patterns: ["**/components/**", "**/ai/**", "**/llm/**", "**/render*"],
+        framework: "owasp_llm"
+      },
+      {
+        id_suffix: "owasp_llm08_excessive_agency",
+        category: "security",
+        summary: "[OWASP LLM08] AI agents MUST have strict RBAC on tool calls. No agent should execute destructive actions without human approval.",
+        keywords: ["owasp-llm", "excessive-agency", "rbac", "tool-use", "human-in-the-loop"],
+        severity: "critical",
+        action: "Enforce per-tool permission checks. Require human approval for destructive operations. Log all agent tool invocations.",
+        checklist_ref: "LLM08",
+        file_patterns: ["**/agents/**", "**/tools/**", "**/mcp/**", "**/orchestrator/**"],
+        framework: "owasp_llm"
+      },
+      {
+        id_suffix: "owasp_llm_data_compartment",
+        category: "security",
+        summary: "[OWASP LLM06] RAG contexts MUST be compartmentalized per-user/per-tenant. User A's data must never appear in User B's retrieval context.",
+        keywords: ["owasp-llm", "data-poisoning", "rag", "compartmentalization", "tenant-isolation"],
+        severity: "critical",
+        action: "Filter vector search results by user/org ID. Namespace embeddings per tenant. Audit retrieval pipelines for cross-tenant leakage.",
+        checklist_ref: "LLM06",
+        file_patterns: ["**/ai/**", "**/rag/**", "**/embeddings/**", "**/vector*"],
+        framework: "owasp_llm"
+      }
+    ]
+  },
+  // ── GLBA (Gramm-Leach-Bliley Act) & Financial Privacy ────────────────────
+  {
+    trigger: (eco, ctx) => {
+      const finLibs = /plaid|mx|yodlee|finicity|teller|akoya|dwolla|synapse|marqeta|galileo|lithic|unit/i;
+      const hasDep = eco.all_dependencies.some((d) => finLibs.test(d));
+      const descMatch = ctx?.productDescription ? /\b(kyc|aml|loan|bank|wealth|fintech|lending|mortgage|credit.?score|underwriting|npi|non.?public.?personal)\b/i.test(ctx.productDescription) : false;
+      const entityMatch = ctx?.existingEntityNames?.some((n) => /bank|loan|kyc|lending|financial|wealth|fintech/i.test(n)) ?? false;
+      return hasDep || descMatch || entityMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "glba_npi_isolation",
+        category: "compliance",
+        summary: "[GLBA \xA76802] Non-Public Personal Information (NPI) MUST be isolated in dedicated stores with field-level encryption and access logging.",
+        keywords: ["glba", "npi", "financial-privacy", "isolation", "field-encryption"],
+        severity: "critical",
+        action: "Store NPI in dedicated encrypted collections. Implement field-level encryption for SSN, account numbers. Log all NPI access.",
+        checklist_ref: "GLBA-6802",
+        file_patterns: ["**/api/**", "**/models/**", "**/db/**", "**/crypto/**"],
+        framework: "glba"
+      },
+      {
+        id_suffix: "glba_mfa_enforcement",
+        category: "compliance",
+        summary: "[GLBA Safeguards Rule] MFA MUST be enforced at the API gateway level for all endpoints that access or modify financial data.",
+        keywords: ["glba", "mfa", "multi-factor", "authentication", "gateway"],
+        severity: "critical",
+        action: "Enforce MFA step-up for financial data endpoints. Verify MFA status in middleware before granting access to NPI.",
+        checklist_ref: "GLBA-MFA",
+        file_patterns: ["**/api/**", "**/auth/**", "**/middleware/**"],
+        framework: "glba"
+      },
+      {
+        id_suffix: "glba_intrusion_detection",
+        category: "compliance",
+        summary: "[GLBA Safeguards Rule] Intrusion detection logging MUST capture unauthorized access attempts to financial systems and trigger alerts.",
+        keywords: ["glba", "intrusion-detection", "ids", "alerting", "unauthorized-access"],
+        severity: "critical",
+        action: "Log failed auth attempts, anomalous data access patterns, and privilege escalation. Set up real-time alerting.",
+        checklist_ref: "GLBA-IDS",
+        file_patterns: ["**/auth/**", "**/api/**", "**/monitoring/**", "**/logger/**"],
+        framework: "glba"
+      },
+      {
+        id_suffix: "glba_retention_worm",
+        category: "compliance",
+        summary: "[GLBA/SEC 17a-4] Financial records MUST be retained for 7 years in immutable (WORM) storage. No early deletion permitted.",
+        keywords: ["glba", "retention", "worm", "immutable", "7-year", "archival"],
+        severity: "critical",
+        action: "Configure WORM-compliant storage for financial records. Implement retention policies preventing deletion before 7 years.",
+        checklist_ref: "GLBA-RET",
+        file_patterns: ["**/storage/**", "**/archive/**", "**/config/**", "**/logger/**"],
+        framework: "glba"
+      }
+    ]
+  },
+  // ── CSA Cloud Controls Matrix (cloud deployment) ───────────────────────────
+  {
+    trigger: (eco, ctx) => {
+      const cloudInfra = /aws|gcp|azure|firebase|vercel|supabase|google-cloud|@aws-sdk|@azure|@google-cloud/i;
+      const hasCloudInfra = eco.infrastructure.some((i) => cloudInfra.test(i));
+      const hasCloudDep = eco.all_dependencies.some((d) => cloudInfra.test(d));
+      const hasIac = eco.iac_tools.some((t) => /terraform|docker|kubernetes|pulumi|cloudformation/i.test(t));
+      return hasCloudInfra || hasCloudDep || hasIac;
+    },
+    constraints: [
+      {
+        id_suffix: "csa_ccm_iam",
+        category: "compliance",
+        summary: "[CSA CCM IAM-01] Identity and access management MUST enforce unique credentials, MFA for privileged access, and least-privilege.",
+        keywords: ["csa", "ccm", "iam", "access-control", "mfa", "least-privilege"],
+        severity: "critical",
+        action: "Implement IAM with unique credentials per user. Enforce MFA for admin roles. Audit permissions for least-privilege.",
+        checklist_ref: "CCM-IAM-01",
+        file_patterns: ["**/auth/**", "**/api/**", "**/middleware/**"],
+        framework: "csa_ccm"
+      },
+      {
+        id_suffix: "csa_ccm_encryption",
+        category: "compliance",
+        summary: "[CSA CCM DSI-01] Data MUST be encrypted in transit (TLS 1.2+) and sensitive data encrypted at rest.",
+        keywords: ["csa", "ccm", "encryption", "tls", "at-rest", "transit"],
+        severity: "critical",
+        action: "Enforce HTTPS everywhere. Encrypt PII and sensitive fields at rest. Verify cloud storage encryption settings.",
+        checklist_ref: "CCM-DSI-01",
+        file_patterns: ["**/config/**", "**/storage/**", "**/database/**"],
+        framework: "csa_ccm"
+      },
+      {
+        id_suffix: "csa_ccm_logging",
+        category: "compliance",
+        summary: "[CSA CCM LOG-01] Security-relevant events MUST be logged with sufficient detail for audit and incident response.",
+        keywords: ["csa", "ccm", "logging", "audit", "security-events", "monitoring"],
+        severity: "critical",
+        action: "Log auth events, data access, config changes, and admin actions. Ensure logs are tamper-evident and retained.",
+        checklist_ref: "CCM-LOG-01",
+        file_patterns: ["**/api/**", "**/auth/**", "**/logger/**", "**/monitoring/**"],
+        framework: "csa_ccm"
+      },
+      {
+        id_suffix: "csa_ccm_incident",
+        category: "compliance",
+        summary: "[CSA CCM IVS-01] Security incident management MUST include detection, response, and remediation procedures.",
+        keywords: ["csa", "ccm", "incident-response", "breach", "remediation", "alerting"],
+        severity: "warning",
+        action: "Document incident response plan. Implement alerting for security events. Define escalation and remediation workflows.",
+        checklist_ref: "CCM-IVS-01",
+        file_patterns: ["**/error*", "**/monitoring/**", "**/sentry/**"],
+        framework: "csa_ccm"
+      },
+      {
+        id_suffix: "csa_ccm_supply_chain",
+        category: "compliance",
+        summary: "[CSA CCM SEF-01] Supply chain risks MUST be assessed. Dependencies must be vetted and integrity-verified.",
+        keywords: ["csa", "ccm", "supply-chain", "sbom", "dependencies", "integrity"],
+        severity: "warning",
+        action: "Maintain dependency inventory. Use lockfiles and verify checksums. Consider SBOM generation for cloud deployments.",
+        checklist_ref: "CCM-SEF-01",
+        file_patterns: ["**/package.json", "**/package-lock*", "**/yarn.lock", "**/pnpm-lock*"],
+        framework: "csa_ccm"
+      }
+    ]
+  },
+  // ── FERPA & COPPA (EdTech & Minors) ───────────────────────────────────────
+  {
+    trigger: (eco, ctx) => {
+      const edLibs = /clever|canvas-api|schoology|google-classroom|classlink|sis-api|lti/i;
+      const hasDep = eco.all_dependencies.some((d) => edLibs.test(d));
+      const descMatch = ctx?.productDescription ? /\b(student|school|child|minor|classroom|edtech|education|teacher|k.?12|ferpa|coppa|parental.?consent|lms)\b/i.test(ctx.productDescription) : false;
+      const entityMatch = ctx?.existingEntityNames?.some((n) => /student|school|classroom|education|child|minor|teacher/i.test(n)) ?? false;
+      return hasDep || descMatch || entityMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "ferpa_coppa_parental_consent",
+        category: "compliance",
+        summary: "[COPPA \xA7312.5 / FERPA \xA799.30] Mandatory parental/guardian consent API gates MUST exist before collecting data from minors (<13).",
+        keywords: ["coppa", "ferpa", "parental-consent", "minor", "guardian", "age-gate"],
+        severity: "critical",
+        action: "Implement verifiable parental consent flow. Block data collection until consent is recorded. Provide consent withdrawal mechanism.",
+        checklist_ref: "COPPA-312",
+        file_patterns: ["**/api/auth/**", "**/api/signup*", "**/api/consent*", "**/middleware/**"],
+        framework: "ferpa_coppa"
+      },
+      {
+        id_suffix: "ferpa_coppa_no_profiling",
+        category: "compliance",
+        summary: "[COPPA \xA7312.3] Behavioral profiling, ad-tracking scripts, and targeted advertising MUST be completely banned for minor users.",
+        keywords: ["coppa", "profiling", "ad-tracking", "behavioral", "advertising", "minor"],
+        severity: "critical",
+        action: "Audit all analytics/tracking scripts. Block ad networks and behavioral profiling for accounts flagged as minors. Strip tracking from student sessions.",
+        checklist_ref: "COPPA-NOPROF",
+        file_patterns: ["**/analytics/**", "**/tracking/**", "**/components/**", "**/middleware/**"],
+        framework: "ferpa_coppa"
+      },
+      {
+        id_suffix: "ferpa_coppa_data_destruction",
+        category: "compliance",
+        summary: "[FERPA \xA799.4 / COPPA \xA7312.10] Student/minor data MUST be automatically destroyed when the account expires or the school year ends.",
+        keywords: ["ferpa", "data-destruction", "expiration", "retention", "school-year"],
+        severity: "critical",
+        action: "Implement automated data lifecycle. Schedule deletion of student data at account expiry. Notify administrators before destruction.",
+        checklist_ref: "FERPA-DEST",
+        file_patterns: ["**/api/user*", "**/cron/**", "**/jobs/**", "**/models/**"],
+        framework: "ferpa_coppa"
+      },
+      {
+        id_suffix: "ferpa_coppa_age_gating",
+        category: "compliance",
+        summary: "[COPPA \xA7312.2] Age-gating logic MUST be implemented at signup to detect minors and route them through compliant consent flows.",
+        keywords: ["coppa", "age-gate", "age-verification", "minor-detection", "signup"],
+        severity: "critical",
+        action: "Add age verification at signup. Route users under 13 to parental consent flow. Block account creation without verified age.",
+        checklist_ref: "COPPA-AGE",
+        file_patterns: ["**/api/auth/**", "**/api/signup*", "**/components/signup*"],
+        framework: "ferpa_coppa"
+      }
+    ]
+  },
+  // ── iOS App Store Review Guidelines (mobile iOS apps) ──────────────────────
+  {
+    trigger: (eco, ctx) => {
+      const iosSignals = /ios|swift|swiftui|xcode|uikit|storekit|appstore|testflight|cocoapods|xcframework/i;
+      const hasLang = eco.languages.some((l) => /swift|objective-c|objc/i.test(l));
+      const hasFramework = eco.frameworks.some((f) => iosSignals.test(f));
+      const hasDep = eco.all_dependencies.some((d) => iosSignals.test(d));
+      const descMatch = ctx?.productDescription ? /\b(ios|iphone|ipad|app\s*store|testflight|storekit|in-app purchase|apple sign in)\b/i.test(ctx.productDescription) : false;
+      const entityMatch = ctx?.existingEntityNames?.some((n) => /\b(ios|mobile|iphone|ipad|app store|iap|storekit)\b/i.test(n)) ?? false;
+      return hasLang || hasFramework || hasDep || descMatch || entityMatch;
+    },
+    constraints: [
+      {
+        id_suffix: "ios_app_store_privacy_disclosure",
+        category: "compliance",
+        summary: "[iOS App Store 5.1] Apps collecting user data MUST provide accurate privacy disclosures and clear in-app data handling flows.",
+        keywords: ["ios", "app-store", "privacy", "disclosure", "tracking", "app-privacy"],
+        severity: "critical",
+        action: "Document data collection in App Privacy labels and align runtime behavior. Gate tracking behind explicit consent where required.",
+        checklist_ref: "IOS-5.1",
+        file_patterns: ["**/ios/**", "**/*.swift", "**/privacy*", "**/tracking/**", "**/analytics/**"],
+        framework: "ios_app_store"
+      },
+      {
+        id_suffix: "ios_app_store_iap_policy",
+        category: "compliance",
+        summary: "[iOS App Store 3.1] Digital goods/services sold in-app MUST use Apple's In-App Purchase flows where required.",
+        keywords: ["ios", "app-store", "iap", "storekit", "payments", "digital-goods"],
+        severity: "warning",
+        action: "Use StoreKit for digital purchases in iOS app surfaces. Avoid bypass payment links that violate App Store rules.",
+        checklist_ref: "IOS-3.1",
+        file_patterns: ["**/ios/**", "**/*.swift", "**/billing/**", "**/payment/**", "**/storekit/**"],
+        framework: "ios_app_store"
+      },
+      {
+        id_suffix: "ios_app_store_account_deletion",
+        category: "compliance",
+        summary: "[iOS App Store 5.1.1(v)] If account creation exists, apps MUST provide in-app account deletion with data handling consistent with policy.",
+        keywords: ["ios", "app-store", "account-deletion", "user-account", "privacy-rights"],
+        severity: "warning",
+        action: "Expose account deletion in-app for iOS users and ensure backend deletion flow is implemented and verifiable.",
+        checklist_ref: "IOS-5.1.1",
+        file_patterns: ["**/ios/**", "**/*.swift", "**/api/account*", "**/api/user*", "**/settings/**"],
+        framework: "ios_app_store"
+      }
+    ]
+  }
+];
+function buildBlueprintConstraints(ecosystem, context) {
+  const results = [...UNIVERSAL_CONSTRAINTS, ...SCALABILITY_CONSTRAINTS, ...RELIABILITY_CONSTRAINTS, ...IAC_CONSTRAINTS, ...SOC2_CONSTRAINTS];
+  for (const rule of BLUEPRINT_RULES) {
+    if (rule.trigger(ecosystem, context)) {
+      results.push(...rule.constraints);
+    }
+  }
+  return results;
+}
+function getActiveFrameworks(ecosystem, context) {
+  const constraints = buildBlueprintConstraints(ecosystem, context);
+  const frameworks = /* @__PURE__ */ new Set();
+  for (const c of constraints) {
+    frameworks.add(c.framework);
+  }
+  return [...frameworks].sort();
+}
+function graphNeedsBlueprintSeeding(existingConstraintIds) {
+  return !existingConstraintIds.some((id) => id.startsWith("constraint:blueprint:"));
+}
+var SECURITY_SYSTEM_PROMPT = `You are a senior security engineer performing a structured code audit. You MUST work through the checklist below systematically. For each checklist item, either report a finding or confirm it was checked and found acceptable.
+
+## AUDIT CHECKLIST
+
+Work through every category. For each, check the provided source files and ecosystem data.
+
+### A. Authentication & Authorization (OWASP A01, A07)
+A1. Are all API routes / server endpoints protected by auth middleware? List any unprotected routes.
+A2. Is there role-based or attribute-based access control? Are authorization checks per-resource, not just per-route?
+A3. Are session tokens / JWTs validated on every request? Is token expiry enforced?
+A4. Are passwords hashed with a strong algorithm (bcrypt/scrypt/argon2), not MD5/SHA?
+A5. Is there brute-force protection (rate limiting on login, account lockout)?
+A6. Are OAuth/SSO flows using state parameters to prevent CSRF?
+A7. Are auth tokens stored in httpOnly secure cookies (not localStorage/sessionStorage)?
+A8. Do login, signup, and password reset flows avoid revealing whether an account exists (user enumeration)?
+A9. Are session/JWT lifetimes capped (<=7 days for JWTs)? Is refresh token rotation implemented?
+
+### B. Injection & Input Validation (OWASP A03)
+B1. Are user inputs validated/sanitized before use in queries, commands, or templates?
+B2. Is there parameterized query usage (no string concatenation for SQL/Firestore)?
+B3. Are file uploads validated for type, size, and content?
+B4. Is there protection against NoSQL injection (especially for Firestore/MongoDB)?
+B5. Is untrusted data deserialized safely? Check for pickle.load, yaml.load, eval, new Function on user input.
+B6. Are user-supplied file paths sanitized to prevent directory traversal (../ sequences)?
+
+### C. Data Protection (OWASP A02, A04)
+C1. Is PII encrypted at rest? Are sensitive fields (SSN, credit card) masked in logs?
+C2. Are API responses stripped of internal fields (stack traces, internal IDs, user emails of other users)?
+C3. Is data access scoped per-user/per-org? Can User A access User B's data?
+C4. Are .env files, secrets, and API keys excluded from version control?
+C5. Is HTTPS enforced? Are security headers set (HSTS, CSP, X-Frame-Options)?
+C6. Are default credentials, example configs with real-looking values, or scaffolding secrets still present?
+C7. Is debug mode, verbose logging, or dev tools (DEBUG=*, React DevTools, source maps) disabled in production?
+C8. Is there a secret rotation schedule? Are long-lived API keys (>90 days) flagged?
+
+### D. API Security (OWASP A05, A06, A08)
+D1. Is there rate limiting on sensitive endpoints (auth, payment, data export)?
+D2. Is CSRF protection enabled on state-changing endpoints?
+D3. Are error responses generic (no stack traces, internal paths, or SQL errors leaked)?
+D4. Is there request size limiting to prevent payload abuse?
+D5. Are CORS origins explicitly whitelisted (not wildcard)?
+D6. Do API endpoints return only needed fields (no over-fetching of user records, internal IDs, or other users' data)?
+D7. Do sensitive actions (account deletion, email change, role escalation) require re-authentication or a confirmation step?
+D8. Is payment/billing logic validated server-side? Can prices or quantities be tampered with client-side?
+D9. Are redirect URLs validated against an allowlist? Can open redirects be exploited for phishing?
+D10. Are webhook signatures verified before processing payment or event data?
+D11. Are auth/session/API tokens kept out of URL query params (including callback/returnUrl redirects) and transported via headers or httpOnly cookies instead?
+D12. Are secrets (revalidate/API/webhook/etc.) kept out of URL query params and accepted only via headers or signed bodies?
+D13. Are side-effecting endpoints using non-GET methods, and are cookie-auth GET fallbacks protected with strict same-origin checks?
+
+### E. Security Rules & Infrastructure
+E1. For Firestore/database rules: do they enforce per-user data isolation?
+E2. Are Cloud Function / serverless permissions least-privilege?
+E3. Are admin/internal APIs separated from public APIs?
+E4. Is there audit logging for sensitive operations (data access, auth events, config changes)?
+E5. Are critical actions (deletions, role changes, payments, exports) logged with actor, timestamp, and resource?
+E6. Are backups automated and regularly tested with restore verification?
+E7. Are test and production environments fully separated? Do test webhooks avoid touching production systems?
+
+### F. Dependency & Supply Chain
+F1. Are there known-vulnerable dependencies (check versions against ecosystem data)?
+F2. Are lockfiles committed? Is there integrity checking?
+F3. Are AI/LLM API keys scoped with minimal permissions?
+F4. Are AI API costs capped in code (max_tokens, request budgets) and/or provider dashboards?
+
+### G. Framework-Specific (check based on detected ecosystem)
+- **Next.js**: Are server-side-only modules imported in API routes (not client bundles)? Is getServerSideProps/getStaticProps leaking secrets to props?
+- **Firebase**: Are Firestore rules tested? Is Firebase Admin SDK only used server-side?
+- **React**: Is dangerouslySetInnerHTML used safely? Are user inputs sanitized before rendering?
+- **Express/Node**: Is helmet configured? Are cookies httpOnly + secure + sameSite?
+
+### H. Compliance Framework Signals
+Flag if the codebase contains signals that would require specific compliance frameworks:
+- **PCI-DSS**: Stripe, Braintree, Adyen, or any payment/billing/checkout code
+- **HIPAA**: Health/medical data, FHIR/HL7 libraries, patient records, PHI handling
+- **FedRAMP**: Government contracts, FIPS requirements, .gov integrations, GovCloud
+- **GDPR/CCPA**: Analytics libraries (PostHog, Segment, GA), auth providers (Auth0, Clerk), EU/California user data, tracking/cookies
+- **OWASP LLM**: OpenAI, Anthropic, LangChain, vector DBs (Pinecone, Weaviate), RAG pipelines, AI agents
+- **GLBA**: Plaid, banking SDKs, KYC/AML, lending/mortgage/wealth management code
+- **FERPA/COPPA**: EdTech integrations (Clever, Canvas), student/minor data, classroom/school references
+- **iOS App Store**: iOS/Swift codepaths, App Store/TestFlight distribution, StoreKit/IAP, mobile app privacy policies
+
+For each detected signal, note:
+- H1. Which framework(s) apply and why
+- H2. Whether the code currently meets key requirements of that framework
+- H3. Critical gaps that need immediate attention
+
+### I. Scalability & Performance
+I1. Are there N+1 query patterns \u2014 fetching related records in loops instead of using JOINs or batch loading?
+I2. Are database columns used in WHERE, ORDER BY, and JOIN clauses properly indexed?
+I3. Are there O(n\xB2) nested loops over collections that could use Map/Set lookups?
+I4. Are database connections, event listeners, timers, and streams properly cleaned up (no memory leaks)?
+I5. Are unbounded queries paginated? Could any endpoint load an entire table into memory?
+I6. Is CPU-intensive or blocking I/O offloaded from the main thread/event loop?
+I7. Is connection pooling used for database and HTTP clients?
+I8. Is concurrency bounded for workers, parallel API calls, and queue consumers?
+
+### J. Reliability & Code Quality
+J1. Do all catch blocks log or re-throw errors? Are there any empty catch blocks or swallowed promises?
+J2. Are external API responses validated against a schema before use?
+J3. Are edge cases handled (null, undefined, empty arrays, unauthenticated users, network timeouts)?
+J4. Are there god functions (>150 lines mixing multiple concerns)?
+J5. Is shared state managed from a single source of truth, or is there state duplication/drift?
+J6. Are all imported packages verified to exist in the registry? Any phantom/hallucinated imports?
+
+### K. Infrastructure as Code (IaC)
+K1. Are Terraform/IAM resources using default or overly permissive policies (Action: "*", Resource: "*")?
+K2. Are storage buckets or blobs publicly accessible? Is ACL set to "public-read" without justification?
+K3. Are security groups or firewall rules open to 0.0.0.0/0 on non-HTTPS ports?
+K4. Are databases and storage encrypted at rest? Is encryption explicitly enabled in the IaC config?
+K5. Are Dockerfiles running as root? Is a non-root USER specified?
+K6. Are Docker images using \`latest\` tag instead of pinned version tags?
+K7. Are secrets or credentials passed as build args or environment variables in Docker/Compose files?
+K8. Are Kubernetes pods running with privileged: true or missing CPU/memory resource limits?
+
+## OUTPUT FORMAT
+
+Return a JSON object with exactly these fields:
+- productName (string): Name of the product/project.
+- productBrief (string): 1-2 paragraph summary of security posture, referencing the most critical findings.
+- risks (array of {title, description, category, severity, checklist_ref}): Risks found. severity: low|medium|high|critical. checklist_ref: the checklist ID (e.g. "A1", "C3", "I1", "K5"). category should be one of: auth, injection, data_protection, api_security, infrastructure, dependency, framework_specific, scalability, performance, reliability, code_quality, iac.
+- assumptions (array of {statement, category, confidence, importance}): Security assumptions the code makes implicitly. confidence/importance: 0-1.
+- competitors (array of {name, description, threat_level}): Any referenced tools or services. Return [] if none.
+- marketContext (string): Brief context about the security landscape for this type of application.
+- targetUsers (string): Who uses this product, from a security perspective.
+- referenceClasses (string[]): Security frameworks or standards that apply (e.g., "OWASP Top 10 2021", "SOC 2 Type II").
+- constraints (object?): Resource constraints \u2014 team, budget_usd, deadline_days, must_ship_scope.
+- checklist_summary (object): Keys are checklist IDs (A1-A8, B1-B6, C1-C8, D1-D13, E1-E7, F1-F4, G-*, H1-H3, I1-I8, J1-J6, K1-K8), values are "pass"|"fail"|"warn"|"not_applicable". This forces systematic coverage.
+- compliance_signals (array of {framework: "pci_dss"|"hipaa"|"fedramp"|"gdpr_ccpa"|"owasp_llm"|"glba"|"ferpa_coppa"|"csa_ccm"|"ios_app_store", signal: string, confidence: number}?): Detected compliance framework signals. Return [] if none.
+
+Be concrete and specific. Reference file paths and line numbers where possible. If a checklist item cannot be assessed from the provided files, mark it "not_applicable" and note why. Cover ALL sections A through K.`;
+var FULL_SYSTEM_PROMPT = `You are a product analyst reviewing a codebase. Given file contents, an ecosystem fingerprint, and existing constraints, extract structured product context.
+
+Return a JSON object with exactly these fields:
+- productName (string): Name of the product/project.
+- productBrief (string): 2-3 paragraph summary of the product, its architecture, and purpose.
+- risks (array of {title, description, category, severity}): Identified risks including security, architecture, scalability, and business risks. severity: low|medium|high|critical.
+- assumptions (array of {statement, category, confidence, importance}): Technical and business assumptions.
+- competitors (array of {name, description, threat_level}): Referenced alternatives or competing tools.
+- marketContext (string): Market/industry context for this product.
+- targetUsers (string): Who the product serves.
+- referenceClasses (string[]): Analogous products or frameworks.
+- constraints (object?): Resource constraints \u2014 team, budget_usd, deadline_days, must_ship_scope.
+
+Be thorough but concise. Reference specific files where relevant.`;
+function getSystemPrompt(mode) {
+  return mode === "security" ? SECURITY_SYSTEM_PROMPT : FULL_SYSTEM_PROMPT;
+}
+function buildUserPrompt(opts) {
+  const parts = [];
+  if (opts.taskDescription) {
+    parts.push(`## Task
+${opts.taskDescription}`);
+  }
+  const iacLine = opts.ecosystem.iac_tools?.length ? `
+- IaC tools: ${opts.ecosystem.iac_tools.join(", ")}` : "";
+  parts.push(`## Ecosystem
+- Languages: ${opts.ecosystem.languages.join(", ") || "unknown"}
+- Frameworks: ${opts.ecosystem.frameworks.join(", ") || "none detected"}
+- ORMs: ${opts.ecosystem.orms.join(", ") || "none"}
+- Infrastructure: ${opts.ecosystem.infrastructure.join(", ") || "none"}
+- Security libraries: ${opts.ecosystem.security_libs.join(", ") || "none detected"}
+- AI/LLM libraries: ${opts.ecosystem.ai_libs.join(", ") || "none"}
+- Testing: ${opts.ecosystem.testing.join(", ") || "none detected"}${iacLine}`);
+  if (opts.scaContext) {
+    parts.push(opts.scaContext);
+  }
+  if (opts.sensitiveData.fields.length > 0) {
+    const byClass = Object.entries(opts.sensitiveData.by_class).filter(([, count]) => count > 0).map(([cls, count]) => `${cls}: ${count}`).join(", ");
+    const topFields = opts.sensitiveData.fields.slice(0, 20).map((f) => `  - ${f.file}:${f.line} \u2014 ${f.field} (${f.classification})`).join("\n");
+    parts.push(`## Sensitive Data Found
+${byClass}
+${topFields}`);
+  }
+  if (opts.existingConstraints.length > 0) {
+    parts.push(`## Existing Constraints (from product graph)
+${opts.existingConstraints.slice(0, 30).join("\n")}`);
+  }
+  if (opts.existingGaps.length > 0) {
+    parts.push(`## Constraint Graph Gaps
+${opts.existingGaps.join("\n")}`);
+  }
+  parts.push(`## Source Files (${opts.fileContents.length})`);
+  for (const f of opts.fileContents) {
+    parts.push(`### ${f.path}
+\`\`\`
+${f.content}
+\`\`\``);
+  }
+  parts.push("Extract the structured context from the above. Return valid JSON only.");
+  return parts.join("\n\n");
+}
+
+// ../mcp/dist/mcp/src/tools/sca-scanner.js
+var OSV_BATCH_URL = "https://api.osv.dev/v1/querybatch";
+var BATCH_SIZE = 100;
+var REQUEST_TIMEOUT_MS = 1e4;
+var ECOSYSTEM_MAP = {
+  npm: "npm",
+  PyPI: "PyPI",
+  Go: "Go",
+  RubyGems: "RubyGems",
+  "crates.io": "crates.io"
+};
+function cvssToSeverity(score) {
+  if (score >= 9)
+    return "critical";
+  if (score >= 7)
+    return "high";
+  if (score >= 4)
+    return "medium";
+  return "low";
+}
+function extractSeverity(vuln) {
+  if (vuln.severity?.length) {
+    for (const s of vuln.severity) {
+      if (s.type === "CVSS_V3" || s.type === "CVSS_V4") {
+        const score = parseFloat(s.score);
+        if (!isNaN(score))
+          return { severity: cvssToSeverity(score), cvss: score };
+      }
+    }
+  }
+  const dbSev = vuln.database_specific?.severity?.toUpperCase();
+  if (dbSev === "CRITICAL")
+    return { severity: "critical" };
+  if (dbSev === "HIGH")
+    return { severity: "high" };
+  if (dbSev === "MODERATE" || dbSev === "MEDIUM")
+    return { severity: "medium" };
+  if (dbSev === "LOW")
+    return { severity: "low" };
+  return { severity: "medium" };
+}
+function extractFixedVersion(vuln) {
+  for (const aff of vuln.affected ?? []) {
+    for (const range of aff.ranges ?? []) {
+      for (const event of range.events ?? []) {
+        if (event.fixed)
+          return event.fixed;
+      }
+    }
+  }
+  return void 0;
+}
+async function queryOsvBatch(queries) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const res = await fetch(OSV_BATCH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ queries }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      console.warn(`[sca] OSV.dev returned ${res.status}: ${res.statusText}`);
+      return { results: queries.map(() => ({ vulns: [] })) };
+    }
+    return await res.json();
+  } catch (err) {
+    console.warn("[sca] OSV.dev request failed:", err.message);
+    return { results: queries.map(() => ({ vulns: [] })) };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function scanDependencies(deps) {
+  if (deps.length === 0)
+    return [];
+  const prodDeps = deps.filter((d) => !d.dev);
+  const depsToScan = prodDeps.length > 0 ? prodDeps : deps;
+  const queries = depsToScan.map((dep) => ({
+    query: {
+      package: { name: dep.name, ecosystem: ECOSYSTEM_MAP[dep.ecosystem] },
+      version: dep.version
+    },
+    dep
+  }));
+  const findings = [];
+  const seenVulnIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < queries.length; i += BATCH_SIZE) {
+    const batch = queries.slice(i, i + BATCH_SIZE);
+    const response = await queryOsvBatch(batch.map((b) => b.query));
+    for (let j = 0; j < batch.length; j++) {
+      const vulns = response.results[j]?.vulns ?? [];
+      const dep = batch[j].dep;
+      for (const vuln of vulns) {
+        if (seenVulnIds.has(vuln.id))
+          continue;
+        seenVulnIds.add(vuln.id);
+        const { severity, cvss } = extractSeverity(vuln);
+        const fixedVersion = extractFixedVersion(vuln);
+        findings.push({
+          id: vuln.id,
+          package_name: dep.name,
+          package_version: dep.version,
+          ecosystem: dep.ecosystem,
+          severity,
+          cvss_score: cvss,
+          summary: (vuln.summary || vuln.details || "No description available").slice(0, 300),
+          fixed_version: fixedVersion,
+          references: (vuln.references ?? []).map((r) => r.url).slice(0, 3)
+        });
+      }
+    }
+  }
+  findings.sort((a, b) => {
+    const order = { critical: 0, high: 1, medium: 2, low: 3 };
+    return order[a.severity] - order[b.severity];
+  });
+  return findings;
+}
+function formatScaContext(findings, maxEntries = 10) {
+  if (findings.length === 0)
+    return "";
+  const lines = [
+    `## Known Dependency Vulnerabilities (${findings.length} found)`,
+    ""
+  ];
+  for (const f of findings.slice(0, maxEntries)) {
+    const fix = f.fixed_version ? ` Fix: upgrade to ${f.fixed_version}.` : "";
+    lines.push(`- **[${f.severity.toUpperCase()}]** ${f.package_name}@${f.package_version}: ${f.id} \u2014 ${f.summary}${fix}`);
+  }
+  if (findings.length > maxEntries) {
+    lines.push(`- ...and ${findings.length - maxEntries} more vulnerabilities`);
+  }
+  return lines.join("\n");
+}
+
+// ../mcp/dist/mcp/src/tools/security-scan-free.js
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+function buildGenericGraphId(uid, projectRoot) {
+  const slug = projectRoot.split("/").filter(Boolean).pop()?.replace(/[^a-z0-9]+/gi, "-").toLowerCase().slice(0, 40) ?? "unknown";
+  return `freeaudit:${uid}:${slug}`;
+}
+var SECURITY_PATH_PATTERNS = [
+  /auth/i,
+  /login/i,
+  /session/i,
+  /token/i,
+  /jwt/i,
+  /oauth/i,
+  /api\//i,
+  /routes?\//i,
+  /endpoint/i,
+  /handler/i,
+  /middleware/i,
+  /guard/i,
+  /interceptor/i,
+  /policy/i,
+  /firestore\.rules$/i,
+  /\.rules$/i,
+  /security/i,
+  /config/i,
+  /env/i,
+  /secret/i,
+  /credential/i,
+  /encrypt/i,
+  /decrypt/i,
+  /hash/i,
+  /crypto/i,
+  /schema/i,
+  /model/i,
+  /migration/i,
+  /prisma/i,
+  /drizzle/i,
+  /payment/i,
+  /billing/i,
+  /stripe/i,
+  /webhook/i,
+  /redirect/i,
+  /callback/i,
+  /returnurl/i,
+  /mcp-auth/i,
+  /checkout-link/i,
+  // Scalability & reliability patterns
+  /\/db\//i,
+  /queries?\//i,
+  /repositor/i,
+  /worker/i,
+  /queue/i,
+  /\/jobs?\//i,
+  /cron/i,
+  /store/i,
+  /\/state\//i,
+  /reducer/i,
+  /\/context\//i,
+  /services?\//i,
+  /hooks?\//i,
+  // IaC patterns
+  /\.tf$/i,
+  /Dockerfile/i,
+  /docker-compose/i,
+  /\/terraform\//i,
+  /\/infra\//i,
+  /\/deploy\//i,
+  /cloudformation/i,
+  /\/k8s\//i,
+  /\/helm\//i
+];
+var READABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".rb",
+  ".rules",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".env",
+  ".conf",
+  ".tf",
+  ".hcl"
+]);
+function isReadableFile(filePath) {
+  const ext = "." + filePath.split(".").pop()?.toLowerCase();
+  if (READABLE_EXTENSIONS.has(ext))
+    return true;
+  const name = filePath.split("/").pop() ?? "";
+  if (name === "Dockerfile" || /^Dockerfile\./i.test(name))
+    return true;
+  if (/^docker-compose/i.test(name))
+    return true;
+  return false;
+}
+function selectSecurityFiles(files, sensitiveFilePaths, maxFiles) {
+  const scored = [];
+  for (const entry of files) {
+    if (!isReadableFile(entry.path))
+      continue;
+    let priority = 0;
+    if (sensitiveFilePaths.has(entry.path))
+      priority += 10;
+    for (const pattern of SECURITY_PATH_PATTERNS) {
+      if (pattern.test(entry.path)) {
+        priority += 5;
+        break;
+      }
+    }
+    if (entry.path.includes("middleware"))
+      priority += 3;
+    if (entry.path.endsWith(".rules"))
+      priority += 6;
+    if (priority > 0)
+      scored.push({ entry, priority });
+  }
+  scored.sort((a, b) => b.priority - a.priority);
+  return scored.slice(0, maxFiles).map((s) => s.entry);
+}
+async function readFileContents(root, files, maxBytesPerFile) {
+  const results = [];
+  for (const file of files) {
+    try {
+      let content = await readFile2(join2(root, file.path), "utf-8");
+      if (content.length > maxBytesPerFile) {
+        content = content.slice(0, maxBytesPerFile) + "\n// ... [truncated]";
+      }
+      results.push({ path: file.path, content });
+    } catch {
+    }
+  }
+  return results;
+}
+async function seedBlueprint(productId, ecosystem, deps, ctx) {
+  if (!deps.upsertNodes || !deps.addEntity || !deps.addEdges || !deps.upsertBindings) {
+    return { constraintsCreated: 0, frameworks: [] };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const sourceId = `blueprint_${Date.now()}`;
+  const blueprintConstraints = buildBlueprintConstraints(ecosystem, ctx);
+  const activeFrameworks = getActiveFrameworks(ecosystem, ctx);
+  if (blueprintConstraints.length === 0) {
+    return { constraintsCreated: 0, frameworks: activeFrameworks };
+  }
+  const constraintNodes = blueprintConstraints.map((bc) => ({
+    id: `constraint:blueprint:${bc.id_suffix}`,
+    category: bc.category,
+    severity: bc.severity,
+    summary: bc.summary,
+    keywords: bc.keywords,
+    source_id: sourceId,
+    source_type: "premortem",
+    ingested_at: now,
+    action: bc.action,
+    phase: "mvp"
+  }));
+  await deps.upsertNodes(productId, "premortem", sourceId, constraintNodes);
+  const categorySet = new Set(blueprintConstraints.map((bc) => bc.category));
+  const entities = [];
+  const edges = [];
+  const bindings = [];
+  for (const category of categorySet) {
+    const entityId = `component:blueprint_${category}`;
+    entities.push({
+      id: entityId,
+      type: "component",
+      name: `Security Blueprint: ${category}`,
+      aliases: [category, "security", "blueprint"],
+      description: `Proactive ${category} constraints from security blueprint`,
+      source_id: sourceId,
+      source_type: "premortem",
+      ingested_at: now
+    });
+    const categoryConstraints = blueprintConstraints.filter((bc) => bc.category === category);
+    for (const bc of categoryConstraints) {
+      const constraintId = `constraint:blueprint:${bc.id_suffix}`;
+      edges.push({
+        id: `edge:blueprint:${entityId}:${constraintId}`,
+        source_id: entityId,
+        source_type: "component",
+        target_id: constraintId,
+        target_type: "constraint",
+        edge_type: "BOUNDED_BY"
+      });
+    }
+    if (bc_filePatterns(category, ecosystem).length > 0) {
+      bindings.push({
+        id: `binding:blueprint:${category}`,
+        entity_id: entityId,
+        entity_type: "component",
+        file_patterns: bc_filePatterns(category, ecosystem),
+        confidence: 0.7,
+        manual: false
+      });
+    }
+  }
+  for (const entity of entities)
+    await deps.addEntity(productId, entity);
+  if (edges.length > 0)
+    await deps.addEdges(productId, edges);
+  if (bindings.length > 0)
+    await deps.upsertBindings(productId, bindings);
+  return { constraintsCreated: constraintNodes.length, frameworks: activeFrameworks };
+}
+function bc_filePatterns(category, ecosystem) {
+  const patterns = [];
+  if (category === "security" || category === "compliance") {
+    patterns.push("**/auth/**", "**/security/**", "**/middleware/**");
+    if (ecosystem.frameworks.some((f) => /firebase|firestore/i.test(f)))
+      patterns.push("**/firestore.rules");
+  }
+  if (category === "infrastructure")
+    patterns.push("**/config/**", "**/deploy/**", "**/infra/**");
+  if (category === "performance")
+    patterns.push("**/api/**", "**/routes/**");
+  return patterns;
+}
+async function ingestFindings(productId, extracted, fileContents, deps) {
+  if (!deps.upsertNodes || !deps.addEntity || !deps.addEdges || !deps.upsertBindings)
+    return 0;
+  if (!extracted.risks?.length)
+    return 0;
+  const now = /* @__PURE__ */ new Date();
+  const sourceId = `audit_${Date.now()}`;
+  const actionableRisks = extracted.risks.filter((r) => r.checklist_ref && extracted.checklist_summary?.[r.checklist_ref] !== "pass");
+  if (actionableRisks.length === 0)
+    return 0;
+  const domainRisks = /* @__PURE__ */ new Map();
+  for (const risk of actionableRisks) {
+    const domain = risk.category?.toLowerCase().replace(/[^a-z0-9]+/g, "_") || "general";
+    const existing = domainRisks.get(domain) ?? [];
+    existing.push(risk);
+    domainRisks.set(domain, existing);
+  }
+  let created = 0;
+  for (const [domain, risks] of domainRisks) {
+    const entityId = `component:security_${domain}`;
+    await deps.addEntity(productId, {
+      id: entityId,
+      type: "component",
+      name: `Security: ${domain.replace(/_/g, " ")}`,
+      aliases: [domain, "security", "audit"],
+      source_id: sourceId,
+      source_type: "premortem",
+      ingested_at: now
+    });
+    const constraintNodes = [];
+    const edges = [];
+    for (let i = 0; i < risks.length; i++) {
+      const risk = risks[i];
+      const cid = `constraint:audit:${domain}:${i}`;
+      constraintNodes.push({
+        id: cid,
+        category: "security",
+        severity: risk.severity === "critical" ? "critical" : risk.severity === "high" ? "critical" : "warning",
+        summary: risk.description?.slice(0, 200) || risk.title,
+        keywords: [domain, "security", "audit", ...risk.category ? [risk.category] : []],
+        source_id: sourceId,
+        source_type: "premortem",
+        ingested_at: now,
+        action: `Address: ${risk.title}`
+      });
+      edges.push({
+        id: `edge:audit:${entityId}:${cid}`,
+        source_id: entityId,
+        source_type: "component",
+        target_id: cid,
+        target_type: "constraint",
+        edge_type: "BOUNDED_BY"
+      });
+      created++;
+    }
+    await deps.upsertNodes(productId, "premortem", sourceId, constraintNodes);
+    if (edges.length > 0)
+      await deps.addEdges(productId, edges);
+    const auditedFiles = fileContents.map((f) => `**/${f.path.split("/").pop()}`);
+    if (auditedFiles.length > 0) {
+      await deps.upsertBindings(productId, [{
+        id: `binding:audit:${domain}`,
+        entity_id: entityId,
+        entity_type: "component",
+        file_patterns: auditedFiles.slice(0, 10),
+        confidence: 0.8,
+        manual: false
+      }]);
+    }
+  }
+  return created;
+}
+async function ingestScaFindingsFree(graphId, findings, deps) {
+  if (!deps.upsertNodes || !deps.addEntity || !deps.addEdges || !deps.upsertBindings)
+    return;
+  const now = /* @__PURE__ */ new Date();
+  const sourceId = `sca_${Date.now()}`;
+  const entityId = "component:dependencies";
+  await deps.addEntity(graphId, {
+    id: entityId,
+    type: "component",
+    name: "Dependencies (SCA)",
+    aliases: ["dependencies", "sca", "packages"],
+    description: `${findings.length} known vulnerability(s) detected`,
+    source_id: sourceId,
+    source_type: "premortem",
+    ingested_at: now
+  });
+  const constraints = [];
+  const edges = [];
+  const MAX_SCA_CONSTRAINTS = 50;
+  for (const f of findings.slice(0, MAX_SCA_CONSTRAINTS)) {
+    const cid = `constraint:sca:${f.id.toLowerCase().replace(/[^a-z0-9-]/g, "_")}`;
+    const fix = f.fixed_version ? ` Fix: upgrade to ${f.fixed_version}.` : "";
+    constraints.push({
+      id: cid,
+      category: "dependency",
+      severity: f.severity === "critical" || f.severity === "high" ? "critical" : "warning",
+      summary: `[${f.id}] ${f.package_name}@${f.package_version}: ${f.summary.slice(0, 200)}${fix}`,
+      keywords: [f.package_name, "cve", "vulnerability", "sca", "dependency"],
+      source_id: sourceId,
+      source_type: "premortem",
+      ingested_at: now,
+      action: f.fixed_version ? `Upgrade ${f.package_name} to ${f.fixed_version}` : `Review ${f.package_name}@${f.package_version} for ${f.id}`
+    });
+    edges.push({
+      id: `edge:sca:${entityId}:${cid}`,
+      source_id: entityId,
+      source_type: "component",
+      target_id: cid,
+      target_type: "constraint",
+      edge_type: "BOUNDED_BY"
+    });
+  }
+  await deps.upsertNodes(graphId, "premortem", sourceId, constraints);
+  if (edges.length > 0)
+    await deps.addEdges(graphId, edges);
+  await deps.upsertBindings(graphId, [{
+    id: "binding:sca:dependencies",
+    entity_id: entityId,
+    entity_type: "component",
+    file_patterns: [
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/pnpm-lock.yaml",
+      "**/requirements.txt",
+      "**/poetry.lock",
+      "**/go.sum",
+      "**/Gemfile.lock"
+    ],
+    confidence: 0.95,
+    manual: false
+  }]);
+}
+function buildExtractionPrompt(fileContents, ecosystem, sensitiveDataCount, scaContext) {
+  const fileSummary = fileContents.map((f) => `### ${f.path}
+${f.content}`).join("\n\n");
+  const system = `You are a senior engineering auditor. Analyze the provided source code and produce a structured assessment covering security, scalability, and reliability. Focus on ACTIVE ISSUES \u2014 real vulnerabilities, anti-patterns, or gaps in the code as written today:
+1. Authentication & authorization gaps
+2. Input validation & injection risks (including deserialization and path traversal)
+3. Data exposure & PII handling
+4. API security & rate limiting
+5. Dependency & configuration risks
+6. Scalability risks (N+1 queries, missing indexes, unbounded queries, blocking I/O, no connection pooling)
+7. Reliability risks (silent failures / empty catch blocks, unvalidated API contracts, edge case neglect, state drift)
+8. Infrastructure-as-Code misconfigurations (Terraform, Docker, Kubernetes)
+
+IMPORTANT: You MUST return at least one risk, even for well-maintained codebases. If no critical/high issues exist, identify the single most impactful medium or low-severity improvement \u2014 e.g., missing security headers, suboptimal error handling, a missing index, or a hardening opportunity. There is always a most-important next thing to improve.
+Return ONLY valid JSON matching the schema.`;
+  const scaSection = scaContext ? `
+
+${scaContext}` : "";
+  const iacLine = ecosystem.iac_tools?.length ? `
+IaC tools detected: ${ecosystem.iac_tools.join(", ")}` : "";
+  const user = `Ecosystem: ${JSON.stringify(ecosystem)}${iacLine}
+Sensitive data locations found: ${sensitiveDataCount}${scaSection}
+
+Source files:
+${fileSummary}
+
+Produce a JSON object with:
+{
+  "risks": [{ "title": string, "description": string, "category": "auth"|"injection"|"data_protection"|"api_security"|"infrastructure"|"dependency"|"iac"|"scalability"|"performance"|"reliability"|"code_quality", "severity": "critical"|"high"|"medium"|"low", "checklist_ref": string }],
+  "checklist_summary": { [ref: string]: "pass"|"fail"|"warn"|"not_applicable" },
+  "productName": string,
+  "productBrief": string
+}`;
+  return { system, user };
+}
+async function handleSecurityScan(genericGraphId, uid, args, deps) {
+  const maxFileBytes = args.max_file_bytes ?? 5e4;
+  let previousMetrics;
+  try {
+    const prevEntities = await deps.getAllEntities(genericGraphId);
+    if (prevEntities.length > 0) {
+      const [prevEdges, prevConstraints, prevBindings] = await Promise.all([
+        deps.getAllEdges(genericGraphId),
+        deps.getAllNodes(genericGraphId),
+        deps.getAllBindings(genericGraphId)
+      ]);
+      previousMetrics = computeGenericGraphMetrics(prevEntities, prevEdges, prevConstraints, prevBindings);
+    }
+  } catch {
+  }
+  const scan = await scanCodebase({ root: args.project_root });
+  let scaFindings = [];
+  if (scan.dependencies.length > 0) {
+    try {
+      scaFindings = await scanDependencies(scan.dependencies);
+    } catch (e) {
+      console.warn("[code_audit] SCA scan failed:", e.message);
+    }
+  }
+  const sensitiveFilePaths = new Set(scan.sensitive_data.fields?.map((f) => f.file).filter(Boolean) ?? []);
+  const selectedFiles = selectSecurityFiles(scan.files, sensitiveFilePaths, 15);
+  const fileContents = await readFileContents(args.project_root, selectedFiles, maxFileBytes);
+  const existingNodes = await deps.getAllNodes(genericGraphId);
+  const existingIds = existingNodes.map((n) => n.id);
+  let constraintsSeeded = 0;
+  let frameworksLoaded = [];
+  if (graphNeedsBlueprintSeeding(existingIds)) {
+    const blueprintResult = await seedBlueprint(genericGraphId, scan.ecosystem, deps);
+    constraintsSeeded = blueprintResult.constraintsCreated;
+    frameworksLoaded = blueprintResult.frameworks.map((f) => String(f));
+  }
+  let findingsIngested = 0;
+  let extractedContext = null;
+  if (fileContents.length > 0) {
+    const prompt = buildExtractionPrompt(fileContents, scan.ecosystem, scan.sensitive_data.fields?.length ?? 0, formatScaContext(scaFindings));
+    try {
+      const raw = await deps.generateStructuredContent({
+        system: prompt.system,
+        user: prompt.user,
+        temperature: 0.1
+      });
+      extractedContext = JSON.parse(raw);
+      findingsIngested = await ingestFindings(genericGraphId, extractedContext, fileContents, deps);
+    } catch (e) {
+      console.error("[security_scan] LLM extraction failed:", e.message);
+    }
+  }
+  if (scaFindings.length > 0 && deps.upsertNodes && deps.addEntity && deps.addEdges && deps.upsertBindings) {
+    await ingestScaFindingsFree(genericGraphId, scaFindings, deps);
+    findingsIngested += scaFindings.length;
+  }
+  const [entities, edges, constraints, bindings] = await Promise.all([
+    deps.getAllEntities(genericGraphId),
+    deps.getAllEdges(genericGraphId),
+    deps.getAllNodes(genericGraphId),
+    deps.getAllBindings(genericGraphId)
+  ]);
+  const metrics = computeGenericGraphMetrics(entities, edges, constraints, bindings);
+  if (deps.updateGraphMetadata) {
+    await deps.updateGraphMetadata(genericGraphId, {
+      metrics,
+      type: "generic",
+      uid,
+      ecosystem: scan.ecosystem,
+      project_root_hash: args.project_root,
+      last_scan: /* @__PURE__ */ new Date()
+    });
+  }
+  const boundEntityIds = new Set(bindings.map((b) => b.entity_id));
+  const totalEntities = entities.length;
+  const healthyBindings = entities.filter((e) => boundEntityIds.has(e.id)).length;
+  const allRisks = extractedContext?.risks ?? [];
+  const criticalRisks = allRisks.filter((r) => r.severity === "critical" || r.severity === "high");
+  const gatedGapDetails = allRisks.map((r) => ({
+    title: r.title,
+    description: r.description ?? "",
+    severity: r.severity ?? "medium",
+    category: r.category ?? "general"
+  }));
+  if (gatedGapDetails.length === 0 && metrics) {
+    const pillars = [
+      {
+        name: "Reliability",
+        score: metrics.reliability_readiness_pct ?? 100,
+        category: "reliability",
+        advice: "Improve error handling coverage, add retry logic for external calls, and ensure all async operations have proper failure modes."
+      },
+      {
+        name: "Scalability",
+        score: metrics.scalability_readiness_pct ?? 100,
+        category: "scalability",
+        advice: "Review database query patterns for N+1 issues, ensure connection pooling is configured, and add pagination to list endpoints."
+      },
+      {
+        name: "Engineering",
+        score: metrics.engineering_readiness_pct ?? 100,
+        category: "code_quality",
+        advice: "Increase constraint binding coverage by adding tests, improving input validation, and documenting non-obvious architectural decisions."
+      },
+      {
+        name: "Security",
+        score: metrics.security_readiness_pct ?? 100,
+        category: "auth",
+        advice: "Review authentication flows, tighten CORS policies, add security headers (CSP, HSTS), and ensure all sensitive endpoints have rate limiting."
+      }
+    ];
+    const weakest = pillars.sort((a, b) => a.score - b.score)[0];
+    if (weakest.score < 100) {
+      gatedGapDetails.push({
+        title: `${weakest.name} readiness at ${weakest.score.toFixed(0)}% \u2014 room for improvement`,
+        description: weakest.advice,
+        severity: weakest.score < 40 ? "high" : weakest.score < 60 ? "medium" : "low",
+        category: weakest.category
+      });
+    }
+  }
+  return {
+    genericGraphId,
+    metrics,
+    previousMetrics,
+    ecosystem: {
+      languages: scan.ecosystem.languages,
+      frameworks: scan.ecosystem.frameworks,
+      orms: scan.ecosystem.orms ?? []
+    },
+    sensitiveDataCount: scan.sensitive_data.fields?.length ?? 0,
+    constraintsSeeded,
+    findingsIngested,
+    frameworksLoaded,
+    bindingHealth: {
+      healthy: healthyBindings,
+      total: totalEntities,
+      coverage_pct: totalEntities > 0 ? Math.round(healthyBindings / totalEntities * 100) : 0
+    },
+    securityGaps: criticalRisks.map((r) => `[${r.severity?.toUpperCase()}] ${r.title}`),
+    gatedGapDetails,
+    scaFindings: scaFindings.length > 0 ? {
+      total: scaFindings.length,
+      critical: scaFindings.filter((f) => f.severity === "critical").length,
+      high: scaFindings.filter((f) => f.severity === "high").length,
+      all: scaFindings.map((f) => ({
+        id: f.id,
+        package: `${f.package_name}@${f.package_version}`,
+        severity: f.severity,
+        fix: f.fixed_version ? `Upgrade to ${f.fixed_version}` : void 0
+      })),
+      top: scaFindings.slice(0, 5).map((f) => ({
+        id: f.id,
+        package: `${f.package_name}@${f.package_version}`,
+        severity: f.severity,
+        fix: f.fixed_version ? `Upgrade to ${f.fixed_version}` : void 0
+      }))
+    } : void 0,
+    selectedFilePaths: selectedFiles.map((entry) => String(entry.path || "").trim()).filter(Boolean)
+  };
+}
+function deltaStr(current, previous) {
+  if (previous === void 0 || current === void 0)
+    return "";
+  const diff = current - previous;
+  if (diff === 0)
+    return " (no change)";
+  return diff > 0 ? ` (**+${diff}** since last scan)` : ` (**${diff}** since last scan)`;
+}
+function formatAuditOutput(result, reportId, publicSiteUrl = "https://thecutline.ai", hiddenAuditDimensions = [], fullReport = false) {
+  const m = result.metrics;
+  const p = result.previousMetrics;
+  const isRescan = !!p;
+  const hiddenSet = new Set(hiddenAuditDimensions.map((d) => String(d).trim().toLowerCase()));
+  const securityVisible = !hiddenSet.has("security");
+  const inferFindingDimension = (category) => {
+    const c = (category ?? "").toLowerCase();
+    if (["reliability"].includes(c))
+      return "reliability";
+    if (["scalability", "performance"].includes(c))
+      return "scalability";
+    if (["compliance"].includes(c))
+      return "compliance";
+    if (["code_quality", "general"].includes(c))
+      return "engineering";
+    return "security";
+  };
+  const hasComplianceFrameworks = result.frameworksLoaded.length > 0;
+  const complianceCurrent = hasComplianceFrameworks ? Math.round((m.nfr_coverage?.compliance ?? 0) * 100) : void 0;
+  const compliancePrevious = hasComplianceFrameworks ? Math.round((p?.nfr_coverage?.compliance ?? 0) * 100) : void 0;
+  const lines = [
+    `# Cutline Code Audit`,
+    ``,
+    `**Ecosystem:** ${result.ecosystem.languages.join(", ")} / ${result.ecosystem.frameworks.join(", ") || "none detected"}`,
+    `**Sensitive data locations:** ${result.sensitiveDataCount}`
+  ];
+  if (result.frameworksLoaded.length > 0) {
+    lines.push(`**Compliance frameworks:** ${result.frameworksLoaded.join(", ")}`);
+  }
+  const scoreRows = [
+    {
+      key: "engineering",
+      label: "Engineering",
+      current: m.engineering_readiness_pct ?? 0,
+      previous: p?.engineering_readiness_pct
+    },
+    {
+      key: "security",
+      label: "Security",
+      current: m.security_readiness_pct ?? 0,
+      previous: p?.security_readiness_pct
+    },
+    {
+      key: "reliability",
+      label: "Reliability",
+      current: m.reliability_readiness_pct ?? 0,
+      previous: p?.reliability_readiness_pct
+    },
+    {
+      key: "scalability",
+      label: "Scalability",
+      current: m.scalability_readiness_pct ?? 0,
+      previous: p?.scalability_readiness_pct
+    },
+    {
+      key: "compliance",
+      label: "Compliance",
+      current: complianceCurrent,
+      previous: compliancePrevious,
+      na: !hasComplianceFrameworks
+    }
+  ].filter((row) => !hiddenSet.has(row.key));
+  lines.push(``, `## Readiness Scores`, ``, `| Pillar | Score |${isRescan ? " Change |" : ""}`, `|--------|-------|${isRescan ? "--------|" : ""}`);
+  if (scoreRows.length > 0) {
+    for (const row of scoreRows) {
+      lines.push(`| ${row.label} | ${row.na ? "N/A" : `${row.current ?? 0}%`} |${isRescan ? row.na ? " (n/a) |" : deltaStr(row.current, row.previous) + " |" : ""}`);
+    }
+    lines.push(``);
+  } else {
+    lines.push(`| _Hidden by local audit visibility settings_ | - |${isRescan ? " - |" : ""}`, ``);
+  }
+  lines.push(`**Constraints mapped:** ${m.complexity_factors?.nfr_count ?? 0} (${m.complexity_factors?.critical_nfr_count ?? 0} critical)`, `**Binding coverage:** ${result.bindingHealth.coverage_pct}%`);
+  if (securityVisible && result.scaFindings && result.scaFindings.total > 0) {
+    const sca = result.scaFindings;
+    lines.push(``, `## Dependency Vulnerabilities (SCA)`, ``, `**${sca.total} known vulnerabilities** found (${sca.critical} critical, ${sca.high} high)`, ``);
+    const scaEntries = fullReport && sca.all?.length ? sca.all : sca.top;
+    for (const v of scaEntries) {
+      const fix = v.fix ? ` \u2192 ${v.fix}` : "";
+      lines.push(`- **[${v.severity.toUpperCase()}]** ${v.package}: ${v.id}${fix}`);
+    }
+    if (!fullReport && sca.total > sca.top.length) {
+      lines.push(`- ...and ${sca.total - sca.top.length} more`);
+    }
+  }
+  const visibleFindings = result.gatedGapDetails.filter((g) => !hiddenSet.has(inferFindingDimension(g.category)));
+  const totalFindings = visibleFindings.length;
+  const criticalCount = visibleFindings.filter((g) => g.severity === "critical" || g.severity === "high").length;
+  if (totalFindings > 0) {
+    if (fullReport) {
+      lines.push(``, `## Findings`, ``);
+      for (const finding of visibleFindings) {
+        lines.push(`**[${finding.severity.toUpperCase()}] ${finding.title}**`, `*Category: ${finding.category}*`, finding.description || "Address this finding to improve your readiness scores.", ``);
+      }
+      lines.push(`> Re-run \`code_audit\` after fixes to measure score improvements.`);
+    } else {
+      const topFinding = visibleFindings[0];
+      lines.push(``, `## #1 Finding \u2014 Fix This Now`, ``, `**[${topFinding.severity.toUpperCase()}] ${topFinding.title}**`, `*Category: ${topFinding.category}*`, ``, topFinding.description || "Address this finding to improve your readiness scores.", ``, `> Fix this issue, then re-run \`code_audit\` to see your scores improve.`);
+      const remaining = visibleFindings.slice(1);
+      if (remaining.length > 0) {
+        lines.push(``, `## ${remaining.length} More Finding${remaining.length > 1 ? "s" : ""} Detected`);
+        const teaserLimit = Math.min(remaining.length, 5);
+        for (let i = 0; i < teaserLimit; i++) {
+          lines.push(`- [${remaining[i].severity.toUpperCase()}] ${remaining[i].title}`);
+        }
+        if (remaining.length > teaserLimit) {
+          lines.push(`- ... and **${remaining.length - teaserLimit} more**`);
+        }
+      }
+    }
+  }
+  lines.push(``, `---`, ``);
+  if (!fullReport && totalFindings > 1) {
+    lines.push(`### Unlock Full Analysis`, ``, `You fixed one \u2014 **${totalFindings - 1} findings** remain (${criticalCount} critical/high).`, `Upgrade to Cutline Pro for:`, `- Full details and remediation for every finding`, `- Prioritized RGR remediation plans your coding agent can execute`, `- Product-specific deep dive with feature-level constraint mapping`, `- Continuous score tracking with this audit as a baseline prior`, ``, `\u2192 Run \`cutline-mcp upgrade\` or visit **https://thecutline.ai/upgrade**`);
+  } else if (totalFindings >= 1) {
+    lines.push(`### Next Steps`, ``, `Fix the finding above, then re-scan to see your scores improve.`, `When ready, run a **deep dive** for product-specific analysis \u2014`, `these generic scores will serve as a prior for your product graph.`);
+  } else {
+    lines.push(`### Next Steps`, ``, `No critical findings detected. Run a **deep dive** for product-specific`, `analysis with feature coverage and the generic scores as a prior.`);
+  }
+  if (reportId) {
+    lines.push(``, `---`, ``, `**View & share this report:** ${publicSiteUrl}/report/${reportId}`);
+  }
+  lines.push(``, `> Scores reflect constraint binding health \u2014 how well your codebase maps to`, `> engineering guardrails. They improve as you address findings and re-scan.`);
+  return lines.join("\n");
+}
+
+export {
+  scanCodebase,
+  buildBlueprintConstraints,
+  getActiveFrameworks,
+  graphNeedsBlueprintSeeding,
+  getSystemPrompt,
+  buildUserPrompt,
+  scanDependencies,
+  formatScaContext,
+  buildGenericGraphId,
+  handleSecurityScan,
+  formatAuditOutput
+};