@probelabs/visor 0.1.74 → 0.1.76

package/dist/sdk/sdk.js

@@ -259,7 +259,7 @@ ${content}
        * Sleep utility
        */
       sleep(ms) {
-        return new Promise((resolve2) => setTimeout(resolve2, ms));
+        return new Promise((resolve3) => setTimeout(resolve3, ms));
       }
       /**
        * Group results by specified criteria
@@ -1448,7 +1448,7 @@ $ ${cliCommand}
        * Generate mock response for testing
        */
       async generateMockResponse(_prompt) {
-        await new Promise((resolve2) => setTimeout(resolve2, 500));
+        await new Promise((resolve3) => setTimeout(resolve3, 500));
         const mockResponse = {
           content: JSON.stringify({
             issues: [
@@ -6049,7 +6049,7 @@ var init_check_execution_engine = __esm({
         }
       }
       async sleep(ms) {
-        return new Promise((resolve2) => setTimeout(resolve2, ms));
+        return new Promise((resolve3) => setTimeout(resolve3, ms));
       }
       deterministicJitter(baseMs, seedStr) {
         let h = 2166136261;
@@ -7252,6 +7252,27 @@ ${expr}
                   dependencyResults.set(depId, depResult);
                 }
               }
+              const directDeps = checkConfig.depends_on || [];
+              const failedDeps = [];
+              for (const depId of directDeps) {
+                const depRes = results.get(depId);
+                if (!depRes) continue;
+                const hasFatalCommandFailure = (depRes.issues || []).some((issue) => {
+                  const id = issue.ruleId || "";
+                  return id.endsWith("/command/execution_error") || id.endsWith("/command/transform_js_error") || id.endsWith("/command/transform_error");
+                });
+                if (hasFatalCommandFailure) failedDeps.push(depId);
+              }
+              if (failedDeps.length > 0) {
+                this.recordSkip(checkName, "dependency_failed");
+                logger.info(`\u23ED  Skipped (dependency failed: ${failedDeps.join(", ")})`);
+                return {
+                  checkName,
+                  error: null,
+                  result: { issues: [] },
+                  skipped: true
+                };
+              }
               for (const depId of checkConfig.depends_on || []) {
                 if (results.has(depId)) {
                   const depResult = results.get(depId);
@@ -9085,6 +9106,994 @@ var init_config_merger = __esm({
   }
 });
 
+// src/generated/config-schema.ts
+var config_schema_exports = {};
+__export(config_schema_exports, {
+  configSchema: () => configSchema,
+  default: () => config_schema_default
+});
+var configSchema, config_schema_default;
+var init_config_schema = __esm({
+  "src/generated/config-schema.ts"() {
+    "use strict";
+    configSchema = {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "$ref": "#/definitions/VisorConfig",
+      "definitions": {
+        "VisorConfig": {
+          "type": "object",
+          "properties": {
+            "version": {
+              "type": "string",
+              "description": "Configuration version"
+            },
+            "extends": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              ],
+              "description": 'Extends from other configurations - can be file path, HTTP(S) URL, or "default"'
+            },
+            "checks": {
+              "$ref": "#/definitions/Record%3Cstring%2CCheckConfig%3E",
+              "description": "Check configurations"
+            },
+            "output": {
+              "$ref": "#/definitions/OutputConfig",
+              "description": "Output configuration"
+            },
+            "http_server": {
+              "$ref": "#/definitions/HttpServerConfig",
+              "description": "HTTP server configuration for receiving webhooks"
+            },
+            "env": {
+              "$ref": "#/definitions/EnvConfig",
+              "description": "Global environment variables"
+            },
+            "ai_model": {
+              "type": "string",
+              "description": "Global AI model setting"
+            },
+            "ai_provider": {
+              "type": "string",
+              "description": "Global AI provider setting"
+            },
+            "ai_mcp_servers": {
+              "$ref": "#/definitions/Record%3Cstring%2CMcpServerConfig%3E",
+              "description": "Global MCP servers configuration for AI checks"
+            },
+            "max_parallelism": {
+              "type": "number",
+              "description": "Maximum number of checks to run in parallel (default: 3)"
+            },
+            "fail_fast": {
+              "type": "boolean",
+              "description": "Stop execution when any check fails (default: false)"
+            },
+            "fail_if": {
+              "type": "string",
+              "description": "Simple global fail condition - fails if expression evaluates to true"
+            },
+            "failure_conditions": {
+              "$ref": "#/definitions/FailureConditions",
+              "description": "Global failure conditions - optional (deprecated, use fail_if)"
+            },
+            "tag_filter": {
+              "$ref": "#/definitions/TagFilter",
+              "description": "Tag filter for selective check execution"
+            },
+            "routing": {
+              "$ref": "#/definitions/RoutingDefaults",
+              "description": "Optional routing defaults for retry/goto/run policies"
+            }
+          },
+          "required": [
+            "version",
+            "checks",
+            "output"
+          ],
+          "additionalProperties": false,
+          "description": "Main Visor configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "Record<string,CheckConfig>": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/CheckConfig"
+          }
+        },
+        "CheckConfig": {
+          "type": "object",
+          "properties": {
+            "type": {
+              "$ref": "#/definitions/ConfigCheckType",
+              "description": "Type of check to perform (defaults to 'ai' if not specified)"
+            },
+            "prompt": {
+              "type": "string",
+              "description": "AI prompt for the check - can be inline string or file path (auto-detected) - required for AI checks"
+            },
+            "appendPrompt": {
+              "type": "string",
+              "description": "Additional prompt to append when extending configurations - merged with parent prompt"
+            },
+            "exec": {
+              "type": "string",
+              "description": "Command execution with Liquid template support - required for command checks"
+            },
+            "stdin": {
+              "type": "string",
+              "description": "Stdin input for tools with Liquid template support - optional for tool checks"
+            },
+            "url": {
+              "type": "string",
+              "description": "HTTP URL - required for http output checks"
+            },
+            "body": {
+              "type": "string",
+              "description": "HTTP body template (Liquid) - required for http output checks"
+            },
+            "method": {
+              "type": "string",
+              "description": "HTTP method (defaults to POST)"
+            },
+            "headers": {
+              "$ref": "#/definitions/Record%3Cstring%2Cstring%3E",
+              "description": "HTTP headers"
+            },
+            "endpoint": {
+              "type": "string",
+              "description": "HTTP endpoint path - required for http_input checks"
+            },
+            "transform": {
+              "type": "string",
+              "description": "Transform template for http_input data (Liquid) - optional"
+            },
+            "transform_js": {
+              "type": "string",
+              "description": "Transform using JavaScript expressions (evaluated in secure sandbox) - optional"
+            },
+            "schedule": {
+              "type": "string",
+              "description": 'Cron schedule expression (e.g., "0 2 * * *") - optional for any check type'
+            },
+            "focus": {
+              "type": "string",
+              "description": "Focus area for the check (security/performance/style/architecture/all) - optional"
+            },
+            "command": {
+              "type": "string",
+              "description": 'Command that triggers this check (e.g., "review", "security-scan") - optional'
+            },
+            "on": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/EventTrigger"
+              },
+              "description": "Events that trigger this check (defaults to ['manual'] if not specified)"
+            },
+            "triggers": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "File patterns that trigger this check (optional)"
+            },
+            "ai": {
+              "$ref": "#/definitions/AIProviderConfig",
+              "description": "AI provider configuration (optional)"
+            },
+            "ai_model": {
+              "type": "string",
+              "description": "AI model to use for this check - overrides global setting"
+            },
+            "ai_provider": {
+              "type": "string",
+              "description": "AI provider to use for this check - overrides global setting"
+            },
+            "ai_mcp_servers": {
+              "$ref": "#/definitions/Record%3Cstring%2CMcpServerConfig%3E",
+              "description": "MCP servers for this AI check - overrides global setting"
+            },
+            "claude_code": {
+              "$ref": "#/definitions/ClaudeCodeConfig",
+              "description": "Claude Code configuration (for claude-code type checks)"
+            },
+            "env": {
+              "$ref": "#/definitions/EnvConfig",
+              "description": "Environment variables for this check"
+            },
+            "depends_on": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Check IDs that this check depends on (optional)"
+            },
+            "group": {
+              "type": "string",
+              "description": 'Group name for comment separation (e.g., "code-review", "pr-overview") - optional'
+            },
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "$ref": "#/definitions/Record%3Cstring%2Cunknown%3E"
+                }
+              ],
+              "description": 'Schema type for template rendering (e.g., "code-review", "markdown") or inline JSON schema object - optional'
+            },
+            "template": {
+              "$ref": "#/definitions/CustomTemplateConfig",
+              "description": "Custom template configuration - optional"
+            },
+            "if": {
+              "type": "string",
+              "description": "Condition to determine if check should run - runs if expression evaluates to true"
+            },
+            "reuse_ai_session": {
+              "type": "boolean",
+              "description": "Whether to reuse AI session from dependency checks (only works with depends_on)"
+            },
+            "fail_if": {
+              "type": "string",
+              "description": "Simple fail condition - fails check if expression evaluates to true"
+            },
+            "failure_conditions": {
+              "$ref": "#/definitions/FailureConditions",
+              "description": "Check-specific failure conditions - optional (deprecated, use fail_if)"
+            },
+            "tags": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": 'Tags for categorizing and filtering checks (e.g., ["local", "fast", "security"])'
+            },
+            "forEach": {
+              "type": "boolean",
+              "description": "Process output as array and run dependent checks for each item"
+            },
+            "on_fail": {
+              "$ref": "#/definitions/OnFailConfig",
+              "description": "Failure routing configuration for this check (retry/goto/run)"
+            },
+            "on_success": {
+              "$ref": "#/definitions/OnSuccessConfig",
+              "description": "Success routing configuration for this check (post-actions and optional goto)"
+            }
+          },
+          "additionalProperties": false,
+          "description": "Configuration for a single check",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "ConfigCheckType": {
+          "type": "string",
+          "enum": [
+            "ai",
+            "command",
+            "http",
+            "http_input",
+            "http_client",
+            "noop",
+            "log",
+            "claude-code"
+          ],
+          "description": "Valid check types in configuration"
+        },
+        "Record<string,string>": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "EventTrigger": {
+          "type": "string",
+          "enum": [
+            "pr_opened",
+            "pr_updated",
+            "pr_closed",
+            "issue_opened",
+            "issue_comment",
+            "manual",
+            "schedule",
+            "webhook_received"
+          ],
+          "description": "Valid event triggers for checks"
+        },
+        "AIProviderConfig": {
+          "type": "object",
+          "properties": {
+            "provider": {
+              "type": "string",
+              "enum": [
+                "google",
+                "anthropic",
+                "openai",
+                "bedrock",
+                "mock"
+              ],
+              "description": "AI provider to use"
+            },
+            "model": {
+              "type": "string",
+              "description": "Model name to use"
+            },
+            "apiKey": {
+              "type": "string",
+              "description": "API key (usually from environment variables)"
+            },
+            "timeout": {
+              "type": "number",
+              "description": "Request timeout in milliseconds"
+            },
+            "debug": {
+              "type": "boolean",
+              "description": "Enable debug mode"
+            },
+            "mcpServers": {
+              "$ref": "#/definitions/Record%3Cstring%2CMcpServerConfig%3E",
+              "description": "MCP servers configuration"
+            }
+          },
+          "additionalProperties": false,
+          "description": "AI provider configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "Record<string,McpServerConfig>": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/McpServerConfig"
+          }
+        },
+        "McpServerConfig": {
+          "type": "object",
+          "properties": {
+            "command": {
+              "type": "string",
+              "description": "Command to execute for the MCP server"
+            },
+            "args": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Arguments to pass to the command"
+            },
+            "env": {
+              "$ref": "#/definitions/Record%3Cstring%2Cstring%3E",
+              "description": "Environment variables for the MCP server"
+            }
+          },
+          "required": [
+            "command"
+          ],
+          "additionalProperties": false,
+          "description": "MCP Server configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "ClaudeCodeConfig": {
+          "type": "object",
+          "properties": {
+            "allowedTools": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "List of allowed tools for Claude Code to use"
+            },
+            "maxTurns": {
+              "type": "number",
+              "description": "Maximum number of turns in conversation"
+            },
+            "systemPrompt": {
+              "type": "string",
+              "description": "System prompt for Claude Code"
+            },
+            "mcpServers": {
+              "$ref": "#/definitions/Record%3Cstring%2CMcpServerConfig%3E",
+              "description": "MCP servers configuration"
+            },
+            "subagent": {
+              "type": "string",
+              "description": "Path to subagent script"
+            },
+            "hooks": {
+              "type": "object",
+              "properties": {
+                "onStart": {
+                  "type": "string",
+                  "description": "Called when check starts"
+                },
+                "onEnd": {
+                  "type": "string",
+                  "description": "Called when check ends"
+                },
+                "onError": {
+                  "type": "string",
+                  "description": "Called when check encounters an error"
+                }
+              },
+              "additionalProperties": false,
+              "description": "Event hooks for lifecycle management",
+              "patternProperties": {
+                "^x-": {}
+              }
+            }
+          },
+          "additionalProperties": false,
+          "description": "Claude Code configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "EnvConfig": {
+          "type": "object",
+          "additionalProperties": {
+            "type": [
+              "string",
+              "number",
+              "boolean"
+            ]
+          },
+          "description": "Environment variable reference configuration"
+        },
+        "Record<string,unknown>": {
+          "type": "object",
+          "additionalProperties": {}
+        },
+        "CustomTemplateConfig": {
+          "type": "object",
+          "properties": {
+            "file": {
+              "type": "string",
+              "description": "Path to custom template file (relative to config file or absolute)"
+            },
+            "content": {
+              "type": "string",
+              "description": "Raw template content as string"
+            }
+          },
+          "additionalProperties": false,
+          "description": "Custom template configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "FailureConditions": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/FailureCondition"
+          },
+          "description": "Collection of failure conditions"
+        },
+        "FailureCondition": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SimpleFailureCondition"
+            },
+            {
+              "$ref": "#/definitions/ComplexFailureCondition"
+            }
+          ],
+          "description": "Failure condition - can be a simple expression string or complex object"
+        },
+        "SimpleFailureCondition": {
+          "type": "string",
+          "description": "Simple failure condition - just an expression string"
+        },
+        "ComplexFailureCondition": {
+          "type": "object",
+          "properties": {
+            "condition": {
+              "type": "string",
+              "description": "Expression to evaluate using Function Constructor"
+            },
+            "message": {
+              "type": "string",
+              "description": "Human-readable message when condition is met"
+            },
+            "severity": {
+              "$ref": "#/definitions/FailureConditionSeverity",
+              "description": "Severity level of the failure"
+            },
+            "halt_execution": {
+              "type": "boolean",
+              "description": "Whether this condition should halt execution"
+            }
+          },
+          "required": [
+            "condition"
+          ],
+          "additionalProperties": false,
+          "description": "Complex failure condition with additional metadata",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "FailureConditionSeverity": {
+          "type": "string",
+          "enum": [
+            "error",
+            "warning",
+            "info"
+          ],
+          "description": "Failure condition severity levels"
+        },
+        "OnFailConfig": {
+          "type": "object",
+          "properties": {
+            "retry": {
+              "$ref": "#/definitions/RetryPolicy",
+              "description": "Retry policy"
+            },
+            "run": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Remediation steps to run before reattempt"
+            },
+            "goto": {
+              "type": "string",
+              "description": "Jump back to an ancestor step (by id)"
+            },
+            "goto_js": {
+              "type": "string",
+              "description": "Dynamic goto: JS expression returning step id or null"
+            },
+            "run_js": {
+              "type": "string",
+              "description": "Dynamic remediation list: JS expression returning string[]"
+            }
+          },
+          "additionalProperties": false,
+          "description": "Failure routing configuration per check",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "RetryPolicy": {
+          "type": "object",
+          "properties": {
+            "max": {
+              "type": "number",
+              "description": "Maximum retry attempts (excluding the first attempt)"
+            },
+            "backoff": {
+              "$ref": "#/definitions/BackoffPolicy",
+              "description": "Backoff policy"
+            }
+          },
+          "additionalProperties": false,
+          "description": "Retry policy for a step",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "BackoffPolicy": {
+          "type": "object",
+          "properties": {
+            "mode": {
+              "type": "string",
+              "enum": [
+                "fixed",
+                "exponential"
+              ],
+              "description": "Backoff mode"
+            },
+            "delay_ms": {
+              "type": "number",
+              "description": "Initial delay in milliseconds"
+            }
+          },
+          "additionalProperties": false,
+          "description": "Backoff policy for retries",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "OnSuccessConfig": {
+          "type": "object",
+          "properties": {
+            "run": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Post-success steps to run"
+            },
+            "goto": {
+              "type": "string",
+              "description": "Optional jump back to ancestor step (by id)"
+            },
+            "goto_js": {
+              "type": "string",
+              "description": "Dynamic goto: JS expression returning step id or null"
+            },
+            "run_js": {
+              "type": "string",
+              "description": "Dynamic post-success steps: JS expression returning string[]"
+            }
+          },
+          "additionalProperties": false,
+          "description": "Success routing configuration per check",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "OutputConfig": {
+          "type": "object",
+          "properties": {
+            "pr_comment": {
+              "$ref": "#/definitions/PrCommentOutput",
+              "description": "PR comment configuration"
+            },
+            "file_comment": {
+              "$ref": "#/definitions/FileCommentOutput",
+              "description": "File comment configuration (optional)"
+            },
+            "github_checks": {
+              "$ref": "#/definitions/GitHubCheckOutput",
+              "description": "GitHub check runs configuration (optional)"
+            },
+            "suppressionEnabled": {
+              "type": "boolean",
+              "description": "Whether to enable issue suppression via visor-disable comments (default: true)"
+            }
+          },
+          "required": [
+            "pr_comment"
+          ],
+          "additionalProperties": false,
+          "description": "Output configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "PrCommentOutput": {
+          "type": "object",
+          "properties": {
+            "format": {
+              "$ref": "#/definitions/ConfigOutputFormat",
+              "description": "Format of the output"
+            },
+            "group_by": {
+              "$ref": "#/definitions/GroupByOption",
+              "description": "How to group the results"
+            },
+            "collapse": {
+              "type": "boolean",
+              "description": "Whether to collapse sections by default"
+            },
+            "debug": {
+              "$ref": "#/definitions/DebugConfig",
+              "description": "Debug mode configuration (optional)"
+            }
+          },
+          "required": [
+            "format",
+            "group_by",
+            "collapse"
+          ],
+          "additionalProperties": false,
+          "description": "PR comment output configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "ConfigOutputFormat": {
+          "type": "string",
+          "enum": [
+            "table",
+            "json",
+            "markdown",
+            "sarif"
+          ],
+          "description": "Valid output formats"
+        },
+        "GroupByOption": {
+          "type": "string",
+          "enum": [
+            "check",
+            "file",
+            "severity"
+          ],
+          "description": "Valid grouping options"
+        },
+        "DebugConfig": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Enable debug mode"
+            },
+            "includePrompts": {
+              "type": "boolean",
+              "description": "Include AI prompts in debug output"
+            },
+            "includeRawResponses": {
+              "type": "boolean",
+              "description": "Include raw AI responses in debug output"
+            },
+            "includeTiming": {
+              "type": "boolean",
+              "description": "Include timing information"
+            },
+            "includeProviderInfo": {
+              "type": "boolean",
+              "description": "Include provider information"
+            }
+          },
+          "required": [
+            "enabled",
+            "includePrompts",
+            "includeRawResponses",
+            "includeTiming",
+            "includeProviderInfo"
+          ],
+          "additionalProperties": false,
+          "description": "Debug mode configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "FileCommentOutput": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Whether file comments are enabled"
+            },
+            "inline": {
+              "type": "boolean",
+              "description": "Whether to show inline comments"
+            }
+          },
+          "required": [
+            "enabled",
+            "inline"
+          ],
+          "additionalProperties": false,
+          "description": "File comment output configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "GitHubCheckOutput": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Whether GitHub check runs are enabled"
+            },
+            "per_check": {
+              "type": "boolean",
+              "description": "Whether to create individual check runs per configured check"
+            },
+            "name_prefix": {
+              "type": "string",
+              "description": "Custom name prefix for check runs"
+            }
+          },
+          "required": [
+            "enabled",
+            "per_check"
+          ],
+          "additionalProperties": false,
+          "description": "GitHub Check Runs output configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "HttpServerConfig": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Whether HTTP server is enabled"
+            },
+            "port": {
+              "type": "number",
+              "description": "Port to listen on"
+            },
+            "host": {
+              "type": "string",
+              "description": "Host/IP to bind to (defaults to 0.0.0.0)"
+            },
+            "tls": {
+              "$ref": "#/definitions/TlsConfig",
+              "description": "TLS/SSL configuration for HTTPS"
+            },
+            "auth": {
+              "$ref": "#/definitions/HttpAuthConfig",
+              "description": "Authentication configuration"
+            },
+            "endpoints": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/HttpEndpointConfig"
+              },
+              "description": "HTTP endpoints configuration"
+            }
+          },
+          "required": [
+            "enabled",
+            "port"
+          ],
+          "additionalProperties": false,
+          "description": "HTTP server configuration for receiving webhooks",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "TlsConfig": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Enable TLS/HTTPS"
+            },
+            "cert": {
+              "type": "string",
+              "description": "Path to TLS certificate file or certificate content"
+            },
+            "key": {
+              "type": "string",
+              "description": "Path to TLS key file or key content"
+            },
+            "ca": {
+              "type": "string",
+              "description": "Path to CA certificate file or CA content (optional)"
+            },
+            "rejectUnauthorized": {
+              "type": "boolean",
+              "description": "Reject unauthorized connections (default: true)"
+            }
+          },
+          "required": [
+            "enabled"
+          ],
+          "additionalProperties": false,
+          "description": "TLS/SSL configuration for HTTPS server",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "HttpAuthConfig": {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "enum": [
+                "bearer_token",
+                "hmac",
+                "basic",
+                "none"
+              ],
+              "description": "Authentication type"
+            },
+            "secret": {
+              "type": "string",
+              "description": "Secret or token for authentication"
+            },
+            "username": {
+              "type": "string",
+              "description": "Username for basic auth"
+            },
+            "password": {
+              "type": "string",
+              "description": "Password for basic auth"
+            }
+          },
+          "required": [
+            "type"
+          ],
+          "additionalProperties": false,
+          "description": "HTTP server authentication configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "HttpEndpointConfig": {
+          "type": "object",
+          "properties": {
+            "path": {
+              "type": "string",
+              "description": "Path for the webhook endpoint"
+            },
+            "transform": {
+              "type": "string",
+              "description": "Optional transform template (Liquid) for the received data"
+            },
+            "name": {
+              "type": "string",
+              "description": "Optional name/ID for this endpoint"
+            }
+          },
+          "required": [
+            "path"
+          ],
+          "additionalProperties": false,
+          "description": "HTTP server endpoint configuration",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "TagFilter": {
+          "type": "object",
+          "properties": {
+            "include": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Tags that checks must have to be included (ANY match)"
+            },
+            "exclude": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Tags that will exclude checks if present (ANY match)"
+            }
+          },
+          "additionalProperties": false,
+          "description": "Tag filter configuration for selective check execution",
+          "patternProperties": {
+            "^x-": {}
+          }
+        },
+        "RoutingDefaults": {
+          "type": "object",
+          "properties": {
+            "max_loops": {
+              "type": "number",
+              "description": "Per-scope cap on routing transitions (success + failure)"
+            },
+            "defaults": {
+              "type": "object",
+              "properties": {
+                "on_fail": {
+                  "$ref": "#/definitions/OnFailConfig"
+                }
+              },
+              "additionalProperties": false,
+              "description": "Default policies applied to checks (step-level overrides take precedence)",
+              "patternProperties": {
+                "^x-": {}
+              }
+            }
+          },
+          "additionalProperties": false,
+          "description": "Global routing defaults",
+          "patternProperties": {
+            "^x-": {}
+          }
+        }
+      }
+    };
+    config_schema_default = configSchema;
+  }
+});
+
 // src/sdk.ts
 var sdk_exports = {};
 __export(sdk_exports, {
@@ -9099,6 +10108,7 @@ init_check_execution_engine();
 var yaml2 = __toESM(require("js-yaml"));
 var fs7 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
+init_logger();
 var import_simple_git2 = __toESM(require("simple-git"));
 
 // src/utils/config-loader.ts
@@ -9443,6 +10453,8 @@ var ConfigLoader = class {
 
 // src/config.ts
 init_config_merger();
+var import_ajv = __toESM(require("ajv"));
+var import_ajv_formats = __toESM(require("ajv-formats"));
 var ConfigManager = class {
   validCheckTypes = [
     "ai",
@@ -9695,6 +10707,8 @@ var ConfigManager = class {
    */
   validateConfig(config) {
     const errors = [];
+    const warnings = [];
+    this.validateWithAjvSchema(config, errors, warnings);
     if (!config.version) {
       errors.push({
         field: "version",
@@ -9712,8 +10726,38 @@ var ConfigManager = class {
           checkConfig.type = "ai";
         }
         this.validateCheckConfig(checkName, checkConfig, errors);
+        if (checkConfig.ai_mcp_servers) {
+          this.validateMcpServersObject(
+            checkConfig.ai_mcp_servers,
+            `checks.${checkName}.ai_mcp_servers`,
+            errors,
+            warnings
+          );
+        }
+        if (checkConfig.ai?.mcpServers) {
+          this.validateMcpServersObject(
+            checkConfig.ai.mcpServers,
+            `checks.${checkName}.ai.mcpServers`,
+            errors,
+            warnings
+          );
+        }
+        if (checkConfig.ai_mcp_servers && checkConfig.ai?.mcpServers) {
+          const lower = Object.keys(checkConfig.ai_mcp_servers);
+          const higher = Object.keys(checkConfig.ai.mcpServers);
+          const overridden = lower.filter((k) => higher.includes(k));
+          warnings.push({
+            field: `checks.${checkName}.ai.mcpServers`,
+            message: overridden.length > 0 ? `Both ai_mcp_servers and ai.mcpServers are set; ai.mcpServers overrides these servers: ${overridden.join(
+              ", "
+            )}` : "Both ai_mcp_servers and ai.mcpServers are set; ai.mcpServers takes precedence for this check."
+          });
+        }
       }
     }
+    if (config.ai_mcp_servers) {
+      this.validateMcpServersObject(config.ai_mcp_servers, "ai_mcp_servers", errors, warnings);
+    }
     if (config.output) {
       this.validateOutputConfig(config.output, errors);
     }
@@ -9738,6 +10782,11 @@ var ConfigManager = class {
     if (errors.length > 0) {
       throw new Error(errors[0].message);
     }
+    if (warnings.length > 0) {
+      for (const w of warnings) {
+        logger.warn(`\u26A0\uFE0F  Config warning [${w.field}]: ${w.message}`);
+      }
+    }
   }
   /**
    * Validate individual check configuration
@@ -9863,6 +10912,122 @@ var ConfigManager = class {
       }
     }
   }
+  /**
+   * Validate MCP servers object shape and values (basic shape only)
+   */
+  validateMcpServersObject(mcpServers, fieldPrefix, errors, _warnings) {
+    if (typeof mcpServers !== "object" || mcpServers === null) {
+      errors.push({
+        field: fieldPrefix,
+        message: `${fieldPrefix} must be an object mapping server names to { command, args?, env? }`,
+        value: mcpServers
+      });
+      return;
+    }
+    for (const [serverName, cfg] of Object.entries(mcpServers)) {
+      const pathStr = `${fieldPrefix}.${serverName}`;
+      if (!cfg || typeof cfg !== "object") {
+        errors.push({ field: pathStr, message: `${pathStr} must be an object`, value: cfg });
+        continue;
+      }
+      const { command, args, env } = cfg;
+      if (typeof command !== "string" || command.trim() === "") {
+        errors.push({
+          field: `${pathStr}.command`,
+          message: `${pathStr}.command must be a non-empty string`,
+          value: command
+        });
+      }
+      if (args !== void 0 && !Array.isArray(args)) {
+        errors.push({
+          field: `${pathStr}.args`,
+          message: `${pathStr}.args must be an array of strings`,
+          value: args
+        });
+      }
+      if (env !== void 0) {
+        if (typeof env !== "object" || env === null) {
+          errors.push({
+            field: `${pathStr}.env`,
+            message: `${pathStr}.env must be an object of string values`,
+            value: env
+          });
+        } else {
+          for (const [k, v] of Object.entries(env)) {
+            if (typeof v !== "string") {
+              errors.push({
+                field: `${pathStr}.env.${k}`,
+                message: `${pathStr}.env.${k} must be a string`,
+                value: v
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Validate configuration using generated JSON Schema via Ajv, if available.
+   * Adds to errors/warnings but does not throw directly.
+   */
+  validateWithAjvSchema(config, errors, warnings) {
+    try {
+      if (!__ajvValidate) {
+        try {
+          const jsonPath = path7.resolve(__dirname, "generated", "config-schema.json");
+          const jsonSchema = require(jsonPath);
+          if (jsonSchema) {
+            const ajv = new import_ajv.default({ allErrors: true, allowUnionTypes: true, strict: false });
+            (0, import_ajv_formats.default)(ajv);
+            const validate = ajv.compile(jsonSchema);
+            __ajvValidate = (data) => validate(data);
+            __ajvErrors = () => validate.errors;
+          }
+        } catch {
+        }
+        if (!__ajvValidate) {
+          try {
+            const mod = (init_config_schema(), __toCommonJS(config_schema_exports));
+            const schema = mod?.configSchema || mod?.default || mod;
+            if (schema) {
+              const ajv = new import_ajv.default({ allErrors: true, allowUnionTypes: true, strict: false });
+              (0, import_ajv_formats.default)(ajv);
+              const validate = ajv.compile(schema);
+              __ajvValidate = (data) => validate(data);
+              __ajvErrors = () => validate.errors;
+            } else {
+              return;
+            }
+          } catch {
+            return;
+          }
+        }
+      }
+      const ok = __ajvValidate(config);
+      const errs = __ajvErrors ? __ajvErrors() : null;
+      if (!ok && Array.isArray(errs)) {
+        for (const e of errs) {
+          const pathStr = e.instancePath ? e.instancePath.replace(/^\//, "").replace(/\//g, ".") : "";
+          const msg = e.message || "Invalid configuration";
+          if (e.keyword === "additionalProperties") {
+            const addl = e.params && e.params.additionalProperty || "unknown";
+            const fullField = pathStr ? `${pathStr}.${addl}` : addl;
+            const topLevel = !pathStr;
+            warnings.push({
+              field: fullField || "config",
+              message: topLevel ? `Unknown top-level key '${addl}' will be ignored.` : `Unknown key '${addl}' will be ignored`
+            });
+          } else {
+            logger.debug(`Ajv note [${pathStr || "config"}]: ${msg}`);
+          }
+        }
+      }
+    } catch (err) {
+      logger.debug(`Ajv validation skipped: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  // Unknown-key warnings are fully handled by Ajv using the generated schema
+  // Unknown-key hints are produced by Ajv (additionalProperties=false)
   /**
    * Validate tag filter configuration
    */
@@ -10039,6 +11204,8 @@ var ConfigManager = class {
     return merged;
   }
 };
+var __ajvValidate = null;
+var __ajvErrors = null;
 
 // src/sdk.ts
 async function loadConfig(configPath) {