@probelabs/visor 0.1.131 → 0.1.132-ee

package/dist/sdk/sdk.js

@@ -646,7 +646,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@probelabs/visor",
-      version: "0.1.131",
+      version: "0.1.42",
       main: "dist/index.js",
       bin: {
         visor: "./dist/index.js"
@@ -731,7 +731,7 @@ var require_package = __commonJS({
       ],
       author: "Probe Labs",
       license: "MIT",
-      description: "AI-powered code review tool for GitHub Pull Requests - CLI and GitHub Action",
+      description: "AI workflow engine for code review, assistants, and automation \u2014 orchestrate checks, MCP tools, and AI providers with YAML-driven pipelines",
       repository: {
         type: "git",
         url: "git+https://github.com/probelabs/visor.git"
@@ -748,7 +748,7 @@ var require_package = __commonJS({
         "@octokit/auth-app": "^8.1.0",
         "@octokit/core": "^7.0.3",
         "@octokit/rest": "^22.0.0",
-        "@probelabs/probe": "^0.6.0-rc232",
+        "@probelabs/probe": "^0.6.0-rc245",
         "@types/commander": "^2.12.0",
         "@types/uuid": "^10.0.0",
         ajv: "^8.17.1",
@@ -857,11 +857,11 @@ function getTracer() {
 }
 async function withActiveSpan(name, attrs, fn) {
   const tracer = getTracer();
-  return await new Promise((resolve11, reject) => {
+  return await new Promise((resolve15, reject) => {
     const callback = async (span) => {
       try {
         const res = await fn(span);
-        resolve11(res);
+        resolve15(res);
       } catch (err) {
         try {
           if (err instanceof Error) span.recordException(err);
@@ -938,19 +938,19 @@ function __getOrCreateNdjsonPath() {
   try {
     if (process.env.VISOR_TELEMETRY_SINK && process.env.VISOR_TELEMETRY_SINK !== "file")
       return null;
-    const path25 = require("path");
-    const fs21 = require("fs");
+    const path29 = require("path");
+    const fs25 = require("fs");
     if (process.env.VISOR_FALLBACK_TRACE_FILE) {
       __ndjsonPath = process.env.VISOR_FALLBACK_TRACE_FILE;
-      const dir = path25.dirname(__ndjsonPath);
-      if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
+      const dir = path29.dirname(__ndjsonPath);
+      if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
       return __ndjsonPath;
     }
-    const outDir = process.env.VISOR_TRACE_DIR || path25.join(process.cwd(), "output", "traces");
-    if (!fs21.existsSync(outDir)) fs21.mkdirSync(outDir, { recursive: true });
+    const outDir = process.env.VISOR_TRACE_DIR || path29.join(process.cwd(), "output", "traces");
+    if (!fs25.existsSync(outDir)) fs25.mkdirSync(outDir, { recursive: true });
     if (!__ndjsonPath) {
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      __ndjsonPath = path25.join(outDir, `${ts}.ndjson`);
+      __ndjsonPath = path29.join(outDir, `${ts}.ndjson`);
     }
     return __ndjsonPath;
   } catch {
@@ -959,11 +959,11 @@ function __getOrCreateNdjsonPath() {
 }
 function _appendRunMarker() {
   try {
-    const fs21 = require("fs");
+    const fs25 = require("fs");
     const p = __getOrCreateNdjsonPath();
     if (!p) return;
     const line = { name: "visor.run", attributes: { started: true } };
-    fs21.appendFileSync(p, JSON.stringify(line) + "\n", "utf8");
+    fs25.appendFileSync(p, JSON.stringify(line) + "\n", "utf8");
   } catch {
   }
 }
@@ -3156,7 +3156,7 @@ var init_failure_condition_evaluator = __esm({
        */
       evaluateExpression(condition, context2) {
         try {
-          const normalize4 = (expr) => {
+          const normalize8 = (expr) => {
             const trimmed = expr.trim();
             if (!/[\n;]/.test(trimmed)) return trimmed;
             const parts = trimmed.split(/[\n;]+/).map((s) => s.trim()).filter((s) => s.length > 0 && !s.startsWith("//"));
@@ -3314,7 +3314,7 @@ var init_failure_condition_evaluator = __esm({
           try {
             exec2 = this.sandbox.compile(`return (${raw});`);
           } catch {
-            const normalizedExpr = normalize4(condition);
+            const normalizedExpr = normalize8(condition);
             exec2 = this.sandbox.compile(`return (${normalizedExpr});`);
           }
           const result = exec2(scope).run();
@@ -3697,9 +3697,9 @@ function configureLiquidWithExtensions(liquid) {
   });
   liquid.registerFilter("get", (obj, pathExpr) => {
     if (obj == null) return void 0;
-    const path25 = typeof pathExpr === "string" ? pathExpr : String(pathExpr || "");
-    if (!path25) return obj;
-    const parts = path25.split(".");
+    const path29 = typeof pathExpr === "string" ? pathExpr : String(pathExpr || "");
+    if (!path29) return obj;
+    const parts = path29.split(".");
     let cur = obj;
     for (const p of parts) {
       if (cur == null) return void 0;
@@ -3818,9 +3818,9 @@ function configureLiquidWithExtensions(liquid) {
           }
         }
         const defaultRole = typeof rolesCfg.default === "string" && rolesCfg.default.trim() ? rolesCfg.default.trim() : void 0;
-        const getNested = (obj, path25) => {
-          if (!obj || !path25) return void 0;
-          const parts = path25.split(".");
+        const getNested = (obj, path29) => {
+          if (!obj || !path29) return void 0;
+          const parts = path29.split(".");
           let cur = obj;
           for (const p of parts) {
             if (cur == null) return void 0;
@@ -6372,8 +6372,8 @@ var init_dependency_gating = __esm({
 async function renderTemplateContent(checkId, checkConfig, reviewSummary) {
   try {
     const { createExtendedLiquid: createExtendedLiquid2 } = await Promise.resolve().then(() => (init_liquid_extensions(), liquid_extensions_exports));
-    const fs21 = await import("fs/promises");
-    const path25 = await import("path");
+    const fs25 = await import("fs/promises");
+    const path29 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
     const schema = typeof schemaRaw === "string" ? schemaRaw : "code-review";
     let templateContent;
@@ -6381,24 +6381,24 @@ async function renderTemplateContent(checkId, checkConfig, reviewSummary) {
       templateContent = String(checkConfig.template.content);
     } else if (checkConfig.template && checkConfig.template.file) {
       const file = String(checkConfig.template.file);
-      const resolved = path25.resolve(process.cwd(), file);
-      templateContent = await fs21.readFile(resolved, "utf-8");
+      const resolved = path29.resolve(process.cwd(), file);
+      templateContent = await fs25.readFile(resolved, "utf-8");
     } else if (schema && schema !== "plain") {
       const sanitized = String(schema).replace(/[^a-zA-Z0-9-]/g, "");
       if (sanitized) {
         const candidatePaths = [
-          path25.join(__dirname, "output", sanitized, "template.liquid"),
+          path29.join(__dirname, "output", sanitized, "template.liquid"),
           // bundled: dist/output/
-          path25.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
+          path29.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
           // source: output/
-          path25.join(process.cwd(), "output", sanitized, "template.liquid"),
+          path29.join(process.cwd(), "output", sanitized, "template.liquid"),
           // fallback: cwd/output/
-          path25.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
+          path29.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
           // fallback: cwd/dist/output/
         ];
         for (const p of candidatePaths) {
           try {
-            templateContent = await fs21.readFile(p, "utf-8");
+            templateContent = await fs25.readFile(p, "utf-8");
             if (templateContent) break;
           } catch {
           }
@@ -6803,7 +6803,7 @@ async function processDiffWithOutline(diffContent) {
   }
   try {
     const originalProbePath = process.env.PROBE_PATH;
-    const fs21 = require("fs");
+    const fs25 = require("fs");
     const possiblePaths = [
       // Relative to current working directory (most common in production)
       path6.join(process.cwd(), "node_modules/@probelabs/probe/bin/probe-binary"),
@@ -6814,7 +6814,7 @@ async function processDiffWithOutline(diffContent) {
     ];
     let probeBinaryPath;
     for (const candidatePath of possiblePaths) {
-      if (fs21.existsSync(candidatePath)) {
+      if (fs25.existsSync(candidatePath)) {
         probeBinaryPath = candidatePath;
         break;
       }
@@ -7739,7 +7739,7 @@ ${this.escapeXml(processedFallbackDiff)}
       <user>${this.escapeXml(String(m.user || ""))}</user>
       <text>${this.escapeXml(String(m.text || ""))}</text>
       <timestamp>${this.escapeXml(String(m.timestamp || ""))}</timestamp>
-      <origin>${this.escapeXml(String(m.origin || ""))}</origin>
+      <origin>${this.escapeXml(String(m.origin || ""))}</origin>${this.formatFilesXml(m.files)}
     </message>`;
             }
             xml += `
@@ -7751,7 +7751,7 @@ ${this.escapeXml(processedFallbackDiff)}
     <user>${this.escapeXml(String(current.user || ""))}</user>
     <text>${this.escapeXml(String(current.text || ""))}</text>
     <timestamp>${this.escapeXml(String(current.timestamp || ""))}</timestamp>
-    <origin>${this.escapeXml(String(current.origin || ""))}</origin>
+    <origin>${this.escapeXml(String(current.origin || ""))}</origin>${this.formatFilesXml(current.files)}
   </current>
 </slack_context>`;
           return xml;
@@ -7759,6 +7759,25 @@ ${this.escapeXml(processedFallbackDiff)}
           return "";
         }
       }
+      /** Render file attachment metadata as XML fragment for a message. */
+      formatFilesXml(files) {
+        if (!Array.isArray(files) || files.length === 0) return "";
+        let xml = `
+      <files>`;
+        for (const f of files) {
+          xml += `
+        <file>
+          <name>${this.escapeXml(String(f.name || ""))}</name>
+          <mimetype>${this.escapeXml(String(f.mimetype || ""))}</mimetype>
+          <filetype>${this.escapeXml(String(f.filetype || ""))}</filetype>
+          <url>${this.escapeXml(String(f.url_private || f.permalink || ""))}</url>
+          <size>${f.size || 0}</size>
+        </file>`;
+        }
+        xml += `
+      </files>`;
+        return xml;
+      }
       /**
        * Build a normalized ConversationContext for GitHub (PR/issue + comments)
        * using the same contract as Slack's ConversationContext. This is exposed
@@ -7881,8 +7900,8 @@ ${schemaString}`);
           }
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs21 = require("fs");
-              const path25 = require("path");
+              const fs25 = require("fs");
+              const path29 = require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const provider = this.config.provider || "auto";
               const model = this.config.model || "default";
@@ -7996,20 +8015,20 @@ ${"=".repeat(60)}
 `;
               readableVersion += `${"=".repeat(60)}
 `;
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path25.join(process.cwd(), "debug-artifacts");
-              if (!fs21.existsSync(debugArtifactsDir)) {
-                fs21.mkdirSync(debugArtifactsDir, { recursive: true });
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path29.join(process.cwd(), "debug-artifacts");
+              if (!fs25.existsSync(debugArtifactsDir)) {
+                fs25.mkdirSync(debugArtifactsDir, { recursive: true });
               }
-              const debugFile = path25.join(
+              const debugFile = path29.join(
                 debugArtifactsDir,
                 `prompt-${_checkName || "unknown"}-${timestamp}.json`
               );
-              fs21.writeFileSync(debugFile, debugJson, "utf-8");
-              const readableFile = path25.join(
+              fs25.writeFileSync(debugFile, debugJson, "utf-8");
+              const readableFile = path29.join(
                 debugArtifactsDir,
                 `prompt-${_checkName || "unknown"}-${timestamp}.txt`
               );
-              fs21.writeFileSync(readableFile, readableVersion, "utf-8");
+              fs25.writeFileSync(readableFile, readableVersion, "utf-8");
               log(`
 \u{1F4BE} Full debug info saved to:`);
               log(`   JSON: ${debugFile}`);
@@ -8042,8 +8061,8 @@ ${"=".repeat(60)}
           log(`\u{1F4E4} Response length: ${response.length} characters`);
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs21 = require("fs");
-              const path25 = require("path");
+              const fs25 = require("fs");
+              const path29 = require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const agentAny2 = agent;
               let fullHistory = [];
@@ -8054,8 +8073,8 @@ ${"=".repeat(60)}
               } else if (agentAny2._messages) {
                 fullHistory = agentAny2._messages;
               }
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path25.join(process.cwd(), "debug-artifacts");
-              const sessionBase = path25.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path29.join(process.cwd(), "debug-artifacts");
+              const sessionBase = path29.join(
                 debugArtifactsDir,
                 `session-${_checkName || "unknown"}-${timestamp}`
               );
@@ -8067,7 +8086,7 @@ ${"=".repeat(60)}
                 schema: effectiveSchema,
                 totalMessages: fullHistory.length
               };
-              fs21.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
+              fs25.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
               let readable = `=============================================================
 `;
               readable += `COMPLETE AI SESSION HISTORY (AFTER RESPONSE)
@@ -8094,7 +8113,7 @@ ${"=".repeat(60)}
 `;
                 readable += content + "\n";
               });
-              fs21.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
+              fs25.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
               log(`\u{1F4BE} Complete session history saved:`);
               log(`   - Contains ALL ${fullHistory.length} messages (prompts + responses)`);
             } catch (error) {
@@ -8103,11 +8122,11 @@ ${"=".repeat(60)}
           }
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs21 = require("fs");
-              const path25 = require("path");
+              const fs25 = require("fs");
+              const path29 = require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path25.join(process.cwd(), "debug-artifacts");
-              const responseFile = path25.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path29.join(process.cwd(), "debug-artifacts");
+              const responseFile = path29.join(
                 debugArtifactsDir,
                 `response-${_checkName || "unknown"}-${timestamp}.txt`
               );
@@ -8140,7 +8159,7 @@ ${"=".repeat(60)}
 `;
               responseContent += `${"=".repeat(60)}
 `;
-              fs21.writeFileSync(responseFile, responseContent, "utf-8");
+              fs25.writeFileSync(responseFile, responseContent, "utf-8");
               log(`\u{1F4BE} Response saved to: ${responseFile}`);
             } catch (error) {
               log(`\u26A0\uFE0F Could not save response file: ${error}`);
@@ -8156,9 +8175,9 @@ ${"=".repeat(60)}
                 await agentAny._telemetryConfig.shutdown();
                 log(`\u{1F4CA} OpenTelemetry trace saved to: ${agentAny._traceFilePath}`);
                 if (process.env.GITHUB_ACTIONS) {
-                  const fs21 = require("fs");
-                  if (fs21.existsSync(agentAny._traceFilePath)) {
-                    const stats = fs21.statSync(agentAny._traceFilePath);
+                  const fs25 = require("fs");
+                  if (fs25.existsSync(agentAny._traceFilePath)) {
+                    const stats = fs25.statSync(agentAny._traceFilePath);
                     console.log(
                       `::notice title=AI Trace Saved::${agentAny._traceFilePath} (${stats.size} bytes)`
                     );
@@ -8264,6 +8283,9 @@ ${"=".repeat(60)}
           if (this.config.enableTasks !== void 0) {
             options.enableTasks = this.config.enableTasks;
           }
+          if (this.config.enableExecutePlan !== void 0) {
+            options.enableExecutePlan = this.config.enableExecutePlan;
+          }
           if (this.config.retry) {
             options.retry = this.config.retry;
           }
@@ -8356,9 +8378,9 @@ ${schemaString}`);
           const model = this.config.model || "default";
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs21 = require("fs");
-              const path25 = require("path");
-              const os2 = require("os");
+              const fs25 = require("fs");
+              const path29 = require("path");
+              const os3 = require("os");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const debugData = {
                 timestamp,
@@ -8430,19 +8452,19 @@ ${"=".repeat(60)}
 `;
               readableVersion += `${"=".repeat(60)}
 `;
-              const tempDir = os2.tmpdir();
-              const promptFile = path25.join(tempDir, `visor-prompt-${timestamp}.txt`);
-              fs21.writeFileSync(promptFile, prompt, "utf-8");
+              const tempDir = os3.tmpdir();
+              const promptFile = path29.join(tempDir, `visor-prompt-${timestamp}.txt`);
+              fs25.writeFileSync(promptFile, prompt, "utf-8");
               log(`
 \u{1F4BE} Prompt saved to: ${promptFile}`);
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path25.join(process.cwd(), "debug-artifacts");
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path29.join(process.cwd(), "debug-artifacts");
               try {
-                const base = path25.join(
+                const base = path29.join(
                   debugArtifactsDir,
                   `prompt-${_checkName || "unknown"}-${timestamp}`
                 );
-                fs21.writeFileSync(base + ".json", debugJson, "utf-8");
-                fs21.writeFileSync(base + ".summary.txt", readableVersion, "utf-8");
+                fs25.writeFileSync(base + ".json", debugJson, "utf-8");
+                fs25.writeFileSync(base + ".summary.txt", readableVersion, "utf-8");
                 log(`
 \u{1F4BE} Full debug info saved to directory: ${debugArtifactsDir}`);
               } catch {
@@ -8487,8 +8509,8 @@ $ ${cliCommand}
           log(`\u{1F4E4} Response length: ${response.length} characters`);
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs21 = require("fs");
-              const path25 = require("path");
+              const fs25 = require("fs");
+              const path29 = require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const agentAny = agent;
               let fullHistory = [];
@@ -8499,8 +8521,8 @@ $ ${cliCommand}
               } else if (agentAny._messages) {
                 fullHistory = agentAny._messages;
               }
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path25.join(process.cwd(), "debug-artifacts");
-              const sessionBase = path25.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path29.join(process.cwd(), "debug-artifacts");
+              const sessionBase = path29.join(
                 debugArtifactsDir,
                 `session-${_checkName || "unknown"}-${timestamp}`
               );
@@ -8512,7 +8534,7 @@ $ ${cliCommand}
                 schema: effectiveSchema,
                 totalMessages: fullHistory.length
               };
-              fs21.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
+              fs25.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
               let readable = `=============================================================
 `;
               readable += `COMPLETE AI SESSION HISTORY (AFTER RESPONSE)
@@ -8539,7 +8561,7 @@ ${"=".repeat(60)}
 `;
                 readable += content + "\n";
               });
-              fs21.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
+              fs25.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
               log(`\u{1F4BE} Complete session history saved:`);
               log(`   - Contains ALL ${fullHistory.length} messages (prompts + responses)`);
             } catch (error) {
@@ -8548,11 +8570,11 @@ ${"=".repeat(60)}
           }
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs21 = require("fs");
-              const path25 = require("path");
+              const fs25 = require("fs");
+              const path29 = require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path25.join(process.cwd(), "debug-artifacts");
-              const responseFile = path25.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path29.join(process.cwd(), "debug-artifacts");
+              const responseFile = path29.join(
                 debugArtifactsDir,
                 `response-${_checkName || "unknown"}-${timestamp}.txt`
               );
@@ -8585,7 +8607,7 @@ ${"=".repeat(60)}
 `;
               responseContent += `${"=".repeat(60)}
 `;
-              fs21.writeFileSync(responseFile, responseContent, "utf-8");
+              fs25.writeFileSync(responseFile, responseContent, "utf-8");
               log(`\u{1F4BE} Response saved to: ${responseFile}`);
             } catch (error) {
               log(`\u26A0\uFE0F Could not save response file: ${error}`);
@@ -8603,9 +8625,9 @@ ${"=".repeat(60)}
                 await telemetry.shutdown();
                 log(`\u{1F4CA} OpenTelemetry trace saved to: ${traceFilePath}`);
                 if (process.env.GITHUB_ACTIONS) {
-                  const fs21 = require("fs");
-                  if (fs21.existsSync(traceFilePath)) {
-                    const stats = fs21.statSync(traceFilePath);
+                  const fs25 = require("fs");
+                  if (fs25.existsSync(traceFilePath)) {
+                    const stats = fs25.statSync(traceFilePath);
                     console.log(
                       `::notice title=AI Trace Saved::OpenTelemetry trace file size: ${stats.size} bytes`
                     );
@@ -8643,8 +8665,8 @@ ${"=".repeat(60)}
        * Load schema content from schema files or inline definitions
        */
       async loadSchemaContent(schema) {
-        const fs21 = require("fs").promises;
-        const path25 = require("path");
+        const fs25 = require("fs").promises;
+        const path29 = require("path");
         if (typeof schema === "object" && schema !== null) {
           log("\u{1F4CB} Using inline schema object from configuration");
           return JSON.stringify(schema);
@@ -8657,14 +8679,14 @@ ${"=".repeat(60)}
           }
         } catch {
         }
-        if ((schema.startsWith("./") || schema.includes(".json")) && !path25.isAbsolute(schema)) {
+        if ((schema.startsWith("./") || schema.includes(".json")) && !path29.isAbsolute(schema)) {
           if (schema.includes("..") || schema.includes("\0")) {
             throw new Error("Invalid schema path: path traversal not allowed");
           }
           try {
-            const schemaPath = path25.resolve(process.cwd(), schema);
+            const schemaPath = path29.resolve(process.cwd(), schema);
             log(`\u{1F4CB} Loading custom schema from file: ${schemaPath}`);
-            const schemaContent = await fs21.readFile(schemaPath, "utf-8");
+            const schemaContent = await fs25.readFile(schemaPath, "utf-8");
             return schemaContent.trim();
           } catch (error) {
             throw new Error(
@@ -8678,22 +8700,22 @@ ${"=".repeat(60)}
         }
         const candidatePaths = [
           // GitHub Action bundle location
-          path25.join(__dirname, "output", sanitizedSchemaName, "schema.json"),
+          path29.join(__dirname, "output", sanitizedSchemaName, "schema.json"),
           // Historical fallback when src/output was inadvertently bundled as output1/
-          path25.join(__dirname, "output1", sanitizedSchemaName, "schema.json"),
+          path29.join(__dirname, "output1", sanitizedSchemaName, "schema.json"),
           // Local dev (repo root)
-          path25.join(process.cwd(), "output", sanitizedSchemaName, "schema.json")
+          path29.join(process.cwd(), "output", sanitizedSchemaName, "schema.json")
         ];
         for (const schemaPath of candidatePaths) {
           try {
-            const schemaContent = await fs21.readFile(schemaPath, "utf-8");
+            const schemaContent = await fs25.readFile(schemaPath, "utf-8");
             return schemaContent.trim();
           } catch {
           }
         }
-        const distPath = path25.join(__dirname, "output", sanitizedSchemaName, "schema.json");
-        const distAltPath = path25.join(__dirname, "output1", sanitizedSchemaName, "schema.json");
-        const cwdPath = path25.join(process.cwd(), "output", sanitizedSchemaName, "schema.json");
+        const distPath = path29.join(__dirname, "output", sanitizedSchemaName, "schema.json");
+        const distAltPath = path29.join(__dirname, "output1", sanitizedSchemaName, "schema.json");
+        const cwdPath = path29.join(process.cwd(), "output", sanitizedSchemaName, "schema.json");
         throw new Error(
           `Failed to load schema '${sanitizedSchemaName}'. Tried: ${distPath}, ${distAltPath}, and ${cwdPath}. Ensure build copies 'output/' into dist (build:cli), or provide a custom schema file/path.`
         );
@@ -8711,7 +8733,22 @@ ${"=".repeat(60)}
           log("\u{1F4CB} Full response preview:", response);
         }
         try {
-          let reviewData;
+          let reviewData = void 0;
+          const RAW_OUTPUT_RE = /\n<<<RAW_OUTPUT>>>\n([\s\S]*?)\n<<<END_RAW_OUTPUT>>>/g;
+          const rawOutputBlocks = [];
+          let responseForParsing = response;
+          {
+            let rawMatch;
+            while ((rawMatch = RAW_OUTPUT_RE.exec(response)) !== null) {
+              rawOutputBlocks.push(rawMatch[1]);
+            }
+            if (rawOutputBlocks.length > 0) {
+              responseForParsing = response.replace(RAW_OUTPUT_RE, "");
+              log(
+                `\u{1F4E6} Extracted ${rawOutputBlocks.length} RAW_OUTPUT blocks (${rawOutputBlocks.reduce((s, b) => s + b.length, 0)} chars) from response`
+              );
+            }
+          }
           if (_schema === "plain" || !_schema) {
             log(
               `\u{1F4CB} ${_schema === "plain" ? "Plain" : "No"} schema detected - treating raw response as text output`
@@ -8728,7 +8765,7 @@ ${"=".repeat(60)}
           }
           {
             log("\u{1F50D} Extracting JSON from AI response...");
-            const sanitizedResponse = response.replace(/^\uFEFF/, "").replace(/[\u200B-\u200D\uFEFF\u00A0]/g, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").trim();
+            const sanitizedResponse = responseForParsing.replace(/^\uFEFF/, "").replace(/[\u200B-\u200D\uFEFF\u00A0]/g, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").trim();
             try {
               reviewData = JSON.parse(sanitizedResponse);
               log("\u2705 Successfully parsed direct JSON response");
@@ -8736,22 +8773,48 @@ ${"=".repeat(60)}
             } catch (parseErr) {
               const errMsg = parseErr instanceof Error ? parseErr.message : String(parseErr);
               log(`\u{1F50D} Direct JSON parsing failed: ${errMsg}`);
-              if (response.toLowerCase().includes("i cannot") || response.toLowerCase().includes("unable to")) {
-                console.error("\u{1F6AB} AI refused to analyze - returning refusal as output");
-                const trimmed2 = response.trim();
+              let recovered = false;
+              const trailingMatch = errMsg.match(/after JSON at position (\d+)/);
+              if (trailingMatch) {
+                const pos = parseInt(trailingMatch[1], 10);
+                try {
+                  reviewData = JSON.parse(sanitizedResponse.substring(0, pos));
+                  const trailing = sanitizedResponse.substring(pos).trim();
+                  if (trailing && reviewData && typeof reviewData === "object" && typeof reviewData.text === "string") {
+                    reviewData.text = reviewData.text + "\n\n" + trailing;
+                    log(
+                      `\u2705 Recovered JSON and appended ${trailing.length} chars of trailing content to text field`
+                    );
+                  } else {
+                    log(`\u2705 Recovered JSON by trimming trailing content at position ${pos}`);
+                  }
+                  if (debugInfo) debugInfo.jsonParseSuccess = true;
+                  recovered = true;
+                } catch {
+                }
+              }
+              if (!recovered) {
+                if (response.toLowerCase().includes("i cannot") || response.toLowerCase().includes("unable to")) {
+                  console.error("\u{1F6AB} AI refused to analyze - returning refusal as output");
+                  const trimmed2 = responseForParsing.trim();
+                  const out = trimmed2 ? { text: trimmed2 } : {};
+                  if (rawOutputBlocks.length > 0) out._rawOutput = rawOutputBlocks.join("\n\n");
+                  return {
+                    issues: [],
+                    output: out,
+                    debug: debugInfo
+                  };
+                }
+                log("\u{1F527} Treating response as plain text (no JSON extraction)");
+                const trimmed = responseForParsing.trim();
+                const fallbackOut = { text: trimmed };
+                if (rawOutputBlocks.length > 0) fallbackOut._rawOutput = rawOutputBlocks.join("\n\n");
                 return {
                   issues: [],
-                  output: trimmed2 ? { text: trimmed2 } : {},
+                  output: fallbackOut,
                   debug: debugInfo
                 };
               }
-              log("\u{1F527} Treating response as plain text (no JSON extraction)");
-              const trimmed = response.trim();
-              return {
-                issues: [],
-                output: { text: trimmed },
-                debug: debugInfo
-              };
             }
           }
           const looksLikeTextOutput = reviewData && typeof reviewData === "object" && typeof reviewData.text === "string" && String(reviewData.text).trim().length > 0;
@@ -8799,6 +8862,9 @@ ${"=".repeat(60)}
                 out.text = fallbackText;
               }
             }
+            if (rawOutputBlocks.length > 0) {
+              out._rawOutput = rawOutputBlocks.join("\n\n");
+            }
             const result2 = {
               // Keep issues empty for custom-schema rendering; consumers read from output.*
               issues: [],
@@ -8884,7 +8950,7 @@ ${"=".repeat(60)}
        * Generate mock response for testing
        */
       async generateMockResponse(_prompt, _checkName, _schema) {
-        await new Promise((resolve11) => setTimeout(resolve11, 500));
+        await new Promise((resolve15) => setTimeout(resolve15, 500));
         const name = (_checkName || "").toLowerCase();
         if (name.includes("extract-facts")) {
           const arr = Array.from({ length: 6 }, (_, i) => ({
@@ -9245,7 +9311,7 @@ var init_command_executor = __esm({
        * Execute command with stdin input
        */
       executeWithStdin(command, options) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve15, reject) => {
           const childProcess = (0, import_child_process.exec)(
             command,
             {
@@ -9257,7 +9323,7 @@ var init_command_executor = __esm({
               if (error && error.killed && (error.code === "ETIMEDOUT" || error.signal === "SIGTERM")) {
                 reject(new Error(`Command timed out after ${options.timeout || 3e4}ms`));
               } else {
-                resolve11({
+                resolve15({
                   stdout: stdout || "",
                   stderr: stderr || "",
                   exitCode: error ? error.code || 1 : 0
@@ -11112,6 +11178,10 @@ var init_config_schema = __esm({
               type: "number",
               description: "Maximum number of checks to run in parallel (default: 3)"
             },
+            max_ai_concurrency: {
+              type: "number",
+              description: "Maximum total concurrent AI API calls across all checks (default: unlimited). When set, creates a shared concurrency limiter that gates every LLM request across all ProbeAgent instances in this run."
+            },
             fail_fast: {
               type: "boolean",
               description: "Stop execution when any check fails (default: false)"
@@ -11158,6 +11228,18 @@ var init_config_schema = __esm({
               $ref: "#/definitions/WorkspaceConfig",
               description: "Workspace isolation configuration for sandboxed execution"
             },
+            sandbox: {
+              type: "string",
+              description: "Workspace-level default sandbox name (all checks use this unless overridden)"
+            },
+            sandboxes: {
+              $ref: "#/definitions/Record%3Cstring%2CSandboxConfig%3E",
+              description: "Named sandbox environment definitions"
+            },
+            sandbox_defaults: {
+              $ref: "#/definitions/SandboxDefaults",
+              description: "Workspace-level sandbox defaults (env allowlist, etc.)"
+            },
             slack: {
               $ref: "#/definitions/SlackConfig",
               description: "Slack configuration"
@@ -11168,7 +11250,7 @@ var init_config_schema = __esm({
             },
             policy: {
               $ref: "#/definitions/PolicyConfig",
-              description: "Enterprise policy engine configuration (EE feature)"
+              description: "Enterprise policy engine configuration"
             }
           },
           required: ["version"],
@@ -11471,7 +11553,7 @@ var init_config_schema = __esm({
             },
             ai_bash_config_js: {
               type: "string",
-              description: "JavaScript expression to dynamically compute bash configuration for this AI check. Expression has access to: outputs, inputs, pr, files, env, memory. Must return a BashConfig object with optional allow/deny string arrays.\n\nExample: ``` return outputs['build-config']?.bash_config ?? {}; ```"
+              description: "JavaScript expression to dynamically compute bash configuration for this AI check. Expression has access to: outputs, inputs, pr, files, env, memory Must return a BashConfig object with allow/deny arrays.\n\nExample: ``` return outputs['build-config']?.bash_config ?? {}; ```"
             },
             claude_code: {
               $ref: "#/definitions/ClaudeCodeConfig",
@@ -11737,7 +11819,7 @@ var init_config_schema = __esm({
               description: "Arguments/inputs for the workflow"
             },
             overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-12605-26099-src_types_config.ts-0-46407%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-13489-27516-src_types_config.ts-0-51381%3E%3E",
               description: "Override specific step configurations in the workflow"
             },
             output_mapping: {
@@ -11753,7 +11835,7 @@ var init_config_schema = __esm({
               description: "Config file path - alternative to workflow ID (loads a Visor config file as workflow)"
             },
             workflow_overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-12605-26099-src_types_config.ts-0-46407%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-13489-27516-src_types_config.ts-0-51381%3E%3E",
               description: "Alias for overrides - workflow step overrides (backward compatibility)"
             },
             ref: {
@@ -11823,6 +11905,10 @@ var init_config_schema = __esm({
               type: "boolean",
               description: "Keep worktree after workflow completion (default: false)"
             },
+            sandbox: {
+              type: "string",
+              description: "Sandbox name to use for this check (overrides workspace-level default)"
+            },
             policy: {
               $ref: "#/definitions/StepPolicyOverride",
               description: "Per-step policy override (enterprise)"
@@ -11967,6 +12053,14 @@ var init_config_schema = __esm({
             completion_prompt: {
               type: "string",
               description: "Completion prompt for post-completion validation/review (runs after attempt_completion)"
+            },
+            enable_scheduler: {
+              type: "boolean",
+              description: "Enable the schedule tool for scheduling workflow executions (requires scheduler configuration)"
+            },
+            enableExecutePlan: {
+              type: "boolean",
+              description: "Enable the execute_plan DSL orchestration tool (replaces analyze_all when enabled)"
             }
           },
           additionalProperties: false,
@@ -12429,7 +12523,7 @@ var init_config_schema = __esm({
               description: "Custom output name (defaults to workflow name)"
             },
             overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-12605-26099-src_types_config.ts-0-46407%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-13489-27516-src_types_config.ts-0-51381%3E%3E",
               description: "Step overrides"
             },
             output_mapping: {
@@ -12444,13 +12538,13 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
-        "Record<string,Partial<interface-src_types_config.ts-12605-26099-src_types_config.ts-0-46407>>": {
+        "Record<string,Partial<interface-src_types_config.ts-13489-27516-src_types_config.ts-0-51381>>": {
           type: "object",
           additionalProperties: {
-            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-12605-26099-src_types_config.ts-0-46407%3E"
+            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-13489-27516-src_types_config.ts-0-51381%3E"
           }
         },
-        "Partial<interface-src_types_config.ts-12605-26099-src_types_config.ts-0-46407>": {
+        "Partial<interface-src_types_config.ts-13489-27516-src_types_config.ts-0-51381>": {
           type: "object",
           additionalProperties: false
         },
@@ -12564,9 +12658,9 @@ var init_config_schema = __esm({
             run: {
               type: "array",
               items: {
-                type: "string"
+                $ref: "#/definitions/OnSuccessRunItem"
               },
-              description: "Post-success steps to run"
+              description: "Post-success steps to run - can be step names or rich invocations with arguments"
             },
             goto: {
               type: "string",
@@ -12598,6 +12692,20 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
+        OnSuccessRunItem: {
+          anyOf: [
+            {
+              type: "string"
+            },
+            {
+              $ref: "#/definitions/OnInitStepInvocation"
+            },
+            {
+              $ref: "#/definitions/OnInitWorkflowInvocation"
+            }
+          ],
+          description: "Success routing run item - can be step name, step with args, or workflow with args"
+        },
         OnFinishConfig: {
           type: "object",
           properties: {
@@ -12638,6 +12746,40 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
+        StepPolicyOverride: {
+          type: "object",
+          properties: {
+            require: {
+              anyOf: [
+                {
+                  type: "string"
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              ],
+              description: "Required role(s) - any of these roles suffices"
+            },
+            deny: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Explicit deny for roles"
+            },
+            rule: {
+              type: "string",
+              description: "Custom OPA rule path for this step"
+            }
+          },
+          additionalProperties: false,
+          patternProperties: {
+            "^x-": {}
+          }
+        },
         OutputConfig: {
           type: "object",
           properties: {
@@ -13044,6 +13186,141 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
+        "Record<string,SandboxConfig>": {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/SandboxConfig"
+          }
+        },
+        SandboxConfig: {
+          type: "object",
+          properties: {
+            image: {
+              type: "string",
+              description: 'Docker image to use (e.g., "node:20-alpine")'
+            },
+            dockerfile: {
+              type: "string",
+              description: "Path to Dockerfile (relative to config file or absolute)"
+            },
+            dockerfile_inline: {
+              type: "string",
+              description: "Inline Dockerfile content"
+            },
+            compose: {
+              type: "string",
+              description: "Path to docker-compose file"
+            },
+            service: {
+              type: "string",
+              description: "Service name within the compose file"
+            },
+            workdir: {
+              type: "string",
+              description: "Working directory inside container (default: /workspace)"
+            },
+            env_passthrough: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Glob patterns for host env vars to forward into sandbox"
+            },
+            network: {
+              type: "boolean",
+              description: "Enable/disable network access (default: true)"
+            },
+            read_only: {
+              type: "boolean",
+              description: "Mount repo as read-only (default: false)"
+            },
+            resources: {
+              $ref: "#/definitions/SandboxResourceConfig",
+              description: "Resource limits"
+            },
+            visor_path: {
+              type: "string",
+              description: "Where visor is mounted inside container (default: /opt/visor)"
+            },
+            cache: {
+              $ref: "#/definitions/SandboxCacheConfig",
+              description: "Cache volume configuration"
+            }
+          },
+          additionalProperties: false,
+          description: "Configuration for a single sandbox environment",
+          patternProperties: {
+            "^x-": {}
+          }
+        },
+        SandboxResourceConfig: {
+          type: "object",
+          properties: {
+            memory: {
+              type: "string",
+              description: 'Memory limit (e.g., "512m", "2g")'
+            },
+            cpu: {
+              type: "number",
+              description: "CPU limit (e.g., 1.0, 0.5)"
+            }
+          },
+          additionalProperties: false,
+          description: "Resource limits for sandbox containers",
+          patternProperties: {
+            "^x-": {}
+          }
+        },
+        SandboxCacheConfig: {
+          type: "object",
+          properties: {
+            prefix: {
+              type: "string",
+              description: "Liquid template for cache scope prefix (default: git branch)"
+            },
+            fallback_prefix: {
+              type: "string",
+              description: "Fallback prefix when current prefix has no cache"
+            },
+            paths: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Paths inside the container to cache"
+            },
+            ttl: {
+              type: "string",
+              description: 'Time-to-live for cache volumes (e.g., "7d", "24h")'
+            },
+            max_scopes: {
+              type: "number",
+              description: "Maximum number of cache scopes to keep"
+            }
+          },
+          required: ["paths"],
+          additionalProperties: false,
+          description: "Cache configuration for sandbox volumes",
+          patternProperties: {
+            "^x-": {}
+          }
+        },
+        SandboxDefaults: {
+          type: "object",
+          properties: {
+            env_passthrough: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Base env var patterns for all sandboxes (replaces hardcoded defaults when set)"
+            }
+          },
+          additionalProperties: false,
+          patternProperties: {
+            "^x-": {}
+          }
+        },
         SlackConfig: {
           type: "object",
           properties: {
@@ -13103,7 +13380,16 @@ var init_config_schema = __esm({
               properties: {
                 path: {
                   type: "string",
-                  description: "Path to schedules JSON file (default: .visor/schedules.json)"
+                  description: "Path to schedules JSON file (legacy, triggers auto-migration)"
+                },
+                driver: {
+                  type: "string",
+                  enum: ["sqlite", "postgresql", "mysql", "mssql"],
+                  description: "Database driver (default: 'sqlite')"
+                },
+                connection: {
+                  $ref: "#/definitions/SchedulerStorageConnectionConfig",
+                  description: "Database connection configuration"
                 }
               },
               additionalProperties: false,
@@ -13112,6 +13398,10 @@ var init_config_schema = __esm({
                 "^x-": {}
               }
             },
+            ha: {
+              $ref: "#/definitions/SchedulerHAConfig",
+              description: "High-availability configuration for multi-node deployments"
+            },
             limits: {
               $ref: "#/definitions/SchedulerLimitsConfig",
               description: "Limits for dynamic schedules"
@@ -13139,44 +13429,123 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
-        PolicyConfig: {
+        SchedulerStorageConnectionConfig: {
           type: "object",
           properties: {
-            engine: {
+            filename: {
               type: "string",
-              enum: ["local", "remote", "disabled"],
-              description: "Policy engine mode: 'local' (WASM), 'remote' (HTTP OPA server), or 'disabled'"
+              description: "SQLite database file path (default: '.visor/schedules.db')"
             },
-            rules: {
-              anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
-              description: "Path to .rego files or .wasm bundle (local mode)"
+            host: {
+              type: "string",
+              description: "Database host (PostgreSQL/MySQL/MSSQL)"
             },
-            data: {
+            port: {
+              type: "number",
+              description: "Database port (PostgreSQL/MySQL/MSSQL)"
+            },
+            database: {
               type: "string",
-              description: "Path to a JSON file to load as OPA data document (local mode)"
+              description: "Database name (PostgreSQL/MySQL/MSSQL)"
             },
-            url: {
+            user: {
               type: "string",
-              description: "OPA server URL (remote mode)"
+              description: "Database user (PostgreSQL/MySQL/MSSQL)"
             },
-            fallback: {
+            password: {
               type: "string",
-              enum: ["allow", "deny", "warn"],
-              description: "Default decision when policy evaluation fails (default: 'deny'). Use 'warn' for audit mode: violations are logged but not enforced."
+              description: "Database password (PostgreSQL/MySQL/MSSQL)"
             },
-            timeout: {
-              type: "number",
-              description: "Evaluation timeout in milliseconds (default: 5000)"
+            ssl: {
+              anyOf: [
+                {
+                  type: "boolean"
+                },
+                {
+                  $ref: "#/definitions/SchedulerSslConfig"
+                }
+              ],
+              description: "SSL/TLS configuration (PostgreSQL/MySQL/MSSQL)"
             },
-            roles: {
+            connection_string: {
+              type: "string",
+              description: "Connection string URL (e.g., postgresql://user:pass@host/db)"
+            },
+            pool: {
               type: "object",
-              additionalProperties: {
-                $ref: "#/definitions/PolicyRoleConfig"
+              properties: {
+                min: {
+                  type: "number"
+                },
+                max: {
+                  type: "number"
+                }
               },
-              description: "Role definitions: map role names to conditions"
+              additionalProperties: false,
+              description: "Connection pool configuration",
+              patternProperties: {
+                "^x-": {}
+              }
             }
           },
           additionalProperties: false,
+          description: "Scheduler storage connection configuration",
+          patternProperties: {
+            "^x-": {}
+          }
+        },
+        SchedulerSslConfig: {
+          type: "object",
+          properties: {
+            enabled: {
+              type: "boolean",
+              description: "Enable SSL (default: true when SslConfig object is provided)"
+            },
+            reject_unauthorized: {
+              type: "boolean",
+              description: "Reject unauthorized certificates (default: true)"
+            },
+            ca: {
+              type: "string",
+              description: "Path to CA certificate PEM file"
+            },
+            cert: {
+              type: "string",
+              description: "Path to client certificate PEM file"
+            },
+            key: {
+              type: "string",
+              description: "Path to client key PEM file"
+            }
+          },
+          additionalProperties: false,
+          description: "SSL/TLS configuration for scheduler database connections",
+          patternProperties: {
+            "^x-": {}
+          }
+        },
+        SchedulerHAConfig: {
+          type: "object",
+          properties: {
+            enabled: {
+              type: "boolean",
+              description: "Enable distributed locking for multi-node deployments (default: false)"
+            },
+            node_id: {
+              type: "string",
+              description: "Unique node identifier (default: hostname-pid)"
+            },
+            lock_ttl: {
+              type: "number",
+              description: "Lock time-to-live in seconds (default: 60)"
+            },
+            heartbeat_interval: {
+              type: "number",
+              description: "Heartbeat interval for lock renewal in seconds (default: 15)"
+            }
+          },
+          additionalProperties: false,
+          description: "Scheduler high-availability configuration",
           patternProperties: {
             "^x-": {}
           }
@@ -13239,45 +13608,6 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
-        PolicyRoleConfig: {
-          type: "object",
-          properties: {
-            author_association: {
-              type: "array",
-              items: { type: "string" },
-              description: "GitHub author associations that map to this role"
-            },
-            teams: {
-              type: "array",
-              items: { type: "string" },
-              description: "GitHub team slugs"
-            },
-            users: {
-              type: "array",
-              items: { type: "string" },
-              description: "Explicit GitHub usernames"
-            },
-            slack_users: {
-              type: "array",
-              items: { type: "string" },
-              description: "Slack user IDs (e.g., U0123ABC)"
-            },
-            emails: {
-              type: "array",
-              items: { type: "string" },
-              description: "Email addresses for identity matching"
-            },
-            slack_channels: {
-              type: "array",
-              items: { type: "string" },
-              description: "Slack channel IDs \u2014 role only applies when triggered from these channels"
-            }
-          },
-          additionalProperties: false,
-          patternProperties: {
-            "^x-": {}
-          }
-        },
         "Record<string,StaticCronJob>": {
           type: "object",
           additionalProperties: {
@@ -13343,21 +13673,106 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
-        StepPolicyOverride: {
+        PolicyConfig: {
           type: "object",
           properties: {
-            require: {
-              anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
-              description: "Required role(s) \u2014 any of these roles suffices"
+            engine: {
+              type: "string",
+              enum: ["local", "remote", "disabled"],
+              description: "Policy engine mode"
             },
-            deny: {
-              type: "array",
-              items: { type: "string" },
-              description: "Explicit deny for roles"
+            rules: {
+              anyOf: [
+                {
+                  type: "string"
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              ],
+              description: "Path to .rego files or .wasm bundle (local mode)"
             },
-            rule: {
+            data: {
               type: "string",
-              description: "Custom OPA rule path for this step"
+              description: "Path to a JSON file to load as OPA data document"
+            },
+            url: {
+              type: "string",
+              description: "OPA server URL (remote mode)"
+            },
+            fallback: {
+              type: "string",
+              enum: ["allow", "deny", "warn"],
+              description: "Default decision when policy evaluation fails"
+            },
+            timeout: {
+              type: "number",
+              description: "Evaluation timeout in ms (default: 5000)"
+            },
+            roles: {
+              $ref: "#/definitions/Record%3Cstring%2CPolicyRoleConfig%3E",
+              description: "Role definitions: map role names to conditions"
+            }
+          },
+          required: ["engine"],
+          additionalProperties: false,
+          patternProperties: {
+            "^x-": {}
+          }
+        },
+        "Record<string,PolicyRoleConfig>": {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/PolicyRoleConfig"
+          }
+        },
+        PolicyRoleConfig: {
+          type: "object",
+          properties: {
+            author_association: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "GitHub author associations that map to this role"
+            },
+            teams: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "GitHub team slugs (requires GitHub API)"
+            },
+            users: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Explicit GitHub usernames"
+            },
+            slack_users: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: 'Slack user IDs (e.g., ["U0123ABC"])'
+            },
+            emails: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: 'Email addresses for identity matching (e.g., ["alice@co.com"])'
+            },
+            slack_channels: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Slack channel IDs \u2014 role only applies when triggered from these channels"
             }
           },
           additionalProperties: false,
@@ -15517,6 +15932,20 @@ var init_workflow_check_provider = __esm({
             `[WorkflowProvider] Workflow '${workflow.id}' has null/undefined outputs: [${nullOutputs.join(", ")}]. This may indicate value_js expressions are not finding expected data.`
           );
         }
+        if (!outputs._rawOutput) {
+          const rawParts = [];
+          for (const stepOutput of Object.values(outputsMap)) {
+            if (stepOutput && typeof stepOutput === "object" && typeof stepOutput._rawOutput === "string") {
+              rawParts.push(stepOutput._rawOutput);
+            }
+          }
+          if (rawParts.length > 0) {
+            outputs._rawOutput = rawParts.join("\n\n");
+            logger.debug(
+              `[WorkflowProvider] Propagated _rawOutput from steps (${rawParts.length} blocks, ${outputs._rawOutput.length} chars)`
+            );
+          }
+        }
         return outputs;
       }
       /**
@@ -15580,17 +16009,17 @@ var init_workflow_check_provider = __esm({
        * so it can be executed by the state machine as a nested workflow.
        */
       async loadWorkflowFromConfigPath(sourcePath, baseDir) {
-        const path25 = require("path");
-        const fs21 = require("fs");
+        const path29 = require("path");
+        const fs25 = require("fs");
         const yaml5 = require("js-yaml");
-        const resolved = path25.isAbsolute(sourcePath) ? sourcePath : path25.resolve(baseDir, sourcePath);
-        if (!fs21.existsSync(resolved)) {
+        const resolved = path29.isAbsolute(sourcePath) ? sourcePath : path29.resolve(baseDir, sourcePath);
+        if (!fs25.existsSync(resolved)) {
           throw new Error(`Workflow config not found at: ${resolved}`);
         }
-        const rawContent = fs21.readFileSync(resolved, "utf8");
+        const rawContent = fs25.readFileSync(resolved, "utf8");
         const rawData = yaml5.load(rawContent);
         if (rawData.imports && Array.isArray(rawData.imports)) {
-          const configDir = path25.dirname(resolved);
+          const configDir = path29.dirname(resolved);
           for (const source of rawData.imports) {
             const results = await this.registry.import(source, {
               basePath: configDir,
@@ -15620,8 +16049,8 @@ ${errors}`);
         if (!steps || Object.keys(steps).length === 0) {
           throw new Error(`Config '${resolved}' does not contain any steps to execute as a workflow`);
         }
-        const id = path25.basename(resolved).replace(/\.(ya?ml)$/i, "");
-        const name = loaded.name || `Workflow from ${path25.basename(resolved)}`;
+        const id = path29.basename(resolved).replace(/\.(ya?ml)$/i, "");
+        const name = loaded.name || `Workflow from ${path29.basename(resolved)}`;
         const workflowDef = {
           id,
           name,
@@ -15689,7 +16118,7 @@ function workflowInputsToJsonSchema(inputs) {
     required: required.length > 0 ? required : void 0
   };
 }
-function createWorkflowToolDefinition(workflow, argsOverrides) {
+function createWorkflowToolDefinition(workflow, argsOverrides, nameOverride) {
   const baseSchema = workflowInputsToJsonSchema(workflow.inputs);
   let inputSchema = baseSchema;
   if (argsOverrides && baseSchema && typeof baseSchema === "object") {
@@ -15707,7 +16136,7 @@ function createWorkflowToolDefinition(workflow, argsOverrides) {
     };
   }
   return {
-    name: workflow.id,
+    name: nameOverride || workflow.id,
     description: workflow.description || `Execute the ${workflow.name} workflow`,
     inputSchema,
     // Workflow tools don't have an exec command - they're executed specially
@@ -15757,6 +16186,16 @@ async function executeWorkflowAsTool(workflowId, args, context2, argsOverrides)
   );
   logger.debug(`[WorkflowToolExecutor] Workflow '${workflowId}' output preview: ${outputPreview}`);
   if (output !== void 0) {
+    if (output && typeof output === "object" && typeof output._rawOutput === "string") {
+      const rawOutput = output._rawOutput;
+      const cleanOutput = { ...output };
+      delete cleanOutput._rawOutput;
+      const jsonStr = JSON.stringify(cleanOutput, null, 2);
+      logger.debug(
+        `[WorkflowToolExecutor] Wrapping _rawOutput (${rawOutput.length} chars) in RAW_OUTPUT delimiters for '${workflowId}'`
+      );
+      return jsonStr + "\n<<<RAW_OUTPUT>>>\n" + rawOutput + "\n<<<END_RAW_OUTPUT>>>";
+    }
     return output;
   }
   if (result.content) {
@@ -15781,7 +16220,7 @@ function resolveWorkflowToolFromItem(item) {
       logger.warn(`[WorkflowToolExecutor] Workflow '${item.workflow}' not found in registry`);
       return void 0;
     }
-    return createWorkflowToolDefinition(workflow, item.args);
+    return createWorkflowToolDefinition(workflow, item.args, item.name);
   }
   return void 0;
 }
@@ -16240,8 +16679,8 @@ async function createStoreBackend(storageConfig, haConfig) {
     case "mssql": {
       try {
         const loaderPath = "../../enterprise/loader";
-        const { loadEnterpriseStoreBackend } = await import(loaderPath);
-        return await loadEnterpriseStoreBackend(driver, storageConfig, haConfig);
+        const { loadEnterpriseStoreBackend: loadEnterpriseStoreBackend2 } = await import(loaderPath);
+        return await loadEnterpriseStoreBackend2(driver, storageConfig, haConfig);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         logger.error(`[StoreFactory] Failed to load enterprise ${driver} backend: ${msg}`);
@@ -17508,7 +17947,7 @@ var init_mcp_custom_sse_server = __esm({
        * Returns the actual bound port number
        */
       async start() {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve15, reject) => {
           try {
             this.server = import_http.default.createServer((req, res) => {
               this.handleRequest(req, res).catch((error) => {
@@ -17542,7 +17981,7 @@ var init_mcp_custom_sse_server = __esm({
                 );
               }
               this.startKeepalive();
-              resolve11(this.port);
+              resolve15(this.port);
             });
           } catch (error) {
             reject(error);
@@ -17605,7 +18044,7 @@ var init_mcp_custom_sse_server = __esm({
             logger.debug(
               `[CustomToolsSSEServer:${this.sessionId}] Grace period before stop: ${waitMs}ms (activeToolCalls=${this.activeToolCalls})`
             );
-            await new Promise((resolve11) => setTimeout(resolve11, waitMs));
+            await new Promise((resolve15) => setTimeout(resolve15, waitMs));
           }
         }
         if (this.activeToolCalls > 0) {
@@ -17614,7 +18053,7 @@ var init_mcp_custom_sse_server = __esm({
             `[CustomToolsSSEServer:${this.sessionId}] Waiting for ${this.activeToolCalls} active tool call(s) before stop`
           );
           while (this.activeToolCalls > 0 && Date.now() - startedAt < effectiveDrainTimeoutMs) {
-            await new Promise((resolve11) => setTimeout(resolve11, 250));
+            await new Promise((resolve15) => setTimeout(resolve15, 250));
           }
           if (this.activeToolCalls > 0) {
             logger.warn(
@@ -17639,21 +18078,21 @@ var init_mcp_custom_sse_server = __esm({
         }
         this.connections.clear();
         if (this.server) {
-          await new Promise((resolve11, reject) => {
+          await new Promise((resolve15, reject) => {
             const timeout = setTimeout(() => {
               if (this.debug) {
                 logger.debug(
                   `[CustomToolsSSEServer:${this.sessionId}] Force closing server after timeout`
                 );
               }
-              this.server?.close(() => resolve11());
+              this.server?.close(() => resolve15());
             }, 5e3);
             this.server.close((error) => {
               clearTimeout(timeout);
               if (error) {
                 reject(error);
               } else {
-                resolve11();
+                resolve15();
               }
             });
           });
@@ -18067,7 +18506,7 @@ var init_mcp_custom_sse_server = __esm({
               logger.warn(
                 `[CustomToolsSSEServer:${this.sessionId}] Tool ${toolName} failed (attempt ${attempt + 1}/${retryCount + 1}): ${errorMsg}. Retrying in ${delay}ms`
               );
-              await new Promise((resolve11) => setTimeout(resolve11, delay));
+              await new Promise((resolve15) => setTimeout(resolve15, delay));
               attempt++;
             }
           }
@@ -18162,7 +18601,7 @@ var init_ai_check_provider = __esm({
     init_sandbox();
     init_schedule_tool();
     init_schedule_tool_handler();
-    AICheckProvider = class extends CheckProvider {
+    AICheckProvider = class _AICheckProvider extends CheckProvider {
       aiReviewService;
       liquidEngine;
       sandbox = null;
@@ -18332,9 +18771,9 @@ var init_ai_check_provider = __esm({
           } else {
             resolvedPath = import_path6.default.resolve(process.cwd(), str);
           }
-          const fs21 = require("fs").promises;
+          const fs25 = require("fs").promises;
           try {
-            const stat = await fs21.stat(resolvedPath);
+            const stat = await fs25.stat(resolvedPath);
             return stat.isFile();
           } catch {
             return hasFileExtension && (isRelativePath || isAbsolutePath || hasPathSeparators);
@@ -18744,6 +19183,9 @@ ${preview}`);
           if (aiAny2.enableTasks !== void 0) {
             aiConfig.enableTasks = aiAny2.enableTasks;
           }
+          if (aiAny2.enableExecutePlan !== void 0) {
+            aiConfig.enableExecutePlan = aiAny2.enableExecutePlan;
+          }
           if (aiAny2.allowEdit !== void 0) {
             aiConfig.allowEdit = aiAny2.allowEdit;
           }
@@ -18889,13 +19331,10 @@ ${preview}`);
               if (decision.capabilities.allowEdit === false) aiConfig.allowEdit = false;
               if (decision.capabilities.allowBash === false) aiConfig.allowBash = false;
               if (decision.capabilities.allowedTools) {
-                if (aiConfig.allowedTools) {
-                  aiConfig.allowedTools = aiConfig.allowedTools.filter(
-                    (t) => decision.capabilities.allowedTools.includes(t)
-                  );
-                } else {
-                  aiConfig.allowedTools = decision.capabilities.allowedTools;
-                }
+                aiConfig.allowedTools = _AICheckProvider.intersectAllowedTools(
+                  aiConfig.allowedTools,
+                  decision.capabilities.allowedTools
+                );
               }
             }
           } catch (err) {
@@ -19016,7 +19455,8 @@ ${preview}`);
           if (cfg.workflow && typeof cfg.workflow === "string") {
             workflowEntriesFromMcp.push({
               workflow: cfg.workflow,
-              args: cfg.inputs
+              args: cfg.inputs,
+              name: serverName
             });
             mcpEntriesToRemove.push(serverName);
             logger.debug(
@@ -19157,6 +19597,27 @@ ${preview}`);
             );
           }
         }
+        const allowedToolsJsExpr = config.ai_allowed_tools_js;
+        if (allowedToolsJsExpr && _dependencyResults) {
+          try {
+            const dynamicAllowedTools = this.evaluateAllowedToolsJs(
+              allowedToolsJsExpr,
+              prInfo,
+              _dependencyResults,
+              config
+            );
+            if (dynamicAllowedTools !== null) {
+              aiConfig.allowedTools = dynamicAllowedTools;
+              this.logDebug(
+                `[AI Provider] ai_allowed_tools_js evaluated to: ${JSON.stringify(dynamicAllowedTools)}`
+              );
+            }
+          } catch (error) {
+            logger.error(
+              `[AICheckProvider] Failed to evaluate ai_allowed_tools_js: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        }
         const templateContext = {
           pr: {
             number: prInfo.number,
@@ -19660,6 +20121,65 @@ ${processedPrompt}` : processedPrompt;
           return {};
         }
       }
+      /**
+       * Evaluate ai_allowed_tools_js expression to dynamically compute allowed tools list.
+       * Returns a string array of tool names, or null if the expression returns a non-array.
+       */
+      evaluateAllowedToolsJs(expression, prInfo, dependencyResults, config) {
+        if (!this.sandbox) {
+          this.sandbox = createSecureSandbox();
+        }
+        const outputs = {};
+        for (const [checkId, result] of dependencyResults.entries()) {
+          const summary = result;
+          outputs[checkId] = summary.output !== void 0 ? summary.output : summary;
+        }
+        const jsContext = {
+          outputs,
+          inputs: config.inputs || {},
+          pr: {
+            number: prInfo.number,
+            title: prInfo.title,
+            description: prInfo.body,
+            author: prInfo.author,
+            branch: prInfo.head,
+            base: prInfo.base,
+            authorAssociation: prInfo.authorAssociation
+          },
+          files: prInfo.files?.map((f) => ({
+            filename: f.filename,
+            status: f.status,
+            additions: f.additions,
+            deletions: f.deletions,
+            changes: f.changes
+          })) || [],
+          env: this.buildSafeEnv(),
+          memory: config.__memoryAccessor || {}
+        };
+        try {
+          const result = compileAndRun(this.sandbox, expression, jsContext, {
+            injectLog: true,
+            wrapFunction: true,
+            logPrefix: "[ai_allowed_tools_js]"
+          });
+          if (!Array.isArray(result)) {
+            logger.warn(
+              `[AICheckProvider] ai_allowed_tools_js must return an array, got ${typeof result}`
+            );
+            return null;
+          }
+          const tools = result.filter((item) => typeof item === "string");
+          logger.debug(
+            `[AICheckProvider] ai_allowed_tools_js evaluated to ${tools.length} tools: ${tools.join(", ")}`
+          );
+          return tools;
+        } catch (error) {
+          logger.error(
+            `[AICheckProvider] Failed to evaluate ai_allowed_tools_js: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+          return null;
+        }
+      }
       /**
        * Build a safe subset of environment variables for sandbox access.
        * Excludes sensitive keys like API keys, secrets, tokens.
@@ -19721,6 +20241,22 @@ ${processedPrompt}` : processedPrompt;
         }
         return tools;
       }
+      /**
+       * Intersect config-level allowedTools with policy-level allowedTools.
+       * When the config list contains glob patterns ("*", "!" exclusions),
+       * it is passed through unchanged — ProbeAgent resolves those patterns.
+       * Literal tool name lists are intersected normally.
+       */
+      static intersectAllowedTools(configTools, policyTools) {
+        if (!configTools) {
+          return policyTools;
+        }
+        const hasGlobs = configTools.some((t) => t === "*" || t.startsWith("!"));
+        if (hasGlobs) {
+          return configTools;
+        }
+        return configTools.filter((t) => policyTools.includes(t));
+      }
       getSupportedConfigKeys() {
         return [
           "type",
@@ -19736,6 +20272,7 @@ ${processedPrompt}` : processedPrompt;
           "ai.mcpServers",
           "ai.enableDelegate",
           "ai.enableTasks",
+          "ai.enableExecutePlan",
           // legacy persona/prompt keys supported in config
           "ai_persona",
           "ai_prompt_type",
@@ -19757,6 +20294,7 @@ ${processedPrompt}` : processedPrompt;
           "ai_custom_tools",
           "ai_custom_tools_js",
           "ai_bash_config_js",
+          "ai_allowed_tools_js",
           "env"
         ];
       }
@@ -24115,14 +24653,14 @@ var require_util = __commonJS({
         }
         const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
         let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`;
-        let path25 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
+        let path29 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
         if (origin.endsWith("/")) {
           origin = origin.substring(0, origin.length - 1);
         }
-        if (path25 && !path25.startsWith("/")) {
-          path25 = `/${path25}`;
+        if (path29 && !path29.startsWith("/")) {
+          path29 = `/${path29}`;
         }
-        url = new URL(origin + path25);
+        url = new URL(origin + path29);
       }
       return url;
     }
@@ -25736,20 +26274,20 @@ var require_parseParams = __commonJS({
 var require_basename = __commonJS({
   "node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) {
     "use strict";
-    module2.exports = function basename4(path25) {
-      if (typeof path25 !== "string") {
+    module2.exports = function basename4(path29) {
+      if (typeof path29 !== "string") {
         return "";
       }
-      for (var i = path25.length - 1; i >= 0; --i) {
-        switch (path25.charCodeAt(i)) {
+      for (var i = path29.length - 1; i >= 0; --i) {
+        switch (path29.charCodeAt(i)) {
           case 47:
           // '/'
           case 92:
-            path25 = path25.slice(i + 1);
-            return path25 === ".." || path25 === "." ? "" : path25;
+            path29 = path29.slice(i + 1);
+            return path29 === ".." || path29 === "." ? "" : path29;
         }
       }
-      return path25 === ".." || path25 === "." ? "" : path25;
+      return path29 === ".." || path29 === "." ? "" : path29;
     };
   }
 });
@@ -26753,11 +27291,11 @@ var require_util2 = __commonJS({
     var assert = require("assert");
     var { isUint8Array } = require("util/types");
     var supportedHashes = [];
-    var crypto2;
+    var crypto4;
     try {
-      crypto2 = require("crypto");
+      crypto4 = require("crypto");
       const possibleRelevantHashes = ["sha256", "sha384", "sha512"];
-      supportedHashes = crypto2.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
+      supportedHashes = crypto4.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
     } catch {
     }
     function responseURL(response) {
@@ -27034,7 +27572,7 @@ var require_util2 = __commonJS({
       }
     }
     function bytesMatch(bytes, metadataList) {
-      if (crypto2 === void 0) {
+      if (crypto4 === void 0) {
         return true;
       }
       const parsedMetadata = parseMetadata(metadataList);
@@ -27049,7 +27587,7 @@ var require_util2 = __commonJS({
       for (const item of metadata) {
         const algorithm = item.algo;
         const expectedValue = item.hash;
-        let actualValue = crypto2.createHash(algorithm).update(bytes).digest("base64");
+        let actualValue = crypto4.createHash(algorithm).update(bytes).digest("base64");
         if (actualValue[actualValue.length - 1] === "=") {
           if (actualValue[actualValue.length - 2] === "=") {
             actualValue = actualValue.slice(0, -2);
@@ -27142,8 +27680,8 @@ var require_util2 = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise = new Promise((resolve11, reject) => {
-        res = resolve11;
+      const promise = new Promise((resolve15, reject) => {
+        res = resolve15;
         rej = reject;
       });
       return { promise, resolve: res, reject: rej };
@@ -28396,8 +28934,8 @@ var require_body = __commonJS({
     var { parseMIMEType, serializeAMimeType } = require_dataURL();
     var random;
     try {
-      const crypto2 = require("crypto");
-      random = (max) => crypto2.randomInt(0, max);
+      const crypto4 = require("crypto");
+      random = (max) => crypto4.randomInt(0, max);
     } catch {
       random = (max) => Math.floor(Math.random(max));
     }
@@ -28648,8 +29186,8 @@ Content-Type: ${value.type || "application/octet-stream"}\r
                 });
               }
             });
-            const busboyResolve = new Promise((resolve11, reject) => {
-              busboy.on("finish", resolve11);
+            const busboyResolve = new Promise((resolve15, reject) => {
+              busboy.on("finish", resolve15);
               busboy.on("error", (err) => reject(new TypeError(err)));
             });
             if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk);
@@ -28780,7 +29318,7 @@ var require_request = __commonJS({
     }
     var Request = class _Request {
       constructor(origin, {
-        path: path25,
+        path: path29,
         method,
         body,
         headers,
@@ -28794,11 +29332,11 @@ var require_request = __commonJS({
         throwOnError,
         expectContinue
       }, handler) {
-        if (typeof path25 !== "string") {
+        if (typeof path29 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path25[0] !== "/" && !(path25.startsWith("http://") || path25.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path29[0] !== "/" && !(path29.startsWith("http://") || path29.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.exec(path25) !== null) {
+        } else if (invalidPathRegex.exec(path29) !== null) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -28861,7 +29399,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? util.buildURL(path25, query) : path25;
+        this.path = query ? util.buildURL(path29, query) : path29;
         this.origin = origin;
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
         this.blocking = blocking == null ? false : blocking;
@@ -29183,9 +29721,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve11, reject) => {
+          return new Promise((resolve15, reject) => {
             this.close((err, data) => {
-              return err ? reject(err) : resolve11(data);
+              return err ? reject(err) : resolve15(data);
             });
           });
         }
@@ -29223,12 +29761,12 @@ var require_dispatcher_base = __commonJS({
           err = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve11, reject) => {
+          return new Promise((resolve15, reject) => {
             this.destroy(err, (err2, data) => {
               return err2 ? (
                 /* istanbul ignore next: should never error */
                 reject(err2)
-              ) : resolve11(data);
+              ) : resolve15(data);
             });
           });
         }
@@ -29869,9 +30407,9 @@ var require_RedirectHandler = __commonJS({
           return this.handler.onHeaders(statusCode, headers, resume, statusText);
         }
         const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path25 = search ? `${pathname}${search}` : pathname;
+        const path29 = search ? `${pathname}${search}` : pathname;
         this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path25;
+        this.opts.path = path29;
         this.opts.origin = origin;
         this.opts.maxRedirections = 0;
         this.opts.query = null;
@@ -30290,16 +30828,16 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       async [kClose]() {
-        return new Promise((resolve11) => {
+        return new Promise((resolve15) => {
           if (!this[kSize]) {
-            resolve11(null);
+            resolve15(null);
           } else {
-            this[kClosedResolve] = resolve11;
+            this[kClosedResolve] = resolve15;
           }
         });
       }
       async [kDestroy](err) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve15) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request = requests[i];
@@ -30310,7 +30848,7 @@ var require_client = __commonJS({
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve11();
+            resolve15();
           };
           if (this[kHTTP2Session] != null) {
             util.destroy(this[kHTTP2Session], err);
@@ -30890,7 +31428,7 @@ var require_client = __commonJS({
         });
       }
       try {
-        const socket = await new Promise((resolve11, reject) => {
+        const socket = await new Promise((resolve15, reject) => {
           client[kConnector]({
             host,
             hostname,
@@ -30902,7 +31440,7 @@ var require_client = __commonJS({
             if (err) {
               reject(err);
             } else {
-              resolve11(socket2);
+              resolve15(socket2);
             }
           });
         });
@@ -31113,7 +31651,7 @@ var require_client = __commonJS({
         writeH2(client, client[kHTTP2Session], request);
         return;
       }
-      const { body, method, path: path25, host, upgrade, headers, blocking, reset } = request;
+      const { body, method, path: path29, host, upgrade, headers, blocking, reset } = request;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
         body.read(0);
@@ -31163,7 +31701,7 @@ var require_client = __commonJS({
       if (blocking) {
         socket[kBlocking] = true;
       }
-      let header = `${method} ${path25} HTTP/1.1\r
+      let header = `${method} ${path29} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -31226,7 +31764,7 @@ upgrade: ${upgrade}\r
       return true;
     }
     function writeH2(client, session, request) {
-      const { body, method, path: path25, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
+      const { body, method, path: path29, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
       let headers;
       if (typeof reqHeaders === "string") headers = Request[kHTTP2CopyHeaders](reqHeaders.trim());
       else headers = reqHeaders;
@@ -31269,7 +31807,7 @@ upgrade: ${upgrade}\r
         });
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path25;
+      headers[HTTP2_HEADER_PATH] = path29;
       headers[HTTP2_HEADER_SCHEME] = "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
@@ -31526,12 +32064,12 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve11, reject) => {
+      const waitForDrain = () => new Promise((resolve15, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve11;
+          callback = resolve15;
         }
       });
       if (client[kHTTPConnVersion] === "h2") {
@@ -31877,8 +32415,8 @@ var require_pool_base = __commonJS({
         if (this[kQueue].isEmpty()) {
           return Promise.all(this[kClients].map((c) => c.close()));
         } else {
-          return new Promise((resolve11) => {
-            this[kClosedResolve] = resolve11;
+          return new Promise((resolve15) => {
+            this[kClosedResolve] = resolve15;
           });
         }
       }
@@ -32456,7 +32994,7 @@ var require_readable = __commonJS({
         if (this.closed) {
           return Promise.resolve(null);
         }
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve15, reject) => {
           const signalListenerCleanup = signal ? util.addAbortListener(signal, () => {
             this.destroy();
           }) : noop;
@@ -32465,7 +33003,7 @@ var require_readable = __commonJS({
             if (signal && signal.aborted) {
               reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
             } else {
-              resolve11(null);
+              resolve15(null);
             }
           }).on("error", noop).on("data", function(chunk) {
             limit -= chunk.length;
@@ -32487,11 +33025,11 @@ var require_readable = __commonJS({
         throw new TypeError("unusable");
       }
       assert(!stream[kConsume]);
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve15, reject) => {
         stream[kConsume] = {
           type,
           stream,
-          resolve: resolve11,
+          resolve: resolve15,
           reject,
           length: 0,
           body: []
@@ -32526,12 +33064,12 @@ var require_readable = __commonJS({
       }
     }
     function consumeEnd(consume2) {
-      const { type, body, resolve: resolve11, stream, length } = consume2;
+      const { type, body, resolve: resolve15, stream, length } = consume2;
       try {
         if (type === "text") {
-          resolve11(toUSVString(Buffer.concat(body)));
+          resolve15(toUSVString(Buffer.concat(body)));
         } else if (type === "json") {
-          resolve11(JSON.parse(Buffer.concat(body)));
+          resolve15(JSON.parse(Buffer.concat(body)));
         } else if (type === "arrayBuffer") {
           const dst = new Uint8Array(length);
           let pos = 0;
@@ -32539,12 +33077,12 @@ var require_readable = __commonJS({
             dst.set(buf, pos);
             pos += buf.byteLength;
           }
-          resolve11(dst.buffer);
+          resolve15(dst.buffer);
         } else if (type === "blob") {
           if (!Blob2) {
             Blob2 = require("buffer").Blob;
           }
-          resolve11(new Blob2(body, { type: stream[kContentType] }));
+          resolve15(new Blob2(body, { type: stream[kContentType] }));
         }
         consumeFinish(consume2);
       } catch (err) {
@@ -32801,9 +33339,9 @@ var require_api_request = __commonJS({
     };
     function request(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve15, reject) => {
           request.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve15(data);
           });
         });
       }
@@ -32976,9 +33514,9 @@ var require_api_stream = __commonJS({
     };
     function stream(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve15, reject) => {
           stream.call(this, opts, factory, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve15(data);
           });
         });
       }
@@ -33259,9 +33797,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve15, reject) => {
           upgrade.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve15(data);
           });
         });
       }
@@ -33350,9 +33888,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve15, reject) => {
           connect.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve15(data);
           });
         });
       }
@@ -33512,20 +34050,20 @@ var require_mock_utils = __commonJS({
       }
       return true;
     }
-    function safeUrl(path25) {
-      if (typeof path25 !== "string") {
-        return path25;
+    function safeUrl(path29) {
+      if (typeof path29 !== "string") {
+        return path29;
       }
-      const pathSegments = path25.split("?");
+      const pathSegments = path29.split("?");
       if (pathSegments.length !== 2) {
-        return path25;
+        return path29;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path25, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path25);
+    function matchKey(mockDispatch2, { path: path29, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path29);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -33543,7 +34081,7 @@ var require_mock_utils = __commonJS({
     function getMockDispatch(mockDispatches, key) {
       const basePath = key.query ? buildURL(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path25 }) => matchValue(safeUrl(path25), resolvedPath));
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path29 }) => matchValue(safeUrl(path29), resolvedPath));
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
       }
@@ -33580,9 +34118,9 @@ var require_mock_utils = __commonJS({
       }
     }
     function buildKey(opts) {
-      const { path: path25, method, body, headers, query } = opts;
+      const { path: path29, method, body, headers, query } = opts;
       return {
-        path: path25,
+        path: path29,
         method,
         body,
         headers,
@@ -34031,10 +34569,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path25, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path29, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path25,
+            Path: path29,
             "Status code": statusCode,
             Persistent: persist ? "\u2705" : "\u274C",
             Invocations: timesInvoked,
@@ -36975,7 +37513,7 @@ var require_fetch = __commonJS({
       async function dispatch({ body }) {
         const url = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
-        return new Promise((resolve11, reject) => agent.dispatch(
+        return new Promise((resolve15, reject) => agent.dispatch(
           {
             path: url.pathname + url.search,
             origin: url.origin,
@@ -37051,7 +37589,7 @@ var require_fetch = __commonJS({
                   }
                 }
               }
-              resolve11({
+              resolve15({
                 status,
                 statusText,
                 headersList: headers[kHeadersList],
@@ -37094,7 +37632,7 @@ var require_fetch = __commonJS({
                 const val = headersList[n + 1].toString("latin1");
                 headers[kHeadersList].append(key, val);
               }
-              resolve11({
+              resolve15({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList: headers[kHeadersList],
@@ -38655,8 +39193,8 @@ var require_util6 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path25) {
-      for (const char of path25) {
+    function validateCookiePath(path29) {
+      for (const char of path29) {
         const code = char.charCodeAt(0);
         if (code < 33 || char === ";") {
           throw new Error("Invalid cookie path");
@@ -39453,9 +39991,9 @@ var require_connection = __commonJS({
     channels.open = diagnosticsChannel.channel("undici:websocket:open");
     channels.close = diagnosticsChannel.channel("undici:websocket:close");
     channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
-    var crypto2;
+    var crypto4;
     try {
-      crypto2 = require("crypto");
+      crypto4 = require("crypto");
     } catch {
     }
     function establishWebSocketConnection(url, protocols, ws, onEstablish, options) {
@@ -39474,7 +40012,7 @@ var require_connection = __commonJS({
         const headersList = new Headers(options.headers)[kHeadersList];
         request.headersList = headersList;
       }
-      const keyValue = crypto2.randomBytes(16).toString("base64");
+      const keyValue = crypto4.randomBytes(16).toString("base64");
       request.headersList.append("sec-websocket-key", keyValue);
       request.headersList.append("sec-websocket-version", "13");
       for (const protocol of protocols) {
@@ -39503,7 +40041,7 @@ var require_connection = __commonJS({
             return;
           }
           const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
-          const digest = crypto2.createHash("sha1").update(keyValue + uid).digest("base64");
+          const digest = crypto4.createHash("sha1").update(keyValue + uid).digest("base64");
           if (secWSAccept !== digest) {
             failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
             return;
@@ -39583,9 +40121,9 @@ var require_frame = __commonJS({
   "node_modules/undici/lib/websocket/frame.js"(exports2, module2) {
     "use strict";
     var { maxUnsigned16Bit } = require_constants5();
-    var crypto2;
+    var crypto4;
     try {
-      crypto2 = require("crypto");
+      crypto4 = require("crypto");
     } catch {
     }
     var WebsocketFrameSend = class {
@@ -39594,7 +40132,7 @@ var require_frame = __commonJS({
        */
       constructor(data) {
         this.frameData = data;
-        this.maskKey = crypto2.randomBytes(4);
+        this.maskKey = crypto4.randomBytes(4);
       }
       createFrame(opcode) {
         const bodyLength = this.frameData?.byteLength ?? 0;
@@ -40336,11 +40874,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path25 = opts.path;
+          let path29 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path25 = `/${path25}`;
+            path29 = `/${path29}`;
           }
-          url = new URL(util.parseOrigin(url).origin + path25);
+          url = new URL(util.parseOrigin(url).origin + path29);
         } else {
           if (!opts) {
             opts = typeof url === "object" ? url : {};
@@ -40867,7 +41405,7 @@ var init_mcp_check_provider = __esm({
             logger.warn(
               `MCP ${transportName} failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms: ${error instanceof Error ? error.message : String(error)}`
             );
-            await new Promise((resolve11) => setTimeout(resolve11, delay));
+            await new Promise((resolve15) => setTimeout(resolve15, delay));
             attempt += 1;
           } finally {
             try {
@@ -41136,7 +41674,7 @@ async function acquirePromptLock() {
     activePrompt = true;
     return;
   }
-  await new Promise((resolve11) => waiters.push(resolve11));
+  await new Promise((resolve15) => waiters.push(resolve15));
   activePrompt = true;
 }
 function releasePromptLock() {
@@ -41146,7 +41684,7 @@ function releasePromptLock() {
 }
 async function interactivePrompt(options) {
   await acquirePromptLock();
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve15, reject) => {
     const dbg = process.env.VISOR_DEBUG === "true";
     try {
       if (dbg) {
@@ -41233,12 +41771,12 @@ async function interactivePrompt(options) {
     };
     const finish = (value) => {
       cleanup();
-      resolve11(value);
+      resolve15(value);
     };
     if (options.timeout && options.timeout > 0) {
       timeoutId = setTimeout(() => {
         cleanup();
-        if (defaultValue !== void 0) return resolve11(defaultValue);
+        if (defaultValue !== void 0) return resolve15(defaultValue);
         return reject(new Error("Input timeout"));
       }, options.timeout);
     }
@@ -41370,7 +41908,7 @@ async function interactivePrompt(options) {
   });
 }
 async function simplePrompt(prompt) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve15) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -41386,7 +41924,7 @@ async function simplePrompt(prompt) {
     rl.question(`${prompt}
 > `, (answer) => {
       rl.close();
-      resolve11(answer.trim());
+      resolve15(answer.trim());
     });
   });
 }
@@ -41554,7 +42092,7 @@ function isStdinAvailable() {
   return !process.stdin.isTTY;
 }
 async function readStdin(timeout, maxSize = 1024 * 1024) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve15, reject) => {
     let data = "";
     let timeoutId;
     if (timeout) {
@@ -41581,7 +42119,7 @@ async function readStdin(timeout, maxSize = 1024 * 1024) {
     };
     const onEnd = () => {
       cleanup();
-      resolve11(data.trim());
+      resolve15(data.trim());
     };
     const onError = (err) => {
       cleanup();
@@ -44906,23 +45444,23 @@ __export(renderer_schema_exports, {
 });
 async function loadRendererSchema(name) {
   try {
-    const fs21 = await import("fs/promises");
-    const path25 = await import("path");
+    const fs25 = await import("fs/promises");
+    const path29 = await import("path");
     const sanitized = String(name).replace(/[^a-zA-Z0-9-]/g, "");
     if (!sanitized) return void 0;
     const candidates = [
       // When bundled with ncc, __dirname is dist/ and output/ is at dist/output/
-      path25.join(__dirname, "output", sanitized, "schema.json"),
+      path29.join(__dirname, "output", sanitized, "schema.json"),
       // When running from source, __dirname is src/state-machine/dispatch/ and output/ is at output/
-      path25.join(__dirname, "..", "..", "output", sanitized, "schema.json"),
+      path29.join(__dirname, "..", "..", "output", sanitized, "schema.json"),
       // When running from a checkout with output/ folder copied to CWD
-      path25.join(process.cwd(), "output", sanitized, "schema.json"),
+      path29.join(process.cwd(), "output", sanitized, "schema.json"),
       // Fallback: cwd/dist/output/
-      path25.join(process.cwd(), "dist", "output", sanitized, "schema.json")
+      path29.join(process.cwd(), "dist", "output", sanitized, "schema.json")
     ];
     for (const p of candidates) {
       try {
-        const raw = await fs21.readFile(p, "utf-8");
+        const raw = await fs25.readFile(p, "utf-8");
         return JSON.parse(raw);
       } catch {
       }
@@ -47341,37 +47879,37 @@ function updateStats2(results, state, isForEachIteration = false) {
 async function renderTemplateContent2(checkId, checkConfig, reviewSummary) {
   try {
     const { createExtendedLiquid: createExtendedLiquid2 } = await Promise.resolve().then(() => (init_liquid_extensions(), liquid_extensions_exports));
-    const fs21 = await import("fs/promises");
-    const path25 = await import("path");
+    const fs25 = await import("fs/promises");
+    const path29 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
-    const schema = typeof schemaRaw === "string" ? schemaRaw : "code-review";
+    const schema = typeof schemaRaw === "string" && !schemaRaw.includes("{{") && !schemaRaw.includes("{%") ? schemaRaw : typeof schemaRaw === "object" ? "code-review" : "plain";
     let templateContent;
     if (checkConfig.template && checkConfig.template.content) {
       templateContent = String(checkConfig.template.content);
       logger.debug(`[LevelDispatch] Using inline template for ${checkId}`);
     } else if (checkConfig.template && checkConfig.template.file) {
       const file = String(checkConfig.template.file);
-      const resolved = path25.resolve(process.cwd(), file);
-      templateContent = await fs21.readFile(resolved, "utf-8");
+      const resolved = path29.resolve(process.cwd(), file);
+      templateContent = await fs25.readFile(resolved, "utf-8");
       logger.debug(`[LevelDispatch] Using template file for ${checkId}: ${resolved}`);
     } else if (schema && schema !== "plain") {
       const sanitized = String(schema).replace(/[^a-zA-Z0-9-]/g, "");
       if (sanitized) {
         const candidatePaths = [
-          path25.join(__dirname, "output", sanitized, "template.liquid"),
+          path29.join(__dirname, "output", sanitized, "template.liquid"),
           // bundled: dist/output/
-          path25.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
+          path29.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
           // source (from state-machine/states)
-          path25.join(__dirname, "..", "..", "..", "output", sanitized, "template.liquid"),
+          path29.join(__dirname, "..", "..", "..", "output", sanitized, "template.liquid"),
           // source (alternate)
-          path25.join(process.cwd(), "output", sanitized, "template.liquid"),
+          path29.join(process.cwd(), "output", sanitized, "template.liquid"),
           // fallback: cwd/output/
-          path25.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
+          path29.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
           // fallback: cwd/dist/output/
         ];
         for (const p of candidatePaths) {
           try {
-            templateContent = await fs21.readFile(p, "utf-8");
+            templateContent = await fs25.readFile(p, "utf-8");
             if (templateContent) {
               logger.debug(`[LevelDispatch] Using schema template for ${checkId}: ${p}`);
               break;
@@ -49172,8 +49710,8 @@ var init_workspace_manager = __esm({
         );
         if (this.cleanupRequested && this.activeOperations === 0) {
           logger.debug(`[Workspace] All references released, proceeding with deferred cleanup`);
-          for (const resolve11 of this.cleanupResolvers) {
-            resolve11();
+          for (const resolve15 of this.cleanupResolvers) {
+            resolve15();
           }
           this.cleanupResolvers = [];
         }
@@ -49298,19 +49836,19 @@ var init_workspace_manager = __esm({
           );
           this.cleanupRequested = true;
           await Promise.race([
-            new Promise((resolve11) => {
+            new Promise((resolve15) => {
               if (this.activeOperations === 0) {
-                resolve11();
+                resolve15();
               } else {
-                this.cleanupResolvers.push(resolve11);
+                this.cleanupResolvers.push(resolve15);
               }
             }),
-            new Promise((resolve11) => {
+            new Promise((resolve15) => {
               setTimeout(() => {
                 logger.warn(
                   `[Workspace] Cleanup timeout after ${timeout}ms, proceeding anyway (${this.activeOperations} operations still active)`
                 );
-                resolve11();
+                resolve15();
               }, timeout);
             })
           ]);
@@ -49589,6 +50127,1264 @@ var init_build_engine_context = __esm({
   }
 });
 
+// src/policy/default-engine.ts
+var DefaultPolicyEngine;
+var init_default_engine = __esm({
+  "src/policy/default-engine.ts"() {
+    "use strict";
+    DefaultPolicyEngine = class {
+      async initialize(_config) {
+      }
+      async evaluateCheckExecution(_checkId, _checkConfig) {
+        return { allowed: true };
+      }
+      async evaluateToolInvocation(_serverName, _methodName, _transport) {
+        return { allowed: true };
+      }
+      async evaluateCapabilities(_checkId, _capabilities) {
+        return { allowed: true };
+      }
+      async shutdown() {
+      }
+    };
+  }
+});
+
+// src/enterprise/license/validator.ts
+var validator_exports = {};
+__export(validator_exports, {
+  LicenseValidator: () => LicenseValidator
+});
+var crypto2, fs18, path22, LicenseValidator;
+var init_validator = __esm({
+  "src/enterprise/license/validator.ts"() {
+    "use strict";
+    crypto2 = __toESM(require("crypto"));
+    fs18 = __toESM(require("fs"));
+    path22 = __toESM(require("path"));
+    LicenseValidator = class _LicenseValidator {
+      /** Ed25519 public key for license verification (PEM format). */
+      static PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAI/Zd08EFmgIdrDm/HXd0l3/5GBt7R1PrdvhdmEXhJlU=\n-----END PUBLIC KEY-----\n";
+      cache = null;
+      static CACHE_TTL = 5 * 60 * 1e3;
+      // 5 minutes
+      static GRACE_PERIOD = 72 * 3600 * 1e3;
+      // 72 hours after expiry
+      /**
+       * Load and validate license from environment or file.
+       *
+       * Resolution order:
+       * 1. VISOR_LICENSE env var (JWT string)
+       * 2. VISOR_LICENSE_FILE env var (path to file)
+       * 3. .visor-license in project root (cwd)
+       * 4. .visor-license in ~/.config/visor/
+       */
+      async loadAndValidate() {
+        if (this.cache && Date.now() - this.cache.validatedAt < _LicenseValidator.CACHE_TTL) {
+          return this.cache.payload;
+        }
+        const token = this.resolveToken();
+        if (!token) return null;
+        const payload = this.verifyAndDecode(token);
+        if (!payload) return null;
+        this.cache = { payload, validatedAt: Date.now() };
+        return payload;
+      }
+      /** Check if a specific feature is licensed */
+      hasFeature(feature) {
+        if (!this.cache) return false;
+        return this.cache.payload.features.includes(feature);
+      }
+      /** Check if license is valid (with grace period) */
+      isValid() {
+        if (!this.cache) return false;
+        const now = Date.now();
+        const expiryMs = this.cache.payload.exp * 1e3;
+        return now < expiryMs + _LicenseValidator.GRACE_PERIOD;
+      }
+      /** Check if the license is within its grace period (expired but still valid) */
+      isInGracePeriod() {
+        if (!this.cache) return false;
+        const now = Date.now();
+        const expiryMs = this.cache.payload.exp * 1e3;
+        return now >= expiryMs && now < expiryMs + _LicenseValidator.GRACE_PERIOD;
+      }
+      resolveToken() {
+        if (process.env.VISOR_LICENSE) {
+          return process.env.VISOR_LICENSE.trim();
+        }
+        if (process.env.VISOR_LICENSE_FILE) {
+          const resolved = path22.resolve(process.env.VISOR_LICENSE_FILE);
+          const home2 = process.env.HOME || process.env.USERPROFILE || "";
+          const allowedPrefixes = [path22.normalize(process.cwd())];
+          if (home2) allowedPrefixes.push(path22.normalize(path22.join(home2, ".config", "visor")));
+          let realPath;
+          try {
+            realPath = fs18.realpathSync(resolved);
+          } catch {
+            return null;
+          }
+          const isSafe = allowedPrefixes.some(
+            (prefix) => realPath === prefix || realPath.startsWith(prefix + path22.sep)
+          );
+          if (!isSafe) return null;
+          return this.readFile(realPath);
+        }
+        const cwdPath = path22.join(process.cwd(), ".visor-license");
+        const cwdToken = this.readFile(cwdPath);
+        if (cwdToken) return cwdToken;
+        const home = process.env.HOME || process.env.USERPROFILE || "";
+        if (home) {
+          const configPath = path22.join(home, ".config", "visor", ".visor-license");
+          const configToken = this.readFile(configPath);
+          if (configToken) return configToken;
+        }
+        return null;
+      }
+      readFile(filePath) {
+        try {
+          return fs18.readFileSync(filePath, "utf-8").trim();
+        } catch {
+          return null;
+        }
+      }
+      verifyAndDecode(token) {
+        try {
+          const parts = token.split(".");
+          if (parts.length !== 3) return null;
+          const [headerB64, payloadB64, signatureB64] = parts;
+          const header = JSON.parse(Buffer.from(headerB64, "base64url").toString());
+          if (header.alg !== "EdDSA") return null;
+          const data = `${headerB64}.${payloadB64}`;
+          const signature = Buffer.from(signatureB64, "base64url");
+          const publicKey = crypto2.createPublicKey(_LicenseValidator.PUBLIC_KEY);
+          if (publicKey.asymmetricKeyType !== "ed25519") {
+            return null;
+          }
+          const isValid = crypto2.verify(null, Buffer.from(data), publicKey, signature);
+          if (!isValid) return null;
+          const payload = JSON.parse(Buffer.from(payloadB64, "base64url").toString());
+          if (!payload.org || !Array.isArray(payload.features) || typeof payload.exp !== "number" || typeof payload.iat !== "number" || !payload.sub) {
+            return null;
+          }
+          const now = Date.now();
+          const expiryMs = payload.exp * 1e3;
+          if (now >= expiryMs + _LicenseValidator.GRACE_PERIOD) {
+            return null;
+          }
+          return payload;
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/enterprise/policy/opa-compiler.ts
+var fs19, path23, os, crypto3, import_child_process5, OpaCompiler;
+var init_opa_compiler = __esm({
+  "src/enterprise/policy/opa-compiler.ts"() {
+    "use strict";
+    fs19 = __toESM(require("fs"));
+    path23 = __toESM(require("path"));
+    os = __toESM(require("os"));
+    crypto3 = __toESM(require("crypto"));
+    import_child_process5 = require("child_process");
+    OpaCompiler = class _OpaCompiler {
+      static CACHE_DIR = path23.join(os.tmpdir(), "visor-opa-cache");
+      /**
+       * Resolve the input paths to WASM bytes.
+       *
+       * Strategy:
+       * 1. If any path is a .wasm file, read it directly
+       * 2. If a directory contains policy.wasm, read it
+       * 3. Otherwise, collect all .rego files and auto-compile via `opa build`
+       */
+      async resolveWasmBytes(paths) {
+        const regoFiles = [];
+        for (const p of paths) {
+          const resolved = path23.resolve(p);
+          if (path23.normalize(resolved).includes("..")) {
+            throw new Error(`Policy path contains traversal sequences: ${p}`);
+          }
+          if (resolved.endsWith(".wasm") && fs19.existsSync(resolved)) {
+            return fs19.readFileSync(resolved);
+          }
+          if (!fs19.existsSync(resolved)) continue;
+          const stat = fs19.statSync(resolved);
+          if (stat.isDirectory()) {
+            const wasmCandidate = path23.join(resolved, "policy.wasm");
+            if (fs19.existsSync(wasmCandidate)) {
+              return fs19.readFileSync(wasmCandidate);
+            }
+            const files = fs19.readdirSync(resolved);
+            for (const f of files) {
+              if (f.endsWith(".rego")) {
+                regoFiles.push(path23.join(resolved, f));
+              }
+            }
+          } else if (resolved.endsWith(".rego")) {
+            regoFiles.push(resolved);
+          }
+        }
+        if (regoFiles.length === 0) {
+          throw new Error(
+            `OPA WASM evaluator: no .wasm bundle or .rego files found in: ${paths.join(", ")}`
+          );
+        }
+        return this.compileRego(regoFiles);
+      }
+      /**
+       * Auto-compile .rego files to a WASM bundle using the `opa` CLI.
+       *
+       * Caches the compiled bundle based on a content hash of all input .rego files
+       * so subsequent runs skip compilation if policies haven't changed.
+       */
+      compileRego(regoFiles) {
+        try {
+          (0, import_child_process5.execFileSync)("opa", ["version"], { stdio: "pipe" });
+        } catch {
+          throw new Error(
+            "OPA CLI (`opa`) not found on PATH. Install it from https://www.openpolicyagent.org/docs/latest/#running-opa\nOr pre-compile your .rego files: opa build -t wasm -e visor -o bundle.tar.gz " + regoFiles.join(" ")
+          );
+        }
+        const hash = crypto3.createHash("sha256");
+        for (const f of regoFiles.sort()) {
+          hash.update(fs19.readFileSync(f));
+          hash.update(f);
+        }
+        const cacheKey = hash.digest("hex").slice(0, 16);
+        const cacheDir = _OpaCompiler.CACHE_DIR;
+        const cachedWasm = path23.join(cacheDir, `${cacheKey}.wasm`);
+        if (fs19.existsSync(cachedWasm)) {
+          return fs19.readFileSync(cachedWasm);
+        }
+        fs19.mkdirSync(cacheDir, { recursive: true });
+        const bundleTar = path23.join(cacheDir, `${cacheKey}-bundle.tar.gz`);
+        try {
+          const args = [
+            "build",
+            "-t",
+            "wasm",
+            "-e",
+            "visor",
+            // entrypoint: the visor package tree
+            "-o",
+            bundleTar,
+            ...regoFiles
+          ];
+          (0, import_child_process5.execFileSync)("opa", args, {
+            stdio: "pipe",
+            timeout: 3e4
+          });
+        } catch (err) {
+          const stderr = err?.stderr?.toString() || "";
+          throw new Error(
+            `Failed to compile .rego files to WASM:
+${stderr}
+Ensure your .rego files are valid and the \`opa\` CLI is installed.`
+          );
+        }
+        try {
+          (0, import_child_process5.execFileSync)("tar", ["-xzf", bundleTar, "-C", cacheDir, "/policy.wasm"], {
+            stdio: "pipe"
+          });
+          const extractedWasm = path23.join(cacheDir, "policy.wasm");
+          if (fs19.existsSync(extractedWasm)) {
+            fs19.renameSync(extractedWasm, cachedWasm);
+          }
+        } catch {
+          try {
+            (0, import_child_process5.execFileSync)("tar", ["-xzf", bundleTar, "-C", cacheDir, "policy.wasm"], {
+              stdio: "pipe"
+            });
+            const extractedWasm = path23.join(cacheDir, "policy.wasm");
+            if (fs19.existsSync(extractedWasm)) {
+              fs19.renameSync(extractedWasm, cachedWasm);
+            }
+          } catch (err2) {
+            throw new Error(`Failed to extract policy.wasm from OPA bundle: ${err2?.message || err2}`);
+          }
+        }
+        try {
+          fs19.unlinkSync(bundleTar);
+        } catch {
+        }
+        if (!fs19.existsSync(cachedWasm)) {
+          throw new Error("OPA build succeeded but policy.wasm was not found in the bundle");
+        }
+        return fs19.readFileSync(cachedWasm);
+      }
+    };
+  }
+});
+
+// src/enterprise/policy/opa-wasm-evaluator.ts
+var fs20, path24, OpaWasmEvaluator;
+var init_opa_wasm_evaluator = __esm({
+  "src/enterprise/policy/opa-wasm-evaluator.ts"() {
+    "use strict";
+    fs20 = __toESM(require("fs"));
+    path24 = __toESM(require("path"));
+    init_opa_compiler();
+    OpaWasmEvaluator = class {
+      policy = null;
+      dataDocument = {};
+      compiler = new OpaCompiler();
+      async initialize(rulesPath) {
+        const paths = Array.isArray(rulesPath) ? rulesPath : [rulesPath];
+        const wasmBytes = await this.compiler.resolveWasmBytes(paths);
+        try {
+          const { createRequire } = require("module");
+          const runtimeRequire = createRequire(__filename);
+          const opaWasm = runtimeRequire("@open-policy-agent/opa-wasm");
+          const loadPolicy = opaWasm.loadPolicy || opaWasm.default?.loadPolicy;
+          if (!loadPolicy) {
+            throw new Error("loadPolicy not found in @open-policy-agent/opa-wasm");
+          }
+          this.policy = await loadPolicy(wasmBytes);
+        } catch (err) {
+          if (err?.code === "MODULE_NOT_FOUND" || err?.code === "ERR_MODULE_NOT_FOUND") {
+            throw new Error(
+              "OPA WASM evaluator requires @open-policy-agent/opa-wasm. Install it with: npm install @open-policy-agent/opa-wasm"
+            );
+          }
+          throw err;
+        }
+      }
+      /**
+       * Load external data from a JSON file to use as the OPA data document.
+       * The loaded data will be passed to `policy.setData()` during evaluation,
+       * making it available in Rego via `data.<key>`.
+       */
+      loadData(dataPath) {
+        const resolved = path24.resolve(dataPath);
+        if (path24.normalize(resolved).includes("..")) {
+          throw new Error(`Data path contains traversal sequences: ${dataPath}`);
+        }
+        if (!fs20.existsSync(resolved)) {
+          throw new Error(`OPA data file not found: ${resolved}`);
+        }
+        const stat = fs20.statSync(resolved);
+        if (stat.size > 10 * 1024 * 1024) {
+          throw new Error(`OPA data file exceeds 10MB limit: ${resolved} (${stat.size} bytes)`);
+        }
+        const raw = fs20.readFileSync(resolved, "utf-8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new Error("OPA data file must contain a JSON object (not an array or primitive)");
+          }
+          this.dataDocument = parsed;
+        } catch (err) {
+          if (err.message.startsWith("OPA data file must")) {
+            throw err;
+          }
+          throw new Error(`Failed to parse OPA data file ${resolved}: ${err.message}`);
+        }
+      }
+      async evaluate(input) {
+        if (!this.policy) {
+          throw new Error("OPA WASM evaluator not initialized");
+        }
+        this.policy.setData(this.dataDocument);
+        const resultSet = this.policy.evaluate(input);
+        if (Array.isArray(resultSet) && resultSet.length > 0) {
+          return resultSet[0].result;
+        }
+        return void 0;
+      }
+      async shutdown() {
+        if (this.policy) {
+          if (typeof this.policy.close === "function") {
+            try {
+              this.policy.close();
+            } catch {
+            }
+          } else if (typeof this.policy.free === "function") {
+            try {
+              this.policy.free();
+            } catch {
+            }
+          }
+        }
+        this.policy = null;
+      }
+    };
+  }
+});
+
+// src/enterprise/policy/opa-http-evaluator.ts
+var OpaHttpEvaluator;
+var init_opa_http_evaluator = __esm({
+  "src/enterprise/policy/opa-http-evaluator.ts"() {
+    "use strict";
+    OpaHttpEvaluator = class {
+      baseUrl;
+      timeout;
+      constructor(baseUrl, timeout = 5e3) {
+        let parsed;
+        try {
+          parsed = new URL(baseUrl);
+        } catch {
+          throw new Error(`OPA HTTP evaluator: invalid URL: ${baseUrl}`);
+        }
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+          throw new Error(
+            `OPA HTTP evaluator: url must use http:// or https:// protocol, got: ${baseUrl}`
+          );
+        }
+        const hostname = parsed.hostname;
+        if (this.isBlockedHostname(hostname)) {
+          throw new Error(
+            `OPA HTTP evaluator: url must not point to internal, loopback, or private network addresses`
+          );
+        }
+        this.baseUrl = baseUrl.replace(/\/+$/, "");
+        this.timeout = timeout;
+      }
+      /**
+       * Check if a hostname is blocked due to SSRF concerns.
+       *
+       * Blocks:
+       * - Loopback addresses (127.x.x.x, localhost, 0.0.0.0, ::1)
+       * - Link-local addresses (169.254.x.x)
+       * - Private networks (10.x.x.x, 172.16-31.x.x, 192.168.x.x)
+       * - IPv6 unique local addresses (fd00::/8)
+       * - Cloud metadata services (*.internal)
+       */
+      isBlockedHostname(hostname) {
+        if (!hostname) return true;
+        const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+        if (normalized === "metadata.google.internal" || normalized.endsWith(".internal")) {
+          return true;
+        }
+        if (normalized === "localhost" || normalized === "localhost.localdomain") {
+          return true;
+        }
+        if (normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") {
+          return true;
+        }
+        const ipv4Pattern = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+        const ipv4Match = normalized.match(ipv4Pattern);
+        if (ipv4Match) {
+          const octets = ipv4Match.slice(1, 5).map(Number);
+          if (octets.some((octet) => octet > 255)) {
+            return false;
+          }
+          const [a, b] = octets;
+          if (a === 127) {
+            return true;
+          }
+          if (a === 0) {
+            return true;
+          }
+          if (a === 169 && b === 254) {
+            return true;
+          }
+          if (a === 10) {
+            return true;
+          }
+          if (a === 172 && b >= 16 && b <= 31) {
+            return true;
+          }
+          if (a === 192 && b === 168) {
+            return true;
+          }
+        }
+        if (normalized.startsWith("fd") || normalized.startsWith("fc")) {
+          return true;
+        }
+        if (normalized.startsWith("fe80:")) {
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Evaluate a policy rule against an input document via OPA REST API.
+       *
+       * @param input - The input document to evaluate
+       * @param rulePath - OPA rule path (e.g., 'visor/check/execute')
+       * @returns The result object from OPA, or undefined on error
+       */
+      async evaluate(input, rulePath) {
+        const encodedPath = rulePath.split("/").map((s) => encodeURIComponent(s)).join("/");
+        const url = `${this.baseUrl}/v1/data/${encodedPath}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ input }),
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            throw new Error(`OPA HTTP ${response.status}: ${response.statusText}`);
+          }
+          let body;
+          try {
+            body = await response.json();
+          } catch (jsonErr) {
+            throw new Error(
+              `OPA HTTP evaluator: failed to parse JSON response: ${jsonErr instanceof Error ? jsonErr.message : String(jsonErr)}`
+            );
+          }
+          return body?.result;
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      async shutdown() {
+      }
+    };
+  }
+});
+
+// src/enterprise/policy/policy-input-builder.ts
+var PolicyInputBuilder;
+var init_policy_input_builder = __esm({
+  "src/enterprise/policy/policy-input-builder.ts"() {
+    "use strict";
+    PolicyInputBuilder = class {
+      roles;
+      actor;
+      repository;
+      pullRequest;
+      constructor(policyConfig, actor, repository, pullRequest) {
+        this.roles = policyConfig.roles || {};
+        this.actor = actor;
+        this.repository = repository;
+        this.pullRequest = pullRequest;
+      }
+      /** Resolve which roles apply to the current actor. */
+      resolveRoles() {
+        const matched = [];
+        for (const [roleName, roleConfig] of Object.entries(this.roles)) {
+          let identityMatch = false;
+          if (roleConfig.author_association && this.actor.authorAssociation && roleConfig.author_association.includes(this.actor.authorAssociation)) {
+            identityMatch = true;
+          }
+          if (!identityMatch && roleConfig.users && this.actor.login && roleConfig.users.includes(this.actor.login)) {
+            identityMatch = true;
+          }
+          if (!identityMatch && roleConfig.slack_users && this.actor.slack?.userId && roleConfig.slack_users.includes(this.actor.slack.userId)) {
+            identityMatch = true;
+          }
+          if (!identityMatch && roleConfig.emails && this.actor.slack?.email) {
+            const actorEmail = this.actor.slack.email.toLowerCase();
+            if (roleConfig.emails.some((e) => e.toLowerCase() === actorEmail)) {
+              identityMatch = true;
+            }
+          }
+          if (!identityMatch) continue;
+          if (roleConfig.slack_channels && roleConfig.slack_channels.length > 0) {
+            if (!this.actor.slack?.channelId || !roleConfig.slack_channels.includes(this.actor.slack.channelId)) {
+              continue;
+            }
+          }
+          matched.push(roleName);
+        }
+        return matched;
+      }
+      buildActor() {
+        return {
+          authorAssociation: this.actor.authorAssociation,
+          login: this.actor.login,
+          roles: this.resolveRoles(),
+          isLocalMode: this.actor.isLocalMode,
+          ...this.actor.slack && { slack: this.actor.slack }
+        };
+      }
+      forCheckExecution(check) {
+        return {
+          scope: "check.execute",
+          check: {
+            id: check.id,
+            type: check.type,
+            group: check.group,
+            tags: check.tags,
+            criticality: check.criticality,
+            sandbox: check.sandbox,
+            policy: check.policy
+          },
+          actor: this.buildActor(),
+          repository: this.repository,
+          pullRequest: this.pullRequest
+        };
+      }
+      forToolInvocation(serverName, methodName, transport) {
+        return {
+          scope: "tool.invoke",
+          tool: { serverName, methodName, transport },
+          actor: this.buildActor(),
+          repository: this.repository,
+          pullRequest: this.pullRequest
+        };
+      }
+      forCapabilityResolve(checkId, capabilities) {
+        return {
+          scope: "capability.resolve",
+          check: { id: checkId, type: "ai" },
+          capability: capabilities,
+          actor: this.buildActor(),
+          repository: this.repository,
+          pullRequest: this.pullRequest
+        };
+      }
+    };
+  }
+});
+
+// src/enterprise/policy/opa-policy-engine.ts
+var opa_policy_engine_exports = {};
+__export(opa_policy_engine_exports, {
+  OpaPolicyEngine: () => OpaPolicyEngine
+});
+var OpaPolicyEngine;
+var init_opa_policy_engine = __esm({
+  "src/enterprise/policy/opa-policy-engine.ts"() {
+    "use strict";
+    init_opa_wasm_evaluator();
+    init_opa_http_evaluator();
+    init_policy_input_builder();
+    OpaPolicyEngine = class {
+      evaluator = null;
+      fallback;
+      timeout;
+      config;
+      inputBuilder = null;
+      logger = null;
+      constructor(config) {
+        this.config = config;
+        this.fallback = config.fallback || "deny";
+        this.timeout = config.timeout || 5e3;
+      }
+      async initialize(config) {
+        try {
+          this.logger = (init_logger(), __toCommonJS(logger_exports)).logger;
+        } catch {
+        }
+        const actor = {
+          authorAssociation: process.env.VISOR_AUTHOR_ASSOCIATION,
+          login: process.env.VISOR_AUTHOR_LOGIN || process.env.GITHUB_ACTOR,
+          isLocalMode: !process.env.GITHUB_ACTIONS
+        };
+        const repo = {
+          owner: process.env.GITHUB_REPOSITORY_OWNER,
+          name: process.env.GITHUB_REPOSITORY?.split("/")[1],
+          branch: process.env.GITHUB_HEAD_REF,
+          baseBranch: process.env.GITHUB_BASE_REF,
+          event: process.env.GITHUB_EVENT_NAME
+        };
+        const prNum = process.env.GITHUB_PR_NUMBER ? parseInt(process.env.GITHUB_PR_NUMBER, 10) : void 0;
+        const pullRequest = {
+          number: prNum !== void 0 && Number.isFinite(prNum) ? prNum : void 0
+        };
+        this.inputBuilder = new PolicyInputBuilder(config, actor, repo, pullRequest);
+        if (config.engine === "local") {
+          if (!config.rules) {
+            throw new Error("OPA local mode requires `policy.rules` path to .wasm or .rego files");
+          }
+          const wasm = new OpaWasmEvaluator();
+          await wasm.initialize(config.rules);
+          if (config.data) {
+            wasm.loadData(config.data);
+          }
+          this.evaluator = wasm;
+        } else if (config.engine === "remote") {
+          if (!config.url) {
+            throw new Error("OPA remote mode requires `policy.url` pointing to OPA server");
+          }
+          this.evaluator = new OpaHttpEvaluator(config.url, this.timeout);
+        } else {
+          this.evaluator = null;
+        }
+      }
+      /**
+       * Update actor/repo/PR context (e.g., after PR info becomes available).
+       * Called by the enterprise loader when engine context is enriched.
+       */
+      setActorContext(actor, repo, pullRequest) {
+        this.inputBuilder = new PolicyInputBuilder(this.config, actor, repo, pullRequest);
+      }
+      async evaluateCheckExecution(checkId, checkConfig) {
+        if (!this.evaluator || !this.inputBuilder) return { allowed: true };
+        const cfg = checkConfig && typeof checkConfig === "object" ? checkConfig : {};
+        const policyOverride = cfg.policy;
+        const input = this.inputBuilder.forCheckExecution({
+          id: checkId,
+          type: cfg.type || "ai",
+          group: cfg.group,
+          tags: cfg.tags,
+          criticality: cfg.criticality,
+          sandbox: cfg.sandbox,
+          policy: policyOverride
+        });
+        return this.doEvaluate(input, this.resolveRulePath("check.execute", policyOverride?.rule));
+      }
+      async evaluateToolInvocation(serverName, methodName, transport) {
+        if (!this.evaluator || !this.inputBuilder) return { allowed: true };
+        const input = this.inputBuilder.forToolInvocation(serverName, methodName, transport);
+        return this.doEvaluate(input, "visor/tool/invoke");
+      }
+      async evaluateCapabilities(checkId, capabilities) {
+        if (!this.evaluator || !this.inputBuilder) return { allowed: true };
+        const input = this.inputBuilder.forCapabilityResolve(checkId, capabilities);
+        return this.doEvaluate(input, "visor/capability/resolve");
+      }
+      async shutdown() {
+        if (this.evaluator && "shutdown" in this.evaluator) {
+          await this.evaluator.shutdown();
+        }
+        this.evaluator = null;
+        this.inputBuilder = null;
+      }
+      resolveRulePath(defaultScope, override) {
+        if (override) {
+          return override.startsWith("visor/") ? override : `visor/${override}`;
+        }
+        return `visor/${defaultScope.replace(/\./g, "/")}`;
+      }
+      async doEvaluate(input, rulePath) {
+        try {
+          this.logger?.debug(`[PolicyEngine] Evaluating ${rulePath}`, JSON.stringify(input));
+          let timer;
+          const timeoutPromise = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(new Error("policy evaluation timeout")), this.timeout);
+          });
+          try {
+            const result = await Promise.race([this.rawEvaluate(input, rulePath), timeoutPromise]);
+            const decision = this.parseDecision(result);
+            if (!decision.allowed && this.fallback === "warn") {
+              decision.allowed = true;
+              decision.warn = true;
+              decision.reason = `audit: ${decision.reason || "policy denied"}`;
+            }
+            this.logger?.debug(
+              `[PolicyEngine] Decision for ${rulePath}: allowed=${decision.allowed}, warn=${decision.warn || false}, reason=${decision.reason || "none"}`
+            );
+            return decision;
+          } finally {
+            if (timer) clearTimeout(timer);
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          this.logger?.warn(`[PolicyEngine] Evaluation failed for ${rulePath}: ${msg}`);
+          return {
+            allowed: this.fallback === "allow" || this.fallback === "warn",
+            warn: this.fallback === "warn" ? true : void 0,
+            reason: `policy evaluation failed, fallback=${this.fallback}`
+          };
+        }
+      }
+      async rawEvaluate(input, rulePath) {
+        if (this.evaluator instanceof OpaWasmEvaluator) {
+          const result = await this.evaluator.evaluate(input);
+          return this.navigateWasmResult(result, rulePath);
+        }
+        return this.evaluator.evaluate(input, rulePath);
+      }
+      /**
+       * Navigate nested OPA WASM result tree to reach the specific rule's output.
+       * The WASM entrypoint `-e visor` means the result root IS the visor package,
+       * so we strip the `visor/` prefix and walk the remaining segments.
+       */
+      navigateWasmResult(result, rulePath) {
+        if (!result || typeof result !== "object") return result;
+        const segments = rulePath.replace(/^visor\//, "").split("/");
+        let current = result;
+        for (const seg of segments) {
+          if (current && typeof current === "object" && seg in current) {
+            current = current[seg];
+          } else {
+            return void 0;
+          }
+        }
+        return current;
+      }
+      parseDecision(result) {
+        if (result === void 0 || result === null) {
+          return {
+            allowed: this.fallback === "allow" || this.fallback === "warn",
+            warn: this.fallback === "warn" ? true : void 0,
+            reason: this.fallback === "warn" ? "audit: no policy result" : "no policy result"
+          };
+        }
+        const allowed = result.allowed !== false;
+        const decision = {
+          allowed,
+          reason: result.reason
+        };
+        if (result.capabilities) {
+          decision.capabilities = result.capabilities;
+        }
+        return decision;
+      }
+    };
+  }
+});
+
+// src/enterprise/scheduler/knex-store.ts
+var knex_store_exports = {};
+__export(knex_store_exports, {
+  KnexStoreBackend: () => KnexStoreBackend
+});
+function toNum(val) {
+  if (val === null || val === void 0) return void 0;
+  return typeof val === "string" ? parseInt(val, 10) : val;
+}
+function safeJsonParse2(value) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function fromDbRow2(row) {
+  return {
+    id: row.id,
+    creatorId: row.creator_id,
+    creatorContext: row.creator_context ?? void 0,
+    creatorName: row.creator_name ?? void 0,
+    timezone: row.timezone,
+    schedule: row.schedule_expr,
+    runAt: toNum(row.run_at),
+    isRecurring: row.is_recurring === true || row.is_recurring === 1,
+    originalExpression: row.original_expression,
+    workflow: row.workflow ?? void 0,
+    workflowInputs: safeJsonParse2(row.workflow_inputs),
+    outputContext: safeJsonParse2(row.output_context),
+    status: row.status,
+    createdAt: toNum(row.created_at),
+    lastRunAt: toNum(row.last_run_at),
+    nextRunAt: toNum(row.next_run_at),
+    runCount: row.run_count,
+    failureCount: row.failure_count,
+    lastError: row.last_error ?? void 0,
+    previousResponse: row.previous_response ?? void 0
+  };
+}
+function toInsertRow(schedule) {
+  return {
+    id: schedule.id,
+    creator_id: schedule.creatorId,
+    creator_context: schedule.creatorContext ?? null,
+    creator_name: schedule.creatorName ?? null,
+    timezone: schedule.timezone,
+    schedule_expr: schedule.schedule,
+    run_at: schedule.runAt ?? null,
+    is_recurring: schedule.isRecurring,
+    original_expression: schedule.originalExpression,
+    workflow: schedule.workflow ?? null,
+    workflow_inputs: schedule.workflowInputs ? JSON.stringify(schedule.workflowInputs) : null,
+    output_context: schedule.outputContext ? JSON.stringify(schedule.outputContext) : null,
+    status: schedule.status,
+    created_at: schedule.createdAt,
+    last_run_at: schedule.lastRunAt ?? null,
+    next_run_at: schedule.nextRunAt ?? null,
+    run_count: schedule.runCount,
+    failure_count: schedule.failureCount,
+    last_error: schedule.lastError ?? null,
+    previous_response: schedule.previousResponse ?? null
+  };
+}
+var fs21, path25, import_uuid2, KnexStoreBackend;
+var init_knex_store = __esm({
+  "src/enterprise/scheduler/knex-store.ts"() {
+    "use strict";
+    fs21 = __toESM(require("fs"));
+    path25 = __toESM(require("path"));
+    import_uuid2 = require("uuid");
+    init_logger();
+    KnexStoreBackend = class {
+      knex = null;
+      driver;
+      connection;
+      constructor(driver, storageConfig, _haConfig) {
+        this.driver = driver;
+        this.connection = storageConfig.connection || {};
+      }
+      async initialize() {
+        const { createRequire } = require("module");
+        const runtimeRequire = createRequire(__filename);
+        let knexFactory;
+        try {
+          knexFactory = runtimeRequire("knex");
+        } catch (err) {
+          const code = err?.code;
+          if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+            throw new Error(
+              "knex is required for PostgreSQL/MySQL/MSSQL schedule storage. Install it with: npm install knex"
+            );
+          }
+          throw err;
+        }
+        const clientMap = {
+          postgresql: "pg",
+          mysql: "mysql2",
+          mssql: "tedious"
+        };
+        const client = clientMap[this.driver];
+        let connection;
+        if (this.connection.connection_string) {
+          connection = this.connection.connection_string;
+        } else if (this.driver === "mssql") {
+          connection = this.buildMssqlConnection();
+        } else {
+          connection = this.buildStandardConnection();
+        }
+        this.knex = knexFactory({
+          client,
+          connection,
+          pool: {
+            min: this.connection.pool?.min ?? 0,
+            max: this.connection.pool?.max ?? 10
+          }
+        });
+        await this.migrateSchema();
+        logger.info(`[KnexStore] Initialized (${this.driver})`);
+      }
+      buildStandardConnection() {
+        return {
+          host: this.connection.host || "localhost",
+          port: this.connection.port,
+          database: this.connection.database || "visor",
+          user: this.connection.user,
+          password: this.connection.password,
+          ssl: this.resolveSslConfig()
+        };
+      }
+      buildMssqlConnection() {
+        const ssl = this.connection.ssl;
+        const sslEnabled = ssl === true || typeof ssl === "object" && ssl.enabled !== false;
+        return {
+          server: this.connection.host || "localhost",
+          port: this.connection.port,
+          database: this.connection.database || "visor",
+          user: this.connection.user,
+          password: this.connection.password,
+          options: {
+            encrypt: sslEnabled,
+            trustServerCertificate: typeof ssl === "object" ? ssl.reject_unauthorized === false : !sslEnabled
+          }
+        };
+      }
+      resolveSslConfig() {
+        const ssl = this.connection.ssl;
+        if (ssl === false || ssl === void 0) return false;
+        if (ssl === true) return { rejectUnauthorized: true };
+        if (ssl.enabled === false) return false;
+        const result = {
+          rejectUnauthorized: ssl.reject_unauthorized !== false
+        };
+        if (ssl.ca) {
+          const caPath = this.validateSslPath(ssl.ca, "CA certificate");
+          result.ca = fs21.readFileSync(caPath, "utf8");
+        }
+        if (ssl.cert) {
+          const certPath = this.validateSslPath(ssl.cert, "client certificate");
+          result.cert = fs21.readFileSync(certPath, "utf8");
+        }
+        if (ssl.key) {
+          const keyPath = this.validateSslPath(ssl.key, "client key");
+          result.key = fs21.readFileSync(keyPath, "utf8");
+        }
+        return result;
+      }
+      validateSslPath(filePath, label) {
+        const resolved = path25.resolve(filePath);
+        if (resolved !== path25.normalize(resolved)) {
+          throw new Error(`SSL ${label} path contains invalid sequences: ${filePath}`);
+        }
+        if (!fs21.existsSync(resolved)) {
+          throw new Error(`SSL ${label} not found: ${filePath}`);
+        }
+        return resolved;
+      }
+      async shutdown() {
+        if (this.knex) {
+          await this.knex.destroy();
+          this.knex = null;
+        }
+      }
+      async migrateSchema() {
+        const knex = this.getKnex();
+        const exists = await knex.schema.hasTable("schedules");
+        if (!exists) {
+          await knex.schema.createTable("schedules", (table) => {
+            table.string("id", 36).primary();
+            table.string("creator_id", 255).notNullable().index();
+            table.string("creator_context", 255);
+            table.string("creator_name", 255);
+            table.string("timezone", 64).notNullable().defaultTo("UTC");
+            table.string("schedule_expr", 255);
+            table.bigInteger("run_at");
+            table.boolean("is_recurring").notNullable();
+            table.text("original_expression");
+            table.string("workflow", 255);
+            table.text("workflow_inputs");
+            table.text("output_context");
+            table.string("status", 20).notNullable().index();
+            table.bigInteger("created_at").notNullable();
+            table.bigInteger("last_run_at");
+            table.bigInteger("next_run_at");
+            table.integer("run_count").notNullable().defaultTo(0);
+            table.integer("failure_count").notNullable().defaultTo(0);
+            table.text("last_error");
+            table.text("previous_response");
+            table.index(["status", "next_run_at"]);
+          });
+        }
+        const locksExist = await knex.schema.hasTable("scheduler_locks");
+        if (!locksExist) {
+          await knex.schema.createTable("scheduler_locks", (table) => {
+            table.string("lock_id", 255).primary();
+            table.string("node_id", 255).notNullable();
+            table.string("lock_token", 36).notNullable();
+            table.bigInteger("acquired_at").notNullable();
+            table.bigInteger("expires_at").notNullable();
+          });
+        }
+      }
+      getKnex() {
+        if (!this.knex) {
+          throw new Error("[KnexStore] Not initialized. Call initialize() first.");
+        }
+        return this.knex;
+      }
+      // --- CRUD ---
+      async create(schedule) {
+        const knex = this.getKnex();
+        const newSchedule = {
+          ...schedule,
+          id: (0, import_uuid2.v4)(),
+          createdAt: Date.now(),
+          runCount: 0,
+          failureCount: 0,
+          status: "active"
+        };
+        await knex("schedules").insert(toInsertRow(newSchedule));
+        logger.info(`[KnexStore] Created schedule ${newSchedule.id} for user ${newSchedule.creatorId}`);
+        return newSchedule;
+      }
+      async importSchedule(schedule) {
+        const knex = this.getKnex();
+        const existing = await knex("schedules").where("id", schedule.id).first();
+        if (existing) return;
+        await knex("schedules").insert(toInsertRow(schedule));
+      }
+      async get(id) {
+        const knex = this.getKnex();
+        const row = await knex("schedules").where("id", id).first();
+        return row ? fromDbRow2(row) : void 0;
+      }
+      async update(id, patch) {
+        const knex = this.getKnex();
+        const existing = await knex("schedules").where("id", id).first();
+        if (!existing) return void 0;
+        const current = fromDbRow2(existing);
+        const updated = { ...current, ...patch, id: current.id };
+        const row = toInsertRow(updated);
+        delete row.id;
+        await knex("schedules").where("id", id).update(row);
+        return updated;
+      }
+      async delete(id) {
+        const knex = this.getKnex();
+        const deleted = await knex("schedules").where("id", id).del();
+        if (deleted > 0) {
+          logger.info(`[KnexStore] Deleted schedule ${id}`);
+          return true;
+        }
+        return false;
+      }
+      // --- Queries ---
+      async getByCreator(creatorId) {
+        const knex = this.getKnex();
+        const rows = await knex("schedules").where("creator_id", creatorId);
+        return rows.map((r) => fromDbRow2(r));
+      }
+      async getActiveSchedules() {
+        const knex = this.getKnex();
+        const rows = await knex("schedules").where("status", "active");
+        return rows.map((r) => fromDbRow2(r));
+      }
+      async getDueSchedules(now) {
+        const ts = now ?? Date.now();
+        const knex = this.getKnex();
+        const bFalse = this.driver === "mssql" ? 0 : false;
+        const bTrue = this.driver === "mssql" ? 1 : true;
+        const rows = await knex("schedules").where("status", "active").andWhere(function() {
+          this.where(function() {
+            this.where("is_recurring", bFalse).whereNotNull("run_at").where("run_at", "<=", ts);
+          }).orWhere(function() {
+            this.where("is_recurring", bTrue).whereNotNull("next_run_at").where("next_run_at", "<=", ts);
+          });
+        });
+        return rows.map((r) => fromDbRow2(r));
+      }
+      async findByWorkflow(creatorId, workflowName) {
+        const knex = this.getKnex();
+        const escaped = workflowName.toLowerCase().replace(/[%_\\]/g, "\\$&");
+        const pattern = `%${escaped}%`;
+        const rows = await knex("schedules").where("creator_id", creatorId).where("status", "active").whereRaw("LOWER(workflow) LIKE ? ESCAPE '\\'", [pattern]);
+        return rows.map((r) => fromDbRow2(r));
+      }
+      async getAll() {
+        const knex = this.getKnex();
+        const rows = await knex("schedules");
+        return rows.map((r) => fromDbRow2(r));
+      }
+      async getStats() {
+        const knex = this.getKnex();
+        const boolTrue = this.driver === "mssql" ? "1" : "true";
+        const boolFalse = this.driver === "mssql" ? "0" : "false";
+        const result = await knex("schedules").select(
+          knex.raw("COUNT(*) as total"),
+          knex.raw("SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END) as active"),
+          knex.raw("SUM(CASE WHEN status = 'paused' THEN 1 ELSE 0 END) as paused"),
+          knex.raw("SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed"),
+          knex.raw("SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed"),
+          knex.raw(`SUM(CASE WHEN is_recurring = ${boolTrue} THEN 1 ELSE 0 END) as recurring`),
+          knex.raw(`SUM(CASE WHEN is_recurring = ${boolFalse} THEN 1 ELSE 0 END) as one_time`)
+        ).first();
+        return {
+          total: Number(result.total) || 0,
+          active: Number(result.active) || 0,
+          paused: Number(result.paused) || 0,
+          completed: Number(result.completed) || 0,
+          failed: Number(result.failed) || 0,
+          recurring: Number(result.recurring) || 0,
+          oneTime: Number(result.one_time) || 0
+        };
+      }
+      async validateLimits(creatorId, isRecurring, limits) {
+        const knex = this.getKnex();
+        if (limits.maxGlobal) {
+          const result = await knex("schedules").count("* as cnt").first();
+          if (Number(result?.cnt) >= limits.maxGlobal) {
+            throw new Error(`Global schedule limit reached (${limits.maxGlobal})`);
+          }
+        }
+        if (limits.maxPerUser) {
+          const result = await knex("schedules").where("creator_id", creatorId).count("* as cnt").first();
+          if (Number(result?.cnt) >= limits.maxPerUser) {
+            throw new Error(`You have reached the maximum number of schedules (${limits.maxPerUser})`);
+          }
+        }
+        if (isRecurring && limits.maxRecurringPerUser) {
+          const bTrue = this.driver === "mssql" ? 1 : true;
+          const result = await knex("schedules").where("creator_id", creatorId).where("is_recurring", bTrue).count("* as cnt").first();
+          if (Number(result?.cnt) >= limits.maxRecurringPerUser) {
+            throw new Error(
+              `You have reached the maximum number of recurring schedules (${limits.maxRecurringPerUser})`
+            );
+          }
+        }
+      }
+      // --- HA Distributed Locking (via scheduler_locks table) ---
+      async tryAcquireLock(lockId, nodeId, ttlSeconds) {
+        const knex = this.getKnex();
+        const now = Date.now();
+        const expiresAt = now + ttlSeconds * 1e3;
+        const token = (0, import_uuid2.v4)();
+        const updated = await knex("scheduler_locks").where("lock_id", lockId).where("expires_at", "<", now).update({
+          node_id: nodeId,
+          lock_token: token,
+          acquired_at: now,
+          expires_at: expiresAt
+        });
+        if (updated > 0) return token;
+        try {
+          await knex("scheduler_locks").insert({
+            lock_id: lockId,
+            node_id: nodeId,
+            lock_token: token,
+            acquired_at: now,
+            expires_at: expiresAt
+          });
+          return token;
+        } catch {
+          return null;
+        }
+      }
+      async releaseLock(lockId, lockToken) {
+        const knex = this.getKnex();
+        await knex("scheduler_locks").where("lock_id", lockId).where("lock_token", lockToken).del();
+      }
+      async renewLock(lockId, lockToken, ttlSeconds) {
+        const knex = this.getKnex();
+        const now = Date.now();
+        const expiresAt = now + ttlSeconds * 1e3;
+        const updated = await knex("scheduler_locks").where("lock_id", lockId).where("lock_token", lockToken).update({ acquired_at: now, expires_at: expiresAt });
+        return updated > 0;
+      }
+      async flush() {
+      }
+    };
+  }
+});
+
+// src/enterprise/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  loadEnterprisePolicyEngine: () => loadEnterprisePolicyEngine,
+  loadEnterpriseStoreBackend: () => loadEnterpriseStoreBackend
+});
+async function loadEnterprisePolicyEngine(config) {
+  try {
+    const { LicenseValidator: LicenseValidator2 } = await Promise.resolve().then(() => (init_validator(), validator_exports));
+    const validator = new LicenseValidator2();
+    const license = await validator.loadAndValidate();
+    if (!license || !validator.hasFeature("policy")) {
+      return new DefaultPolicyEngine();
+    }
+    if (validator.isInGracePeriod()) {
+      console.warn(
+        "[visor:enterprise] License has expired but is within the 72-hour grace period. Please renew your license."
+      );
+    }
+    const { OpaPolicyEngine: OpaPolicyEngine2 } = await Promise.resolve().then(() => (init_opa_policy_engine(), opa_policy_engine_exports));
+    const engine = new OpaPolicyEngine2(config);
+    await engine.initialize(config);
+    return engine;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    try {
+      const { logger: logger2 } = (init_logger(), __toCommonJS(logger_exports));
+      logger2.warn(`[PolicyEngine] Enterprise policy init failed, falling back to default: ${msg}`);
+    } catch {
+    }
+    return new DefaultPolicyEngine();
+  }
+}
+async function loadEnterpriseStoreBackend(driver, storageConfig, haConfig) {
+  const { LicenseValidator: LicenseValidator2 } = await Promise.resolve().then(() => (init_validator(), validator_exports));
+  const validator = new LicenseValidator2();
+  const license = await validator.loadAndValidate();
+  if (!license || !validator.hasFeature("scheduler-sql")) {
+    throw new Error(
+      `The ${driver} schedule storage driver requires a Visor Enterprise license with the 'scheduler-sql' feature. Please upgrade or use driver: 'sqlite' (default).`
+    );
+  }
+  if (validator.isInGracePeriod()) {
+    console.warn(
+      "[visor:enterprise] License has expired but is within the 72-hour grace period. Please renew your license."
+    );
+  }
+  const { KnexStoreBackend: KnexStoreBackend2 } = await Promise.resolve().then(() => (init_knex_store(), knex_store_exports));
+  return new KnexStoreBackend2(driver, storageConfig, haConfig);
+}
+var init_loader = __esm({
+  "src/enterprise/loader.ts"() {
+    "use strict";
+    init_default_engine();
+  }
+});
+
 // src/event-bus/event-bus.ts
 var event_bus_exports = {};
 __export(event_bus_exports, {
@@ -50495,8 +52291,8 @@ ${content}
        * Sleep utility
        */
       sleep(ms) {
-        return new Promise((resolve11) => {
-          const t = setTimeout(resolve11, ms);
+        return new Promise((resolve15) => {
+          const t = setTimeout(resolve15, ms);
           if (typeof t.unref === "function") {
             try {
               t.unref();
@@ -50770,8 +52566,8 @@ ${end}`);
       async updateGroupedComment(ctx, comments, group, changedIds) {
         const existingLock = this.updateLocks.get(group);
         let resolveLock;
-        const ourLock = new Promise((resolve11) => {
-          resolveLock = resolve11;
+        const ourLock = new Promise((resolve15) => {
+          resolveLock = resolve15;
         });
         this.updateLocks.set(group, ourLock);
         try {
@@ -51083,7 +52879,7 @@ ${blocks}
        * Sleep utility for enforcing delays
        */
       sleep(ms) {
-        return new Promise((resolve11) => setTimeout(resolve11, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
     };
   }
@@ -51281,7 +53077,8 @@ var init_client = __esm({
             user: m.user,
             text: m.text,
             bot_id: m.bot_id,
-            thread_ts: m.thread_ts
+            thread_ts: m.thread_ts,
+            files: Array.isArray(m.files) ? m.files : void 0
           }));
         } catch (e) {
           console.warn(
@@ -51304,9 +53101,9 @@ var init_client = __esm({
           initial_comment
         }) => {
           try {
-            const getUrlResp = await this.api("files.getUploadURLExternal", {
+            const getUrlResp = await this.apiForm("files.getUploadURLExternal", {
               filename,
-              length: content.length
+              length: String(content.length)
             });
             if (!getUrlResp || getUrlResp.ok !== true || !getUrlResp.upload_url) {
               console.warn(
@@ -51364,6 +53161,19 @@ var init_client = __esm({
         });
         return await res.json();
       }
+      /** Send a Slack API request as application/x-www-form-urlencoded (required by some file methods). */
+      async apiForm(method, params) {
+        const body = new URLSearchParams(params);
+        const res = await fetch(`https://slack.com/api/${method}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Authorization: `Bearer ${this.token}`
+          },
+          body: body.toString()
+        });
+        return await res.json();
+      }
     };
   }
 });
@@ -51384,17 +53194,17 @@ function extractMermaidDiagrams(text) {
   return diagrams;
 }
 async function renderMermaidToPng(mermaidCode) {
-  const tmpDir = os.tmpdir();
-  const inputFile = path23.join(
+  const tmpDir = os2.tmpdir();
+  const inputFile = path27.join(
     tmpDir,
     `mermaid-${Date.now()}-${Math.random().toString(36).slice(2)}.mmd`
   );
-  const outputFile = path23.join(
+  const outputFile = path27.join(
     tmpDir,
     `mermaid-${Date.now()}-${Math.random().toString(36).slice(2)}.png`
   );
   try {
-    fs19.writeFileSync(inputFile, mermaidCode, "utf-8");
+    fs23.writeFileSync(inputFile, mermaidCode, "utf-8");
     const chromiumPaths = [
       "/usr/bin/chromium",
       "/usr/bin/chromium-browser",
@@ -51403,7 +53213,7 @@ async function renderMermaidToPng(mermaidCode) {
     ];
     let chromiumPath;
     for (const p of chromiumPaths) {
-      if (fs19.existsSync(p)) {
+      if (fs23.existsSync(p)) {
         chromiumPath = p;
         break;
       }
@@ -51412,8 +53222,8 @@ async function renderMermaidToPng(mermaidCode) {
     if (chromiumPath) {
       env.PUPPETEER_EXECUTABLE_PATH = chromiumPath;
     }
-    const result = await new Promise((resolve11) => {
-      const proc = (0, import_child_process5.spawn)(
+    const result = await new Promise((resolve15) => {
+      const proc = (0, import_child_process6.spawn)(
         "npx",
         [
           "--yes",
@@ -51442,32 +53252,32 @@ async function renderMermaidToPng(mermaidCode) {
       });
       proc.on("close", (code) => {
         if (code === 0) {
-          resolve11({ success: true });
+          resolve15({ success: true });
         } else {
-          resolve11({ success: false, error: stderr || `Exit code ${code}` });
+          resolve15({ success: false, error: stderr || `Exit code ${code}` });
         }
       });
       proc.on("error", (err) => {
-        resolve11({ success: false, error: err.message });
+        resolve15({ success: false, error: err.message });
       });
     });
     if (!result.success) {
       console.warn(`Mermaid rendering failed: ${result.error}`);
       return null;
     }
-    if (!fs19.existsSync(outputFile)) {
+    if (!fs23.existsSync(outputFile)) {
       console.warn("Mermaid output file not created");
       return null;
     }
-    const pngBuffer = fs19.readFileSync(outputFile);
+    const pngBuffer = fs23.readFileSync(outputFile);
     return pngBuffer;
   } catch (e) {
     console.warn(`Mermaid rendering error: ${e instanceof Error ? e.message : String(e)}`);
     return null;
   } finally {
     try {
-      if (fs19.existsSync(inputFile)) fs19.unlinkSync(inputFile);
-      if (fs19.existsSync(outputFile)) fs19.unlinkSync(outputFile);
+      if (fs23.existsSync(inputFile)) fs23.unlinkSync(inputFile);
+      if (fs23.existsSync(outputFile)) fs23.unlinkSync(outputFile);
     } catch {
     }
   }
@@ -51528,17 +53338,58 @@ function markdownToSlack(text) {
   out = lines.join("\n");
   return out;
 }
+function extractFileSections(text) {
+  const sections = [];
+  const delimRegex = /^--- ([\w][\w.\-]*\.\w+) ---$/gm;
+  const delimiters = [];
+  let m;
+  while ((m = delimRegex.exec(text)) !== null) {
+    delimiters.push({
+      filename: m[1],
+      start: m.index,
+      end: m.index + m[0].length
+    });
+  }
+  if (delimiters.length === 0) return sections;
+  for (let i = 0; i < delimiters.length; i++) {
+    const open = delimiters[i];
+    const contentStart = open.end < text.length && text[open.end] === "\n" ? open.end + 1 : open.end;
+    const sectionEnd = i + 1 < delimiters.length ? delimiters[i + 1].start : text.length;
+    const content = text.substring(contentStart, sectionEnd).trim();
+    if (content.length > 0) {
+      sections.push({
+        fullMatch: text.substring(open.start, sectionEnd),
+        filename: open.filename,
+        content,
+        startIndex: open.start,
+        endIndex: sectionEnd
+      });
+    }
+  }
+  return sections;
+}
+function replaceFileSections(text, sections, replacement = (idx) => `_(See file: ${sections[idx].filename} above)_`) {
+  if (sections.length === 0) return text;
+  const sorted = [...sections].sort((a, b) => b.startIndex - a.startIndex);
+  let result = text;
+  sorted.forEach((section, sortedIndex) => {
+    const originalIndex = sections.length - 1 - sortedIndex;
+    const rep = typeof replacement === "function" ? replacement(originalIndex) : replacement;
+    result = result.slice(0, section.startIndex) + rep + result.slice(section.endIndex);
+  });
+  return result;
+}
 function formatSlackText(text) {
   return markdownToSlack(text);
 }
-var import_child_process5, fs19, path23, os;
+var import_child_process6, fs23, path27, os2;
 var init_markdown = __esm({
   "src/slack/markdown.ts"() {
     "use strict";
-    import_child_process5 = require("child_process");
-    fs19 = __toESM(require("fs"));
-    path23 = __toESM(require("path"));
-    os = __toESM(require("os"));
+    import_child_process6 = require("child_process");
+    fs23 = __toESM(require("fs"));
+    path27 = __toESM(require("path"));
+    os2 = __toESM(require("os"));
   }
 });
 
@@ -51956,6 +53807,9 @@ ${message}`;
               text = String(out);
             }
           }
+          if (out && typeof out._rawOutput === "string" && out._rawOutput.trim().length > 0) {
+            text = (text || "") + "\n\n" + out._rawOutput.trim();
+          }
           if (!text) {
             ctx.logger.info(
               `[slack-frontend] skip posting AI reply for ${checkId}: no renderable text in check output`
@@ -52014,6 +53868,39 @@ ${message}`;
               );
             }
           }
+          processedText = processedText.replace(/\\n/g, "\n");
+          const fileSections = extractFileSections(processedText);
+          if (fileSections.length > 0) {
+            const uploadedFileIndices = [];
+            for (let i = 0; i < fileSections.length; i++) {
+              const section = fileSections[i];
+              try {
+                const buffer = Buffer.from(section.content, "utf-8");
+                const uploadResult = await slack.files.uploadV2({
+                  content: buffer,
+                  filename: section.filename,
+                  channel,
+                  thread_ts: threadTs,
+                  title: section.filename
+                });
+                if (uploadResult.ok) {
+                  uploadedFileIndices.push(i);
+                  ctx.logger.info(`[slack-frontend] uploaded file ${section.filename} to ${channel}`);
+                } else {
+                  ctx.logger.warn(`[slack-frontend] upload failed for file ${section.filename}`);
+                }
+              } catch (e) {
+                ctx.logger.warn(
+                  `[slack-frontend] failed to upload file ${section.filename}: ${e instanceof Error ? e.message : String(e)}`
+                );
+              }
+            }
+            processedText = replaceFileSections(
+              processedText,
+              fileSections,
+              (idx) => uploadedFileIndices.includes(idx) ? `_(See file: ${fileSections[idx].filename} above)_` : `_(File upload failed: ${fileSections[idx].filename})_`
+            );
+          }
           let decoratedText = processedText;
           const telemetryEnabled = telemetryCfg === true || telemetryCfg && typeof telemetryCfg === "object" && telemetryCfg.enabled === true;
           if (telemetryEnabled) {
@@ -52478,15 +54365,15 @@ function serializeRunState(state) {
     ])
   };
 }
-var path24, fs20, StateMachineExecutionEngine;
+var path28, fs24, StateMachineExecutionEngine;
 var init_state_machine_execution_engine = __esm({
   "src/state-machine-execution-engine.ts"() {
     "use strict";
     init_runner();
     init_logger();
     init_sandbox_manager();
-    path24 = __toESM(require("path"));
-    fs20 = __toESM(require("fs"));
+    path28 = __toESM(require("path"));
+    fs24 = __toESM(require("fs"));
     StateMachineExecutionEngine = class _StateMachineExecutionEngine {
       workingDirectory;
       executionContext;
@@ -52709,8 +54596,8 @@ var init_state_machine_execution_engine = __esm({
             logger.debug(
               `[PolicyEngine] Loading enterprise policy engine (engine=${configWithTagFilter.policy.engine})`
             );
-            const { loadEnterprisePolicyEngine } = await import("./enterprise/loader");
-            context2.policyEngine = await loadEnterprisePolicyEngine(configWithTagFilter.policy);
+            const { loadEnterprisePolicyEngine: loadEnterprisePolicyEngine2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+            context2.policyEngine = await loadEnterprisePolicyEngine2(configWithTagFilter.policy);
             logger.debug(
               `[PolicyEngine] Initialized: ${context2.policyEngine?.constructor?.name || "unknown"}`
             );
@@ -52862,9 +54749,9 @@ var init_state_machine_execution_engine = __esm({
                   }
                   const checkId = String(ev?.checkId || "unknown");
                   const threadKey = ev?.threadKey || (channel && threadTs ? `${channel}:${threadTs}` : "session");
-                  const baseDir = process.env.VISOR_SNAPSHOT_DIR || path24.resolve(process.cwd(), ".visor", "snapshots");
-                  fs20.mkdirSync(baseDir, { recursive: true });
-                  const filePath = path24.join(baseDir, `${threadKey}-${checkId}.json`);
+                  const baseDir = process.env.VISOR_SNAPSHOT_DIR || path28.resolve(process.cwd(), ".visor", "snapshots");
+                  fs24.mkdirSync(baseDir, { recursive: true });
+                  const filePath = path28.join(baseDir, `${threadKey}-${checkId}.json`);
                   await this.saveSnapshotToFile(filePath);
                   logger.info(`[Snapshot] Saved run snapshot: ${filePath}`);
                   try {
@@ -53005,7 +54892,7 @@ var init_state_machine_execution_engine = __esm({
        * Does not include secrets. Intended for debugging and future resume support.
        */
       async saveSnapshotToFile(filePath) {
-        const fs21 = await import("fs/promises");
+        const fs25 = await import("fs/promises");
         const ctx = this._lastContext;
         const runner = this._lastRunner;
         if (!ctx || !runner) {
@@ -53025,14 +54912,14 @@ var init_state_machine_execution_engine = __esm({
           journal: entries,
           requestedChecks: ctx.requestedChecks || []
         };
-        await fs21.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
+        await fs25.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
       }
       /**
        * Load a snapshot JSON from file and return it. Resume support can build on this.
        */
       async loadSnapshotFromFile(filePath) {
-        const fs21 = await import("fs/promises");
-        const raw = await fs21.readFile(filePath, "utf8");
+        const fs25 = await import("fs/promises");
+        const raw = await fs25.readFile(filePath, "utf8");
         return JSON.parse(raw);
       }
       /**