security-mcp 1.0.0

package/dist/cli/install.js

@@ -0,0 +1,161 @@
+/**
+ * security-mcp install command
+ *
+ * Auto-detects installed editors and writes MCP server config + Claude Code skill.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync, copyFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { homedir, platform } from "os";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, "../..");
+const MCP_ENTRY = {
+    command: "npx",
+    args: ["-y", "security-mcp", "serve"]
+};
+function resolveHome(p) {
+    return p.replace(/^~/, homedir());
+}
+function getVsCodeSettingsPath() {
+    const os = platform();
+    if (os === "win32") {
+        return join(process.env["APPDATA"] ?? "", "Code", "User", "settings.json");
+    }
+    if (os === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Code", "User", "settings.json");
+    }
+    return join(homedir(), ".config", "Code", "User", "settings.json");
+}
+function getEditorTargets(opts) {
+    const claudeCodePath = resolveHome("~/.claude/settings.json");
+    const cursorGlobalPath = resolveHome("~/.cursor/mcp.json");
+    const cursorLocalPath = ".cursor/mcp.json";
+    const vscodePath = getVsCodeSettingsPath();
+    const all = [
+        {
+            name: "Claude Code",
+            configPath: claudeCodePath,
+            type: "mcp-servers-json",
+            detected: existsSync(resolveHome("~/.claude"))
+        },
+        {
+            name: "Cursor (global)",
+            configPath: cursorGlobalPath,
+            type: "mcp-servers-json",
+            detected: existsSync(resolveHome("~/.cursor"))
+        },
+        {
+            name: "Cursor (workspace)",
+            configPath: cursorLocalPath,
+            type: "mcp-servers-json",
+            detected: existsSync(".cursor")
+        },
+        {
+            name: "VS Code",
+            configPath: vscodePath,
+            type: "vscode-settings",
+            detected: existsSync(vscodePath)
+        }
+    ];
+    if (opts.all) {
+        return all.filter((t) => t.detected);
+    }
+    return all.filter((t) => {
+        if (opts.claudeCode && t.name.startsWith("Claude Code"))
+            return true;
+        if (opts.cursor && t.name.startsWith("Cursor"))
+            return true;
+        if (opts.vscode && t.name === "VS Code")
+            return true;
+        return false;
+    });
+}
+function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeMcpServersJson(configPath, dryRun) {
+    const existing = readJsonSafe(configPath);
+    const servers = existing["mcpServers"] ?? {};
+    servers["security-mcp"] = MCP_ENTRY;
+    existing["mcpServers"] = servers;
+    const content = JSON.stringify(existing, null, 2) + "\n";
+    if (!dryRun) {
+        mkdirSync(dirname(configPath), { recursive: true });
+        writeFileSync(configPath, content, "utf-8");
+    }
+    return configPath;
+}
+function writeVsCodeSettings(configPath, dryRun) {
+    const existing = readJsonSafe(configPath);
+    const servers = existing["mcp.servers"] ?? {};
+    servers["security-mcp"] = MCP_ENTRY;
+    existing["mcp.servers"] = servers;
+    const content = JSON.stringify(existing, null, 2) + "\n";
+    if (!dryRun) {
+        mkdirSync(dirname(configPath), { recursive: true });
+        writeFileSync(configPath, content, "utf-8");
+    }
+    return configPath;
+}
+function installSkill(dryRun) {
+    const skillSrc = join(PKG_ROOT, "skills", "security-review", "SKILL.md");
+    const skillDest = resolveHome("~/.claude/skills/security-review/SKILL.md");
+    if (!existsSync(skillSrc)) {
+        process.stdout.write("  [skip] skills/security-review/SKILL.md not found in package\n");
+        return;
+    }
+    if (!dryRun) {
+        mkdirSync(dirname(skillDest), { recursive: true });
+        copyFileSync(skillSrc, skillDest);
+    }
+    process.stdout.write(`  ${dryRun ? "[dry-run] would copy" : "installed"} skill: ${skillDest}\n`);
+}
+export async function runInstall(opts) {
+    const dryRun = opts.dryRun;
+    process.stdout.write(`\nsecurity-mcp installer${dryRun ? " (dry-run)" : ""}\n`);
+    process.stdout.write("=".repeat(40) + "\n\n");
+    const targets = getEditorTargets(opts);
+    if (targets.length === 0) {
+        process.stdout.write("No supported editors detected automatically.\n" +
+            "Run with --claude-code, --cursor, or --vscode to target a specific editor.\n" +
+            'Or add the config manually (run "npx security-mcp config" for the snippet).\n\n');
+        return;
+    }
+    for (const target of targets) {
+        process.stdout.write(`Installing for ${target.name}...\n`);
+        try {
+            let written;
+            if (target.type === "vscode-settings") {
+                written = writeVsCodeSettings(target.configPath, dryRun);
+            }
+            else {
+                written = writeMcpServersJson(target.configPath, dryRun);
+            }
+            process.stdout.write(`  ${dryRun ? "[dry-run] would update" : "updated"}: ${written}\n`);
+        }
+        catch (err) {
+            process.stdout.write(`  [error] ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    // Install Claude Code skill if Claude Code is in scope
+    const hasClaudeCode = targets.some((t) => t.name.startsWith("Claude Code"));
+    if (hasClaudeCode || opts.all) {
+        process.stdout.write("\nInstalling Claude Code skill...\n");
+        installSkill(dryRun);
+    }
+    process.stdout.write("\n");
+    process.stdout.write(dryRun
+        ? "Dry-run complete. Re-run without --dry-run to apply.\n"
+        : "Done! Restart your editor to activate the security-mcp server.\n");
+    process.stdout.write("\nNext steps:\n");
+    process.stdout.write("  1. Restart your editor.\n");
+    process.stdout.write('  2. In Claude Code, type /security-review to invoke the security skill.\n');
+    process.stdout.write('  3. Ask your AI: "Run security.run_pr_gate" to check your current diff.\n');
+    process.stdout.write("  4. Copy defaults/security-policy.json to .mcp/policies/security-policy.json\n");
+    process.stdout.write("     and customize it for your project.\n\n");
+}

package/dist/gate/checks/ai.js

@@ -0,0 +1,39 @@
+import { searchRepo } from "../../repo/search.js";
+export async function checkAi(_) {
+    const findings = [];
+    const schemaEnforcement = await searchRepo({
+        query: String.raw `zod\.object\(|outputSchema|json_schema|JSON schema`,
+        isRegex: true,
+        maxMatches: 200
+    });
+    const toolUse = await searchRepo({ query: "tool|function_call|tools:", isRegex: true, maxMatches: 200 });
+    if (toolUse.length > 0 && schemaEnforcement.length === 0) {
+        findings.push({
+            id: "AI_OUTPUT_BOUNDS_MISSING",
+            title: "AI/tooling present but bounded output (schema validation) not detected",
+            severity: "HIGH",
+            requiredActions: [
+                "Enforce bounded outputs via JSON schema validation for every AI response used by code.",
+                "Add prompt-injection defenses: input sanitization, tool allowlists, deny-by-default tool router, and sensitive data redaction."
+            ]
+        });
+    }
+    const systemPromptLeaks = await searchRepo({
+        query: "system prompt|developer message|ignore previous|prompt injection",
+        isRegex: true,
+        maxMatches: 200
+    });
+    if (systemPromptLeaks.length > 0) {
+        findings.push({
+            id: "AI_INJECTION_CUES",
+            title: "Potential prompt injection cues detected. Requires explicit mitigations and tests.",
+            severity: "MEDIUM",
+            evidence: systemPromptLeaks.slice(0, 10).map((m) => `${m.file}:${m.line}:${m.preview}`),
+            requiredActions: [
+                "Add multi-layer prompt-injection protection: instruction hierarchy enforcement, content isolation, tool gating, and output validation.",
+                "Add a red-team test harness with injection payloads and exfil attempts."
+            ]
+        });
+    }
+    return findings;
+}

package/dist/gate/checks/api.js

@@ -0,0 +1,46 @@
+import { searchRepo } from "../../repo/search.js";
+export async function checkApi(_) {
+    const findings = [];
+    const zodHits = await searchRepo({ query: "zod|valibot|yup|joi", isRegex: true, maxMatches: 200 });
+    if (zodHits.length === 0) {
+        findings.push({
+            id: "API_VALIDATION_MISSING",
+            title: "No server-side schema validation library detected in API surface",
+            severity: "HIGH",
+            requiredActions: [
+                "Add mandatory server-side schema validation for all API boundaries (Zod/Valibot/Yup/Joi).",
+                "Enforce allowlist validation and strict normalization at boundaries."
+            ]
+        });
+    }
+    const csrfHits = await searchRepo({ query: "csrf|xsrf", isRegex: true, maxMatches: 200 });
+    if (csrfHits.length === 0) {
+        findings.push({
+            id: "CSRF_MAY_BE_MISSING",
+            title: "CSRF protections not detected",
+            severity: "HIGH",
+            requiredActions: [
+                "Add CSRF protections for all state-changing endpoints.",
+                "Use SameSite cookies + CSRF tokens, validate origin/referer for browser contexts."
+            ]
+        });
+    }
+    const idorCues = await searchRepo({
+        query: String.raw `req\.query\.|params\.|userId\s*=`,
+        isRegex: true,
+        maxMatches: 200
+    });
+    if (idorCues.length > 0) {
+        findings.push({
+            id: "IDOR_RISK_REVIEW",
+            title: "Possible IDOR risk: parameterized resource access patterns detected",
+            severity: "MEDIUM",
+            evidence: idorCues.slice(0, 15).map((m) => `${m.file}:${m.line}:${m.preview}`),
+            requiredActions: [
+                "Ensure every resource access enforces server-side authz checks (UI checks never count).",
+                "Add tests for cross-tenant access attempts."
+            ]
+        });
+    }
+    return findings;
+}

package/dist/gate/checks/dependencies.js

@@ -0,0 +1,39 @@
+import fg from "fast-glob";
+import { readFileSafe } from "../../repo/fs.js";
+export async function checkDependencies(_) {
+    const findings = [];
+    const lockfiles = await fg(["package-lock.json", "pnpm-lock.yaml", "yarn.lock"], { dot: true });
+    if (lockfiles.length === 0) {
+        findings.push({
+            id: "LOCKFILE_MISSING",
+            title: "No JS lockfile found",
+            severity: "HIGH",
+            requiredActions: [
+                "Add and commit a lockfile (package-lock.json, pnpm-lock.yaml, or yarn.lock).",
+                "Pin versions and enable dependency scanning in CI."
+            ]
+        });
+        return findings;
+    }
+    // Basic check: ensure package.json exists and is valid JSON
+    try {
+        const pkg = JSON.parse(await readFileSafe("package.json"));
+        if (!pkg.dependencies && !pkg.devDependencies) {
+            findings.push({
+                id: "PACKAGE_JSON_EMPTY",
+                title: "package.json has no dependencies/devDependencies",
+                severity: "LOW",
+                requiredActions: ["Verify this is intentional. If not, add dependencies with pinned ranges."]
+            });
+        }
+    }
+    catch {
+        findings.push({
+            id: "PACKAGE_JSON_INVALID",
+            title: "package.json is missing or invalid JSON",
+            severity: "HIGH",
+            requiredActions: ["Fix package.json JSON syntax."]
+        });
+    }
+    return findings;
+}

package/dist/gate/checks/infra.js

@@ -0,0 +1,38 @@
+import { searchRepo } from "../../repo/search.js";
+export async function checkInfra(_) {
+    const findings = [];
+    const secretManagerRefs = await searchRepo({
+        query: "secretmanager|Secret Manager|google_secret_manager",
+        isRegex: true,
+        maxMatches: 200
+    });
+    if (secretManagerRefs.length === 0) {
+        findings.push({
+            id: "SECRET_MANAGER_NOT_DETECTED",
+            title: "GCP Secret Manager usage not detected in infra/app config",
+            severity: "HIGH",
+            requiredActions: [
+                "Store secrets only in GCP Secret Manager.",
+                "Configure workload identity / service accounts to access secrets, never plaintext env in repo."
+            ]
+        });
+    }
+    const publicIngress = await searchRepo({
+        query: String.raw `0\.0\.0\.0/0|::/0|public\s*=\s*true|allowAll|allUsers`,
+        isRegex: true,
+        maxMatches: 200
+    });
+    if (publicIngress.length > 0) {
+        findings.push({
+            id: "PUBLIC_EXPOSURE_RISK",
+            title: "Potential public exposure patterns detected in IaC/config",
+            severity: "HIGH",
+            evidence: publicIngress.slice(0, 20).map((m) => `${m.file}:${m.line}:${m.preview}`),
+            requiredActions: [
+                "Remove or justify public ingress. Enforce Zero Trust. No implicit trust for any request or service call.",
+                "Use private services, IAM-based auth, and least-privileged firewall rules."
+            ]
+        });
+    }
+    return findings;
+}

package/dist/gate/checks/mobile-android.js

@@ -0,0 +1,35 @@
+import fg from "fast-glob";
+import { readFileSafe } from "../../repo/fs.js";
+export async function checkMobileAndroid(_) {
+    const findings = [];
+    const manifests = await fg(["**/AndroidManifest.xml"], { dot: true, ignore: ["**/node_modules/**"] });
+    for (const m of manifests) {
+        const xml = await readFileSafe(m).catch(() => "");
+        const lower = xml.toLowerCase();
+        if (lower.includes('android:debuggable="true"')) {
+            findings.push({
+                id: "ANDROID_DEBUGGABLE",
+                title: "Android app is debuggable in manifest",
+                severity: "CRITICAL",
+                files: [m],
+                requiredActions: [
+                    "Remove android:debuggable=\"true\" for release builds.",
+                    "Ensure signing configs and build variants enforce non-debuggable release artifacts."
+                ]
+            });
+        }
+        if (lower.includes('android:usescleartexttraffic="true"')) {
+            findings.push({
+                id: "ANDROID_CLEARTEXT",
+                title: "Android cleartext traffic allowed",
+                severity: "CRITICAL",
+                files: [m],
+                requiredActions: [
+                    "Disable cleartext traffic. Enforce TLS 1.3.",
+                    "Use Network Security Config with strict domain allowlists if exceptions are required."
+                ]
+            });
+        }
+    }
+    return findings;
+}

package/dist/gate/checks/mobile-ios.js

@@ -0,0 +1,23 @@
+import fg from "fast-glob";
+import { readFileSafe } from "../../repo/fs.js";
+export async function checkMobileIos(_) {
+    const findings = [];
+    const plists = await fg(["**/Info.plist"], { dot: true, ignore: ["**/node_modules/**"] });
+    for (const p of plists) {
+        const text = await readFileSafe(p).catch(() => "");
+        const lower = text.toLowerCase();
+        if (lower.includes("nsallowsarbitraryloads") || lower.includes("allowsarbitraryloads")) {
+            findings.push({
+                id: "IOS_ATS_WEAK",
+                title: "iOS ATS appears weakened (NSAllowsArbitraryLoads)",
+                severity: "CRITICAL",
+                files: [p],
+                requiredActions: [
+                    "Remove NSAllowsArbitraryLoads. Enforce TLS 1.3. Restrict exceptions to specific domains with justification.",
+                    "Enable certificate pinning for high-risk APIs where appropriate."
+                ]
+            });
+        }
+    }
+    return findings;
+}

package/dist/gate/checks/required-artifacts.js

@@ -0,0 +1,25 @@
+import fg from "fast-glob";
+import picomatch from "picomatch";
+export async function checkRequiredArtifacts(opts) {
+    const findings = [];
+    for (const req of opts.policy.artifacts_required ?? []) {
+        const matchers = req.on_changes.map((pattern) => picomatch(pattern, { dot: true }));
+        const touched = opts.changedFiles.some((file) => matchers.some((match) => match(file)));
+        if (!touched)
+            continue;
+        const matches = await fg(req.pattern, { dot: true });
+        if (matches.length === 0) {
+            findings.push({
+                id: "ARTIFACTS_MISSING",
+                title: `Missing required artifact(s) for changes affecting: ${req.on_changes.join(", ")}`,
+                severity: "HIGH",
+                evidence: [`Expected at least one file matching: ${req.pattern}`],
+                requiredActions: [
+                    `Add required artifact(s) matching "${req.pattern}" (e.g., threat model for the changed flow).`,
+                    `Include STRIDE + OWASP mapping + MITRE mapping + required logging and tests.`
+                ]
+            });
+        }
+    }
+    return findings;
+}

package/dist/gate/checks/secrets.js

@@ -0,0 +1,31 @@
+import { execa } from "execa";
+export async function checkSecrets(_) {
+    // CI will also run gitleaks. This is a fast local heuristic backup.
+    const findings = [];
+    const patterns = [
+        "-----BEGIN PRIVATE KEY-----",
+        "AKIA", // AWS
+        "AIza", // Google API key prefix
+        "xoxb-", // Slack bot token
+        "sk-", // common LLM key prefix
+        "SECRET_KEY",
+        "PRIVATE_KEY"
+    ];
+    const { stdout } = await execa("git", ["grep", "-n", "--untracked", "--no-index", "-I", "-e", patterns.join("|"), "."], {
+        reject: false
+    });
+    if (stdout.trim()) {
+        findings.push({
+            id: "POSSIBLE_SECRET",
+            title: "Potential secret material detected by heuristic scan",
+            severity: "CRITICAL",
+            evidence: stdout.split("\n").slice(0, 50),
+            requiredActions: [
+                "Remove secrets from repo immediately.",
+                "Rotate any exposed credentials.",
+                "Store secrets only in GCP Secret Manager. Do not log secrets."
+            ]
+        });
+    }
+    return findings;
+}

package/dist/gate/checks/web-nextjs.js

@@ -0,0 +1,76 @@
+import { searchRepo } from "../../repo/search.js";
+import fg from "fast-glob";
+import { readFileSafe } from "../../repo/fs.js";
+export async function checkWebNextjs(_) {
+    const findings = [];
+    // 1) CSP and security headers should exist (Next middleware or edge config)
+    const headerFiles = await fg(["middleware.ts", "middleware.tsx", "src/middleware.ts", "next.config.*"], {
+        dot: true
+    });
+    if (headerFiles.length === 0) {
+        findings.push({
+            id: "WEB_HEADERS_MISSING",
+            title: "Security headers not found (CSP/HSTS/etc.)",
+            severity: "HIGH",
+            requiredActions: [
+                "Add strict security headers: CSP (no inline JS), HSTS, X-Frame-Options, Referrer-Policy, Permissions-Policy.",
+                "Enforce secure cookies: HttpOnly, Secure, SameSite, short-lived tokens."
+            ]
+        });
+    }
+    else {
+        const combined = (await Promise.all(headerFiles.map((f) => readFileSafe(f).catch(() => "")))).join("\n");
+        const mustContain = [
+            "content-security-policy",
+            "strict-transport-security",
+            "referrer-policy",
+            "permissions-policy"
+        ];
+        const missing = mustContain.filter((k) => !combined.toLowerCase().includes(k));
+        if (missing.length > 0) {
+            findings.push({
+                id: "WEB_HEADERS_INCOMPLETE",
+                title: "Security headers exist but appear incomplete",
+                severity: "HIGH",
+                evidence: [`Missing: ${missing.join(", ")}`],
+                requiredActions: [
+                    "Add missing headers and ensure CSP forbids inline scripts (no 'unsafe-inline').",
+                    "Add a CSP nonce strategy if you must load dynamic scripts."
+                ]
+            });
+        }
+    }
+    // 2) Flag dangerous React usage
+    const dsi = await searchRepo({ query: "dangerouslySetInnerHTML", isRegex: false, maxMatches: 200 });
+    if (dsi.length > 0) {
+        findings.push({
+            id: "DANGEROUSLY_SET_INNER_HTML",
+            title: "dangerouslySetInnerHTML usage detected",
+            severity: "HIGH",
+            evidence: dsi.slice(0, 20).map((m) => `${m.file}:${m.line}:${m.preview}`),
+            requiredActions: [
+                "Remove dangerouslySetInnerHTML where possible.",
+                "If unavoidable: sanitize with a proven HTML sanitizer and add unit tests with XSS payloads."
+            ]
+        });
+    }
+    // 3) Basic SSRF risk pattern scan (server-side fetch)
+    const fetchHits = await searchRepo({
+        query: String.raw `\bfetch\(|axios\(|got\(|undici\b`,
+        isRegex: true,
+        maxMatches: 200
+    });
+    if (fetchHits.length > 0) {
+        findings.push({
+            id: "SSRF_GUARD_REQUIRED",
+            title: "Server-side fetch patterns detected. SSRF protections must be enforced.",
+            severity: "HIGH",
+            evidence: fetchHits.slice(0, 15).map((m) => `${m.file}:${m.line}:${m.preview}`),
+            requiredActions: [
+                "Implement SSRF guard for any server-side HTTP client: block localhost, private IP ranges, and cloud metadata endpoints.",
+                "Require URL allowlists for outbound calls. Add tests for 127.0.0.1, 10/8, 172.16/12, 192.168/16, 169.254.169.254, metadata.google.internal."
+            ]
+        });
+    }
+    return findings;
+}

package/dist/gate/diff.js

@@ -0,0 +1,11 @@
+import { execa } from "execa";
+export async function getChangedFiles(opts) {
+    // Uses git diff in CI. Assumes checkout has full history for baseRef.
+    const { stdout } = await execa("git", ["diff", "--name-only", `${opts.baseRef}...${opts.headRef}`], {
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    return stdout
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}

package/dist/gate/findings.js

@@ -0,0 +1,11 @@
+export function detectSurfaces(changedFiles) {
+    const has = (re) => changedFiles.some((f) => re.test(f));
+    return {
+        web: has(/^(app|pages|components|src)\/.*\.(ts|tsx|js|jsx)$/) || has(/^next\.config\./),
+        api: has(/^(app\/api|src\/api|api|server)\//),
+        infra: has(/^(infra|terraform|iac|k8s|helm|cloudbuild|\.github\/workflows)\//),
+        mobileIos: has(/^(ios|.*\.xcodeproj|.*\.xcworkspace|.*Info\.plist|Podfile)/),
+        mobileAndroid: has(/^(android|.*\/AndroidManifest\.xml|.*\/build\.gradle(\.kts)?|gradle\.properties)/),
+        ai: has(/^(ai|llm|prompt|rag|agents)\//) || has(/(openai|anthropic|vertexai|langchain|llamaindex)/)
+    };
+}

package/dist/gate/policy.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { getChangedFiles } from "./diff.js";
+import { detectSurfaces } from "./findings.js";
+import { checkRequiredArtifacts } from "./checks/required-artifacts.js";
+import { checkSecrets } from "./checks/secrets.js";
+import { checkDependencies } from "./checks/dependencies.js";
+import { checkWebNextjs } from "./checks/web-nextjs.js";
+import { checkApi } from "./checks/api.js";
+import { checkInfra } from "./checks/infra.js";
+import { checkMobileIos } from "./checks/mobile-ios.js";
+import { checkMobileAndroid } from "./checks/mobile-android.js";
+import { checkAi } from "./checks/ai.js";
+import { readFileSafe } from "../repo/fs.js";
+const PolicySchema = z.object({
+    name: z.string(),
+    version: z.string(),
+    artifacts_required: z
+        .array(z.object({
+        pattern: z.string(),
+        on_changes: z.array(z.string())
+    }))
+        .default([]),
+    required_checks: z.record(z.any()).default({}),
+    requirements: z
+        .array(z.object({
+        id: z.string(),
+        type: z.enum(["gate", "control"]).default("gate"),
+        evidence: z.array(z.string()).default([])
+    }))
+        .default([])
+});
+export async function loadPolicy(policyPath) {
+    const raw = await readFileSafe(policyPath);
+    const parsed = JSON.parse(raw);
+    return PolicySchema.parse(parsed);
+}
+export async function runPrGate(opts) {
+    const policy = await loadPolicy(opts.policyPath);
+    const changedFiles = await getChangedFiles({
+        baseRef: opts.baseRef ?? "origin/main",
+        headRef: opts.headRef ?? "HEAD"
+    });
+    const surfaces = detectSurfaces(changedFiles);
+    const findings = [
+        // Required artifacts first: threat models/checklists.
+        ...(await checkRequiredArtifacts({ policy, changedFiles })),
+        // Baseline scans / checks
+        ...(await checkSecrets({ changedFiles })),
+        ...(await checkDependencies({ changedFiles })),
+        // Surface-specific checks (only run if that surface is impacted or exists)
+        ...(surfaces.web ? await checkWebNextjs({ changedFiles }) : []),
+        ...(surfaces.api ? await checkApi({ changedFiles }) : []),
+        ...(surfaces.infra ? await checkInfra({ changedFiles }) : []),
+        ...(surfaces.mobileIos ? await checkMobileIos({ changedFiles }) : []),
+        ...(surfaces.mobileAndroid ? await checkMobileAndroid({ changedFiles }) : []),
+        ...(surfaces.ai ? await checkAi({ changedFiles }) : [])
+    ];
+    const status = findings.some((f) => f.severity === "HIGH" || f.severity === "CRITICAL")
+        ? "FAIL"
+        : "PASS";
+    return {
+        status,
+        policyVersion: policy.version,
+        evaluatedAt: new Date().toISOString(),
+        scope: { changedFiles, surfaces },
+        findings
+    };
+}

package/dist/gate/result.js

@@ -0,0 +1 @@
+export {};