@probelabs/visor 0.1.96 → 0.1.97

package/dist/sdk/sdk.js

@@ -468,50 +468,7 @@ __export(tracer_init_exports, {
 });
 async function initializeTracer(sessionId, checkName) {
   try {
-    if (import_probe.TelemetryConfig && import_probe.AppTracer) {
-      const sanitizedCheckName = checkName ? path.basename(checkName) : "check";
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const traceDir = process.env.GITHUB_WORKSPACE ? path.join(process.env.GITHUB_WORKSPACE, "debug-artifacts") : path.join(process.cwd(), "debug-artifacts");
-      if (!fs.existsSync(traceDir)) {
-        fs.mkdirSync(traceDir, { recursive: true });
-      }
-      const traceFilePath = path.join(traceDir, `trace-${sanitizedCheckName}-${timestamp}.jsonl`);
-      const resolvedTracePath = path.resolve(traceFilePath);
-      const resolvedTraceDir = path.resolve(traceDir);
-      if (!resolvedTracePath.startsWith(resolvedTraceDir)) {
-        console.error(
-          `\u26A0\uFE0F Security: Attempted path traversal detected. Check name: ${checkName}, resolved path: ${resolvedTracePath}`
-        );
-        return null;
-      }
-      const telemetryConfig = new import_probe.TelemetryConfig({
-        serviceName: "visor-ai",
-        serviceVersion: "1.0.0",
-        enableFile: true,
-        filePath: traceFilePath,
-        enableConsole: false,
-        // Disable console to reduce noise
-        enableRemote: false
-        // Can be enabled via OTEL_EXPORTER_OTLP_ENDPOINT env var
-      });
-      telemetryConfig.initialize();
-      const tracer = new import_probe.AppTracer(telemetryConfig, sessionId);
-      console.error(`\u{1F4CA} OpenTelemetry tracing enabled for visor-ai, saving to: ${traceFilePath}`);
-      console.error(
-        `\u{1F332} Trace spans will show hierarchical relationships between visor checks and probe agent operations`
-      );
-      if (process.env.GITHUB_ACTIONS) {
-        console.log(
-          `::notice title=AI Trace::OpenTelemetry trace will be saved to ${traceFilePath}`
-        );
-        console.log(`::set-output name=trace-path::${traceFilePath}`);
-      }
-      return { tracer, telemetryConfig, filePath: traceFilePath };
-    }
     if (import_probe.SimpleTelemetry && import_probe.SimpleAppTracer) {
-      console.warn(
-        "\u26A0\uFE0F Using SimpleTelemetry fallback - hierarchical span relationships may not be available"
-      );
       const sanitizedCheckName = checkName ? path.basename(checkName) : "check";
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const traceDir = process.env.GITHUB_WORKSPACE ? path.join(process.env.GITHUB_WORKSPACE, "debug-artifacts") : path.join(process.cwd(), "debug-artifacts");
@@ -1184,7 +1141,7 @@ ${prContext}
           log2("\u{1F50D} Including code diffs in AI context");
         }
         if (isIssue) {
-          let context3 = `<issue>
+          let context2 = `<issue>
   <!-- Core issue metadata including identification, status, and timeline information -->
   <metadata>
     <number>${prInfo.number}</number>
@@ -1196,7 +1153,7 @@ ${prContext}
     <comments_count>${prInfo.eventContext?.issue?.comments || 0}</comments_count>
   </metadata>`;
           if (prInfo.body) {
-            context3 += `
+            context2 += `
   <!-- Full issue description and body text provided by the issue author -->
   <description>
 ${this.escapeXml(prInfo.body)}
@@ -1205,33 +1162,33 @@ ${this.escapeXml(prInfo.body)}
           const eventContext = prInfo;
           const labels = eventContext.eventContext?.issue?.labels;
           if (labels && labels.length > 0) {
-            context3 += `
+            context2 += `
   <!-- Applied labels for issue categorization and organization -->
   <labels>`;
             labels.forEach((label) => {
               const labelName = typeof label === "string" ? label : label.name || "unknown";
-              context3 += `
+              context2 += `
     <label>${this.escapeXml(labelName)}</label>`;
             });
-            context3 += `
+            context2 += `
   </labels>`;
           }
           const assignees = prInfo.eventContext?.issue?.assignees;
           if (assignees && assignees.length > 0) {
-            context3 += `
+            context2 += `
   <!-- Users assigned to work on this issue -->
   <assignees>`;
             assignees.forEach((assignee) => {
               const assigneeName = typeof assignee === "string" ? assignee : assignee.login || "unknown";
-              context3 += `
+              context2 += `
     <assignee>${this.escapeXml(assigneeName)}</assignee>`;
             });
-            context3 += `
+            context2 += `
   </assignees>`;
           }
           const milestone = prInfo.eventContext?.issue?.milestone;
           if (milestone) {
-            context3 += `
+            context2 += `
   <!-- Associated project milestone information -->
   <milestone>
     <title>${this.escapeXml(milestone.title || "")}</title>
@@ -1241,7 +1198,7 @@ ${this.escapeXml(prInfo.body)}
           }
           const triggeringComment2 = prInfo.eventContext?.comment;
           if (triggeringComment2) {
-            context3 += `
+            context2 += `
   <!-- The comment that triggered this analysis -->
   <triggering_comment>
     <author>${this.escapeXml(triggeringComment2.user?.login || "unknown")}</author>
@@ -1258,26 +1215,26 @@ ${this.escapeXml(prInfo.body)}
               );
             }
             if (historicalComments.length > 0) {
-              context3 += `
+              context2 += `
   <!-- Previous comments in chronological order (excluding triggering comment) -->
   <comment_history>`;
               historicalComments.forEach((comment) => {
-                context3 += `
+                context2 += `
     <comment>
       <author>${this.escapeXml(comment.author || "unknown")}</author>
       <created_at>${comment.createdAt || ""}</created_at>
       <body>${this.escapeXml(comment.body || "")}</body>
     </comment>`;
               });
-              context3 += `
+              context2 += `
   </comment_history>`;
             }
           }
-          context3 += `
+          context2 += `
 </issue>`;
-          return context3;
+          return context2;
         }
-        let context2 = `<pull_request>
+        let context = `<pull_request>
   <!-- Core pull request metadata including identification, branches, and change statistics -->
   <metadata>
     <number>${prInfo.number}</number>
@@ -1290,7 +1247,7 @@ ${this.escapeXml(prInfo.body)}
     <files_changed_count>${prInfo.files.length}</files_changed_count>
   </metadata>`;
         if (prInfo.body) {
-          context2 += `
+          context += `
   <!-- Full pull request description provided by the author -->
   <description>
 ${this.escapeXml(prInfo.body)}
@@ -1299,7 +1256,7 @@ ${this.escapeXml(prInfo.body)}
         if (includeCodeContext) {
           if (prInfo.fullDiff) {
             const processedFullDiff = await processDiffWithOutline(prInfo.fullDiff);
-            context2 += `
+            context += `
   <!-- Complete unified diff showing all changes in the pull request (processed with outline-diff) -->
   <full_diff>
 ${this.escapeXml(processedFullDiff)}
@@ -1308,14 +1265,14 @@ ${this.escapeXml(processedFullDiff)}
           if (prInfo.isIncremental) {
             if (prInfo.commitDiff && prInfo.commitDiff.length > 0) {
               const processedCommitDiff = await processDiffWithOutline(prInfo.commitDiff);
-              context2 += `
+              context += `
   <!-- Diff of only the latest commit for incremental analysis (processed with outline-diff) -->
   <commit_diff>
 ${this.escapeXml(processedCommitDiff)}
   </commit_diff>`;
             } else {
               const processedFallbackDiff = prInfo.fullDiff ? await processDiffWithOutline(prInfo.fullDiff) : "";
-              context2 += `
+              context += `
   <!-- Commit diff could not be retrieved - falling back to full diff analysis (processed with outline-diff) -->
   <commit_diff>
 ${this.escapeXml(processedFallbackDiff)}
@@ -1323,15 +1280,15 @@ ${this.escapeXml(processedFallbackDiff)}
             }
           }
         } else {
-          context2 += `
+          context += `
   <!-- Code diffs excluded to reduce token usage (no code-review schema detected or disabled by flag) -->`;
         }
         if (prInfo.files.length > 0) {
-          context2 += `
+          context += `
   <!-- Summary of all files changed with statistics -->
   <files_summary>`;
           prInfo.files.forEach((file) => {
-            context2 += `
+            context += `
     <file>
       <filename>${this.escapeXml(file.filename)}</filename>
       <status>${file.status}</status>
@@ -1339,12 +1296,12 @@ ${this.escapeXml(processedFallbackDiff)}
       <deletions>${file.deletions}</deletions>
     </file>`;
           });
-          context2 += `
+          context += `
   </files_summary>`;
         }
         const triggeringComment = prInfo.eventContext?.comment;
         if (triggeringComment) {
-          context2 += `
+          context += `
   <!-- The comment that triggered this analysis -->
   <triggering_comment>
     <author>${this.escapeXml(triggeringComment.user?.login || "unknown")}</author>
@@ -1361,24 +1318,24 @@ ${this.escapeXml(processedFallbackDiff)}
             );
           }
           if (historicalComments.length > 0) {
-            context2 += `
+            context += `
   <!-- Previous PR comments in chronological order (excluding triggering comment) -->
   <comment_history>`;
             historicalComments.forEach((comment) => {
-              context2 += `
+              context += `
     <comment>
       <author>${this.escapeXml(comment.author || "unknown")}</author>
       <created_at>${comment.createdAt || ""}</created_at>
       <body>${this.escapeXml(comment.body || "")}</body>
     </comment>`;
             });
-            context2 += `
+            context += `
   </comment_history>`;
           }
         }
-        context2 += `
+        context += `
 </pull_request>`;
-        return context2;
+        return context;
       }
       /**
        * No longer escaping XML - returning text as-is
@@ -2092,12 +2049,14 @@ ${"=".repeat(60)}
           }
           if (traceFilePath && telemetryConfig) {
             try {
-              if (tracer && typeof tracer.flush === "function") {
-                await tracer.flush();
+              const telemetry = telemetryConfig;
+              const tracerWithMethods = tracer;
+              if (tracerWithMethods && typeof tracerWithMethods.flush === "function") {
+                await tracerWithMethods.flush();
                 log(`\u{1F504} Flushed tracer spans`);
               }
-              if (telemetryConfig && typeof telemetryConfig.shutdown === "function") {
-                await telemetryConfig.shutdown();
+              if (telemetry && typeof telemetry.shutdown === "function") {
+                await telemetry.shutdown();
                 log(`\u{1F4CA} OpenTelemetry trace saved to: ${traceFilePath}`);
                 if (process.env.GITHUB_ACTIONS) {
                   const fs12 = require("fs");
@@ -2108,8 +2067,8 @@ ${"=".repeat(60)}
                     );
                   }
                 }
-              } else if (tracer && typeof tracer.shutdown === "function") {
-                await tracer.shutdown();
+              } else if (tracerWithMethods && typeof tracerWithMethods.shutdown === "function") {
+                await tracerWithMethods.shutdown();
                 log(`\u{1F4CA} Trace saved to: ${traceFilePath}`);
               }
             } catch (exportError) {
@@ -5308,8 +5267,8 @@ var init_log_check_provider = __esm({
         };
       }
       buildTemplateContext(prInfo, dependencyResults, _includePrContext = true, _includeDependencies = true, includeMetadata = true, outputHistory) {
-        const context2 = {};
-        context2.pr = {
+        const context = {};
+        context.pr = {
           number: prInfo.number,
           title: prInfo.title,
           body: prInfo.body,
@@ -5326,13 +5285,13 @@ var init_log_check_provider = __esm({
             changes: f.changes
           }))
         };
-        context2.filenames = prInfo.files.map((f) => f.filename);
-        context2.fileCount = prInfo.files.length;
+        context.filenames = prInfo.files.map((f) => f.filename);
+        context.fileCount = prInfo.files.length;
         if (dependencyResults) {
           const dependencies = {};
           const outputs = {};
           const history = {};
-          context2.dependencyCount = dependencyResults.size;
+          context.dependencyCount = dependencyResults.size;
           for (const [checkName, result] of dependencyResults.entries()) {
             dependencies[checkName] = {
               issueCount: result.issues?.length || 0,
@@ -5348,11 +5307,11 @@ var init_log_check_provider = __esm({
             }
           }
           outputs.history = history;
-          context2.dependencies = dependencies;
-          context2.outputs = outputs;
+          context.dependencies = dependencies;
+          context.outputs = outputs;
         }
         if (includeMetadata) {
-          context2.metadata = {
+          context.metadata = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             executionTime: Date.now(),
             nodeVersion: process.version,
@@ -5360,7 +5319,7 @@ var init_log_check_provider = __esm({
             workingDirectory: process.cwd()
           };
         }
-        return context2;
+        return context;
       }
       formatLogOutput(level, message, templateContext, includePrContext, includeDependencies, includeMetadata) {
         const sections = [];
@@ -6284,8 +6243,8 @@ var init_command_check_provider = __esm({
           const timeoutSeconds = config.timeout || 60;
           const timeoutMs = timeoutSeconds * 1e3;
           const normalizeNodeEval = (cmd) => {
-            const re2 = /^(?<prefix>\s*(?:\/usr\/bin\/env\s+)?node(?:\.exe)?\s+(?:-e|--eval)\s+)(['"])([\s\S]*?)\2(?<suffix>\s|$)/;
-            const m = cmd.match(re2);
+            const re = /^(?<prefix>\s*(?:\/usr\/bin\/env\s+)?node(?:\.exe)?\s+(?:-e|--eval)\s+)(['"])([\s\S]*?)\2(?<suffix>\s|$)/;
+            const m = cmd.match(re);
             if (!m || !m.groups) return cmd;
             const prefix = m.groups.prefix;
             const quote = m[2];
@@ -6293,7 +6252,7 @@ var init_command_check_provider = __esm({
             const suffix = m.groups.suffix || "";
             if (!code.includes("\n")) return cmd;
             const escaped = code.replace(/\n/g, "\\n");
-            return cmd.replace(re2, `${prefix}${quote}${escaped}${quote}${suffix}`);
+            return cmd.replace(re, `${prefix}${quote}${escaped}${quote}${suffix}`);
           };
           const safeCommand = normalizeNodeEval(renderedCommand);
           const { stdout, stderr } = await execAsync(safeCommand, {
@@ -7371,7 +7330,7 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
         }
         return null;
       }
-      async renderCommandTemplate(template, context2) {
+      async renderCommandTemplate(template, context) {
         try {
           let tpl = template;
           if (tpl.includes("{{")) {
@@ -7380,10 +7339,10 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
               return `{{ ${fixed} }}`;
             });
           }
-          let rendered = await this.liquid.parseAndRender(tpl, context2);
+          let rendered = await this.liquid.parseAndRender(tpl, context);
           if (/\{\{[\s\S]*?\}\}/.test(rendered)) {
             try {
-              rendered = this.renderWithJsExpressions(rendered, context2);
+              rendered = this.renderWithJsExpressions(rendered, context);
             } catch {
             }
           }
@@ -7391,18 +7350,18 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
         } catch (error) {
           logger.debug(`\u{1F527} Debug: Liquid templating failed, trying JS-expression fallback: ${error}`);
           try {
-            return this.renderWithJsExpressions(template, context2);
+            return this.renderWithJsExpressions(template, context);
           } catch {
             return template;
           }
         }
       }
-      renderWithJsExpressions(template, context2) {
+      renderWithJsExpressions(template, context) {
         const scope = {
-          pr: context2.pr,
-          files: context2.files,
-          outputs: context2.outputs,
-          env: context2.env
+          pr: context.pr,
+          files: context.files,
+          outputs: context.outputs,
+          env: context.env
         };
         const expressionRegex = /\{\{\s*([^{}]+?)\s*\}\}/g;
         return template.replace(expressionRegex, (_match, expr) => {
@@ -7616,16 +7575,16 @@ var init_memory_check_provider = __esm({
         );
         return value;
       }
-      async handleSet(store, key, config, namespace, context2) {
-        const value = await this.computeValue(config, context2);
+      async handleSet(store, key, config, namespace, context) {
+        const value = await this.computeValue(config, context);
         await store.set(key, value, namespace);
         logger.debug(
           `Memory SET: ${namespace || store.getDefaultNamespace()}.${key} = ${JSON.stringify(value)}`
         );
         return value;
       }
-      async handleAppend(store, key, config, namespace, context2) {
-        const value = await this.computeValue(config, context2);
+      async handleAppend(store, key, config, namespace, context) {
+        const value = await this.computeValue(config, context);
         await store.append(key, value, namespace);
         const result = store.get(key, namespace);
         logger.debug(
@@ -7633,10 +7592,10 @@ var init_memory_check_provider = __esm({
         );
         return result;
       }
-      async handleIncrement(store, key, config, namespace, context2) {
+      async handleIncrement(store, key, config, namespace, context) {
         let amount = 1;
         if (config.value !== void 0 || config.value_js) {
-          const computedValue = await this.computeValue(config, context2);
+          const computedValue = await this.computeValue(config, context);
           if (typeof computedValue === "number") {
             amount = computedValue;
           } else {
@@ -7665,11 +7624,11 @@ var init_memory_check_provider = __esm({
         logger.debug(`Memory LIST: ${namespace || store.getDefaultNamespace()} (${keys.length} keys)`);
         return keys;
       }
-      async handleExecJs(store, config, context2) {
+      async handleExecJs(store, config, context) {
         const script = config.memory_js;
         const pendingOps = [];
         const enhancedContext = {
-          ...context2,
+          ...context,
           memory: {
             get: (key, ns) => store.get(key, ns),
             set: (key, value, ns) => {
@@ -7772,29 +7731,29 @@ var init_memory_check_provider = __esm({
       /**
        * Compute value from config using value, value_js, transform, or transform_js
        */
-      async computeValue(config, context2) {
+      async computeValue(config, context) {
         let value;
         if (config.value_js && typeof config.value_js === "string") {
-          value = this.evaluateJavaScript(config.value_js, context2);
+          value = this.evaluateJavaScript(config.value_js, context);
         } else {
           value = config.value;
         }
         if (config.transform && typeof config.transform === "string") {
           const rendered = await this.liquid.parseAndRender(config.transform, {
-            ...context2,
+            ...context,
             value
           });
           value = rendered;
         }
         if (config.transform_js && typeof config.transform_js === "string") {
-          value = this.evaluateJavaScript(config.transform_js, { ...context2, value });
+          value = this.evaluateJavaScript(config.transform_js, { ...context, value });
         }
         return value;
       }
       /**
        * Evaluate JavaScript expression in context using SandboxJS for secure execution
        */
-      evaluateJavaScript(expression, context2) {
+      evaluateJavaScript(expression, context) {
         if (!this.sandbox) {
           this.sandbox = this.createSecureSandbox();
         }
@@ -7803,7 +7762,7 @@ var init_memory_check_provider = __esm({
             logger.info(`\u{1F50D} [memory-js] ${args.map((a) => JSON.stringify(a)).join(" ")}`);
           };
           const scope = {
-            ...context2,
+            ...context,
             log: log2
           };
           const exec = this.sandbox.compile(`return (${expression});`);
@@ -7817,7 +7776,7 @@ var init_memory_check_provider = __esm({
        * Evaluate JavaScript block (multi-line script) using SandboxJS for secure execution
        * Unlike evaluateJavaScript, this supports full scripts with statements, not just expressions
        */
-      evaluateJavaScriptBlock(script, context2) {
+      evaluateJavaScriptBlock(script, context) {
         if (!this.sandbox) {
           this.sandbox = this.createSecureSandbox();
         }
@@ -7826,7 +7785,7 @@ var init_memory_check_provider = __esm({
             logger.info(`\u{1F50D} [memory-js] ${args.map((a) => JSON.stringify(a)).join(" ")}`);
           };
           const scope = {
-            ...context2,
+            ...context,
             log: log2
           };
           const exec = this.sandbox.compile(script);
@@ -7842,8 +7801,8 @@ var init_memory_check_provider = __esm({
        * Build template context for Liquid and JS evaluation
        */
       buildTemplateContext(prInfo, dependencyResults, memoryStore, outputHistory) {
-        const context2 = {};
-        context2.pr = {
+        const context = {};
+        context.pr = {
           number: prInfo.number,
           title: prInfo.title,
           body: prInfo.body,
@@ -7874,16 +7833,16 @@ var init_memory_check_provider = __esm({
           }
         }
         outputs.history = history;
-        context2.outputs = outputs;
+        context.outputs = outputs;
         if (memoryStore) {
-          context2.memory = {
+          context.memory = {
             get: (key, ns) => memoryStore.get(key, ns),
             has: (key, ns) => memoryStore.has(key, ns),
             list: (ns) => memoryStore.list(ns),
             getAll: (ns) => memoryStore.getAll(ns)
           };
         }
-        return context2;
+        return context;
       }
       getSupportedConfigKeys() {
         return [
@@ -7919,1482 +7878,946 @@ var init_memory_check_provider = __esm({
   }
 });
 
-// src/providers/check-provider-registry.ts
-var CheckProviderRegistry;
-var init_check_provider_registry = __esm({
-  "src/providers/check-provider-registry.ts"() {
+// src/providers/mcp-check-provider.ts
+var import_client, import_stdio, import_sse, import_streamableHttp, import_sandboxjs4, McpCheckProvider;
+var init_mcp_check_provider = __esm({
+  "src/providers/mcp-check-provider.ts"() {
     "use strict";
-    init_ai_check_provider();
-    init_http_check_provider();
-    init_http_input_provider();
-    init_http_client_provider();
-    init_noop_check_provider();
-    init_log_check_provider();
-    init_github_ops_provider();
-    init_claude_code_check_provider();
-    init_command_check_provider();
-    init_memory_check_provider();
-    CheckProviderRegistry = class _CheckProviderRegistry {
-      providers = /* @__PURE__ */ new Map();
-      static instance;
+    init_check_provider_interface();
+    init_logger();
+    init_liquid_extensions();
+    import_client = require("@modelcontextprotocol/sdk/client/index.js");
+    import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+    import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+    import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    import_sandboxjs4 = __toESM(require("@nyariv/sandboxjs"));
+    McpCheckProvider = class extends CheckProvider {
+      liquid;
+      sandbox;
       constructor() {
-        this.registerDefaultProviders();
+        super();
+        this.liquid = createExtendedLiquid({
+          cache: false,
+          strictFilters: false,
+          strictVariables: false
+        });
       }
       /**
-       * Get singleton instance
+       * Create a secure sandbox for JavaScript execution
+       * - Uses Sandbox.SAFE_GLOBALS which excludes: Function, eval, require, process, etc.
+       * - Only allows explicitly whitelisted prototype methods
+       * - No access to filesystem, network, or system resources
        */
-      static getInstance() {
-        if (!_CheckProviderRegistry.instance) {
-          _CheckProviderRegistry.instance = new _CheckProviderRegistry();
-        }
-        return _CheckProviderRegistry.instance;
+      createSecureSandbox() {
+        const log2 = (...args) => {
+          logger.debug(`[transform_js] ${args.map((a) => JSON.stringify(a)).join(" ")}`);
+        };
+        const globals = {
+          ...import_sandboxjs4.default.SAFE_GLOBALS,
+          // Excludes Function, eval, require, process, etc.
+          Math,
+          JSON,
+          console: {
+            log: log2
+          }
+        };
+        const prototypeWhitelist = new Map(import_sandboxjs4.default.SAFE_PROTOTYPES);
+        const arrayMethods = /* @__PURE__ */ new Set([
+          "some",
+          "every",
+          "filter",
+          "map",
+          "reduce",
+          "find",
+          "includes",
+          "indexOf",
+          "length",
+          "slice",
+          "concat",
+          "join",
+          "push",
+          "pop",
+          "shift",
+          "unshift",
+          "sort",
+          "reverse",
+          "flat",
+          "flatMap"
+        ]);
+        prototypeWhitelist.set(Array.prototype, arrayMethods);
+        const stringMethods = /* @__PURE__ */ new Set([
+          "toLowerCase",
+          "toUpperCase",
+          "includes",
+          "indexOf",
+          "startsWith",
+          "endsWith",
+          "slice",
+          "substring",
+          "length",
+          "trim",
+          "split",
+          "replace",
+          // String.prototype.replace for text manipulation (e.g., "hello".replace("h", "H"))
+          "match",
+          "padStart",
+          "padEnd"
+        ]);
+        prototypeWhitelist.set(String.prototype, stringMethods);
+        const objectMethods = /* @__PURE__ */ new Set(["hasOwnProperty", "toString", "valueOf", "keys", "values"]);
+        prototypeWhitelist.set(Object.prototype, objectMethods);
+        return new import_sandboxjs4.default({
+          globals,
+          prototypeWhitelist
+        });
       }
-      /**
-       * Register default built-in providers
-       */
-      registerDefaultProviders() {
-        this.register(new AICheckProvider());
-        this.register(new CommandCheckProvider());
-        this.register(new HttpCheckProvider());
-        this.register(new HttpInputProvider());
-        this.register(new HttpClientProvider());
-        this.register(new NoopCheckProvider());
-        this.register(new LogCheckProvider());
-        this.register(new MemoryCheckProvider());
-        this.register(new GitHubOpsProvider());
-        try {
-          this.register(new ClaudeCodeCheckProvider());
-        } catch (error) {
-          console.error(
-            `Warning: Failed to register ClaudeCodeCheckProvider: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
+      getName() {
+        return "mcp";
       }
-      /**
-       * Register a check provider
-       */
-      register(provider) {
-        const name = provider.getName();
-        if (this.providers.has(name)) {
-          throw new Error(`Provider '${name}' is already registered`);
-        }
-        this.providers.set(name, provider);
-        if (process.env.VISOR_DEBUG === "true") {
-          console.error(`Registered check provider: ${name}`);
-        }
+      getDescription() {
+        return "Call MCP tools directly using stdio, SSE, or Streamable HTTP transport";
       }
-      /**
-       * Unregister a check provider
-       */
-      unregister(name) {
-        if (!this.providers.has(name)) {
-          throw new Error(`Provider '${name}' not found`);
+      async validateConfig(config) {
+        if (!config || typeof config !== "object") {
+          return false;
         }
-        this.providers.delete(name);
-        console.error(`Unregistered check provider: ${name}`);
-      }
-      /**
-       * Get a provider by name
-       */
-      getProvider(name) {
-        return this.providers.get(name);
-      }
-      /**
-       * Get provider or throw if not found
-       */
-      getProviderOrThrow(name) {
-        const provider = this.providers.get(name);
-        if (!provider) {
-          throw new Error(
-            `Check provider '${name}' not found. Available providers: ${this.getAvailableProviders().join(", ")}`
-          );
+        const cfg = config;
+        if (!cfg.method || typeof cfg.method !== "string") {
+          logger.error("MCP check requires a method name");
+          return false;
         }
-        return provider;
-      }
-      /**
-       * Check if a provider exists
-       */
-      hasProvider(name) {
-        return this.providers.has(name);
-      }
-      /**
-       * Get all registered provider names
-       */
-      getAvailableProviders() {
-        return Array.from(this.providers.keys());
-      }
-      /**
-       * Get all providers
-       */
-      getAllProviders() {
-        return Array.from(this.providers.values());
-      }
-      /**
-       * Get providers that are currently available (have required dependencies)
-       */
-      async getActiveProviders() {
-        const providers = this.getAllProviders();
-        const activeProviders = [];
-        for (const provider of providers) {
-          if (await provider.isAvailable()) {
-            activeProviders.push(provider);
+        const transport = cfg.transport || "stdio";
+        if (transport === "stdio") {
+          if (!cfg.command || typeof cfg.command !== "string") {
+            logger.error("MCP stdio transport requires a command");
+            return false;
+          }
+          if (/[;&|`$(){}[\]]/.test(cfg.command)) {
+            logger.error("MCP stdio command contains potentially unsafe characters");
+            return false;
+          }
+        } else if (transport === "sse" || transport === "http") {
+          if (!cfg.url || typeof cfg.url !== "string") {
+            logger.error(`MCP ${transport} transport requires a URL`);
+            return false;
+          }
+          try {
+            const parsedUrl = new URL(cfg.url);
+            if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+              logger.error(
+                `Invalid URL protocol for MCP ${transport} transport: ${parsedUrl.protocol}. Only http: and https: are allowed.`
+              );
+              return false;
+            }
+          } catch {
+            logger.error(`Invalid URL format for MCP ${transport} transport: ${cfg.url}`);
+            return false;
           }
+        } else {
+          logger.error(`Invalid MCP transport: ${transport}. Must be 'stdio', 'sse', or 'http'`);
+          return false;
         }
-        return activeProviders;
+        return true;
       }
-      /**
-       * List provider information
-       */
-      async listProviders() {
-        const providers = this.getAllProviders();
-        const info = [];
-        for (const provider of providers) {
-          info.push({
-            name: provider.getName(),
-            description: provider.getDescription(),
-            available: await provider.isAvailable(),
-            requirements: provider.getRequirements()
-          });
+      async execute(prInfo, config, dependencyResults) {
+        const cfg = config;
+        try {
+          const templateContext = {
+            pr: {
+              number: prInfo.number,
+              title: prInfo.title,
+              author: prInfo.author,
+              branch: prInfo.head,
+              base: prInfo.base
+            },
+            files: prInfo.files,
+            fileCount: prInfo.files.length,
+            outputs: this.buildOutputContext(dependencyResults),
+            env: this.getSafeEnvironmentVariables()
+          };
+          let methodArgs = cfg.methodArgs || {};
+          if (cfg.argsTransform) {
+            const rendered = await this.liquid.parseAndRender(cfg.argsTransform, templateContext);
+            try {
+              methodArgs = JSON.parse(rendered);
+            } catch (error) {
+              logger.error(`Failed to parse argsTransform as JSON: ${error}`);
+              return {
+                issues: [
+                  {
+                    file: "mcp",
+                    line: 0,
+                    ruleId: "mcp/args_transform_error",
+                    message: `Failed to parse argsTransform: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    severity: "error",
+                    category: "logic"
+                  }
+                ]
+              };
+            }
+          }
+          const result = await this.executeMcpMethod(cfg, methodArgs);
+          let finalOutput = result;
+          if (cfg.transform) {
+            try {
+              const transformContext = {
+                ...templateContext,
+                output: result
+              };
+              const rendered = await this.liquid.parseAndRender(cfg.transform, transformContext);
+              try {
+                finalOutput = JSON.parse(rendered.trim());
+              } catch {
+                finalOutput = rendered.trim();
+              }
+            } catch (error) {
+              logger.error(`Failed to apply Liquid transform: ${error}`);
+              return {
+                issues: [
+                  {
+                    file: "mcp",
+                    line: 0,
+                    ruleId: "mcp/transform_error",
+                    message: `Failed to apply transform: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    severity: "error",
+                    category: "logic"
+                  }
+                ]
+              };
+            }
+          }
+          if (cfg.transform_js) {
+            try {
+              if (!this.sandbox) {
+                this.sandbox = this.createSecureSandbox();
+              }
+              const scope = {
+                output: finalOutput,
+                pr: templateContext.pr,
+                files: templateContext.files,
+                outputs: templateContext.outputs,
+                env: templateContext.env
+              };
+              const exec = this.sandbox.compile(`return (${cfg.transform_js});`);
+              finalOutput = exec(scope).run();
+            } catch (error) {
+              logger.error(`Failed to apply JavaScript transform: ${error}`);
+              return {
+                issues: [
+                  {
+                    file: "mcp",
+                    line: 0,
+                    ruleId: "mcp/transform_js_error",
+                    message: `Failed to apply JavaScript transform: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    severity: "error",
+                    category: "logic"
+                  }
+                ]
+              };
+            }
+          }
+          const extracted = this.extractIssuesFromOutput(finalOutput);
+          if (extracted) {
+            return {
+              issues: extracted.issues,
+              ...extracted.remainingOutput ? { output: extracted.remainingOutput } : {}
+            };
+          }
+          return {
+            issues: [],
+            ...finalOutput ? { output: finalOutput } : {}
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          logger.error(`MCP check failed: ${errorMessage}`);
+          return {
+            issues: [
+              {
+                file: "mcp",
+                line: 0,
+                ruleId: "mcp/execution_error",
+                message: `MCP check failed: ${errorMessage}`,
+                severity: "error",
+                category: "logic"
+              }
+            ]
+          };
         }
-        return info;
-      }
-      /**
-       * Reset registry (mainly for testing)
-       */
-      reset() {
-        this.providers.clear();
-        this.registerDefaultProviders();
       }
       /**
-       * Clear singleton instance (for testing)
+       * Execute an MCP method using the configured transport
        */
-      static clearInstance() {
-        _CheckProviderRegistry.instance = void 0;
+      async executeMcpMethod(config, methodArgs) {
+        const transport = config.transport || "stdio";
+        const timeout = (config.timeout || 60) * 1e3;
+        if (transport === "stdio") {
+          return await this.executeStdioMethod(config, methodArgs, timeout);
+        } else if (transport === "sse") {
+          return await this.executeSseMethod(config, methodArgs, timeout);
+        } else if (transport === "http") {
+          return await this.executeHttpMethod(config, methodArgs, timeout);
+        } else {
+          throw new Error(`Unsupported transport: ${transport}`);
+        }
       }
-    };
-  }
-});
-
-// src/dependency-resolver.ts
-var DependencyResolver;
-var init_dependency_resolver = __esm({
-  "src/dependency-resolver.ts"() {
-    "use strict";
-    DependencyResolver = class {
       /**
-       * Build dependency graph from check dependencies
+       * Generic method to execute MCP method with any transport
        */
-      static buildDependencyGraph(checkDependencies) {
-        const nodes = /* @__PURE__ */ new Map();
-        for (const checkId of Object.keys(checkDependencies)) {
-          nodes.set(checkId, {
-            id: checkId,
-            dependencies: checkDependencies[checkId] || [],
-            dependents: [],
-            depth: 0
-          });
-        }
-        for (const [checkId, dependencies] of Object.entries(checkDependencies)) {
-          for (const depId of dependencies || []) {
-            if (!nodes.has(depId)) {
-              throw new Error(`Check "${checkId}" depends on "${depId}" but "${depId}" is not defined`);
+      async executeWithTransport(transport, config, methodArgs, timeout, transportName) {
+        const client = new import_client.Client(
+          {
+            name: "visor-mcp-client",
+            version: "1.0.0"
+          },
+          {
+            capabilities: {}
+          }
+        );
+        try {
+          let timeoutId;
+          try {
+            await Promise.race([
+              client.connect(transport),
+              new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("Connection timeout")), timeout);
+              })
+            ]);
+          } finally {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
             }
-            const depNode = nodes.get(depId);
-            depNode.dependents.push(checkId);
           }
-        }
-        const cycleDetection = this.detectCycles(nodes);
-        if (cycleDetection.hasCycles) {
-          return {
-            nodes,
-            executionOrder: [],
-            hasCycles: true,
-            cycleNodes: cycleDetection.cycleNodes
-          };
-        }
-        const executionOrder = this.topologicalSort(nodes);
-        return {
-          nodes,
-          executionOrder,
-          hasCycles: false
-        };
-      }
-      /**
-       * Detect cycles in the dependency graph using DFS
-       */
-      static detectCycles(nodes) {
-        const visited = /* @__PURE__ */ new Set();
-        const recursionStack = /* @__PURE__ */ new Set();
-        const cycleNodes = [];
-        const dfs = (nodeId) => {
-          if (recursionStack.has(nodeId)) {
-            cycleNodes.push(nodeId);
-            return true;
+          logger.debug(`Connected to MCP server via ${transportName}`);
+          if (transport instanceof import_streamableHttp.StreamableHTTPClientTransport && transport.sessionId) {
+            logger.debug(`MCP Session ID: ${transport.sessionId}`);
           }
-          if (visited.has(nodeId)) {
-            return false;
+          try {
+            const toolsResult = await client.listTools();
+            logger.debug(`Available MCP tools: ${JSON.stringify(toolsResult?.tools || [])}`);
+          } catch (error) {
+            logger.debug(`Could not list MCP tools: ${error}`);
           }
-          visited.add(nodeId);
-          recursionStack.add(nodeId);
-          const node = nodes.get(nodeId);
-          if (node) {
-            for (const depId of node.dependencies) {
-              if (dfs(depId)) {
-                cycleNodes.push(nodeId);
-                return true;
-              }
+          let callTimeoutId;
+          try {
+            const result = await Promise.race([
+              client.callTool({
+                name: config.method,
+                arguments: methodArgs
+              }),
+              new Promise((_, reject) => {
+                callTimeoutId = setTimeout(() => reject(new Error("Request timeout")), timeout);
+              })
+            ]);
+            logger.debug(`MCP method result: ${JSON.stringify(result)}`);
+            return result;
+          } finally {
+            if (callTimeoutId) {
+              clearTimeout(callTimeoutId);
             }
           }
-          recursionStack.delete(nodeId);
-          return false;
-        };
-        for (const nodeId of nodes.keys()) {
-          if (!visited.has(nodeId)) {
-            if (dfs(nodeId)) {
-              return { hasCycles: true, cycleNodes: [...new Set(cycleNodes)] };
-            }
+        } finally {
+          try {
+            await client.close();
+          } catch (error) {
+            logger.debug(`Error closing MCP client: ${error}`);
           }
         }
-        return { hasCycles: false };
       }
       /**
-       * Perform topological sort to determine execution order
-       * Groups checks that can run in parallel at each level
+       * Execute MCP method using stdio transport
        */
-      static topologicalSort(nodes) {
-        const remainingNodes = new Map(nodes);
-        const executionGroups = [];
-        let level = 0;
-        while (remainingNodes.size > 0) {
-          const readyNodes = [];
-          for (const [nodeId, node] of remainingNodes.entries()) {
-            const unmetDependencies = node.dependencies.filter((depId) => remainingNodes.has(depId));
-            if (unmetDependencies.length === 0) {
-              readyNodes.push(nodeId);
-            }
-          }
-          if (readyNodes.length === 0) {
-            throw new Error("Unable to resolve dependencies - possible circular dependency detected");
-          }
-          executionGroups.push({
-            parallel: readyNodes,
-            level
-          });
-          for (const nodeId of readyNodes) {
-            remainingNodes.delete(nodeId);
-          }
-          level++;
-        }
-        return executionGroups;
+      async executeStdioMethod(config, methodArgs, timeout) {
+        const transport = new import_stdio.StdioClientTransport({
+          command: config.command,
+          args: config.args,
+          env: config.env,
+          cwd: config.workingDirectory
+        });
+        return this.executeWithTransport(
+          transport,
+          config,
+          methodArgs,
+          timeout,
+          `stdio: ${config.command}`
+        );
       }
       /**
-       * Validate that all dependencies exist
+       * Execute MCP method using SSE transport
        */
-      static validateDependencies(checkIds, dependencies) {
-        const errors = [];
-        const checkIdSet = new Set(checkIds);
-        for (const [checkId, deps] of Object.entries(dependencies)) {
-          if (!checkIdSet.has(checkId)) {
-            errors.push(`Check "${checkId}" is not in the list of available checks`);
-            continue;
-          }
-          for (const depId of deps || []) {
-            if (!checkIdSet.has(depId)) {
-              errors.push(`Check "${checkId}" depends on "${depId}" which is not available`);
-            }
-          }
+      async executeSseMethod(config, methodArgs, timeout) {
+        const requestInit = {};
+        if (config.headers) {
+          requestInit.headers = config.headers;
         }
-        return {
-          valid: errors.length === 0,
-          errors
-        };
+        const transport = new import_sse.SSEClientTransport(new URL(config.url), {
+          requestInit
+        });
+        return this.executeWithTransport(transport, config, methodArgs, timeout, `SSE: ${config.url}`);
       }
       /**
-       * Get all transitive dependencies (ancestors) for a given check
-       * This returns all checks that must complete before the given check can run,
-       * not just the direct dependencies.
-       *
-       * For example, if A -> B -> C, then:
-       * - getAllDependencies(C) returns [A, B]
-       * - getAllDependencies(B) returns [A]
-       * - getAllDependencies(A) returns []
-       *
-       * @param checkId The check to find dependencies for
-       * @param nodes The dependency graph nodes
-       * @returns Array of all transitive dependency IDs
+       * Execute MCP method using Streamable HTTP transport
        */
-      static getAllDependencies(checkId, nodes) {
-        const allDeps = /* @__PURE__ */ new Set();
-        const visited = /* @__PURE__ */ new Set();
-        const collectDependencies = (currentId) => {
-          if (visited.has(currentId)) {
-            return;
+      async executeHttpMethod(config, methodArgs, timeout) {
+        const requestInit = {};
+        if (config.headers) {
+          requestInit.headers = config.headers;
+        }
+        const transport = new import_streamableHttp.StreamableHTTPClientTransport(new URL(config.url), {
+          requestInit,
+          sessionId: config.sessionId
+        });
+        return this.executeWithTransport(
+          transport,
+          config,
+          methodArgs,
+          timeout,
+          `Streamable HTTP: ${config.url}`
+        );
+      }
+      /**
+       * Build output context from dependency results
+       */
+      buildOutputContext(dependencyResults) {
+        if (!dependencyResults) {
+          return {};
+        }
+        const outputs = {};
+        for (const [checkName, result] of dependencyResults) {
+          const summary = result;
+          outputs[checkName] = summary.output !== void 0 ? summary.output : summary;
+        }
+        return outputs;
+      }
+      /**
+       * Get safe environment variables
+       */
+      getSafeEnvironmentVariables() {
+        const safeVars = {};
+        const allowedPrefixes = ["CI_", "GITHUB_", "RUNNER_", "NODE_", "npm_", "PATH", "HOME", "USER"];
+        for (const [key, value] of Object.entries(process.env)) {
+          if (value !== void 0 && allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
+            safeVars[key] = value;
           }
-          visited.add(currentId);
-          const node = nodes.get(currentId);
-          if (!node) {
-            return;
+        }
+        safeVars["PWD"] = process.cwd();
+        return safeVars;
+      }
+      /**
+       * Extract issues from MCP output
+       */
+      extractIssuesFromOutput(output) {
+        if (output === null || output === void 0) {
+          return null;
+        }
+        if (typeof output === "string") {
+          try {
+            const parsed = JSON.parse(output);
+            return this.extractIssuesFromOutput(parsed);
+          } catch {
+            return null;
           }
-          for (const depId of node.dependencies) {
-            allDeps.add(depId);
-            collectDependencies(depId);
+        }
+        if (Array.isArray(output)) {
+          const issues = this.normalizeIssueArray(output);
+          if (issues) {
+            return { issues, remainingOutput: void 0 };
           }
-        };
-        collectDependencies(checkId);
-        return Array.from(allDeps);
+          return null;
+        }
+        if (typeof output === "object") {
+          const record = output;
+          if (Array.isArray(record.issues)) {
+            const issues = this.normalizeIssueArray(record.issues);
+            if (!issues) {
+              return null;
+            }
+            const remaining = { ...record };
+            delete remaining.issues;
+            return {
+              issues,
+              remainingOutput: Object.keys(remaining).length > 0 ? remaining : void 0
+            };
+          }
+          const singleIssue = this.normalizeIssue(record);
+          if (singleIssue) {
+            return { issues: [singleIssue], remainingOutput: void 0 };
+          }
+        }
+        return null;
       }
       /**
-       * Get execution statistics for debugging
+       * Normalize an array of issues
        */
-      static getExecutionStats(graph) {
-        const totalChecks = graph.nodes.size;
-        const parallelLevels = graph.executionOrder.length;
-        const maxParallelism = Math.max(...graph.executionOrder.map((group) => group.parallel.length));
-        const averageParallelism = totalChecks / parallelLevels;
-        const checksWithDependencies = Array.from(graph.nodes.values()).filter(
-          (node) => node.dependencies.length > 0
-        ).length;
+      normalizeIssueArray(values) {
+        const normalized = [];
+        for (const value of values) {
+          const issue = this.normalizeIssue(value);
+          if (!issue) {
+            return null;
+          }
+          normalized.push(issue);
+        }
+        return normalized;
+      }
+      /**
+       * Normalize a single issue
+       */
+      normalizeIssue(raw) {
+        if (!raw || typeof raw !== "object") {
+          return null;
+        }
+        const data = raw;
+        const message = this.toTrimmedString(
+          data.message || data.text || data.description || data.summary
+        );
+        if (!message) {
+          return null;
+        }
+        const allowedSeverities = /* @__PURE__ */ new Set(["info", "warning", "error", "critical"]);
+        const severityRaw = this.toTrimmedString(data.severity || data.level || data.priority);
+        let severity = "warning";
+        if (severityRaw) {
+          const lower = severityRaw.toLowerCase();
+          if (allowedSeverities.has(lower)) {
+            severity = lower;
+          }
+        }
+        const allowedCategories = /* @__PURE__ */ new Set([
+          "security",
+          "performance",
+          "style",
+          "logic",
+          "documentation"
+        ]);
+        const categoryRaw = this.toTrimmedString(data.category || data.type || data.group);
+        let category = "logic";
+        if (categoryRaw && allowedCategories.has(categoryRaw.toLowerCase())) {
+          category = categoryRaw.toLowerCase();
+        }
+        const file = this.toTrimmedString(data.file || data.path || data.filename) || "system";
+        const line = this.toNumber(data.line || data.startLine || data.lineNumber) ?? 0;
+        const endLine = this.toNumber(data.endLine || data.end_line || data.stopLine);
+        const suggestion = this.toTrimmedString(data.suggestion);
+        const replacement = this.toTrimmedString(data.replacement);
+        const ruleId = this.toTrimmedString(data.ruleId || data.rule || data.id || data.check) || "mcp";
         return {
-          totalChecks,
-          parallelLevels,
-          maxParallelism,
-          averageParallelism,
-          checksWithDependencies
+          file,
+          line,
+          endLine: endLine ?? void 0,
+          ruleId,
+          message,
+          severity,
+          category,
+          suggestion: suggestion || void 0,
+          replacement: replacement || void 0
         };
       }
+      toTrimmedString(value) {
+        if (typeof value === "string") {
+          const trimmed = value.trim();
+          return trimmed.length > 0 ? trimmed : null;
+        }
+        if (value !== null && value !== void 0 && typeof value.toString === "function") {
+          const converted = String(value).trim();
+          return converted.length > 0 ? converted : null;
+        }
+        return null;
+      }
+      toNumber(value) {
+        if (value === null || value === void 0) {
+          return null;
+        }
+        const num = Number(value);
+        if (Number.isFinite(num)) {
+          return Math.trunc(num);
+        }
+        return null;
+      }
+      getSupportedConfigKeys() {
+        return [
+          "type",
+          "transport",
+          "command",
+          "args",
+          "env",
+          "workingDirectory",
+          "url",
+          "headers",
+          "sessionId",
+          "method",
+          "methodArgs",
+          "argsTransform",
+          "transform",
+          "transform_js",
+          "timeout",
+          "depends_on",
+          "on",
+          "if",
+          "group"
+        ];
+      }
+      async isAvailable() {
+        return true;
+      }
+      getRequirements() {
+        return ["MCP method name specified", "Transport configuration (stdio: command, sse/http: url)"];
+      }
     };
   }
 });
 
-// node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
-var _globalThis;
-var init_globalThis = __esm({
-  "node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
-    "use strict";
-    _globalThis = typeof globalThis === "object" ? globalThis : global;
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/platform/node/index.js
-var init_node = __esm({
-  "node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
-    "use strict";
-    init_globalThis();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/platform/index.js
-var init_platform = __esm({
-  "node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
-    "use strict";
-    init_node();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/version.js
-var VERSION;
-var init_version = __esm({
-  "node_modules/@opentelemetry/api/build/esm/version.js"() {
+// src/providers/check-provider-registry.ts
+var CheckProviderRegistry;
+var init_check_provider_registry = __esm({
+  "src/providers/check-provider-registry.ts"() {
     "use strict";
-    VERSION = "1.9.0";
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/internal/semver.js
-function _makeCompatibilityCheck(ownVersion) {
-  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
-  var rejectedVersions = /* @__PURE__ */ new Set();
-  var myVersionMatch = ownVersion.match(re);
-  if (!myVersionMatch) {
-    return function() {
-      return false;
-    };
-  }
-  var ownVersionParsed = {
-    major: +myVersionMatch[1],
-    minor: +myVersionMatch[2],
-    patch: +myVersionMatch[3],
-    prerelease: myVersionMatch[4]
-  };
-  if (ownVersionParsed.prerelease != null) {
-    return function isExactmatch(globalVersion) {
-      return globalVersion === ownVersion;
-    };
-  }
-  function _reject(v) {
-    rejectedVersions.add(v);
-    return false;
-  }
-  function _accept(v) {
-    acceptedVersions.add(v);
-    return true;
-  }
-  return function isCompatible2(globalVersion) {
-    if (acceptedVersions.has(globalVersion)) {
-      return true;
-    }
-    if (rejectedVersions.has(globalVersion)) {
-      return false;
-    }
-    var globalVersionMatch = globalVersion.match(re);
-    if (!globalVersionMatch) {
-      return _reject(globalVersion);
-    }
-    var globalVersionParsed = {
-      major: +globalVersionMatch[1],
-      minor: +globalVersionMatch[2],
-      patch: +globalVersionMatch[3],
-      prerelease: globalVersionMatch[4]
-    };
-    if (globalVersionParsed.prerelease != null) {
-      return _reject(globalVersion);
-    }
-    if (ownVersionParsed.major !== globalVersionParsed.major) {
-      return _reject(globalVersion);
-    }
-    if (ownVersionParsed.major === 0) {
-      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
-        return _accept(globalVersion);
+    init_ai_check_provider();
+    init_http_check_provider();
+    init_http_input_provider();
+    init_http_client_provider();
+    init_noop_check_provider();
+    init_log_check_provider();
+    init_github_ops_provider();
+    init_claude_code_check_provider();
+    init_command_check_provider();
+    init_memory_check_provider();
+    init_mcp_check_provider();
+    CheckProviderRegistry = class _CheckProviderRegistry {
+      providers = /* @__PURE__ */ new Map();
+      static instance;
+      constructor() {
+        this.registerDefaultProviders();
       }
-      return _reject(globalVersion);
-    }
-    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
-      return _accept(globalVersion);
-    }
-    return _reject(globalVersion);
-  };
-}
-var re, isCompatible;
-var init_semver = __esm({
-  "node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
-    "use strict";
-    init_version();
-    re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
-    isCompatible = _makeCompatibilityCheck(VERSION);
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
-function registerGlobal(type, instance, diag, allowOverride) {
-  var _a;
-  if (allowOverride === void 0) {
-    allowOverride = false;
-  }
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
-    version: VERSION
-  };
-  if (!allowOverride && api[type]) {
-    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
-    diag.error(err.stack || err.message);
-    return false;
-  }
-  if (api.version !== VERSION) {
-    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
-    diag.error(err.stack || err.message);
-    return false;
-  }
-  api[type] = instance;
-  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
-  return true;
-}
-function getGlobal(type) {
-  var _a, _b;
-  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
-  if (!globalVersion || !isCompatible(globalVersion)) {
-    return;
-  }
-  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
-}
-function unregisterGlobal(type, diag) {
-  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
-  if (api) {
-    delete api[type];
-  }
-}
-var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
-var init_global_utils = __esm({
-  "node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
-    "use strict";
-    init_platform();
-    init_version();
-    init_semver();
-    major = VERSION.split(".")[0];
-    GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
-    _global = _globalThis;
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
-function logProxy(funcName, namespace, args) {
-  var logger2 = getGlobal("diag");
-  if (!logger2) {
-    return;
-  }
-  args.unshift(namespace);
-  return logger2[funcName].apply(logger2, __spreadArray([], __read(args), false));
-}
-var __read, __spreadArray, DiagComponentLogger;
-var init_ComponentLogger = __esm({
-  "node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
-    "use strict";
-    init_global_utils();
-    __read = function(o, n) {
-      var m = typeof Symbol === "function" && o[Symbol.iterator];
-      if (!m) return o;
-      var i = m.call(o), r, ar = [], e;
-      try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-      } catch (error) {
-        e = { error };
-      } finally {
+      /**
+       * Get singleton instance
+       */
+      static getInstance() {
+        if (!_CheckProviderRegistry.instance) {
+          _CheckProviderRegistry.instance = new _CheckProviderRegistry();
+        }
+        return _CheckProviderRegistry.instance;
+      }
+      /**
+       * Register default built-in providers
+       */
+      registerDefaultProviders() {
+        this.register(new AICheckProvider());
+        this.register(new CommandCheckProvider());
+        this.register(new HttpCheckProvider());
+        this.register(new HttpInputProvider());
+        this.register(new HttpClientProvider());
+        this.register(new NoopCheckProvider());
+        this.register(new LogCheckProvider());
+        this.register(new MemoryCheckProvider());
+        this.register(new GitHubOpsProvider());
         try {
-          if (r && !r.done && (m = i["return"])) m.call(i);
-        } finally {
-          if (e) throw e.error;
+          this.register(new ClaudeCodeCheckProvider());
+        } catch (error) {
+          console.error(
+            `Warning: Failed to register ClaudeCodeCheckProvider: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+        try {
+          this.register(new McpCheckProvider());
+        } catch (error) {
+          console.error(
+            `Warning: Failed to register McpCheckProvider: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+      /**
+       * Register a check provider
+       */
+      register(provider) {
+        const name = provider.getName();
+        if (this.providers.has(name)) {
+          throw new Error(`Provider '${name}' is already registered`);
+        }
+        this.providers.set(name, provider);
+        if (process.env.VISOR_DEBUG === "true") {
+          console.error(`Registered check provider: ${name}`);
         }
       }
-      return ar;
-    };
-    __spreadArray = function(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
+      /**
+       * Unregister a check provider
+       */
+      unregister(name) {
+        if (!this.providers.has(name)) {
+          throw new Error(`Provider '${name}' not found`);
         }
+        this.providers.delete(name);
+        console.error(`Unregistered check provider: ${name}`);
       }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    };
-    DiagComponentLogger = /** @class */
-    (function() {
-      function DiagComponentLogger2(props) {
-        this._namespace = props.namespace || "DiagComponentLogger";
+      /**
+       * Get a provider by name
+       */
+      getProvider(name) {
+        return this.providers.get(name);
       }
-      DiagComponentLogger2.prototype.debug = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return logProxy("debug", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.error = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return logProxy("error", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.info = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
+      /**
+       * Get provider or throw if not found
+       */
+      getProviderOrThrow(name) {
+        const provider = this.providers.get(name);
+        if (!provider) {
+          throw new Error(
+            `Check provider '${name}' not found. Available providers: ${this.getAvailableProviders().join(", ")}`
+          );
         }
-        return logProxy("info", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.warn = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
+        return provider;
+      }
+      /**
+       * Check if a provider exists
+       */
+      hasProvider(name) {
+        return this.providers.has(name);
+      }
+      /**
+       * Get all registered provider names
+       */
+      getAvailableProviders() {
+        return Array.from(this.providers.keys());
+      }
+      /**
+       * Get all providers
+       */
+      getAllProviders() {
+        return Array.from(this.providers.values());
+      }
+      /**
+       * Get providers that are currently available (have required dependencies)
+       */
+      async getActiveProviders() {
+        const providers = this.getAllProviders();
+        const activeProviders = [];
+        for (const provider of providers) {
+          if (await provider.isAvailable()) {
+            activeProviders.push(provider);
+          }
         }
-        return logProxy("warn", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.verbose = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
+        return activeProviders;
+      }
+      /**
+       * List provider information
+       */
+      async listProviders() {
+        const providers = this.getAllProviders();
+        const info = [];
+        for (const provider of providers) {
+          info.push({
+            name: provider.getName(),
+            description: provider.getDescription(),
+            available: await provider.isAvailable(),
+            requirements: provider.getRequirements()
+          });
         }
-        return logProxy("verbose", this._namespace, args);
-      };
-      return DiagComponentLogger2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/diag/types.js
-var DiagLogLevel;
-var init_types = __esm({
-  "node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
-    "use strict";
-    (function(DiagLogLevel2) {
-      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
-      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
-      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
-      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
-      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
-      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
-      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
-    })(DiagLogLevel || (DiagLogLevel = {}));
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
-function createLogLevelDiagLogger(maxLevel, logger2) {
-  if (maxLevel < DiagLogLevel.NONE) {
-    maxLevel = DiagLogLevel.NONE;
-  } else if (maxLevel > DiagLogLevel.ALL) {
-    maxLevel = DiagLogLevel.ALL;
-  }
-  logger2 = logger2 || {};
-  function _filterFunc(funcName, theLevel) {
-    var theFunc = logger2[funcName];
-    if (typeof theFunc === "function" && maxLevel >= theLevel) {
-      return theFunc.bind(logger2);
-    }
-    return function() {
+        return info;
+      }
+      /**
+       * Reset registry (mainly for testing)
+       */
+      reset() {
+        this.providers.clear();
+        this.registerDefaultProviders();
+      }
+      /**
+       * Clear singleton instance (for testing)
+       */
+      static clearInstance() {
+        _CheckProviderRegistry.instance = void 0;
+      }
     };
   }
-  return {
-    error: _filterFunc("error", DiagLogLevel.ERROR),
-    warn: _filterFunc("warn", DiagLogLevel.WARN),
-    info: _filterFunc("info", DiagLogLevel.INFO),
-    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
-    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
-  };
-}
-var init_logLevelLogger = __esm({
-  "node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
-    "use strict";
-    init_types();
-  }
 });
 
-// node_modules/@opentelemetry/api/build/esm/api/diag.js
-var __read2, __spreadArray2, API_NAME, DiagAPI;
-var init_diag = __esm({
-  "node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
+// src/dependency-resolver.ts
+var DependencyResolver;
+var init_dependency_resolver = __esm({
+  "src/dependency-resolver.ts"() {
     "use strict";
-    init_ComponentLogger();
-    init_logLevelLogger();
-    init_types();
-    init_global_utils();
-    __read2 = function(o, n) {
-      var m = typeof Symbol === "function" && o[Symbol.iterator];
-      if (!m) return o;
-      var i = m.call(o), r, ar = [], e;
-      try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-      } catch (error) {
-        e = { error };
-      } finally {
-        try {
-          if (r && !r.done && (m = i["return"])) m.call(i);
-        } finally {
-          if (e) throw e.error;
-        }
-      }
-      return ar;
-    };
-    __spreadArray2 = function(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
+    DependencyResolver = class {
+      /**
+       * Build dependency graph from check dependencies
+       */
+      static buildDependencyGraph(checkDependencies) {
+        const nodes = /* @__PURE__ */ new Map();
+        for (const checkId of Object.keys(checkDependencies)) {
+          nodes.set(checkId, {
+            id: checkId,
+            dependencies: checkDependencies[checkId] || [],
+            dependents: [],
+            depth: 0
+          });
         }
-      }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    };
-    API_NAME = "diag";
-    DiagAPI = /** @class */
-    (function() {
-      function DiagAPI2() {
-        function _logProxy(funcName) {
-          return function() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments[_i];
+        for (const [checkId, dependencies] of Object.entries(checkDependencies)) {
+          for (const depId of dependencies || []) {
+            if (!nodes.has(depId)) {
+              throw new Error(`Check "${checkId}" depends on "${depId}" but "${depId}" is not defined`);
             }
-            var logger2 = getGlobal("diag");
-            if (!logger2)
-              return;
-            return logger2[funcName].apply(logger2, __spreadArray2([], __read2(args), false));
+            const depNode = nodes.get(depId);
+            depNode.dependents.push(checkId);
+          }
+        }
+        const cycleDetection = this.detectCycles(nodes);
+        if (cycleDetection.hasCycles) {
+          return {
+            nodes,
+            executionOrder: [],
+            hasCycles: true,
+            cycleNodes: cycleDetection.cycleNodes
           };
         }
-        var self = this;
-        var setLogger = function(logger2, optionsOrLogLevel) {
-          var _a, _b, _c;
-          if (optionsOrLogLevel === void 0) {
-            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+        const executionOrder = this.topologicalSort(nodes);
+        return {
+          nodes,
+          executionOrder,
+          hasCycles: false
+        };
+      }
+      /**
+       * Detect cycles in the dependency graph using DFS
+       */
+      static detectCycles(nodes) {
+        const visited = /* @__PURE__ */ new Set();
+        const recursionStack = /* @__PURE__ */ new Set();
+        const cycleNodes = [];
+        const dfs = (nodeId) => {
+          if (recursionStack.has(nodeId)) {
+            cycleNodes.push(nodeId);
+            return true;
           }
-          if (logger2 === self) {
-            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-            self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+          if (visited.has(nodeId)) {
             return false;
           }
-          if (typeof optionsOrLogLevel === "number") {
-            optionsOrLogLevel = {
-              logLevel: optionsOrLogLevel
-            };
-          }
-          var oldLogger = getGlobal("diag");
-          var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger2);
-          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
-            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
-            oldLogger.warn("Current logger will be overwritten from " + stack);
-            newLogger.warn("Current logger will overwrite one already registered from " + stack);
+          visited.add(nodeId);
+          recursionStack.add(nodeId);
+          const node = nodes.get(nodeId);
+          if (node) {
+            for (const depId of node.dependencies) {
+              if (dfs(depId)) {
+                cycleNodes.push(nodeId);
+                return true;
+              }
+            }
           }
-          return registerGlobal("diag", newLogger, self, true);
-        };
-        self.setLogger = setLogger;
-        self.disable = function() {
-          unregisterGlobal(API_NAME, self);
-        };
-        self.createComponentLogger = function(options) {
-          return new DiagComponentLogger(options);
-        };
-        self.verbose = _logProxy("verbose");
-        self.debug = _logProxy("debug");
-        self.info = _logProxy("info");
-        self.warn = _logProxy("warn");
-        self.error = _logProxy("error");
-      }
-      DiagAPI2.instance = function() {
-        if (!this._instance) {
-          this._instance = new DiagAPI2();
-        }
-        return this._instance;
-      };
-      return DiagAPI2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/context/context.js
-function createContextKey(description) {
-  return Symbol.for(description);
-}
-var BaseContext, ROOT_CONTEXT;
-var init_context = __esm({
-  "node_modules/@opentelemetry/api/build/esm/context/context.js"() {
-    "use strict";
-    BaseContext = /** @class */
-    /* @__PURE__ */ (function() {
-      function BaseContext2(parentContext) {
-        var self = this;
-        self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
-        self.getValue = function(key) {
-          return self._currentContext.get(key);
-        };
-        self.setValue = function(key, value) {
-          var context2 = new BaseContext2(self._currentContext);
-          context2._currentContext.set(key, value);
-          return context2;
-        };
-        self.deleteValue = function(key) {
-          var context2 = new BaseContext2(self._currentContext);
-          context2._currentContext.delete(key);
-          return context2;
-        };
-      }
-      return BaseContext2;
-    })();
-    ROOT_CONTEXT = new BaseContext();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
-var __extends, NoopMeter, NoopMetric, NoopCounterMetric, NoopUpDownCounterMetric, NoopGaugeMetric, NoopHistogramMetric, NoopObservableMetric, NoopObservableCounterMetric, NoopObservableGaugeMetric, NoopObservableUpDownCounterMetric, NOOP_METER, NOOP_COUNTER_METRIC, NOOP_GAUGE_METRIC, NOOP_HISTOGRAM_METRIC, NOOP_UP_DOWN_COUNTER_METRIC, NOOP_OBSERVABLE_COUNTER_METRIC, NOOP_OBSERVABLE_GAUGE_METRIC, NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
-var init_NoopMeter = __esm({
-  "node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js"() {
-    "use strict";
-    __extends = /* @__PURE__ */ (function() {
-      var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-          d2.__proto__ = b2;
-        } || function(d2, b2) {
-          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+          recursionStack.delete(nodeId);
+          return false;
         };
-        return extendStatics(d, b);
-      };
-      return function(d, b) {
-        if (typeof b !== "function" && b !== null)
-          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() {
-          this.constructor = d;
-        }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-      };
-    })();
-    NoopMeter = /** @class */
-    (function() {
-      function NoopMeter2() {
-      }
-      NoopMeter2.prototype.createGauge = function(_name, _options) {
-        return NOOP_GAUGE_METRIC;
-      };
-      NoopMeter2.prototype.createHistogram = function(_name, _options) {
-        return NOOP_HISTOGRAM_METRIC;
-      };
-      NoopMeter2.prototype.createCounter = function(_name, _options) {
-        return NOOP_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.createUpDownCounter = function(_name, _options) {
-        return NOOP_UP_DOWN_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.createObservableGauge = function(_name, _options) {
-        return NOOP_OBSERVABLE_GAUGE_METRIC;
-      };
-      NoopMeter2.prototype.createObservableCounter = function(_name, _options) {
-        return NOOP_OBSERVABLE_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.createObservableUpDownCounter = function(_name, _options) {
-        return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.addBatchObservableCallback = function(_callback, _observables) {
-      };
-      NoopMeter2.prototype.removeBatchObservableCallback = function(_callback) {
-      };
-      return NoopMeter2;
-    })();
-    NoopMetric = /** @class */
-    /* @__PURE__ */ (function() {
-      function NoopMetric2() {
-      }
-      return NoopMetric2;
-    })();
-    NoopCounterMetric = /** @class */
-    (function(_super) {
-      __extends(NoopCounterMetric2, _super);
-      function NoopCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopCounterMetric2.prototype.add = function(_value, _attributes) {
-      };
-      return NoopCounterMetric2;
-    })(NoopMetric);
-    NoopUpDownCounterMetric = /** @class */
-    (function(_super) {
-      __extends(NoopUpDownCounterMetric2, _super);
-      function NoopUpDownCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopUpDownCounterMetric2.prototype.add = function(_value, _attributes) {
-      };
-      return NoopUpDownCounterMetric2;
-    })(NoopMetric);
-    NoopGaugeMetric = /** @class */
-    (function(_super) {
-      __extends(NoopGaugeMetric2, _super);
-      function NoopGaugeMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopGaugeMetric2.prototype.record = function(_value, _attributes) {
-      };
-      return NoopGaugeMetric2;
-    })(NoopMetric);
-    NoopHistogramMetric = /** @class */
-    (function(_super) {
-      __extends(NoopHistogramMetric2, _super);
-      function NoopHistogramMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopHistogramMetric2.prototype.record = function(_value, _attributes) {
-      };
-      return NoopHistogramMetric2;
-    })(NoopMetric);
-    NoopObservableMetric = /** @class */
-    (function() {
-      function NoopObservableMetric2() {
-      }
-      NoopObservableMetric2.prototype.addCallback = function(_callback) {
-      };
-      NoopObservableMetric2.prototype.removeCallback = function(_callback) {
-      };
-      return NoopObservableMetric2;
-    })();
-    NoopObservableCounterMetric = /** @class */
-    (function(_super) {
-      __extends(NoopObservableCounterMetric2, _super);
-      function NoopObservableCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return NoopObservableCounterMetric2;
-    })(NoopObservableMetric);
-    NoopObservableGaugeMetric = /** @class */
-    (function(_super) {
-      __extends(NoopObservableGaugeMetric2, _super);
-      function NoopObservableGaugeMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return NoopObservableGaugeMetric2;
-    })(NoopObservableMetric);
-    NoopObservableUpDownCounterMetric = /** @class */
-    (function(_super) {
-      __extends(NoopObservableUpDownCounterMetric2, _super);
-      function NoopObservableUpDownCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return NoopObservableUpDownCounterMetric2;
-    })(NoopObservableMetric);
-    NOOP_METER = new NoopMeter();
-    NOOP_COUNTER_METRIC = new NoopCounterMetric();
-    NOOP_GAUGE_METRIC = new NoopGaugeMetric();
-    NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
-    NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
-    NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
-    NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
-    NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
-var __read3, __spreadArray3, NoopContextManager;
-var init_NoopContextManager = __esm({
-  "node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() {
-    "use strict";
-    init_context();
-    __read3 = function(o, n) {
-      var m = typeof Symbol === "function" && o[Symbol.iterator];
-      if (!m) return o;
-      var i = m.call(o), r, ar = [], e;
-      try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-      } catch (error) {
-        e = { error };
-      } finally {
-        try {
-          if (r && !r.done && (m = i["return"])) m.call(i);
-        } finally {
-          if (e) throw e.error;
-        }
-      }
-      return ar;
-    };
-    __spreadArray3 = function(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
-        }
-      }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    };
-    NoopContextManager = /** @class */
-    (function() {
-      function NoopContextManager2() {
-      }
-      NoopContextManager2.prototype.active = function() {
-        return ROOT_CONTEXT;
-      };
-      NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
-        var args = [];
-        for (var _i = 3; _i < arguments.length; _i++) {
-          args[_i - 3] = arguments[_i];
-        }
-        return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
-      };
-      NoopContextManager2.prototype.bind = function(_context, target) {
-        return target;
-      };
-      NoopContextManager2.prototype.enable = function() {
-        return this;
-      };
-      NoopContextManager2.prototype.disable = function() {
-        return this;
-      };
-      return NoopContextManager2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/api/context.js
-var __read4, __spreadArray4, API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI;
-var init_context2 = __esm({
-  "node_modules/@opentelemetry/api/build/esm/api/context.js"() {
-    "use strict";
-    init_NoopContextManager();
-    init_global_utils();
-    init_diag();
-    __read4 = function(o, n) {
-      var m = typeof Symbol === "function" && o[Symbol.iterator];
-      if (!m) return o;
-      var i = m.call(o), r, ar = [], e;
-      try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-      } catch (error) {
-        e = { error };
-      } finally {
-        try {
-          if (r && !r.done && (m = i["return"])) m.call(i);
-        } finally {
-          if (e) throw e.error;
+        for (const nodeId of nodes.keys()) {
+          if (!visited.has(nodeId)) {
+            if (dfs(nodeId)) {
+              return { hasCycles: true, cycleNodes: [...new Set(cycleNodes)] };
+            }
+          }
         }
+        return { hasCycles: false };
       }
-      return ar;
-    };
-    __spreadArray4 = function(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
+      /**
+       * Perform topological sort to determine execution order
+       * Groups checks that can run in parallel at each level
+       */
+      static topologicalSort(nodes) {
+        const remainingNodes = new Map(nodes);
+        const executionGroups = [];
+        let level = 0;
+        while (remainingNodes.size > 0) {
+          const readyNodes = [];
+          for (const [nodeId, node] of remainingNodes.entries()) {
+            const unmetDependencies = node.dependencies.filter((depId) => remainingNodes.has(depId));
+            if (unmetDependencies.length === 0) {
+              readyNodes.push(nodeId);
+            }
+          }
+          if (readyNodes.length === 0) {
+            throw new Error("Unable to resolve dependencies - possible circular dependency detected");
+          }
+          executionGroups.push({
+            parallel: readyNodes,
+            level
+          });
+          for (const nodeId of readyNodes) {
+            remainingNodes.delete(nodeId);
+          }
+          level++;
         }
+        return executionGroups;
       }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    };
-    API_NAME2 = "context";
-    NOOP_CONTEXT_MANAGER = new NoopContextManager();
-    ContextAPI = /** @class */
-    (function() {
-      function ContextAPI2() {
-      }
-      ContextAPI2.getInstance = function() {
-        if (!this._instance) {
-          this._instance = new ContextAPI2();
-        }
-        return this._instance;
-      };
-      ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
-        return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
-      };
-      ContextAPI2.prototype.active = function() {
-        return this._getContextManager().active();
-      };
-      ContextAPI2.prototype.with = function(context2, fn, thisArg) {
-        var _a;
-        var args = [];
-        for (var _i = 3; _i < arguments.length; _i++) {
-          args[_i - 3] = arguments[_i];
-        }
-        return (_a = this._getContextManager()).with.apply(_a, __spreadArray4([context2, fn, thisArg], __read4(args), false));
-      };
-      ContextAPI2.prototype.bind = function(context2, target) {
-        return this._getContextManager().bind(context2, target);
-      };
-      ContextAPI2.prototype._getContextManager = function() {
-        return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
-      };
-      ContextAPI2.prototype.disable = function() {
-        this._getContextManager().disable();
-        unregisterGlobal(API_NAME2, DiagAPI.instance());
-      };
-      return ContextAPI2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
-var TraceFlags;
-var init_trace_flags = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() {
-    "use strict";
-    (function(TraceFlags2) {
-      TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
-      TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
-    })(TraceFlags || (TraceFlags = {}));
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
-var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
-var init_invalid_span_constants = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js"() {
-    "use strict";
-    init_trace_flags();
-    INVALID_SPANID = "0000000000000000";
-    INVALID_TRACEID = "00000000000000000000000000000000";
-    INVALID_SPAN_CONTEXT = {
-      traceId: INVALID_TRACEID,
-      spanId: INVALID_SPANID,
-      traceFlags: TraceFlags.NONE
-    };
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
-var NonRecordingSpan;
-var init_NonRecordingSpan = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js"() {
-    "use strict";
-    init_invalid_span_constants();
-    NonRecordingSpan = /** @class */
-    (function() {
-      function NonRecordingSpan2(_spanContext) {
-        if (_spanContext === void 0) {
-          _spanContext = INVALID_SPAN_CONTEXT;
+      /**
+       * Validate that all dependencies exist
+       */
+      static validateDependencies(checkIds, dependencies) {
+        const errors = [];
+        const checkIdSet = new Set(checkIds);
+        for (const [checkId, deps] of Object.entries(dependencies)) {
+          if (!checkIdSet.has(checkId)) {
+            errors.push(`Check "${checkId}" is not in the list of available checks`);
+            continue;
+          }
+          for (const depId of deps || []) {
+            if (!checkIdSet.has(depId)) {
+              errors.push(`Check "${checkId}" depends on "${depId}" which is not available`);
+            }
+          }
         }
-        this._spanContext = _spanContext;
+        return {
+          valid: errors.length === 0,
+          errors
+        };
       }
-      NonRecordingSpan2.prototype.spanContext = function() {
-        return this._spanContext;
-      };
-      NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.addLink = function(_link) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.addLinks = function(_links) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.setStatus = function(_status) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.updateName = function(_name) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.end = function(_endTime) {
-      };
-      NonRecordingSpan2.prototype.isRecording = function() {
-        return false;
-      };
-      NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
-      };
-      return NonRecordingSpan2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
-function getSpan(context2) {
-  return context2.getValue(SPAN_KEY) || void 0;
-}
-function getActiveSpan() {
-  return getSpan(ContextAPI.getInstance().active());
-}
-function setSpan(context2, span) {
-  return context2.setValue(SPAN_KEY, span);
-}
-function deleteSpan(context2) {
-  return context2.deleteValue(SPAN_KEY);
-}
-function setSpanContext(context2, spanContext) {
-  return setSpan(context2, new NonRecordingSpan(spanContext));
-}
-function getSpanContext(context2) {
-  var _a;
-  return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
-}
-var SPAN_KEY;
-var init_context_utils = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/context-utils.js"() {
-    "use strict";
-    init_context();
-    init_NonRecordingSpan();
-    init_context2();
-    SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
-function isValidTraceId(traceId) {
-  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
-}
-function isValidSpanId(spanId) {
-  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
-}
-function isSpanContextValid(spanContext) {
-  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
-}
-function wrapSpanContext(spanContext) {
-  return new NonRecordingSpan(spanContext);
-}
-var VALID_TRACEID_REGEX, VALID_SPANID_REGEX;
-var init_spancontext_utils = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js"() {
-    "use strict";
-    init_invalid_span_constants();
-    init_NonRecordingSpan();
-    VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
-    VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
-function isSpanContext(spanContext) {
-  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
-}
-var contextApi, NoopTracer;
-var init_NoopTracer = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js"() {
-    "use strict";
-    init_context2();
-    init_context_utils();
-    init_NonRecordingSpan();
-    init_spancontext_utils();
-    contextApi = ContextAPI.getInstance();
-    NoopTracer = /** @class */
-    (function() {
-      function NoopTracer2() {
-      }
-      NoopTracer2.prototype.startSpan = function(name, options, context2) {
-        if (context2 === void 0) {
-          context2 = contextApi.active();
-        }
-        var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
-        if (root) {
-          return new NonRecordingSpan();
-        }
-        var parentFromContext = context2 && getSpanContext(context2);
-        if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
-          return new NonRecordingSpan(parentFromContext);
-        } else {
-          return new NonRecordingSpan();
-        }
-      };
-      NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
-        var opts;
-        var ctx;
-        var fn;
-        if (arguments.length < 2) {
-          return;
-        } else if (arguments.length === 2) {
-          fn = arg2;
-        } else if (arguments.length === 3) {
-          opts = arg2;
-          fn = arg3;
-        } else {
-          opts = arg2;
-          ctx = arg3;
-          fn = arg4;
-        }
-        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-        var span = this.startSpan(name, opts, parentContext);
-        var contextWithSpanSet = setSpan(parentContext, span);
-        return contextApi.with(contextWithSpanSet, fn, void 0, span);
-      };
-      return NoopTracer2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
-var NOOP_TRACER, ProxyTracer;
-var init_ProxyTracer = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js"() {
-    "use strict";
-    init_NoopTracer();
-    NOOP_TRACER = new NoopTracer();
-    ProxyTracer = /** @class */
-    (function() {
-      function ProxyTracer2(_provider, name, version, options) {
-        this._provider = _provider;
-        this.name = name;
-        this.version = version;
-        this.options = options;
-      }
-      ProxyTracer2.prototype.startSpan = function(name, options, context2) {
-        return this._getTracer().startSpan(name, options, context2);
-      };
-      ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
-        var tracer = this._getTracer();
-        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
-      };
-      ProxyTracer2.prototype._getTracer = function() {
-        if (this._delegate) {
-          return this._delegate;
-        }
-        var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
-        if (!tracer) {
-          return NOOP_TRACER;
-        }
-        this._delegate = tracer;
-        return this._delegate;
-      };
-      return ProxyTracer2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
-var NoopTracerProvider;
-var init_NoopTracerProvider = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js"() {
-    "use strict";
-    init_NoopTracer();
-    NoopTracerProvider = /** @class */
-    (function() {
-      function NoopTracerProvider2() {
+      /**
+       * Get all transitive dependencies (ancestors) for a given check
+       * This returns all checks that must complete before the given check can run,
+       * not just the direct dependencies.
+       *
+       * For example, if A -> B -> C, then:
+       * - getAllDependencies(C) returns [A, B]
+       * - getAllDependencies(B) returns [A]
+       * - getAllDependencies(A) returns []
+       *
+       * @param checkId The check to find dependencies for
+       * @param nodes The dependency graph nodes
+       * @returns Array of all transitive dependency IDs
+       */
+      static getAllDependencies(checkId, nodes) {
+        const allDeps = /* @__PURE__ */ new Set();
+        const visited = /* @__PURE__ */ new Set();
+        const collectDependencies = (currentId) => {
+          if (visited.has(currentId)) {
+            return;
+          }
+          visited.add(currentId);
+          const node = nodes.get(currentId);
+          if (!node) {
+            return;
+          }
+          for (const depId of node.dependencies) {
+            allDeps.add(depId);
+            collectDependencies(depId);
+          }
+        };
+        collectDependencies(checkId);
+        return Array.from(allDeps);
       }
-      NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
-        return new NoopTracer();
-      };
-      return NoopTracerProvider2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
-var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
-var init_ProxyTracerProvider = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js"() {
-    "use strict";
-    init_ProxyTracer();
-    init_NoopTracerProvider();
-    NOOP_TRACER_PROVIDER = new NoopTracerProvider();
-    ProxyTracerProvider = /** @class */
-    (function() {
-      function ProxyTracerProvider2() {
-      }
-      ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
-        var _a;
-        return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
-      };
-      ProxyTracerProvider2.prototype.getDelegate = function() {
-        var _a;
-        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
-      };
-      ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
-        this._delegate = delegate;
-      };
-      ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
-        var _a;
-        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
-      };
-      return ProxyTracerProvider2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/context-api.js
-var context;
-var init_context_api = __esm({
-  "node_modules/@opentelemetry/api/build/esm/context-api.js"() {
-    "use strict";
-    init_context2();
-    context = ContextAPI.getInstance();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
-var NoopMeterProvider, NOOP_METER_PROVIDER;
-var init_NoopMeterProvider = __esm({
-  "node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js"() {
-    "use strict";
-    init_NoopMeter();
-    NoopMeterProvider = /** @class */
-    (function() {
-      function NoopMeterProvider2() {
+      /**
+       * Get execution statistics for debugging
+       */
+      static getExecutionStats(graph) {
+        const totalChecks = graph.nodes.size;
+        const parallelLevels = graph.executionOrder.length;
+        const maxParallelism = Math.max(...graph.executionOrder.map((group) => group.parallel.length));
+        const averageParallelism = totalChecks / parallelLevels;
+        const checksWithDependencies = Array.from(graph.nodes.values()).filter(
+          (node) => node.dependencies.length > 0
+        ).length;
+        return {
+          totalChecks,
+          parallelLevels,
+          maxParallelism,
+          averageParallelism,
+          checksWithDependencies
+        };
       }
-      NoopMeterProvider2.prototype.getMeter = function(_name, _version, _options) {
-        return NOOP_METER;
-      };
-      return NoopMeterProvider2;
-    })();
-    NOOP_METER_PROVIDER = new NoopMeterProvider();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/api/metrics.js
-var API_NAME3, MetricsAPI;
-var init_metrics = __esm({
-  "node_modules/@opentelemetry/api/build/esm/api/metrics.js"() {
-    "use strict";
-    init_NoopMeterProvider();
-    init_global_utils();
-    init_diag();
-    API_NAME3 = "metrics";
-    MetricsAPI = /** @class */
-    (function() {
-      function MetricsAPI2() {
-      }
-      MetricsAPI2.getInstance = function() {
-        if (!this._instance) {
-          this._instance = new MetricsAPI2();
-        }
-        return this._instance;
-      };
-      MetricsAPI2.prototype.setGlobalMeterProvider = function(provider) {
-        return registerGlobal(API_NAME3, provider, DiagAPI.instance());
-      };
-      MetricsAPI2.prototype.getMeterProvider = function() {
-        return getGlobal(API_NAME3) || NOOP_METER_PROVIDER;
-      };
-      MetricsAPI2.prototype.getMeter = function(name, version, options) {
-        return this.getMeterProvider().getMeter(name, version, options);
-      };
-      MetricsAPI2.prototype.disable = function() {
-        unregisterGlobal(API_NAME3, DiagAPI.instance());
-      };
-      return MetricsAPI2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/metrics-api.js
-var metrics;
-var init_metrics_api = __esm({
-  "node_modules/@opentelemetry/api/build/esm/metrics-api.js"() {
-    "use strict";
-    init_metrics();
-    metrics = MetricsAPI.getInstance();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/api/trace.js
-var API_NAME4, TraceAPI;
-var init_trace = __esm({
-  "node_modules/@opentelemetry/api/build/esm/api/trace.js"() {
-    "use strict";
-    init_global_utils();
-    init_ProxyTracerProvider();
-    init_spancontext_utils();
-    init_context_utils();
-    init_diag();
-    API_NAME4 = "trace";
-    TraceAPI = /** @class */
-    (function() {
-      function TraceAPI2() {
-        this._proxyTracerProvider = new ProxyTracerProvider();
-        this.wrapSpanContext = wrapSpanContext;
-        this.isSpanContextValid = isSpanContextValid;
-        this.deleteSpan = deleteSpan;
-        this.getSpan = getSpan;
-        this.getActiveSpan = getActiveSpan;
-        this.getSpanContext = getSpanContext;
-        this.setSpan = setSpan;
-        this.setSpanContext = setSpanContext;
-      }
-      TraceAPI2.getInstance = function() {
-        if (!this._instance) {
-          this._instance = new TraceAPI2();
-        }
-        return this._instance;
-      };
-      TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
-        var success = registerGlobal(API_NAME4, this._proxyTracerProvider, DiagAPI.instance());
-        if (success) {
-          this._proxyTracerProvider.setDelegate(provider);
-        }
-        return success;
-      };
-      TraceAPI2.prototype.getTracerProvider = function() {
-        return getGlobal(API_NAME4) || this._proxyTracerProvider;
-      };
-      TraceAPI2.prototype.getTracer = function(name, version) {
-        return this.getTracerProvider().getTracer(name, version);
-      };
-      TraceAPI2.prototype.disable = function() {
-        unregisterGlobal(API_NAME4, DiagAPI.instance());
-        this._proxyTracerProvider = new ProxyTracerProvider();
-      };
-      return TraceAPI2;
-    })();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/trace-api.js
-var trace;
-var init_trace_api = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace-api.js"() {
-    "use strict";
-    init_trace();
-    trace = TraceAPI.getInstance();
-  }
-});
-
-// node_modules/@opentelemetry/api/build/esm/index.js
-var init_esm = __esm({
-  "node_modules/@opentelemetry/api/build/esm/index.js"() {
-    "use strict";
-    init_context_api();
-    init_metrics_api();
-    init_trace_api();
+    };
   }
 });
 
@@ -9471,7 +8894,7 @@ var init_fallback_ndjson = __esm({
 
 // src/telemetry/trace-helpers.ts
 function addEvent(name, attrs) {
-  const span = trace.getSpan(context.active());
+  const span = import_api.trace.getSpan(import_api.context.active());
   if (span) {
     try {
       span.addEvent(name, attrs);
@@ -9490,10 +8913,11 @@ function addEvent(name, attrs) {
   } catch {
   }
 }
+var import_api;
 var init_trace_helpers = __esm({
   "src/telemetry/trace-helpers.ts"() {
     "use strict";
-    init_esm();
+    import_api = require("@opentelemetry/api");
   }
 });
 
@@ -9548,26 +8972,26 @@ function addDiagramBlock(origin) {
   } catch {
   }
 }
-var initialized, meter, TEST_ENABLED, TEST_SNAPSHOT, checkDurationHist, providerDurationHist, foreachDurationHist, issuesCounter, activeChecks, failIfCounter, diagramBlocks;
-var init_metrics2 = __esm({
+var import_api2, initialized, meter, TEST_ENABLED, TEST_SNAPSHOT, checkDurationHist, providerDurationHist, foreachDurationHist, issuesCounter, activeChecks, failIfCounter, diagramBlocks;
+var init_metrics = __esm({
   "src/telemetry/metrics.ts"() {
     "use strict";
-    init_esm();
+    import_api2 = require("@opentelemetry/api");
     initialized = false;
-    meter = metrics.getMeter("visor");
+    meter = import_api2.metrics.getMeter("visor");
     TEST_ENABLED = process.env.VISOR_TEST_METRICS === "true";
     TEST_SNAPSHOT = { fail_if_triggered: 0 };
   }
 });
 
 // src/failure-condition-evaluator.ts
-var import_sandboxjs4, FailureConditionEvaluator;
+var import_sandboxjs5, FailureConditionEvaluator;
 var init_failure_condition_evaluator = __esm({
   "src/failure-condition-evaluator.ts"() {
     "use strict";
     init_trace_helpers();
-    init_metrics2();
-    import_sandboxjs4 = __toESM(require("@nyariv/sandboxjs"));
+    init_metrics();
+    import_sandboxjs5 = __toESM(require("@nyariv/sandboxjs"));
     init_author_permissions();
     init_memory_store();
     FailureConditionEvaluator = class _FailureConditionEvaluator {
@@ -9579,7 +9003,7 @@ var init_failure_condition_evaluator = __esm({
        */
       createSecureSandbox() {
         const globals = {
-          ...import_sandboxjs4.default.SAFE_GLOBALS,
+          ...import_sandboxjs5.default.SAFE_GLOBALS,
           // Allow Math for calculations
           Math,
           // Allow console for debugging (in controlled environment)
@@ -9589,7 +9013,7 @@ var init_failure_condition_evaluator = __esm({
             error: console.error
           }
         };
-        const prototypeWhitelist = new Map(import_sandboxjs4.default.SAFE_PROTOTYPES);
+        const prototypeWhitelist = new Map(import_sandboxjs5.default.SAFE_PROTOTYPES);
         const arrayMethods = /* @__PURE__ */ new Set([
           "some",
           "every",
@@ -9622,7 +9046,7 @@ var init_failure_condition_evaluator = __esm({
         prototypeWhitelist.set(String.prototype, stringMethods);
         const objectMethods = /* @__PURE__ */ new Set(["hasOwnProperty", "toString", "valueOf"]);
         prototypeWhitelist.set(Object.prototype, objectMethods);
-        return new import_sandboxjs4.default({
+        return new import_sandboxjs5.default({
           globals,
           prototypeWhitelist
         });
@@ -9631,7 +9055,7 @@ var init_failure_condition_evaluator = __esm({
        * Evaluate simple fail_if condition
        */
       async evaluateSimpleCondition(checkName, checkSchema, checkGroup, reviewSummary, expression, previousOutputs, authorAssociation) {
-        const context2 = this.buildEvaluationContext(
+        const context = this.buildEvaluationContext(
           checkName,
           checkSchema,
           checkGroup,
@@ -9641,17 +9065,17 @@ var init_failure_condition_evaluator = __esm({
         );
         try {
           try {
-            const isObj = context2.output && typeof context2.output === "object";
-            const keys = isObj ? Object.keys(context2.output).join(",") : typeof context2.output;
+            const isObj = context.output && typeof context.output === "object";
+            const keys = isObj ? Object.keys(context.output).join(",") : typeof context.output;
             let errorVal = void 0;
-            if (isObj && context2.output.error !== void 0)
-              errorVal = context2.output.error;
+            if (isObj && context.output.error !== void 0)
+              errorVal = context.output.error;
             (init_logger(), __toCommonJS(logger_exports)).logger.debug(
               `  fail_if: evaluating '${expression}' with output keys=${keys} error=${String(errorVal)}`
             );
           } catch {
           }
-          const res = this.evaluateExpression(expression, context2);
+          const res = this.evaluateExpression(expression, context);
           if (res === true) {
             try {
               addEvent("fail_if.triggered", {
@@ -9710,7 +9134,7 @@ var init_failure_condition_evaluator = __esm({
        * Evaluate if condition to determine whether a check should run
        */
       async evaluateIfCondition(checkName, expression, contextData) {
-        const context2 = {
+        const context = {
           // Check metadata
           checkName,
           // Git context
@@ -9759,7 +9183,7 @@ var init_failure_condition_evaluator = __esm({
           }
         };
         try {
-          return this.evaluateExpression(expression, context2);
+          return this.evaluateExpression(expression, context);
         } catch (error) {
           console.warn(`Failed to evaluate if expression for check '${checkName}': ${error}`);
           return true;
@@ -9769,7 +9193,7 @@ var init_failure_condition_evaluator = __esm({
        * Evaluate all failure conditions for a check result
        */
       async evaluateConditions(checkName, checkSchema, checkGroup, reviewSummary, globalConditions, checkConditions, previousOutputs, authorAssociation) {
-        const context2 = this.buildEvaluationContext(
+        const context = this.buildEvaluationContext(
           checkName,
           checkSchema,
           checkGroup,
@@ -9779,11 +9203,11 @@ var init_failure_condition_evaluator = __esm({
         );
         const results = [];
         if (globalConditions) {
-          const globalResults = await this.evaluateConditionSet(globalConditions, context2, "global");
+          const globalResults = await this.evaluateConditionSet(globalConditions, context, "global");
           results.push(...globalResults);
         }
         if (checkConditions) {
-          const checkResults = await this.evaluateConditionSet(checkConditions, context2, "check");
+          const checkResults = await this.evaluateConditionSet(checkConditions, context, "check");
           const overriddenConditions = new Set(Object.keys(checkConditions));
           const filteredResults = results.filter(
             (result) => !overriddenConditions.has(result.conditionName)
@@ -9795,7 +9219,7 @@ var init_failure_condition_evaluator = __esm({
           if (checkName === "B") {
             console.error(
               `\u{1F527} Debug: fail_if results for ${checkName}: ${JSON.stringify(results)} context.output=${JSON.stringify(
-                context2.output
+                context.output
               )}`
             );
           }
@@ -9806,12 +9230,12 @@ var init_failure_condition_evaluator = __esm({
       /**
        * Evaluate a set of failure conditions
        */
-      async evaluateConditionSet(conditions, context2, source) {
+      async evaluateConditionSet(conditions, context, source) {
         const results = [];
         for (const [conditionName, condition] of Object.entries(conditions)) {
           try {
             addEvent("fail_if.evaluated", {
-              check: context2.checkName,
+              check: context.checkName,
               scope: source,
               name: conditionName,
               expression: this.extractExpression(condition)
@@ -9822,12 +9246,12 @@ var init_failure_condition_evaluator = __esm({
             const { emitNdjsonSpanWithEvents: emitNdjsonSpanWithEvents2 } = (init_fallback_ndjson(), __toCommonJS(fallback_ndjson_exports));
             emitNdjsonSpanWithEvents2(
               "visor.fail_if",
-              { check: context2.checkName || "unknown", scope: source, name: conditionName },
+              { check: context.checkName || "unknown", scope: source, name: conditionName },
               [
                 {
                   name: "fail_if.evaluated",
                   attrs: {
-                    check: context2.checkName,
+                    check: context.checkName,
                     scope: source,
                     name: conditionName,
                     expression: this.extractExpression(condition)
@@ -9838,12 +9262,12 @@ var init_failure_condition_evaluator = __esm({
           } catch {
           }
           try {
-            const result = await this.evaluateSingleCondition(conditionName, condition, context2);
+            const result = await this.evaluateSingleCondition(conditionName, condition, context);
             results.push(result);
             if (result.failed) {
               try {
                 addEvent("fail_if.triggered", {
-                  check: context2.checkName,
+                  check: context.checkName,
                   scope: source,
                   name: conditionName,
                   expression: result.expression,
@@ -9853,7 +9277,7 @@ var init_failure_condition_evaluator = __esm({
               } catch {
               }
               try {
-                addFailIfTriggered(context2.checkName || "unknown", source);
+                addFailIfTriggered(context.checkName || "unknown", source);
               } catch {
               }
             }
@@ -9873,11 +9297,11 @@ var init_failure_condition_evaluator = __esm({
       /**
        * Evaluate a single failure condition
        */
-      async evaluateSingleCondition(conditionName, condition, context2) {
+      async evaluateSingleCondition(conditionName, condition, context) {
         const expression = this.extractExpression(condition);
         const config = this.extractConditionConfig(condition);
         try {
-          const failed = this.evaluateExpression(expression, context2);
+          const failed = this.evaluateExpression(expression, context);
           return {
             conditionName,
             failed,
@@ -9896,7 +9320,7 @@ var init_failure_condition_evaluator = __esm({
        * Secure expression evaluation using SandboxJS
        * Supports the same GitHub Actions-style functions as the previous implementation
        */
-      evaluateExpression(condition, context2) {
+      evaluateExpression(condition, context) {
         try {
           const normalize2 = (expr) => {
             const trimmed = expr.trim();
@@ -9941,7 +9365,7 @@ var init_failure_condition_evaluator = __esm({
           const hasIssueWith = hasIssue;
           const hasFileWith = hasFileMatching;
           const permissionHelpers = createPermissionHelpers(
-            context2.authorAssociation,
+            context.authorAssociation,
             detectLocalMode()
           );
           const hasMinPermission2 = permissionHelpers.hasMinPermission;
@@ -9950,35 +9374,35 @@ var init_failure_condition_evaluator = __esm({
           const isCollaborator2 = permissionHelpers.isCollaborator;
           const isContributor2 = permissionHelpers.isContributor;
           const isFirstTimer2 = permissionHelpers.isFirstTimer;
-          const output = context2.output || {};
+          const output = context.output || {};
           const issues = output.issues || [];
-          const metadata = context2.metadata || {
-            checkName: context2.checkName || "",
-            schema: context2.schema || "",
-            group: context2.group || "",
+          const metadata = context.metadata || {
+            checkName: context.checkName || "",
+            schema: context.schema || "",
+            group: context.group || "",
             criticalIssues: issues.filter((i) => i.severity === "critical").length,
             errorIssues: issues.filter((i) => i.severity === "error").length,
             warningIssues: issues.filter((i) => i.severity === "warning").length,
             infoIssues: issues.filter((i) => i.severity === "info").length,
             totalIssues: issues.length,
-            hasChanges: context2.hasChanges || false
+            hasChanges: context.hasChanges || false
           };
           const criticalIssues = metadata.criticalIssues;
           const errorIssues = metadata.errorIssues;
           const totalIssues = metadata.totalIssues;
           const warningIssues = metadata.warningIssues;
           const infoIssues = metadata.infoIssues;
-          const checkName = context2.checkName || "";
-          const schema = context2.schema || "";
-          const group = context2.group || "";
-          const branch = context2.branch || "unknown";
-          const baseBranch = context2.baseBranch || "main";
-          const filesChanged = context2.filesChanged || [];
-          const filesCount = context2.filesCount || 0;
-          const event = context2.event || "manual";
-          const env = context2.env || {};
-          const outputs = context2.outputs || {};
-          const debugData = context2.debug || null;
+          const checkName = context.checkName || "";
+          const schema = context.schema || "";
+          const group = context.group || "";
+          const branch = context.branch || "unknown";
+          const baseBranch = context.baseBranch || "main";
+          const filesChanged = context.filesChanged || [];
+          const filesCount = context.filesCount || 0;
+          const event = context.event || "manual";
+          const env = context.env || {};
+          const outputs = context.outputs || {};
+          const debugData = context.debug || null;
           const memoryStore = MemoryStore.getInstance();
           const memoryAccessor = {
             get: (key, ns) => memoryStore.get(key, ns),
@@ -10179,7 +9603,7 @@ var init_failure_condition_evaluator = __esm({
         } catch {
         }
         const memoryStore = MemoryStore.getInstance();
-        const context2 = {
+        const context = {
           output: aggregatedOutput,
           outputs: (() => {
             if (!previousOutputs) return {};
@@ -10204,14 +9628,14 @@ var init_failure_condition_evaluator = __esm({
           authorAssociation
         };
         if (debug) {
-          context2.debug = {
+          context.debug = {
             errors: debug.errors || [],
             processingTime: debug.processingTime || 0,
             provider: debug.provider || "unknown",
             model: debug.model || "unknown"
           };
         }
-        return context2;
+        return context;
       }
       // Minimal JSON-from-end extractor for fail_if context fallback
       tryExtractJsonFromEnd(text) {
@@ -10791,7 +10215,7 @@ var init_mermaid_telemetry = __esm({
   "src/utils/mermaid-telemetry.ts"() {
     "use strict";
     init_trace_helpers();
-    init_metrics2();
+    init_metrics();
     fs9 = __toESM(require("fs"));
     path10 = __toESM(require("path"));
     MERMAID_RE = /```mermaid\s*\n([\s\S]*?)\n```/gi;
@@ -10826,7 +10250,7 @@ function getSafeEnvironmentVariables() {
   }
   return safeEnv;
 }
-var import_sandboxjs5, CheckExecutionEngine;
+var import_sandboxjs6, CheckExecutionEngine;
 var init_check_execution_engine = __esm({
   "src/check-execution-engine.ts"() {
     "use strict";
@@ -10839,12 +10263,12 @@ var init_check_execution_engine = __esm({
     init_github_check_service();
     init_issue_filter();
     init_logger();
-    import_sandboxjs5 = __toESM(require("@nyariv/sandboxjs"));
+    import_sandboxjs6 = __toESM(require("@nyariv/sandboxjs"));
     init_author_permissions();
     init_memory_store();
     init_fallback_ndjson();
     init_trace_helpers();
-    init_metrics2();
+    init_metrics();
     CheckExecutionEngine = class _CheckExecutionEngine {
       gitAnalyzer;
       mockOctokit;
@@ -10898,13 +10322,13 @@ var init_check_execution_engine = __esm({
       getRoutingSandbox() {
         if (this.routingSandbox) return this.routingSandbox;
         const globals = {
-          ...import_sandboxjs5.default.SAFE_GLOBALS,
+          ...import_sandboxjs6.default.SAFE_GLOBALS,
           Math,
           JSON,
           console: { log: console.log }
         };
-        const prototypeWhitelist = new Map(import_sandboxjs5.default.SAFE_PROTOTYPES);
-        this.routingSandbox = new import_sandboxjs5.default({ globals, prototypeWhitelist });
+        const prototypeWhitelist = new Map(import_sandboxjs6.default.SAFE_PROTOTYPES);
+        this.routingSandbox = new import_sandboxjs6.default({ globals, prototypeWhitelist });
         return this.routingSandbox;
       }
       redact(str, limit = 200) {
@@ -12269,7 +11693,7 @@ ${expr}
           if (!sanitizedSchema) {
             throw new Error("Invalid schema name");
           }
-          const templatePath = path13.join(__dirname, `../output/${sanitizedSchema}/template.liquid`);
+          const templatePath = path13.join(__dirname, `output/${sanitizedSchema}/template.liquid`);
           templateContent = await fs12.readFile(templatePath, "utf-8");
           if (sanitizedSchema === "issue-assistant") {
             enrichAssistantContext = true;
@@ -15713,6 +15137,23 @@ var init_config_schema = __esm({
                 }
               ],
               description: "Values for GitHub operations (can be array or single value)"
+            },
+            transport: {
+              type: "string",
+              enum: ["stdio", "sse", "http"],
+              description: "Transport type for MCP: stdio (default), sse (legacy), or http (streamable HTTP)"
+            },
+            methodArgs: {
+              $ref: "#/definitions/Record%3Cstring%2Cunknown%3E",
+              description: "Arguments to pass to the MCP method (supports Liquid templates)"
+            },
+            argsTransform: {
+              type: "string",
+              description: "Transform template for method arguments (Liquid)"
+            },
+            sessionId: {
+              type: "string",
+              description: "Session ID for HTTP transport (optional, server may generate one)"
             }
           },
           additionalProperties: false,
@@ -15733,7 +15174,8 @@ var init_config_schema = __esm({
             "log",
             "memory",
             "github",
-            "claude-code"
+            "claude-code",
+            "mcp"
           ],
           description: "Valid check types in configuration"
         },