seo-gravity-mcp 1.3.1 → 1.3.3

package/README.md

@@ -1,4 +1,4 @@
-# 🚀 SEO Gravity (v1.3.1)
+# 🚀 SEO Gravity (v1.3.3)
 
 <div align="center">
 

package/dist/adapters/adapterRegistry.d.ts

@@ -1,5 +1,6 @@
 import { FrameworkAdapter } from './types.js';
 export declare class AdapterRegistry {
+    private unknownAdapter;
     private adapters;
     getAdapterForProject(projectDir: string): FrameworkAdapter;
     getAdapterById(id: string): FrameworkAdapter | undefined;

package/dist/adapters/adapterRegistry.js

@@ -15,7 +15,9 @@ import { PhpClassicAdapter } from './phpClassicAdapter.js';
 import { SsgAdapter } from './ssgAdapter.js';
 import { ViteReactAdapter } from './viteReactAdapter.js';
 import { StaticAdapter } from './staticAdapter.js';
+import { UnknownAdapter } from './unknownAdapter.js';
 export class AdapterRegistry {
+    unknownAdapter = new UnknownAdapter();
     adapters = [
         // Specialized JS/TS Frameworks
         new NextAppAdapter(),
@@ -36,7 +38,7 @@ export class AdapterRegistry {
         // Static Site Generators & SPAs
         new SsgAdapter(),
         new ViteReactAdapter(),
-        // Universal Fallback
+        // Static HTML Sites
         new StaticAdapter()
     ];
     getAdapterForProject(projectDir) {
@@ -45,9 +47,11 @@ export class AdapterRegistry {
                 return adapter;
             }
         }
-        return this.adapters[this.adapters.length - 1]; // fallback static
+        return this.unknownAdapter;
     }
     getAdapterById(id) {
+        if (id === 'unknown')
+            return this.unknownAdapter;
         return this.adapters.find(a => a.id === id);
     }
     getAllAdapters() {

package/dist/adapters/staticAdapter.d.ts

@@ -3,7 +3,7 @@ import { DiscoveredRoute, ProjectFrameworkInfo, RouteSourceMapping } from '../ty
 export declare class StaticAdapter implements FrameworkAdapter {
     id: string;
     name: string;
-    detect(_projectDir: string): boolean;
+    detect(projectDir: string): boolean;
     getProjectInfo(projectDir: string): ProjectFrameworkInfo;
     discoverRoutes(projectDir: string): DiscoveredRoute[];
     mapRouteToSource(targetUrl: string, routes: DiscoveredRoute[]): RouteSourceMapping;

package/dist/adapters/staticAdapter.js

@@ -3,8 +3,9 @@ import * as path from 'path';
 export class StaticAdapter {
     id = 'static-html';
     name = 'Static HTML / Web Application';
-    detect(_projectDir) {
-        return true; // Fallback
+    detect(projectDir) {
+        return fs.existsSync(path.join(projectDir, 'index.html')) ||
+            fs.existsSync(path.join(projectDir, 'public/index.html'));
     }
     getProjectInfo(projectDir) {
         return {

package/dist/adapters/unknownAdapter.d.ts

@@ -0,0 +1,16 @@
+import { FrameworkAdapter, MetadataLocationInfo, CanonicalLocationInfo, SchemaLocationInfo } from './types.js';
+import { DiscoveredRoute, ProjectFrameworkInfo, RouteSourceMapping } from '../types/findings.js';
+export declare class UnknownAdapter implements FrameworkAdapter {
+    id: string;
+    name: string;
+    detect(_projectDir: string): boolean;
+    getProjectInfo(projectDir: string): ProjectFrameworkInfo;
+    discoverRoutes(_projectDir: string): DiscoveredRoute[];
+    mapRouteToSource(targetUrl: string, _routes: DiscoveredRoute[]): RouteSourceMapping;
+    findMetadataImplementation(_projectDir: string, _route: DiscoveredRoute): Promise<MetadataLocationInfo>;
+    findCanonicalDeclaration(_projectDir: string, _route: DiscoveredRoute): Promise<CanonicalLocationInfo>;
+    findSchemaDeclaration(_projectDir: string, _route: DiscoveredRoute): Promise<SchemaLocationInfo>;
+    findRobotsConfig(_projectDir: string): string | null;
+    findSitemapConfig(_projectDir: string): string | null;
+    findLlmsTxt(_projectDir: string): string | null;
+}

package/dist/adapters/unknownAdapter.js

@@ -0,0 +1,49 @@
+import * as path from 'path';
+export class UnknownAdapter {
+    id = 'unknown';
+    name = 'Unknown / Unrecognized Framework';
+    detect(_projectDir) {
+        return false;
+    }
+    getProjectInfo(projectDir) {
+        return {
+            framework: 'unknown',
+            name: path.basename(projectDir),
+            hasTypeScript: false,
+            hasSitemapConfig: false,
+            hasRobotsConfig: false,
+            hasLlmsTxt: false,
+            rootDir: path.resolve(projectDir),
+            routesDir: '.',
+            defaultDevPort: 3000
+        };
+    }
+    discoverRoutes(_projectDir) {
+        return [];
+    }
+    mapRouteToSource(targetUrl, _routes) {
+        return {
+            urlPath: targetUrl,
+            confidence: 0.0,
+            resolutionMethod: 'unmapped'
+        };
+    }
+    async findMetadataImplementation(_projectDir, _route) {
+        return { hasMetadata: false, type: 'none' };
+    }
+    async findCanonicalDeclaration(_projectDir, _route) {
+        return { hasCanonical: false, type: 'none' };
+    }
+    async findSchemaDeclaration(_projectDir, _route) {
+        return { hasSchema: false, typesFound: [] };
+    }
+    findRobotsConfig(_projectDir) {
+        return null;
+    }
+    findSitemapConfig(_projectDir) {
+        return null;
+    }
+    findLlmsTxt(_projectDir) {
+        return null;
+    }
+}

package/dist/benchmark/methodology.js

@@ -179,7 +179,7 @@ export function generateBenchmarkMethodologyReport() {
     }
     return {
         title: 'SEO Gravity Multi-Framework Correlation & Invariant Benchmark Methodology',
-        version: '1.3.1',
+        version: '1.3.3',
         evaluatedAt: new Date().toISOString(),
         definitionOfCorrelation: 'A correlation is defined as a verified mapping connecting an observed URL or Route Pattern to its exact physical source file, template, route configuration, and AST symbol coordinate range.',
         totalFrameworksTested: BENCHMARK_FIXTURES.length,

package/dist/cli.js

@@ -6,6 +6,7 @@ import { runDifferentialAudit } from './utils/gitDiffEngine.js';
 import { exportFindingsToSarif } from './utils/sarifExporter.js';
 import { PolicyLoader } from './policy/loader.js';
 import { formatPrCommentMarkdown } from './utils/prCommentFormatter.js';
+import { VERSION } from './version.js';
 export const EXIT_CODES = {
     PASS: 0,
     REGRESSION: 1,
@@ -57,7 +58,7 @@ async function runCli() {
                 }
                 else {
                     // Pretty format
-                    console.log(`\n🚀 SEO Gravity CLI (v1.3.1) — SEO Engineering Infrastructure\n`);
+                    console.log(`\n🚀 SEO Gravity CLI (v${VERSION}) — SEO Engineering Infrastructure\n`);
                     console.log(`Auditing project at: ${path.resolve(projectDir)}...`);
                     console.log(`Policy Profile: ${policy.profile}`);
                     console.log(`\n========================================`);
@@ -93,7 +94,7 @@ async function runCli() {
                     console.log(JSON.stringify(snap.snapshot, null, 2));
                 }
                 else {
-                    console.log(`\n🚀 SEO Gravity CLI (v1.3.1)\n`);
+                    console.log(`\n🚀 SEO Gravity CLI (v${VERSION})\n`);
                     console.log(`✅ Snapshot created and saved to: ${snap.savedToPath}`);
                     console.log(`Score: ${snap.snapshot.scores.overallHealth}/100 | Invariants: ${snap.snapshot.invariants?.length || 0}`);
                 }
@@ -105,7 +106,7 @@ async function runCli() {
                     console.error('❌ Configuration Error: --baseline <path_to_snapshot.json> is required for check command.');
                     process.exit(EXIT_CODES.CONFIG_ERROR);
                 }
-                const checkRes = await checkRegression(projectDir, baselinePath, baseUrl);
+                const checkRes = await checkRegression(projectDir, baselinePath, baseUrl, policy);
                 if (format === 'sarif') {
                     const sarif = exportFindingsToSarif(checkRes.regressionReport.newRegressions, projectDir);
                     const serialized = JSON.stringify(sarif, null, 2);

package/dist/index.d.ts

@@ -2,3 +2,4 @@
 export * from './server/types.js';
 export * from './server/registry.js';
 export * from './server/server.js';
+export * from './version.js';

package/dist/index.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import { startStdioServer } from './server/server.js';
+import { VERSION, PACKAGE_NAME } from './version.js';
 export * from './server/types.js';
 export * from './server/registry.js';
 export * from './server/server.js';
+export * from './version.js';
 // Start Stdio MCP Server
 startStdioServer({
-    name: 'seo-gravity-mcp',
-    version: '1.2.0'
+    name: PACKAGE_NAME,
+    version: VERSION
 }).catch((err) => {
     console.error('Fatal error starting SEO Gravity MCP Server:', err);
     process.exit(1);

package/dist/invariants/registry.js

@@ -49,8 +49,8 @@ export const BUILTIN_INVARIANTS = [
                     type: 'ast',
                     description: has ? 'Canonical declaration found in AST' : 'Canonical missing from source AST',
                     sourceFile: ctx.sourceFilePath,
-                    startLine: 1,
-                    endLine: 1,
+                    startLine: ctx.sourceRange?.startLine,
+                    endLine: ctx.sourceRange?.endLine,
                     timestamp: new Date().toISOString()
                 } : undefined
             };
@@ -69,7 +69,7 @@ export const BUILTIN_INVARIANTS = [
         remediationGuide: 'Export title in page metadata, define @section/block title, or add <title> in component head.',
         verificationMethod: 'Inspect page <title> in AST, template, or rendered DOM.',
         evaluate(ctx) {
-            const has = Boolean(ctx.hasMetadata || ctx.extractedTitle);
+            const has = ctx.hasTitle !== undefined ? ctx.hasTitle : Boolean(ctx.extractedTitle || ctx.hasMetadata);
             return {
                 satisfied: has,
                 observedCondition: has ? `Title present ("${ctx.extractedTitle || 'Declared'}")` : 'Title missing',
@@ -78,8 +78,8 @@ export const BUILTIN_INVARIANTS = [
                     type: 'ast',
                     description: has ? `Title metadata: "${ctx.extractedTitle || 'Declared'}"` : 'Title metadata missing',
                     sourceFile: ctx.sourceFilePath,
-                    startLine: 1,
-                    endLine: 1,
+                    startLine: ctx.sourceRange?.startLine,
+                    endLine: ctx.sourceRange?.endLine,
                     timestamp: new Date().toISOString()
                 } : undefined
             };

package/dist/invariants/types.d.ts

@@ -7,7 +7,13 @@ export interface InvariantEvaluationContext {
     url: string;
     logicalPageId: string;
     sourceFilePath?: string;
+    sourceRange?: {
+        startLine: number;
+        endLine: number;
+    };
     statusCode?: number;
+    hasTitle?: boolean;
+    hasDescription?: boolean;
     hasMetadata?: boolean;
     hasCanonical?: boolean;
     isIndexable?: boolean;

package/dist/policy/loader.d.ts

@@ -1,7 +1,132 @@
+import { z } from 'zod';
 import { PolicyConfig } from './types.js';
 import { InvariantDiffItem } from '../types/canonical.js';
+export declare const InvariantRuleSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    requirementLevel: z.ZodOptional<z.ZodEnum<["REQUIRED", "CONDITIONAL", "RECOMMENDED", "OPTIONAL"]>>;
+    severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "info"]>>;
+}, "strip", z.ZodTypeAny, {
+    requirementLevel?: "REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL" | undefined;
+    severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+    enabled?: boolean | undefined;
+}, {
+    requirementLevel?: "REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL" | undefined;
+    severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const RegressionPolicySchema: z.ZodObject<{
+    failOnLevels: z.ZodOptional<z.ZodArray<z.ZodEnum<["REQUIRED", "CONDITIONAL", "RECOMMENDED", "OPTIONAL"]>, "many">>;
+    failOnSeverities: z.ZodOptional<z.ZodArray<z.ZodEnum<["critical", "high", "medium", "low", "info"]>, "many">>;
+    allowExpectedChanges: z.ZodOptional<z.ZodBoolean>;
+    maxAllowedRegressions: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    allowExpectedChanges?: boolean | undefined;
+    failOnLevels?: ("REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL")[] | undefined;
+    failOnSeverities?: ("critical" | "high" | "medium" | "low" | "info")[] | undefined;
+    maxAllowedRegressions?: number | undefined;
+}, {
+    allowExpectedChanges?: boolean | undefined;
+    failOnLevels?: ("REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL")[] | undefined;
+    failOnSeverities?: ("critical" | "high" | "medium" | "low" | "info")[] | undefined;
+    maxAllowedRegressions?: number | undefined;
+}>;
+export declare const PolicyConfigSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    profile: z.ZodOptional<z.ZodEnum<["strict", "balanced", "startup", "ecommerce", "documentation", "custom"]>>;
+    regression: z.ZodOptional<z.ZodObject<{
+        failOnLevels: z.ZodOptional<z.ZodArray<z.ZodEnum<["REQUIRED", "CONDITIONAL", "RECOMMENDED", "OPTIONAL"]>, "many">>;
+        failOnSeverities: z.ZodOptional<z.ZodArray<z.ZodEnum<["critical", "high", "medium", "low", "info"]>, "many">>;
+        allowExpectedChanges: z.ZodOptional<z.ZodBoolean>;
+        maxAllowedRegressions: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        allowExpectedChanges?: boolean | undefined;
+        failOnLevels?: ("REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL")[] | undefined;
+        failOnSeverities?: ("critical" | "high" | "medium" | "low" | "info")[] | undefined;
+        maxAllowedRegressions?: number | undefined;
+    }, {
+        allowExpectedChanges?: boolean | undefined;
+        failOnLevels?: ("REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL")[] | undefined;
+        failOnSeverities?: ("critical" | "high" | "medium" | "low" | "info")[] | undefined;
+        maxAllowedRegressions?: number | undefined;
+    }>>;
+    invariants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        requirementLevel: z.ZodOptional<z.ZodEnum<["REQUIRED", "CONDITIONAL", "RECOMMENDED", "OPTIONAL"]>>;
+        severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "info"]>>;
+    }, "strip", z.ZodTypeAny, {
+        requirementLevel?: "REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL" | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        enabled?: boolean | undefined;
+    }, {
+        requirementLevel?: "REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL" | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        enabled?: boolean | undefined;
+    }>>>;
+    policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    framework: z.ZodOptional<z.ZodObject<{
+        adapter: z.ZodOptional<z.ZodString>;
+        force: z.ZodOptional<z.ZodBoolean>;
+        entrypoint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        adapter?: string | undefined;
+        force?: boolean | undefined;
+        entrypoint?: string | undefined;
+    }, {
+        adapter?: string | undefined;
+        force?: boolean | undefined;
+        entrypoint?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    framework?: {
+        adapter?: string | undefined;
+        force?: boolean | undefined;
+        entrypoint?: string | undefined;
+    } | undefined;
+    invariants?: Record<string, {
+        requirementLevel?: "REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL" | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        enabled?: boolean | undefined;
+    }> | undefined;
+    version?: string | number | undefined;
+    profile?: "strict" | "balanced" | "startup" | "ecommerce" | "documentation" | "custom" | undefined;
+    regression?: {
+        allowExpectedChanges?: boolean | undefined;
+        failOnLevels?: ("REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL")[] | undefined;
+        failOnSeverities?: ("critical" | "high" | "medium" | "low" | "info")[] | undefined;
+        maxAllowedRegressions?: number | undefined;
+    } | undefined;
+    policy?: Record<string, any> | undefined;
+}, {
+    framework?: {
+        adapter?: string | undefined;
+        force?: boolean | undefined;
+        entrypoint?: string | undefined;
+    } | undefined;
+    invariants?: Record<string, {
+        requirementLevel?: "REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL" | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        enabled?: boolean | undefined;
+    }> | undefined;
+    version?: string | number | undefined;
+    profile?: "strict" | "balanced" | "startup" | "ecommerce" | "documentation" | "custom" | undefined;
+    regression?: {
+        allowExpectedChanges?: boolean | undefined;
+        failOnLevels?: ("REQUIRED" | "CONDITIONAL" | "RECOMMENDED" | "OPTIONAL")[] | undefined;
+        failOnSeverities?: ("critical" | "high" | "medium" | "low" | "info")[] | undefined;
+        maxAllowedRegressions?: number | undefined;
+    } | undefined;
+    policy?: Record<string, any> | undefined;
+}>;
 export declare class PolicyLoader {
     static resolvePolicy(projectDir?: string, explicitPath?: string): PolicyConfig;
-    private static parseConfigFile;
+    static parseConfigFile(filePath: string): any;
+    static parseYaml(content: string): Record<string, any>;
     static isRegressionBreachingPolicy(diff: InvariantDiffItem, policy: PolicyConfig): boolean;
+    static evaluatePolicyGate(diffs: InvariantDiffItem[], policy: PolicyConfig): {
+        pass: boolean;
+        breachingDiffs: InvariantDiffItem[];
+        totalBreaches: number;
+        maxAllowed: number;
+        verdict: string;
+    };
 }

package/dist/policy/loader.js

@@ -1,6 +1,31 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import * as YAML from 'yaml';
+import { z } from 'zod';
 import { BUILTIN_PROFILES } from './profiles.js';
+export const InvariantRuleSchema = z.object({
+    enabled: z.boolean().optional(),
+    requirementLevel: z.enum(['REQUIRED', 'CONDITIONAL', 'RECOMMENDED', 'OPTIONAL']).optional(),
+    severity: z.enum(['critical', 'high', 'medium', 'low', 'info']).optional()
+});
+export const RegressionPolicySchema = z.object({
+    failOnLevels: z.array(z.enum(['REQUIRED', 'CONDITIONAL', 'RECOMMENDED', 'OPTIONAL'])).optional(),
+    failOnSeverities: z.array(z.enum(['critical', 'high', 'medium', 'low', 'info'])).optional(),
+    allowExpectedChanges: z.boolean().optional(),
+    maxAllowedRegressions: z.number().int().min(0).optional()
+});
+export const PolicyConfigSchema = z.object({
+    version: z.union([z.number(), z.string()]).optional(),
+    profile: z.enum(['strict', 'balanced', 'startup', 'ecommerce', 'documentation', 'custom']).optional(),
+    regression: RegressionPolicySchema.optional(),
+    invariants: z.record(InvariantRuleSchema).optional(),
+    policy: z.record(z.any()).optional(),
+    framework: z.object({
+        adapter: z.string().optional(),
+        force: z.boolean().optional(),
+        entrypoint: z.string().optional()
+    }).optional()
+});
 export class PolicyLoader {
     static resolvePolicy(projectDir = '.', explicitPath) {
         let rawConfig = null;
@@ -27,18 +52,39 @@ export class PolicyLoader {
         if (!rawConfig) {
             return baseProfile;
         }
-        // Merge overrides
+        // Normalize snake_case regression options to camelCase
+        const rawReg = rawConfig.regression || {};
+        const normalizedRegression = {
+            ...baseProfile.regression,
+            failOnLevels: rawReg.failOnLevels || rawReg.fail_on_levels || baseProfile.regression?.failOnLevels,
+            failOnSeverities: rawReg.failOnSeverities || rawReg.fail_on_severities || baseProfile.regression?.failOnSeverities,
+            allowExpectedChanges: rawReg.allowExpectedChanges ?? rawReg.allow_expected_changes ?? baseProfile.regression?.allowExpectedChanges,
+            maxAllowedRegressions: rawReg.maxAllowedRegressions ?? rawReg.max_allowed_regressions ?? baseProfile.regression?.maxAllowedRegressions
+        };
+        // Normalize invariant policy overrides
+        const mergedInvariants = {
+            ...baseProfile.invariants,
+            ...(rawConfig.invariants || {})
+        };
+        // Support convenient high-level policy shortcuts (e.g. policy: { canonical: required, sitemap: recommended })
+        const rawPolicy = rawConfig.policy || {};
+        if (rawPolicy.canonical) {
+            const lvl = String(rawPolicy.canonical).toUpperCase();
+            mergedInvariants['INV-CANONICAL-RESOLVES'] = { requirementLevel: lvl, severity: 'high', enabled: true };
+        }
+        if (rawPolicy.sitemap) {
+            const lvl = String(rawPolicy.sitemap).toUpperCase();
+            mergedInvariants['INV-SITEMAP-PRESENT'] = { requirementLevel: lvl, severity: 'medium', enabled: true };
+        }
+        if (rawPolicy.llms_txt || rawPolicy.llmsTxt) {
+            const lvl = String(rawPolicy.llms_txt || rawPolicy.llmsTxt).toUpperCase();
+            mergedInvariants['INV-LLMS-TXT'] = { requirementLevel: lvl, severity: 'low', enabled: true };
+        }
         const merged = {
             version: rawConfig.version || baseProfile.version,
             profile: baseProfileName,
-            regression: {
-                ...baseProfile.regression,
-                ...rawConfig.regression
-            },
-            invariants: {
-                ...baseProfile.invariants,
-                ...rawConfig.invariants
-            },
+            regression: normalizedRegression,
+            invariants: mergedInvariants,
             framework: rawConfig.framework
         };
         return merged;
@@ -49,29 +95,30 @@ export class PolicyLoader {
             if (filePath.endsWith('.json')) {
                 return JSON.parse(content);
             }
-            // Basic YAML key-value parser for simple .seo-gravity.yml
-            const parsed = { profile: 'balanced', invariants: {}, regression: {} };
-            const lines = content.split('\n');
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith('#'))
-                    continue;
-                if (trimmed.startsWith('profile:')) {
-                    parsed.profile = trimmed.split(':')[1].trim().replace(/['"]/g, '');
-                }
-            }
-            return parsed;
+            return this.parseYaml(content);
         }
         catch {
             return null;
         }
     }
+    static parseYaml(content) {
+        try {
+            const parsed = YAML.parse(content);
+            return (typeof parsed === 'object' && parsed !== null) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
     static isRegressionBreachingPolicy(diff, policy) {
+        if (diff.status === 'EXPECTED_CHANGE') {
+            return policy.regression?.allowExpectedChanges === false;
+        }
         if (diff.status !== 'NEW_REGRESSION')
             return false;
         const invOverride = policy.invariants?.[diff.invariantId];
         if (invOverride && invOverride.enabled === false) {
-            return false; // Disabled by project policy
+            return false; // Explicitly disabled by project policy
         }
         const level = invOverride?.requirementLevel || diff.requirementLevel || 'REQUIRED';
         const severity = invOverride?.severity || diff.severity || 'high';
@@ -81,4 +128,20 @@ export class PolicyLoader {
         const severityBreached = failSeverities.includes(severity);
         return levelBreached && severityBreached;
     }
+    static evaluatePolicyGate(diffs, policy) {
+        const breachingDiffs = diffs.filter(d => this.isRegressionBreachingPolicy(d, policy));
+        const totalBreaches = breachingDiffs.length;
+        const maxAllowed = policy.regression?.maxAllowedRegressions ?? 0;
+        const pass = totalBreaches <= maxAllowed;
+        const verdict = pass
+            ? `✅ PASSED (Policy: ${policy.profile}): ${totalBreaches} breach(es) within allowed threshold (max: ${maxAllowed}).`
+            : `🚨 FAILED (Policy: ${policy.profile}): ${totalBreaches} invariant regression(s) breached policy (max allowed: ${maxAllowed}).`;
+        return {
+            pass,
+            breachingDiffs,
+            totalBreaches,
+            maxAllowed,
+            verdict
+        };
+    }
 }

package/dist/server/server.js

@@ -2,10 +2,11 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { TOOLS, executeTool } from './registry.js';
+import { VERSION, PACKAGE_NAME } from '../version.js';
 export function createMcpServer(options = {}) {
     const server = new Server({
-        name: options.name || 'seo-gravity-mcp',
-        version: options.version || '1.2.0'
+        name: options.name || PACKAGE_NAME,
+        version: options.version || VERSION
     }, {
         capabilities: {
             tools: {}