@probelabs/visor 0.1.90 → 0.1.92

package/dist/sdk/{chunk-N2PPFOSF.mjs → chunk-LJHRU3WQ.mjs}

@@ -1,6 +1,25 @@
 import {
-  createExtendedLiquid
-} from "./chunk-FIL2OGF6.mjs";
+  init_tracer_init,
+  initializeTracer
+} from "./chunk-KVHVCGY6.mjs";
+import {
+  MemoryStore,
+  createExtendedLiquid,
+  createPermissionHelpers,
+  detectLocalMode,
+  init_logger,
+  logger,
+  logger_exports,
+  resolveAssociationFromEvent
+} from "./chunk-2U6BIWSY.mjs";
+import {
+  addEvent,
+  addFailIfTriggered,
+  emitNdjsonFallback,
+  emitNdjsonSpanWithEvents,
+  fallback_ndjson_exports,
+  init_fallback_ndjson
+} from "./chunk-TWJKAYT6.mjs";
 import {
   __esm,
   __export,
@@ -95,43 +114,61 @@ var init_session_registry = __esm({
         return this.sessions.has(sessionId);
       }
       /**
-       * Clone a session with a new session ID
-       * Creates a new ProbeAgent with a copy of the conversation history
+       * Clone a session with a new session ID using ProbeAgent's official clone() method
+       * This uses ProbeAgent's built-in cloning which automatically handles:
+       * - Intelligent filtering of internal messages (schema reminders, tool prompts, etc.)
+       * - Preserving system message for cache efficiency
+       * - Deep copying conversation history
+       * - Copying agent configuration
        */
-      async cloneSession(sourceSessionId, newSessionId) {
+      async cloneSession(sourceSessionId, newSessionId, checkName) {
         const sourceAgent = this.sessions.get(sourceSessionId);
         if (!sourceAgent) {
           console.error(`\u26A0\uFE0F  Cannot clone session: ${sourceSessionId} not found`);
           return void 0;
         }
         try {
-          const sourceHistory = sourceAgent.conversationHistory || [];
-          const sourceOptions = sourceAgent.options || {};
-          const { ProbeAgent: ProbeAgentClass } = await import("@probelabs/probe");
-          const clonedAgent = new ProbeAgentClass({
-            ...sourceOptions,
-            sessionId: newSessionId
+          const clonedAgent = sourceAgent.clone({
+            sessionId: newSessionId,
+            stripInternalMessages: true,
+            // Remove schema reminders, tool prompts, etc.
+            keepSystemMessage: true,
+            // Keep for cache efficiency
+            deepCopy: true
+            // Safe deep copy of history
           });
-          if (sourceHistory.length > 0) {
+          if (sourceAgent.debug && checkName) {
             try {
-              const deepClonedHistory = JSON.parse(JSON.stringify(sourceHistory));
-              clonedAgent.conversationHistory = deepClonedHistory;
-              console.error(
-                `\u{1F4CB} Cloned session ${sourceSessionId} \u2192 ${newSessionId} (${sourceHistory.length} messages, deep copy)`
-              );
-            } catch (cloneError) {
+              const { initializeTracer: initializeTracer2 } = await import("./tracer-init-O7RLXMJ3.mjs");
+              const tracerResult = await initializeTracer2(newSessionId, checkName);
+              if (tracerResult) {
+                clonedAgent.tracer = tracerResult.tracer;
+                clonedAgent._telemetryConfig = tracerResult.telemetryConfig;
+                clonedAgent._traceFilePath = tracerResult.filePath;
+              }
+            } catch (traceError) {
               console.error(
-                `\u26A0\uFE0F  Warning: Deep clone failed for session ${sourceSessionId}, using shallow copy: ${cloneError}`
+                "\u26A0\uFE0F  Warning: Failed to initialize tracing for cloned session:",
+                traceError
               );
-              clonedAgent.conversationHistory = [...sourceHistory];
             }
-          } else {
-            console.error(`\u{1F4CB} Cloned session ${sourceSessionId} \u2192 ${newSessionId} (no history)`);
           }
+          if (sourceAgent._mcpInitialized && typeof clonedAgent.initialize === "function") {
+            try {
+              await clonedAgent.initialize();
+              console.error(`\u{1F527} Initialized MCP tools for cloned session`);
+            } catch (initError) {
+              console.error(`\u26A0\uFE0F  Warning: Failed to initialize cloned agent: ${initError}`);
+            }
+          }
+          const historyLength = clonedAgent.history?.length || 0;
+          console.error(
+            `\u{1F4CB} Cloned session ${sourceSessionId} \u2192 ${newSessionId} using ProbeAgent.clone() (${historyLength} messages, internal messages filtered)`
+          );
           this.registerSession(newSessionId, clonedAgent);
           return clonedAgent;
         } catch (error) {
-          console.error(`\u26A0\uFE0F  Failed to clone session ${sourceSessionId}: ${error}`);
+          console.error(`\u26A0\uFE0F  Failed to clone session ${sourceSessionId}:`, error);
           return void 0;
         }
       }
@@ -177,113 +214,8 @@ var init_session_registry = __esm({
   }
 });
 
-// src/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
-  configureLoggerFromCli: () => configureLoggerFromCli,
-  logger: () => logger
-});
-function levelToNumber(level) {
-  switch (level) {
-    case "silent":
-      return 0;
-    case "error":
-      return 10;
-    case "warn":
-      return 20;
-    case "info":
-      return 30;
-    case "verbose":
-      return 40;
-    case "debug":
-      return 50;
-  }
-}
-function configureLoggerFromCli(options) {
-  logger.configure({
-    outputFormat: options.output,
-    debug: options.debug,
-    verbose: options.verbose,
-    quiet: options.quiet
-  });
-  try {
-    if (options.output) process.env.VISOR_OUTPUT_FORMAT = String(options.output);
-    if (typeof options.debug === "boolean") {
-      process.env.VISOR_DEBUG = options.debug ? "true" : "false";
-    }
-  } catch {
-  }
-}
-var Logger, logger;
-var init_logger = __esm({
-  "src/logger.ts"() {
-    "use strict";
-    Logger = class {
-      level = "info";
-      isJsonLike = false;
-      isTTY = typeof process !== "undefined" ? !!process.stderr.isTTY : false;
-      configure(opts = {}) {
-        let lvl = "info";
-        if (opts.debug || process.env.VISOR_DEBUG === "true") {
-          lvl = "debug";
-        } else if (opts.verbose || process.env.VISOR_LOG_LEVEL === "verbose") {
-          lvl = "verbose";
-        } else if (opts.quiet || process.env.VISOR_LOG_LEVEL === "quiet") {
-          lvl = "warn";
-        } else if (opts.level) {
-          lvl = opts.level;
-        } else if (process.env.VISOR_LOG_LEVEL) {
-          const envLvl = process.env.VISOR_LOG_LEVEL;
-          if (["silent", "error", "warn", "info", "verbose", "debug"].includes(envLvl)) {
-            lvl = envLvl;
-          }
-        }
-        this.level = lvl;
-        const output = opts.outputFormat || process.env.VISOR_OUTPUT_FORMAT || "table";
-        this.isJsonLike = output === "json" || output === "sarif";
-      }
-      shouldLog(level) {
-        const desired = levelToNumber(level);
-        const current = levelToNumber(this.level);
-        if (desired > current) return false;
-        if (this.isJsonLike && desired < levelToNumber("error") && this.level !== "debug" && this.level !== "verbose") {
-          return false;
-        }
-        return true;
-      }
-      write(msg) {
-        try {
-          process.stderr.write(msg + "\n");
-        } catch {
-        }
-      }
-      info(msg) {
-        if (this.shouldLog("info")) this.write(msg);
-      }
-      warn(msg) {
-        if (this.shouldLog("warn")) this.write(msg);
-      }
-      error(msg) {
-        if (this.shouldLog("error")) this.write(msg);
-      }
-      verbose(msg) {
-        if (this.shouldLog("verbose")) this.write(msg);
-      }
-      debug(msg) {
-        if (this.shouldLog("debug")) this.write(msg);
-      }
-      step(msg) {
-        if (this.shouldLog("info")) this.write(`\u25B6 ${msg}`);
-      }
-      success(msg) {
-        if (this.shouldLog("info")) this.write(`\u2714 ${msg}`);
-      }
-    };
-    logger = new Logger();
-  }
-});
-
 // src/github-comments.ts
+init_logger();
 import { v4 as uuidv4 } from "uuid";
 var CommentManager = class {
   octokit;
@@ -363,6 +295,9 @@ var CommentManager = class {
           comment_id: existingComment.id,
           body: formattedContent
         });
+        logger.info(
+          `\u2705 Successfully updated comment (ID: ${commentId}, GitHub ID: ${existingComment.id}) on PR #${prNumber} in ${owner}/${repo}`
+        );
         return updatedComment.data;
       } else {
         const newComment = await this.octokit.rest.issues.createComment({
@@ -371,6 +306,9 @@ var CommentManager = class {
           issue_number: prNumber,
           body: formattedContent
         });
+        logger.info(
+          `\u2705 Successfully created comment (ID: ${commentId}, GitHub ID: ${newComment.data.id}) on PR #${prNumber} in ${owner}/${repo}`
+        );
         return newComment.data;
       }
     });
@@ -384,6 +322,10 @@ var CommentManager = class {
     return `<!-- visor-comment-id:${commentId} -->
 ${content}
 
+---
+
+*Powered by [Visor](https://probelabs.com/visor) from [Probelabs](https://probelabs.com)*
+
 *Last updated: ${lastUpdated} | Triggered by: ${triggeredBy}${commitInfo}*
 <!-- /visor-comment-id:${commentId} -->`;
   }
@@ -564,6 +506,7 @@ ${content}
 // src/ai-review-service.ts
 init_session_registry();
 init_logger();
+init_tracer_init();
 import { ProbeAgent } from "@probelabs/probe";
 function log(...args) {
   logger.debug(args.join(" "));
@@ -711,18 +654,24 @@ var AIReviewService = class {
         `Session not found for reuse: ${parentSessionId}. Ensure the parent check completed successfully.`
       );
     }
-    const prompt = await this.buildCustomPrompt(prInfo, customPrompt, schema);
+    const prompt = await this.buildCustomPrompt(prInfo, customPrompt, schema, {
+      skipPRContext: true
+    });
     let agentToUse;
     let currentSessionId;
     if (sessionMode === "clone") {
-      currentSessionId = `${parentSessionId}-clone-${Date.now()}`;
-      log(`\u{1F4CB} Cloning AI session ${parentSessionId} \u2192 ${currentSessionId}...`);
+      currentSessionId = `${checkName}-session-${Date.now()}`;
+      log(
+        `\u{1F4CB} Cloning AI session ${parentSessionId} \u2192 ${currentSessionId} for ${checkName} check...`
+      );
       const clonedAgent = await this.sessionRegistry.cloneSession(
         parentSessionId,
-        currentSessionId
+        currentSessionId,
+        checkName
+        // Pass checkName for tracing
       );
       if (!clonedAgent) {
-        throw new Error(`Failed to clone session ${parentSessionId}. Falling back to append mode.`);
+        throw new Error(`Failed to clone session ${parentSessionId}`);
       }
       agentToUse = clonedAgent;
     } else {
@@ -731,7 +680,13 @@ var AIReviewService = class {
       currentSessionId = parentSessionId;
     }
     log(`\u{1F527} Debug: Raw schema parameter: ${JSON.stringify(schema)} (type: ${typeof schema})`);
-    log(`Schema type: ${schema || "none (no schema)"}`);
+    log(`\u{1F4CB} Schema for this check: ${schema || "none (no schema)"}`);
+    if (sessionMode === "clone") {
+      log(`\u2705 Cloned agent will use NEW schema (${schema}) - parent schema does not persist`);
+      log(`\u{1F504} Clone operation ensures fresh agent with copied history but new configuration`);
+    } else {
+      log(`\u{1F504} Append mode - using existing agent instance with shared history and configuration`);
+    }
     let debugInfo;
     if (this.config.debug) {
       debugInfo = {
@@ -809,11 +764,17 @@ var AIReviewService = class {
   /**
    * Build a custom prompt for AI review with XML-formatted data
    */
-  async buildCustomPrompt(prInfo, customInstructions, schema) {
-    const prContext = this.formatPRContext(prInfo);
+  async buildCustomPrompt(prInfo, customInstructions, schema, options) {
+    const skipPRContext = options?.skipPRContext === true;
+    const prContext = skipPRContext ? "" : this.formatPRContext(prInfo);
     const isIssue = prInfo.isIssue === true;
     const isCodeReviewSchema = schema === "code-review";
     if (isIssue) {
+      if (skipPRContext) {
+        return `<instructions>
+${customInstructions}
+</instructions>`;
+      }
       return `<review_request>
   <instructions>
 ${customInstructions}
@@ -836,6 +797,19 @@ ${prContext}
     }
     if (isCodeReviewSchema) {
       const analysisType = prInfo.isIncremental ? "INCREMENTAL" : "FULL";
+      if (skipPRContext) {
+        return `<instructions>
+${customInstructions}
+</instructions>
+
+<reminder>
+  <rule>The code context and diff were provided in the previous message</rule>
+  <rule>Focus on the new analysis instructions above</rule>
+  <rule>Only analyze code that appears with + (additions) or - (deletions) in the diff sections</rule>
+  <rule>STRICT OUTPUT POLICY: Report only actual problems, risks, or deficiencies</rule>
+  <rule>SEVERITY ASSIGNMENT: Assign severity ONLY to problems introduced or left unresolved by this change</rule>
+</reminder>`;
+      }
       return `<review_request>
   <analysis_type>${analysisType}</analysis_type>
 
@@ -864,6 +838,11 @@ ${prContext}
     <rule>SEVERITY ASSIGNMENT: Assign severity ONLY to problems introduced or left unresolved by this change (critical/error/warning/info as appropriate). Do NOT create issue entries solely to acknowledge improvements; if no problems exist, return zero issues.</rule>
   </rules>
 </review_request>`;
+    }
+    if (skipPRContext) {
+      return `<instructions>
+${customInstructions}
+</instructions>`;
     }
     return `<instructions>
 ${customInstructions}
@@ -1123,9 +1102,308 @@ ${schemaString}`);
         log(`\u{1F3AF} Schema options passed to ProbeAgent.answer() (session reuse):`);
         log(JSON.stringify(schemaOptions, null, 2));
       }
-      const response = await agent.answer(prompt, void 0, schemaOptions);
+      if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
+        try {
+          const fs5 = __require("fs");
+          const path5 = __require("path");
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          const provider = this.config.provider || "auto";
+          const model = this.config.model || "default";
+          let conversationHistory = [];
+          try {
+            const agentAny2 = agent;
+            if (agentAny2.history) {
+              conversationHistory = agentAny2.history;
+            } else if (agentAny2.messages) {
+              conversationHistory = agentAny2.messages;
+            } else if (agentAny2._messages) {
+              conversationHistory = agentAny2._messages;
+            }
+          } catch {
+          }
+          const debugData = {
+            timestamp,
+            checkName: _checkName || "unknown",
+            provider,
+            model,
+            schema: effectiveSchema,
+            schemaOptions: schemaOptions || "none",
+            sessionInfo: {
+              isSessionReuse: true,
+              historyMessageCount: conversationHistory.length
+            },
+            currentPromptLength: prompt.length,
+            currentPrompt: prompt,
+            conversationHistory
+          };
+          const debugJson = JSON.stringify(debugData, null, 2);
+          let readableVersion = `=============================================================
+`;
+          readableVersion += `VISOR DEBUG REPORT - SESSION REUSE
+`;
+          readableVersion += `=============================================================
+`;
+          readableVersion += `Timestamp: ${timestamp}
+`;
+          readableVersion += `Check Name: ${_checkName || "unknown"}
+`;
+          readableVersion += `Provider: ${provider}
+`;
+          readableVersion += `Model: ${model}
+`;
+          readableVersion += `Schema: ${effectiveSchema}
+`;
+          readableVersion += `Schema Options: ${schemaOptions ? "provided" : "none"}
+`;
+          readableVersion += `History Messages: ${conversationHistory.length}
+`;
+          readableVersion += `=============================================================
+
+`;
+          if (schemaOptions) {
+            readableVersion += `
+${"=".repeat(60)}
+`;
+            readableVersion += `SCHEMA CONFIGURATION
+`;
+            readableVersion += `${"=".repeat(60)}
+`;
+            readableVersion += JSON.stringify(schemaOptions, null, 2);
+            readableVersion += `
+`;
+          }
+          if (conversationHistory.length > 0) {
+            readableVersion += `
+${"=".repeat(60)}
+`;
+            readableVersion += `CONVERSATION HISTORY (${conversationHistory.length} messages)
+`;
+            readableVersion += `${"=".repeat(60)}
+`;
+            conversationHistory.forEach((msg, index) => {
+              readableVersion += `
+${"-".repeat(60)}
+`;
+              readableVersion += `MESSAGE #${index + 1}
+`;
+              readableVersion += `Role: ${msg.role || "unknown"}
+`;
+              if (msg.content) {
+                const contentStr = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content, null, 2);
+                readableVersion += `Length: ${contentStr.length} characters
+`;
+                readableVersion += `${"-".repeat(60)}
+`;
+                readableVersion += `${contentStr}
+`;
+              }
+            });
+          }
+          readableVersion += `
+${"=".repeat(60)}
+`;
+          readableVersion += `CURRENT PROMPT (NEW MESSAGE)
+`;
+          readableVersion += `${"=".repeat(60)}
+`;
+          readableVersion += `Length: ${prompt.length} characters
+`;
+          readableVersion += `${"-".repeat(60)}
+`;
+          readableVersion += `${prompt}
+`;
+          readableVersion += `
+${"=".repeat(60)}
+`;
+          readableVersion += `END OF DEBUG REPORT
+`;
+          readableVersion += `${"=".repeat(60)}
+`;
+          const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path5.join(process.cwd(), "debug-artifacts");
+          if (!fs5.existsSync(debugArtifactsDir)) {
+            fs5.mkdirSync(debugArtifactsDir, { recursive: true });
+          }
+          const debugFile = path5.join(
+            debugArtifactsDir,
+            `prompt-${_checkName || "unknown"}-${timestamp}.json`
+          );
+          fs5.writeFileSync(debugFile, debugJson, "utf-8");
+          const readableFile = path5.join(
+            debugArtifactsDir,
+            `prompt-${_checkName || "unknown"}-${timestamp}.txt`
+          );
+          fs5.writeFileSync(readableFile, readableVersion, "utf-8");
+          log(`
+\u{1F4BE} Full debug info saved to:`);
+          log(`   JSON: ${debugFile}`);
+          log(`   TXT:  ${readableFile}`);
+          log(`   - Includes: full conversation history, schema, current prompt`);
+        } catch (error) {
+          log(`\u26A0\uFE0F Could not save debug file: ${error}`);
+        }
+      }
+      const agentAny = agent;
+      let response;
+      if (agentAny.tracer && typeof agentAny.tracer.withSpan === "function") {
+        response = await agentAny.tracer.withSpan(
+          "visor.ai_check_reuse",
+          async () => {
+            return await agent.answer(prompt, void 0, schemaOptions);
+          },
+          {
+            "check.name": _checkName || "unknown",
+            "check.mode": "session_reuse",
+            "prompt.length": prompt.length,
+            "schema.type": effectiveSchema || "none"
+          }
+        );
+      } else {
+        response = await agent.answer(prompt, void 0, schemaOptions);
+      }
       log("\u2705 ProbeAgent session reuse completed successfully");
       log(`\u{1F4E4} Response length: ${response.length} characters`);
+      if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
+        try {
+          const fs5 = __require("fs");
+          const path5 = __require("path");
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          const agentAny2 = agent;
+          let fullHistory = [];
+          if (agentAny2.history) {
+            fullHistory = agentAny2.history;
+          } else if (agentAny2.messages) {
+            fullHistory = agentAny2.messages;
+          } else if (agentAny2._messages) {
+            fullHistory = agentAny2._messages;
+          }
+          const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path5.join(process.cwd(), "debug-artifacts");
+          const sessionFile = path5.join(
+            debugArtifactsDir,
+            `session-${_checkName || "unknown"}-${timestamp}.json`
+          );
+          const sessionData = {
+            timestamp,
+            checkName: _checkName || "unknown",
+            provider: this.config.provider || "auto",
+            model: this.config.model || "default",
+            schema: effectiveSchema,
+            fullConversationHistory: fullHistory,
+            totalMessages: fullHistory.length,
+            latestResponse: response
+          };
+          fs5.writeFileSync(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+          const sessionTxtFile = path5.join(
+            debugArtifactsDir,
+            `session-${_checkName || "unknown"}-${timestamp}.txt`
+          );
+          let readable = `=============================================================
+`;
+          readable += `COMPLETE AI SESSION HISTORY (AFTER RESPONSE)
+`;
+          readable += `=============================================================
+`;
+          readable += `Timestamp: ${timestamp}
+`;
+          readable += `Check: ${_checkName || "unknown"}
+`;
+          readable += `Total Messages: ${fullHistory.length}
+`;
+          readable += `=============================================================
+
+`;
+          fullHistory.forEach((msg, idx) => {
+            readable += `
+${"=".repeat(60)}
+`;
+            readable += `MESSAGE ${idx + 1}/${fullHistory.length}
+`;
+            readable += `Role: ${msg.role || "unknown"}
+`;
+            readable += `${"=".repeat(60)}
+`;
+            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content, null, 2);
+            readable += content + "\n";
+          });
+          fs5.writeFileSync(sessionTxtFile, readable, "utf-8");
+          log(`\u{1F4BE} Complete session history saved:`);
+          log(`   JSON: ${sessionFile}`);
+          log(`   TXT:  ${sessionTxtFile}`);
+          log(`   - Contains ALL ${fullHistory.length} messages (prompts + responses)`);
+        } catch (error) {
+          log(`\u26A0\uFE0F Could not save complete session history: ${error}`);
+        }
+      }
+      if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
+        try {
+          const fs5 = __require("fs");
+          const path5 = __require("path");
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path5.join(process.cwd(), "debug-artifacts");
+          const responseFile = path5.join(
+            debugArtifactsDir,
+            `response-${_checkName || "unknown"}-${timestamp}.txt`
+          );
+          let responseContent = `=============================================================
+`;
+          responseContent += `VISOR AI RESPONSE - SESSION REUSE
+`;
+          responseContent += `=============================================================
+`;
+          responseContent += `Timestamp: ${timestamp}
+`;
+          responseContent += `Check Name: ${_checkName || "unknown"}
+`;
+          responseContent += `Response Length: ${response.length} characters
+`;
+          responseContent += `=============================================================
+
+`;
+          responseContent += `${"=".repeat(60)}
+`;
+          responseContent += `AI RESPONSE
+`;
+          responseContent += `${"=".repeat(60)}
+`;
+          responseContent += response;
+          responseContent += `
+${"=".repeat(60)}
+`;
+          responseContent += `END OF RESPONSE
+`;
+          responseContent += `${"=".repeat(60)}
+`;
+          fs5.writeFileSync(responseFile, responseContent, "utf-8");
+          log(`\u{1F4BE} Response saved to: ${responseFile}`);
+        } catch (error) {
+          log(`\u26A0\uFE0F Could not save response file: ${error}`);
+        }
+      }
+      if (agentAny._traceFilePath && agentAny._telemetryConfig) {
+        try {
+          if (agentAny.tracer && typeof agentAny.tracer.flush === "function") {
+            await agentAny.tracer.flush();
+            log(`\u{1F504} Flushed tracer spans for cloned session`);
+          }
+          if (agentAny._telemetryConfig && typeof agentAny._telemetryConfig.shutdown === "function") {
+            await agentAny._telemetryConfig.shutdown();
+            log(`\u{1F4CA} OpenTelemetry trace saved to: ${agentAny._traceFilePath}`);
+            if (process.env.GITHUB_ACTIONS) {
+              const fs5 = __require("fs");
+              if (fs5.existsSync(agentAny._traceFilePath)) {
+                const stats = fs5.statSync(agentAny._traceFilePath);
+                console.log(
+                  `::notice title=AI Trace Saved::${agentAny._traceFilePath} (${stats.size} bytes)`
+                );
+              }
+            }
+          } else if (agentAny.tracer && typeof agentAny.tracer.shutdown === "function") {
+            await agentAny.tracer.shutdown();
+            log(`\u{1F4CA} Trace saved to: ${agentAny._traceFilePath}`);
+          }
+        } catch (exportError) {
+          console.error("\u26A0\uFE0F  Warning: Failed to export trace for cloned session:", exportError);
+        }
+      }
       return { response, effectiveSchema };
     } catch (error) {
       console.error("\u274C ProbeAgent session reuse failed:", error);
@@ -1176,6 +1454,16 @@ ${schemaString}`);
         // We don't want the agent to modify files
         debug: this.config.debug || false
       };
+      let traceFilePath = "";
+      let telemetryConfig = null;
+      if (this.config.debug) {
+        const tracerResult = await initializeTracer(sessionId, _checkName);
+        if (tracerResult) {
+          options.tracer = tracerResult.tracer;
+          telemetryConfig = tracerResult.telemetryConfig;
+          traceFilePath = tracerResult.filePath;
+        }
+      }
       if (this.config.mcpServers && Object.keys(this.config.mcpServers).length > 0) {
         options.enableMcp = true;
         options.mcpConfig = { mcpServers: this.config.mcpServers };
@@ -1220,36 +1508,289 @@ ${schemaString}`);
       }
       const provider = this.config.provider || "auto";
       const model = this.config.model || "default";
-      try {
-        const fs5 = __require("fs");
-        const path5 = __require("path");
-        const os = __require("os");
-        const tempDir = os.tmpdir();
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const promptFile = path5.join(tempDir, `visor-prompt-${timestamp}.txt`);
-        fs5.writeFileSync(promptFile, prompt, "utf-8");
-        log(`
+      if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
+        try {
+          const fs5 = __require("fs");
+          const path5 = __require("path");
+          const os = __require("os");
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          const debugData = {
+            timestamp,
+            checkName: _checkName || "unknown",
+            provider,
+            model,
+            schema: effectiveSchema,
+            schemaOptions: schemaOptions || "none",
+            sessionInfo: {
+              isSessionReuse: false,
+              isNewSession: true
+            },
+            promptLength: prompt.length,
+            prompt
+          };
+          const debugJson = JSON.stringify(debugData, null, 2);
+          let readableVersion = `=============================================================
+`;
+          readableVersion += `VISOR DEBUG REPORT - NEW SESSION
+`;
+          readableVersion += `=============================================================
+`;
+          readableVersion += `Timestamp: ${timestamp}
+`;
+          readableVersion += `Check Name: ${_checkName || "unknown"}
+`;
+          readableVersion += `Provider: ${provider}
+`;
+          readableVersion += `Model: ${model}
+`;
+          readableVersion += `Schema: ${effectiveSchema}
+`;
+          readableVersion += `Schema Options: ${schemaOptions ? "provided" : "none"}
+`;
+          readableVersion += `Session Type: New Session (no history)
+`;
+          readableVersion += `=============================================================
+
+`;
+          if (schemaOptions) {
+            readableVersion += `
+${"=".repeat(60)}
+`;
+            readableVersion += `SCHEMA CONFIGURATION
+`;
+            readableVersion += `${"=".repeat(60)}
+`;
+            readableVersion += JSON.stringify(schemaOptions, null, 2);
+            readableVersion += `
+`;
+          }
+          readableVersion += `
+${"=".repeat(60)}
+`;
+          readableVersion += `PROMPT
+`;
+          readableVersion += `${"=".repeat(60)}
+`;
+          readableVersion += `Length: ${prompt.length} characters
+`;
+          readableVersion += `${"-".repeat(60)}
+`;
+          readableVersion += `${prompt}
+`;
+          readableVersion += `
+${"=".repeat(60)}
+`;
+          readableVersion += `END OF DEBUG REPORT
+`;
+          readableVersion += `${"=".repeat(60)}
+`;
+          const tempDir = os.tmpdir();
+          const promptFile = path5.join(tempDir, `visor-prompt-${timestamp}.txt`);
+          fs5.writeFileSync(promptFile, prompt, "utf-8");
+          log(`
 \u{1F4BE} Prompt saved to: ${promptFile}`);
-        log(`
+          const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path5.join(process.cwd(), "debug-artifacts");
+          try {
+            if (!fs5.existsSync(debugArtifactsDir)) {
+              fs5.mkdirSync(debugArtifactsDir, { recursive: true });
+            }
+            const debugFile = path5.join(
+              debugArtifactsDir,
+              `prompt-${_checkName || "unknown"}-${timestamp}.json`
+            );
+            fs5.writeFileSync(debugFile, debugJson, "utf-8");
+            const readableFile = path5.join(
+              debugArtifactsDir,
+              `prompt-${_checkName || "unknown"}-${timestamp}.txt`
+            );
+            fs5.writeFileSync(readableFile, readableVersion, "utf-8");
+            log(`
+\u{1F4BE} Full debug info saved to:`);
+            log(`   JSON: ${debugFile}`);
+            log(`   TXT:  ${readableFile}`);
+            log(`   - Includes: prompt, schema, provider, model, and schema options`);
+          } catch {
+          }
+          log(`
 \u{1F4DD} To reproduce locally, run:`);
-        let cliCommand = `npx @probelabs/probe@latest agent`;
-        cliCommand += ` --provider ${provider}`;
-        if (model !== "default") {
-          cliCommand += ` --model ${model}`;
-        }
-        if (schema) {
-          cliCommand += ` --schema output/${schema}/schema.json`;
-        }
-        cliCommand += ` "${promptFile}"`;
-        log(`
+          let cliCommand = `npx @probelabs/probe@latest agent`;
+          cliCommand += ` --provider ${provider}`;
+          if (model !== "default") {
+            cliCommand += ` --model ${model}`;
+          }
+          if (schema) {
+            cliCommand += ` --schema output/${schema}/schema.json`;
+          }
+          cliCommand += ` "${promptFile}"`;
+          log(`
 $ ${cliCommand}
 `);
-      } catch (error) {
-        log(`\u26A0\uFE0F Could not save prompt file: ${error}`);
+        } catch (error) {
+          log(`\u26A0\uFE0F Could not save prompt file: ${error}`);
+        }
+      }
+      let response;
+      const tracer = options.tracer;
+      if (tracer && typeof tracer.withSpan === "function") {
+        response = await tracer.withSpan(
+          "visor.ai_check",
+          async () => {
+            return await agent.answer(prompt, void 0, schemaOptions);
+          },
+          {
+            "check.name": _checkName || "unknown",
+            "check.session_id": sessionId,
+            "prompt.length": prompt.length,
+            "schema.type": effectiveSchema || "none"
+          }
+        );
+      } else {
+        response = await agent.answer(prompt, void 0, schemaOptions);
       }
-      const response = await agent.answer(prompt, void 0, schemaOptions);
       log("\u2705 ProbeAgent completed successfully");
       log(`\u{1F4E4} Response length: ${response.length} characters`);
+      if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
+        try {
+          const fs5 = __require("fs");
+          const path5 = __require("path");
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          const agentAny = agent;
+          let fullHistory = [];
+          if (agentAny.history) {
+            fullHistory = agentAny.history;
+          } else if (agentAny.messages) {
+            fullHistory = agentAny.messages;
+          } else if (agentAny._messages) {
+            fullHistory = agentAny._messages;
+          }
+          const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path5.join(process.cwd(), "debug-artifacts");
+          const sessionFile = path5.join(
+            debugArtifactsDir,
+            `session-${_checkName || "unknown"}-${timestamp}.json`
+          );
+          const sessionData = {
+            timestamp,
+            checkName: _checkName || "unknown",
+            provider: this.config.provider || "auto",
+            model: this.config.model || "default",
+            schema: effectiveSchema,
+            fullConversationHistory: fullHistory,
+            totalMessages: fullHistory.length,
+            latestResponse: response
+          };
+          fs5.writeFileSync(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+          const sessionTxtFile = path5.join(
+            debugArtifactsDir,
+            `session-${_checkName || "unknown"}-${timestamp}.txt`
+          );
+          let readable = `=============================================================
+`;
+          readable += `COMPLETE AI SESSION HISTORY (AFTER RESPONSE)
+`;
+          readable += `=============================================================
+`;
+          readable += `Timestamp: ${timestamp}
+`;
+          readable += `Check: ${_checkName || "unknown"}
+`;
+          readable += `Total Messages: ${fullHistory.length}
+`;
+          readable += `=============================================================
+
+`;
+          fullHistory.forEach((msg, idx) => {
+            readable += `
+${"=".repeat(60)}
+`;
+            readable += `MESSAGE ${idx + 1}/${fullHistory.length}
+`;
+            readable += `Role: ${msg.role || "unknown"}
+`;
+            readable += `${"=".repeat(60)}
+`;
+            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content, null, 2);
+            readable += content + "\n";
+          });
+          fs5.writeFileSync(sessionTxtFile, readable, "utf-8");
+          log(`\u{1F4BE} Complete session history saved:`);
+          log(`   JSON: ${sessionFile}`);
+          log(`   TXT:  ${sessionTxtFile}`);
+          log(`   - Contains ALL ${fullHistory.length} messages (prompts + responses)`);
+        } catch (error) {
+          log(`\u26A0\uFE0F Could not save complete session history: ${error}`);
+        }
+      }
+      if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
+        try {
+          const fs5 = __require("fs");
+          const path5 = __require("path");
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path5.join(process.cwd(), "debug-artifacts");
+          const responseFile = path5.join(
+            debugArtifactsDir,
+            `response-${_checkName || "unknown"}-${timestamp}.txt`
+          );
+          let responseContent = `=============================================================
+`;
+          responseContent += `VISOR AI RESPONSE - NEW SESSION
+`;
+          responseContent += `=============================================================
+`;
+          responseContent += `Timestamp: ${timestamp}
+`;
+          responseContent += `Check Name: ${_checkName || "unknown"}
+`;
+          responseContent += `Response Length: ${response.length} characters
+`;
+          responseContent += `=============================================================
+
+`;
+          responseContent += `${"=".repeat(60)}
+`;
+          responseContent += `AI RESPONSE
+`;
+          responseContent += `${"=".repeat(60)}
+`;
+          responseContent += response;
+          responseContent += `
+${"=".repeat(60)}
+`;
+          responseContent += `END OF RESPONSE
+`;
+          responseContent += `${"=".repeat(60)}
+`;
+          fs5.writeFileSync(responseFile, responseContent, "utf-8");
+          log(`\u{1F4BE} Response saved to: ${responseFile}`);
+        } catch (error) {
+          log(`\u26A0\uFE0F Could not save response file: ${error}`);
+        }
+      }
+      if (traceFilePath && telemetryConfig) {
+        try {
+          if (tracer && typeof tracer.flush === "function") {
+            await tracer.flush();
+            log(`\u{1F504} Flushed tracer spans`);
+          }
+          if (telemetryConfig && typeof telemetryConfig.shutdown === "function") {
+            await telemetryConfig.shutdown();
+            log(`\u{1F4CA} OpenTelemetry trace saved to: ${traceFilePath}`);
+            if (process.env.GITHUB_ACTIONS) {
+              const fs5 = __require("fs");
+              if (fs5.existsSync(traceFilePath)) {
+                const stats = fs5.statSync(traceFilePath);
+                console.log(
+                  `::notice title=AI Trace Saved::OpenTelemetry trace file size: ${stats.size} bytes`
+                );
+              }
+            }
+          } else if (tracer && typeof tracer.shutdown === "function") {
+            await tracer.shutdown();
+            log(`\u{1F4CA} Trace saved to: ${traceFilePath}`);
+          }
+        } catch (exportError) {
+          console.error("\u26A0\uFE0F  Warning: Failed to export trace:", exportError);
+        }
+      }
       if (_checkName) {
         this.registerSession(sessionId, agent);
         log(`\u{1F527} Debug: Registered AI session for potential reuse: ${sessionId}`);
@@ -1637,7 +2178,7 @@ var PRReviewer = class {
   async reviewPR(owner, repo, prNumber, prInfo, options = {}) {
     const { debug = false, config, checks } = options;
     if (config && checks && checks.length > 0) {
-      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-Z2USLMN5.mjs");
+      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-L73PFZQY.mjs");
       const engine = new CheckExecutionEngine2();
       const { results } = await engine.executeGroupedChecks(
         prInfo,
@@ -1645,7 +2186,10 @@ var PRReviewer = class {
         void 0,
         config,
         void 0,
-        debug
+        debug,
+        void 0,
+        void 0,
+        options.tagFilter
       );
       return results;
     }
@@ -1655,7 +2199,16 @@ var PRReviewer = class {
   }
   async postReviewComment(owner, repo, prNumber, groupedResults, options = {}) {
     for (const [groupName, checkResults] of Object.entries(groupedResults)) {
-      const comment = await this.formatGroupComment(checkResults, options, {
+      const filteredResults = options.config ? checkResults.filter((r) => {
+        const cfg = options.config.checks?.[r.checkName];
+        const t = cfg?.type || "";
+        const isGitHubOps = t === "github" || r.group === "github" || t === "noop" || t === "command";
+        return !isGitHubOps;
+      }) : checkResults;
+      if (!filteredResults || filteredResults.length === 0) {
+        continue;
+      }
+      const comment = await this.formatGroupComment(filteredResults, options, {
         owner,
         repo,
         prNumber,
@@ -1668,6 +2221,7 @@ var PRReviewer = class {
       } else {
         commentId = options.commentId ? `${options.commentId}-${groupName}` : `visor-review-${groupName}`;
       }
+      if (!comment || !comment.trim()) continue;
       await this.commentManager.updateOrCreateComment(owner, repo, prNumber, comment, {
         commentId,
         triggeredBy: options.triggeredBy || "unknown",
@@ -1677,22 +2231,33 @@ var PRReviewer = class {
     }
   }
   async formatGroupComment(checkResults, _options, _githubContext) {
+    const normalize = (s) => s.replace(/\\n/g, "\n");
+    const checkContents = checkResults.map((result) => {
+      const trimmed = result.content?.trim();
+      if (trimmed) return normalize(trimmed);
+      const out = result.output;
+      if (out) {
+        if (typeof out === "string" && out.trim()) return normalize(out.trim());
+        if (typeof out === "object") {
+          const txt = out.text || out.response || out.message;
+          if (typeof txt === "string" && txt.trim()) return normalize(txt.trim());
+        }
+      }
+      return "";
+    }).filter((content) => content && content.trim());
+    const debugInfo = checkResults.find((result) => result.debug)?.debug;
+    if (checkContents.length === 0 && !debugInfo) {
+      return "";
+    }
     let comment = "";
     comment += `## \u{1F50D} Code Analysis Results
 
 `;
-    const checkContents = checkResults.map((result) => result.content).filter((content) => content.trim());
     comment += checkContents.join("\n\n");
-    const debugInfo = checkResults.find((result) => result.debug)?.debug;
     if (debugInfo) {
       comment += "\n\n" + this.formatDebugSection(debugInfo);
       comment += "\n\n";
     }
-    comment += `
-
----
-
-*Powered by [Visor](https://probelabs.com/visor) from [Probelabs](https://probelabs.com)*`;
     return comment;
   }
   formatDebugSection(debug) {
@@ -1813,6 +2378,7 @@ var PRReviewer = class {
 import { simpleGit } from "simple-git";
 import * as path from "path";
 import * as fs from "fs";
+var MAX_PATCH_SIZE = 50 * 1024;
 var GitRepositoryAnalyzer = class {
   git;
   cwd;
@@ -1823,30 +2389,48 @@ var GitRepositoryAnalyzer = class {
   /**
    * Analyze the current git repository state and return data compatible with PRInfo interface
    */
-  async analyzeRepository(includeContext = true) {
+  async analyzeRepository(includeContext = true, enableBranchDiff = false) {
     const isRepo = await this.isGitRepository();
     if (!isRepo) {
       return this.createEmptyRepositoryInfo("Not a git repository");
     }
     try {
-      const [status, currentBranch] = await Promise.all([
+      const [status, currentBranch, baseBranch] = await Promise.all([
         this.git.status(),
-        this.getCurrentBranch()
+        this.getCurrentBranch(),
+        this.getBaseBranch()
       ]);
-      const uncommittedFiles = await this.getUncommittedChanges(includeContext);
+      const isFeatureBranch = currentBranch !== baseBranch && currentBranch !== "main" && currentBranch !== "master";
+      let uncommittedFiles = await this.getUncommittedChanges(includeContext);
+      if (isFeatureBranch && includeContext && enableBranchDiff) {
+        if (uncommittedFiles.length > 0) {
+          console.error(`\u{1F4CA} Feature branch detected: ${currentBranch}`);
+          console.error(
+            `\u26A0\uFE0F  Ignoring ${uncommittedFiles.length} uncommitted file(s) due to --analyze-branch-diff flag`
+          );
+        } else {
+          console.error(`\u{1F4CA} Feature branch detected: ${currentBranch}`);
+        }
+        console.error(
+          `\u{1F4C2} Analyzing diff vs ${baseBranch} (${uncommittedFiles.length > 0 ? "forced by --analyze-branch-diff" : "auto-enabled for code-review schemas"})`
+        );
+        uncommittedFiles = await this.getBranchDiff(baseBranch, includeContext);
+      } else if (uncommittedFiles.length > 0) {
+        console.error(`\u{1F4DD} Analyzing uncommitted changes (${uncommittedFiles.length} files)`);
+      }
       let lastCommit = null;
       try {
         const recentCommits = await this.git.log({ maxCount: 1 });
         lastCommit = recentCommits.latest;
       } catch {
-        console.log("\u{1F4DD} Repository has no commits yet, analyzing uncommitted changes");
+        console.error("\u{1F4DD} Repository has no commits yet, analyzing uncommitted changes");
       }
       let author = lastCommit?.author_name;
       if (!author) {
         try {
           const [userName, userEmail] = await Promise.all([
-            this.git.raw(["config", "user.name"]).catch(() => null),
-            this.git.raw(["config", "user.email"]).catch(() => null)
+            this.git.raw(["config", "--local", "user.name"]).catch(() => null),
+            this.git.raw(["config", "--local", "user.email"]).catch(() => null)
           ]);
           author = userName?.trim() || userEmail?.trim() || "unknown";
         } catch {
@@ -1857,7 +2441,7 @@ var GitRepositoryAnalyzer = class {
         title: this.generateTitle(status, currentBranch),
         body: this.generateDescription(status, lastCommit),
         author,
-        base: await this.getBaseBranch(),
+        base: baseBranch,
         head: currentBranch,
         files: uncommittedFiles,
         totalAdditions: uncommittedFiles.reduce((sum, file) => sum + file.additions, 0),
@@ -1935,6 +2519,51 @@ ${file.patch}`).join("\n\n");
       return "main";
     }
   }
+  /**
+   * Check if a file should be excluded from analysis
+   * This includes:
+   * - Files in .gitignore (even if force-added)
+   * - Built/generated files (dist/, build/, .next/, etc.)
+   */
+  async shouldExcludeFile(filename) {
+    const excludePatterns = [
+      /^dist\//,
+      /^build\//,
+      /^\.next\//,
+      /^out\//,
+      /^node_modules\//,
+      /^coverage\//,
+      /^\.turbo\//
+    ];
+    for (const pattern of excludePatterns) {
+      if (pattern.test(filename)) {
+        return true;
+      }
+    }
+    try {
+      const result = await this.git.raw(["check-ignore", filename]);
+      return result.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Truncate a patch if it exceeds MAX_PATCH_SIZE
+   */
+  truncatePatch(patch, filename) {
+    const patchSize = Buffer.byteLength(patch, "utf8");
+    if (patchSize <= MAX_PATCH_SIZE) {
+      return { patch, truncated: false };
+    }
+    const truncated = patch.substring(0, MAX_PATCH_SIZE);
+    const truncatedPatch = `${truncated}
+
+... [TRUNCATED: Diff too large (${(patchSize / 1024).toFixed(1)}KB), showing first ${(MAX_PATCH_SIZE / 1024).toFixed(0)}KB] ...`;
+    console.error(
+      `\u26A0\uFE0F  Truncated diff for ${filename} (${(patchSize / 1024).toFixed(1)}KB \u2192 ${(MAX_PATCH_SIZE / 1024).toFixed(0)}KB)`
+    );
+    return { patch: truncatedPatch, truncated: true };
+  }
   async getRemoteInfo() {
     try {
       const remotes = await this.git.getRemotes(true);
@@ -1958,6 +2587,10 @@ ${file.patch}`).join("\n\n");
         }))
       ];
       for (const { file, status: status2 } of fileChanges) {
+        if (await this.shouldExcludeFile(file)) {
+          console.error(`\u23ED\uFE0F  Skipping excluded file: ${file}`);
+          continue;
+        }
         const filePath = path.join(this.cwd, file);
         const fileChange = await this.analyzeFileChange(file, status2, filePath, includeContext);
         changes.push(fileChange);
@@ -1968,16 +2601,78 @@ ${file.patch}`).join("\n\n");
       return [];
     }
   }
+  /**
+   * Get diff between current branch and base branch (for feature branch analysis)
+   */
+  async getBranchDiff(baseBranch, includeContext = true) {
+    try {
+      const diffSummary = await this.git.diffSummary([baseBranch]);
+      const changes = [];
+      if (!diffSummary || !diffSummary.files) {
+        return [];
+      }
+      for (const file of diffSummary.files) {
+        if (await this.shouldExcludeFile(file.file)) {
+          console.error(`\u23ED\uFE0F  Skipping excluded file: ${file.file}`);
+          continue;
+        }
+        const isBinary = "binary" in file && file.binary;
+        const insertions = "insertions" in file ? file.insertions : 0;
+        const deletions = "deletions" in file ? file.deletions : 0;
+        const fileChanges = "changes" in file ? file.changes : 0;
+        let status;
+        if (isBinary) {
+          status = "modified";
+        } else if (insertions > 0 && deletions === 0) {
+          status = "added";
+        } else if (insertions === 0 && deletions > 0) {
+          status = "removed";
+        } else {
+          status = "modified";
+        }
+        let patch;
+        let truncated = false;
+        if (includeContext && !isBinary) {
+          try {
+            const rawPatch = await this.git.diff([baseBranch, "--", file.file]);
+            if (rawPatch) {
+              const result = this.truncatePatch(rawPatch, file.file);
+              patch = result.patch;
+              truncated = result.truncated;
+            }
+          } catch {
+          }
+        }
+        const fileChange = {
+          filename: file.file,
+          additions: insertions,
+          deletions,
+          changes: fileChanges,
+          status,
+          patch,
+          truncated
+        };
+        changes.push(fileChange);
+      }
+      return changes;
+    } catch (error) {
+      console.error("Error getting branch diff:", error);
+      return [];
+    }
+  }
   async analyzeFileChange(filename, status, filePath, includeContext = true) {
     let additions = 0;
     let deletions = 0;
     let patch;
     let content;
+    let truncated = false;
     try {
       if (includeContext && status !== "added" && fs.existsSync(filePath)) {
         const diff = await this.git.diff(["--", filename]).catch(() => "");
         if (diff) {
-          patch = diff;
+          const result = this.truncatePatch(diff, filename);
+          patch = result.patch;
+          truncated = result.truncated;
           const lines = diff.split("\n");
           additions = lines.filter((line) => line.startsWith("+")).length;
           deletions = lines.filter((line) => line.startsWith("-")).length;
@@ -1996,7 +2691,9 @@ ${file.patch}`).join("\n\n");
           if (stats.isFile() && stats.size < 1024 * 1024) {
             if (includeContext) {
               content = fs.readFileSync(filePath, "utf8");
-              patch = content;
+              const result = this.truncatePatch(content, filename);
+              patch = result.patch;
+              truncated = result.truncated;
             }
             const fileContent = includeContext ? content : fs.readFileSync(filePath, "utf8");
             additions = fileContent.split("\n").length;
@@ -2017,7 +2714,8 @@ ${file.patch}`).join("\n\n");
       deletions,
       changes: additions + deletions,
       content,
-      patch
+      patch,
+      truncated
     };
   }
   generateTitle(status, branch) {
@@ -2079,6 +2777,172 @@ ${file.patch}`).join("\n\n");
   }
 };
 
+// src/pr-analyzer.ts
+var PRAnalyzer = class {
+  constructor(octokit, maxRetries = 3) {
+    this.octokit = octokit;
+    this.maxRetries = maxRetries;
+  }
+  /**
+   * Fetch commit diff for incremental analysis
+   */
+  async fetchCommitDiff(owner, repo, commitSha) {
+    try {
+      const { data: commit } = await this.withRetry(
+        () => this.octokit.rest.repos.getCommit({
+          owner,
+          repo,
+          ref: commitSha
+        })
+      );
+      const patches = commit.files?.filter((file) => file.patch).map((file) => `--- ${file.filename}
+${file.patch}`).join("\n\n") || "";
+      return patches;
+    } catch (error) {
+      console.warn(`Failed to fetch commit diff for ${commitSha}:`, error);
+      return "";
+    }
+  }
+  /**
+   * Generate unified diff for all PR files
+   */
+  generateFullDiff(files) {
+    return files.filter((file) => file.patch).map((file) => `--- ${file.filename}
+${file.patch}`).join("\n\n");
+  }
+  async fetchPRDiff(owner, repo, prNumber, commitSha, eventType) {
+    const [prData, filesData] = await Promise.all([
+      this.withRetry(
+        () => this.octokit.rest.pulls.get({
+          owner,
+          repo,
+          pull_number: prNumber
+        })
+      ),
+      this.withRetry(
+        () => this.octokit.rest.pulls.listFiles({
+          owner,
+          repo,
+          pull_number: prNumber
+        })
+      )
+    ]);
+    const pr = prData?.data;
+    const files = filesData?.data || [];
+    if (!pr) {
+      throw new Error("Invalid or missing pull request data");
+    }
+    const title = typeof pr.title === "string" ? pr.title : pr.title ? String(pr.title) : "MISSING";
+    const body = typeof pr.body === "string" ? pr.body : pr.body ? String(pr.body) : "";
+    const author = pr.user && typeof pr.user === "object" && pr.user.login ? typeof pr.user.login === "string" ? pr.user.login : String(pr.user.login) : "unknown";
+    const authorAssociation = pr.author_association && typeof pr.author_association === "string" ? pr.author_association : void 0;
+    const base = pr.base && typeof pr.base === "object" && pr.base.ref ? typeof pr.base.ref === "string" ? pr.base.ref : String(pr.base.ref) : "main";
+    const head = pr.head && typeof pr.head === "object" && pr.head.ref ? typeof pr.head.ref === "string" ? pr.head.ref : String(pr.head.ref) : "feature";
+    const validFiles = files ? files.filter((file) => file && typeof file === "object" && file.filename).map((file) => ({
+      filename: typeof file.filename === "string" ? file.filename : String(file.filename || "unknown"),
+      additions: typeof file.additions === "number" ? Math.max(0, file.additions) : 0,
+      deletions: typeof file.deletions === "number" ? Math.max(0, file.deletions) : 0,
+      changes: typeof file.changes === "number" ? Math.max(0, file.changes) : 0,
+      patch: typeof file.patch === "string" ? file.patch : void 0,
+      status: ["added", "removed", "modified", "renamed"].includes(file.status) ? file.status : "modified"
+    })).filter((file) => file.filename.length > 0) : [];
+    const prInfo = {
+      number: typeof pr.number === "number" ? pr.number : parseInt(String(pr.number || 1), 10),
+      title,
+      body,
+      author,
+      authorAssociation,
+      base,
+      head,
+      files: validFiles,
+      totalAdditions: validFiles.reduce((sum, file) => sum + file.additions, 0),
+      totalDeletions: validFiles.reduce((sum, file) => sum + file.deletions, 0),
+      fullDiff: this.generateFullDiff(validFiles),
+      eventType
+    };
+    try {
+      console.log(`\u{1F4AC} Fetching comment history for PR #${prInfo.number}`);
+      const comments = await this.fetchPRComments(owner, repo, prInfo.number);
+      prInfo.comments = comments;
+      console.log(`\u2705 Retrieved ${comments.length} comments`);
+    } catch (error) {
+      console.warn(
+        `\u26A0\uFE0F Could not fetch comments: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      prInfo.comments = [];
+    }
+    if (commitSha) {
+      console.log(`\u{1F527} Fetching incremental diff for commit: ${commitSha}`);
+      prInfo.commitDiff = await this.fetchCommitDiff(owner, repo, commitSha);
+      prInfo.isIncremental = true;
+      if (!prInfo.commitDiff || prInfo.commitDiff.length === 0) {
+        console.warn(
+          `\u26A0\uFE0F No commit diff retrieved for ${commitSha}, will use full diff as fallback`
+        );
+      } else {
+        console.log(`\u2705 Incremental diff retrieved (${prInfo.commitDiff.length} chars)`);
+      }
+    } else {
+      prInfo.isIncremental = false;
+    }
+    return prInfo;
+  }
+  async fetchPRComments(owner, repo, prNumber) {
+    const { data: comments } = await this.withRetry(
+      () => this.octokit.rest.issues.listComments({
+        owner,
+        repo,
+        issue_number: prNumber
+      })
+    );
+    return comments.map((comment) => ({
+      id: comment.id,
+      author: comment.user?.login || "unknown",
+      body: comment.body || "",
+      createdAt: comment.created_at,
+      updatedAt: comment.updated_at
+    }));
+  }
+  async withRetry(operation) {
+    let lastError = new Error("Unknown error");
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (error instanceof Error) {
+          lastError = error;
+        } else if (typeof error === "object" && error !== null) {
+          const errorObj = error;
+          const message = errorObj.message || errorObj.code || "Unknown error";
+          lastError = new Error(String(message));
+          Object.assign(lastError, error);
+        } else {
+          lastError = new Error(String(error));
+        }
+        if (attempt === this.maxRetries) {
+          break;
+        }
+        if (this.isRetryableError(error)) {
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 5e3);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          throw error;
+        }
+      }
+    }
+    throw lastError;
+  }
+  isRetryableError(error) {
+    const retryableErrors = ["ETIMEDOUT", "ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN"];
+    const retryableStatuses = [408, 429, 500, 502, 503, 504];
+    if (typeof error !== "object" || error === null) {
+      return false;
+    }
+    const err = error;
+    return err.code !== void 0 && retryableErrors.includes(err.code) || err.status !== void 0 && retryableStatuses.includes(err.status) || err.response?.status !== void 0 && retryableStatuses.includes(err.response.status);
+  }
+};
+
 // src/providers/check-provider.interface.ts
 var CheckProvider = class {
 };
@@ -3451,6 +4315,270 @@ var LogCheckProvider = class extends CheckProvider {
   }
 };
 
+// src/providers/github-ops-provider.ts
+import Sandbox from "@nyariv/sandboxjs";
+var GitHubOpsProvider = class extends CheckProvider {
+  sandbox;
+  getName() {
+    return "github";
+  }
+  getDescription() {
+    return "Native GitHub operations (labels, comments, reviewers) executed via Octokit";
+  }
+  async validateConfig(config) {
+    if (!config || typeof config !== "object") return false;
+    const cfg = config;
+    return typeof cfg.op === "string" && cfg.op.length > 0;
+  }
+  getSupportedConfigKeys() {
+    return ["op", "values", "value", "value_js"];
+  }
+  async isAvailable() {
+    return Boolean(
+      process.env.GITHUB_TOKEN || process.env["INPUT_GITHUB-TOKEN"] || process.env.GITHUB_REPOSITORY
+    );
+  }
+  getRequirements() {
+    return ["GITHUB_TOKEN or INPUT_GITHUB-TOKEN", "GITHUB_REPOSITORY"];
+  }
+  async execute(prInfo, config, dependencyResults) {
+    const cfg = config;
+    let octokit = config.eventContext?.octokit;
+    if (!octokit) {
+      const token = process.env["INPUT_GITHUB-TOKEN"] || process.env["GITHUB_TOKEN"];
+      if (!token) {
+        return {
+          issues: [
+            {
+              file: "system",
+              line: 0,
+              ruleId: "github/missing_token",
+              message: "No GitHub token available; set GITHUB_TOKEN or pass github-token input for native GitHub operations",
+              severity: "error",
+              category: "logic"
+            }
+          ]
+        };
+      }
+      const { Octokit } = await import("@octokit/rest");
+      octokit = new Octokit({ auth: token });
+    }
+    const repoEnv = process.env.GITHUB_REPOSITORY || "";
+    const [owner, repo] = repoEnv.split("/");
+    if (!owner || !repo || !prInfo?.number) {
+      return {
+        issues: [
+          {
+            file: "system",
+            line: 0,
+            ruleId: "github/missing_context",
+            message: "Missing owner/repo or PR number; GitHub operations require Action context",
+            severity: "error",
+            category: "logic"
+          }
+        ]
+      };
+    }
+    let valuesRaw = [];
+    if (Array.isArray(cfg.values)) valuesRaw = cfg.values.map((v) => String(v));
+    else if (typeof cfg.values === "string") valuesRaw = [cfg.values];
+    else if (typeof cfg.value === "string") valuesRaw = [cfg.value];
+    const renderValues = async (arr) => {
+      if (!arr || arr.length === 0) return [];
+      const liq = createExtendedLiquid({
+        cache: false,
+        strictFilters: false,
+        strictVariables: false
+      });
+      const outputs = {};
+      if (dependencyResults) {
+        for (const [name, result] of dependencyResults.entries()) {
+          const summary = result;
+          outputs[name] = summary.output !== void 0 ? summary.output : summary;
+        }
+      }
+      const ctx = {
+        pr: {
+          number: prInfo.number,
+          title: prInfo.title,
+          author: prInfo.author,
+          branch: prInfo.head,
+          base: prInfo.base,
+          authorAssociation: prInfo.authorAssociation
+        },
+        outputs
+      };
+      const out = [];
+      for (const item of arr) {
+        if (typeof item === "string" && (item.includes("{{") || item.includes("{%"))) {
+          try {
+            const rendered = await liq.parseAndRender(item, ctx);
+            out.push(rendered);
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return Promise.reject({
+              issues: [
+                {
+                  file: "system",
+                  line: 0,
+                  ruleId: "github/liquid_render_error",
+                  message: `Failed to render template: ${msg}`,
+                  severity: "error",
+                  category: "logic"
+                }
+              ]
+            });
+          }
+        } else {
+          out.push(String(item));
+        }
+      }
+      return out;
+    };
+    let values = await renderValues(valuesRaw);
+    if (cfg.value_js && cfg.value_js.trim()) {
+      try {
+        const sandbox = this.getSecureSandbox();
+        const code = `
+          const __fn = () => {
+${cfg.value_js}
+};
+          return __fn();
+        `;
+        const exec = sandbox.compile(code);
+        const res = exec({ pr: prInfo, values });
+        if (typeof res === "string") values = [res];
+        else if (Array.isArray(res)) values = res.map((v) => String(v));
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+          issues: [
+            {
+              file: "system",
+              line: 0,
+              ruleId: "github/value_js_error",
+              message: `value_js evaluation failed: ${msg}`,
+              severity: "error",
+              category: "logic"
+            }
+          ]
+        };
+      }
+    }
+    values = values.map((v) => v.trim()).filter((v) => v.length > 0);
+    values = Array.from(new Set(values));
+    try {
+      switch (cfg.op) {
+        case "labels.add": {
+          if (values.length === 0) break;
+          await octokit.rest.issues.addLabels({
+            owner,
+            repo,
+            issue_number: prInfo.number,
+            labels: values
+          });
+          break;
+        }
+        case "labels.remove": {
+          for (const l of values) {
+            await octokit.rest.issues.removeLabel({
+              owner,
+              repo,
+              issue_number: prInfo.number,
+              name: l
+            });
+          }
+          break;
+        }
+        case "comment.create": {
+          const body = values.join("\n").trim();
+          if (body)
+            await octokit.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number: prInfo.number,
+              body
+            });
+          break;
+        }
+        default:
+          return {
+            issues: [
+              {
+                file: "system",
+                line: 0,
+                ruleId: "github/unsupported_op",
+                message: `Unsupported GitHub op: ${cfg.op}`,
+                severity: "error",
+                category: "logic"
+              }
+            ]
+          };
+      }
+      return { issues: [] };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return {
+        issues: [
+          {
+            file: "system",
+            line: 0,
+            ruleId: "github/op_failed",
+            message: `GitHub operation failed (${cfg.op}): ${msg}`,
+            severity: "error",
+            category: "logic"
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Create a secure sandbox for evaluating small expressions without access to process/env
+   */
+  getSecureSandbox() {
+    if (this.sandbox) return this.sandbox;
+    const globals = {
+      ...Sandbox.SAFE_GLOBALS,
+      Math
+    };
+    const prototypeWhitelist = new Map(Sandbox.SAFE_PROTOTYPES);
+    const arrayMethods = /* @__PURE__ */ new Set([
+      "some",
+      "every",
+      "filter",
+      "map",
+      "reduce",
+      "find",
+      "includes",
+      "indexOf",
+      "length",
+      "slice",
+      "concat",
+      "join"
+    ]);
+    prototypeWhitelist.set(Array.prototype, arrayMethods);
+    const stringMethods = /* @__PURE__ */ new Set([
+      "toLowerCase",
+      "toUpperCase",
+      "includes",
+      "indexOf",
+      "startsWith",
+      "endsWith",
+      "slice",
+      "substring",
+      "length",
+      "trim",
+      "split",
+      "replace"
+    ]);
+    prototypeWhitelist.set(String.prototype, stringMethods);
+    const objectMethods = /* @__PURE__ */ new Set(["hasOwnProperty", "toString", "valueOf"]);
+    prototypeWhitelist.set(Object.prototype, objectMethods);
+    this.sandbox = new Sandbox({ globals, prototypeWhitelist });
+    return this.sandbox;
+  }
+};
+
 // src/providers/claude-code-check-provider.ts
 import fs4 from "fs/promises";
 import path4 from "path";
@@ -3905,7 +5033,7 @@ var ClaudeCodeCheckProvider = class extends CheckProvider {
 };
 
 // src/providers/command-check-provider.ts
-import Sandbox from "@nyariv/sandboxjs";
+import Sandbox2 from "@nyariv/sandboxjs";
 init_logger();
 var CommandCheckProvider = class extends CheckProvider {
   liquid;
@@ -3920,12 +5048,12 @@ var CommandCheckProvider = class extends CheckProvider {
   }
   createSecureSandbox() {
     const globals = {
-      ...Sandbox.SAFE_GLOBALS,
+      ...Sandbox2.SAFE_GLOBALS,
       console,
       JSON
     };
-    const prototypeWhitelist = new Map(Sandbox.SAFE_PROTOTYPES);
-    return new Sandbox({ globals, prototypeWhitelist });
+    const prototypeWhitelist = new Map(Sandbox2.SAFE_PROTOTYPES);
+    return new Sandbox2({ globals, prototypeWhitelist });
   }
   getName() {
     return "command";
@@ -3995,7 +5123,20 @@ var CommandCheckProvider = class extends CheckProvider {
       const execAsync = promisify(exec);
       const timeoutSeconds = config.timeout || 60;
       const timeoutMs = timeoutSeconds * 1e3;
-      const { stdout, stderr } = await execAsync(renderedCommand, {
+      const normalizeNodeEval = (cmd) => {
+        const re = /^(?<prefix>\s*(?:\/usr\/bin\/env\s+)?node(?:\.exe)?\s+(?:-e|--eval)\s+)(['"])([\s\S]*?)\2(?<suffix>\s|$)/;
+        const m = cmd.match(re);
+        if (!m || !m.groups) return cmd;
+        const prefix = m.groups.prefix;
+        const quote = m[2];
+        const code = m[3];
+        const suffix = m.groups.suffix || "";
+        if (!code.includes("\n")) return cmd;
+        const escaped = code.replace(/\n/g, "\\n");
+        return cmd.replace(re, `${prefix}${quote}${escaped}${quote}${suffix}`);
+      };
+      const safeCommand = normalizeNodeEval(renderedCommand);
+      const { stdout, stderr } = await execAsync(safeCommand, {
         env: scriptEnv,
         timeout: timeoutMs,
         maxBuffer: 10 * 1024 * 1024
@@ -4077,7 +5218,11 @@ var CommandCheckProvider = class extends CheckProvider {
             pr: templateContext.pr,
             files: templateContext.files,
             outputs: this.makeOutputsJsonSmart(templateContext.outputs),
-            env: templateContext.env
+            env: templateContext.env,
+            permissions: createPermissionHelpers(
+              resolveAssociationFromEvent(prInfo.eventContext, prInfo.authorAssociation),
+              detectLocalMode()
+            )
           };
           const trimmedTransform = transformJs.trim();
           const buildBodyWithReturn = (raw) => {
@@ -4104,6 +5249,12 @@ return (${lastExpr});`;
             const outputs = scope.outputs;
             const env = scope.env;
             const log = (...args) => { console.log('\u{1F50D} Debug:', ...args); };
+            const hasMinPermission = scope.permissions.hasMinPermission;
+            const isOwner = scope.permissions.isOwner;
+            const isMember = scope.permissions.isMember;
+            const isCollaborator = scope.permissions.isCollaborator;
+            const isContributor = scope.permissions.isContributor;
+            const isFirstTimer = scope.permissions.isFirstTimer;
             const __result = (function(){
 ${bodyWithReturn}
             })();
@@ -4121,6 +5272,12 @@ ${bodyWithReturn}
               const outputs = scope.outputs;
               const env = scope.env;
               const log = (...args) => { console.log('\u{1F50D} Debug:', ...args); };
+              const hasMinPermission = scope.permissions.hasMinPermission;
+              const isOwner = scope.permissions.isOwner;
+              const isMember = scope.permissions.isMember;
+              const isCollaborator = scope.permissions.isCollaborator;
+              const isContributor = scope.permissions.isContributor;
+              const isFirstTimer = scope.permissions.isFirstTimer;
               const __ret = (function(){
 ${bodyWithReturn}
               })();
@@ -5103,6 +6260,475 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
   }
 };
 
+// src/providers/memory-check-provider.ts
+init_logger();
+import Sandbox3 from "@nyariv/sandboxjs";
+var MemoryCheckProvider = class extends CheckProvider {
+  liquid;
+  sandbox;
+  constructor() {
+    super();
+    this.liquid = createExtendedLiquid({
+      strictVariables: false,
+      strictFilters: false
+    });
+  }
+  /**
+   * Create a secure sandbox for JavaScript execution
+   */
+  createSecureSandbox() {
+    const globals = {
+      ...Sandbox3.SAFE_GLOBALS,
+      Math,
+      console: {
+        log: console.log,
+        warn: console.warn,
+        error: console.error
+      }
+    };
+    const prototypeWhitelist = new Map(Sandbox3.SAFE_PROTOTYPES);
+    const arrayMethods = /* @__PURE__ */ new Set([
+      "some",
+      "every",
+      "filter",
+      "map",
+      "reduce",
+      "find",
+      "includes",
+      "indexOf",
+      "length",
+      "slice",
+      "concat",
+      "join",
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "sort",
+      "reverse"
+    ]);
+    prototypeWhitelist.set(Array.prototype, arrayMethods);
+    const stringMethods = /* @__PURE__ */ new Set([
+      "toLowerCase",
+      "toUpperCase",
+      "includes",
+      "indexOf",
+      "startsWith",
+      "endsWith",
+      "slice",
+      "substring",
+      "length",
+      "trim",
+      "split",
+      "replace",
+      "match",
+      "padStart",
+      "padEnd"
+    ]);
+    prototypeWhitelist.set(String.prototype, stringMethods);
+    const objectMethods = /* @__PURE__ */ new Set(["hasOwnProperty", "toString", "valueOf"]);
+    prototypeWhitelist.set(Object.prototype, objectMethods);
+    return new Sandbox3({
+      globals,
+      prototypeWhitelist
+    });
+  }
+  getName() {
+    return "memory";
+  }
+  getDescription() {
+    return "Memory/state management provider for persistent key-value storage across checks";
+  }
+  async validateConfig(config) {
+    if (!config || typeof config !== "object") {
+      return false;
+    }
+    const cfg = config;
+    if (cfg.type !== "memory") {
+      return false;
+    }
+    if (!cfg.operation || typeof cfg.operation !== "string") {
+      return false;
+    }
+    const operation = cfg.operation;
+    const validOps = ["get", "set", "append", "increment", "delete", "clear", "list", "exec_js"];
+    if (!validOps.includes(operation)) {
+      return false;
+    }
+    if (["get", "set", "append", "increment", "delete"].includes(operation)) {
+      if (!cfg.key || typeof cfg.key !== "string") {
+        return false;
+      }
+    }
+    if (["set", "append"].includes(operation)) {
+      if (cfg.value === void 0 && !cfg.value_js) {
+        return false;
+      }
+    }
+    if (operation === "exec_js") {
+      if (!cfg.memory_js || typeof cfg.memory_js !== "string") {
+        return false;
+      }
+    }
+    return true;
+  }
+  async execute(prInfo, config, dependencyResults, _sessionInfo) {
+    const operation = config.operation;
+    const key = config.key;
+    const namespace = config.namespace;
+    const memoryStore = MemoryStore.getInstance();
+    const templateContext = this.buildTemplateContext(prInfo, dependencyResults, memoryStore);
+    let result;
+    try {
+      switch (operation) {
+        case "get":
+          result = await this.handleGet(memoryStore, key, namespace);
+          break;
+        case "set":
+          result = await this.handleSet(memoryStore, key, config, namespace, templateContext);
+          break;
+        case "append":
+          result = await this.handleAppend(memoryStore, key, config, namespace, templateContext);
+          break;
+        case "increment":
+          result = await this.handleIncrement(
+            memoryStore,
+            key,
+            config,
+            namespace,
+            templateContext
+          );
+          break;
+        case "delete":
+          result = await this.handleDelete(memoryStore, key, namespace);
+          break;
+        case "clear":
+          result = await this.handleClear(memoryStore, namespace);
+          break;
+        case "list":
+          result = await this.handleList(memoryStore, namespace);
+          break;
+        case "exec_js":
+          result = await this.handleExecJs(memoryStore, config, templateContext);
+          break;
+        default:
+          throw new Error(`Unknown memory operation: ${operation}`);
+      }
+      return {
+        issues: [],
+        output: result
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error in memory operation";
+      logger.error(`Memory operation failed: ${errorMsg}`);
+      return {
+        issues: [],
+        output: null,
+        error: errorMsg
+      };
+    }
+  }
+  async handleGet(store, key, namespace) {
+    const value = store.get(key, namespace);
+    logger.debug(
+      `Memory GET: ${namespace || store.getDefaultNamespace()}.${key} = ${JSON.stringify(value)}`
+    );
+    return value;
+  }
+  async handleSet(store, key, config, namespace, context) {
+    const value = await this.computeValue(config, context);
+    await store.set(key, value, namespace);
+    logger.debug(
+      `Memory SET: ${namespace || store.getDefaultNamespace()}.${key} = ${JSON.stringify(value)}`
+    );
+    return value;
+  }
+  async handleAppend(store, key, config, namespace, context) {
+    const value = await this.computeValue(config, context);
+    await store.append(key, value, namespace);
+    const result = store.get(key, namespace);
+    logger.debug(
+      `Memory APPEND: ${namespace || store.getDefaultNamespace()}.${key} += ${JSON.stringify(value)} (now: ${JSON.stringify(result)})`
+    );
+    return result;
+  }
+  async handleIncrement(store, key, config, namespace, context) {
+    let amount = 1;
+    if (config.value !== void 0 || config.value_js) {
+      const computedValue = await this.computeValue(config, context);
+      if (typeof computedValue === "number") {
+        amount = computedValue;
+      } else {
+        throw new Error(`Increment amount must be a number, got ${typeof computedValue}`);
+      }
+    }
+    const result = await store.increment(key, amount, namespace);
+    logger.debug(
+      `Memory INCREMENT: ${namespace || store.getDefaultNamespace()}.${key} += ${amount} (now: ${result})`
+    );
+    return result;
+  }
+  async handleDelete(store, key, namespace) {
+    const deleted = await store.delete(key, namespace);
+    logger.debug(
+      `Memory DELETE: ${namespace || store.getDefaultNamespace()}.${key} (deleted: ${deleted})`
+    );
+    return deleted;
+  }
+  async handleClear(store, namespace) {
+    await store.clear(namespace);
+    logger.debug(`Memory CLEAR: ${namespace ? `namespace ${namespace}` : "all namespaces"}`);
+  }
+  async handleList(store, namespace) {
+    const keys = store.list(namespace);
+    logger.debug(`Memory LIST: ${namespace || store.getDefaultNamespace()} (${keys.length} keys)`);
+    return keys;
+  }
+  async handleExecJs(store, config, context) {
+    const script = config.memory_js;
+    const pendingOps = [];
+    const enhancedContext = {
+      ...context,
+      memory: {
+        get: (key, ns) => store.get(key, ns),
+        set: (key, value, ns) => {
+          const nsName = ns || store.getDefaultNamespace();
+          if (!store["data"].has(nsName)) {
+            store["data"].set(nsName, /* @__PURE__ */ new Map());
+          }
+          store["data"].get(nsName).set(key, value);
+          pendingOps.push(async () => {
+            if (store.getConfig().storage === "file" && store.getConfig().auto_save) {
+              await store.save();
+            }
+          });
+          return value;
+        },
+        append: (key, value, ns) => {
+          const existing = store.get(key, ns);
+          let newValue;
+          if (existing === void 0) {
+            newValue = [value];
+          } else if (Array.isArray(existing)) {
+            newValue = [...existing, value];
+          } else {
+            newValue = [existing, value];
+          }
+          const nsName = ns || store.getDefaultNamespace();
+          if (!store["data"].has(nsName)) {
+            store["data"].set(nsName, /* @__PURE__ */ new Map());
+          }
+          store["data"].get(nsName).set(key, newValue);
+          pendingOps.push(async () => {
+            if (store.getConfig().storage === "file" && store.getConfig().auto_save) {
+              await store.save();
+            }
+          });
+          return newValue;
+        },
+        increment: (key, amount = 1, ns) => {
+          const existing = store.get(key, ns);
+          let newValue;
+          if (existing === void 0 || existing === null) {
+            newValue = amount;
+          } else if (typeof existing === "number") {
+            newValue = existing + amount;
+          } else {
+            throw new Error(
+              `Cannot increment non-numeric value at key '${key}' (type: ${typeof existing})`
+            );
+          }
+          const nsName = ns || store.getDefaultNamespace();
+          if (!store["data"].has(nsName)) {
+            store["data"].set(nsName, /* @__PURE__ */ new Map());
+          }
+          store["data"].get(nsName).set(key, newValue);
+          pendingOps.push(async () => {
+            if (store.getConfig().storage === "file" && store.getConfig().auto_save) {
+              await store.save();
+            }
+          });
+          return newValue;
+        },
+        delete: (key, ns) => {
+          const nsName = ns || store.getDefaultNamespace();
+          const nsData = store["data"].get(nsName);
+          const deleted = nsData?.delete(key) || false;
+          if (deleted) {
+            pendingOps.push(async () => {
+              if (store.getConfig().storage === "file" && store.getConfig().auto_save) {
+                await store.save();
+              }
+            });
+          }
+          return deleted;
+        },
+        clear: (ns) => {
+          if (ns) {
+            store["data"].delete(ns);
+          } else {
+            store["data"].clear();
+          }
+          pendingOps.push(async () => {
+            if (store.getConfig().storage === "file" && store.getConfig().auto_save) {
+              await store.save();
+            }
+          });
+        },
+        list: (ns) => store.list(ns),
+        has: (key, ns) => store.has(key, ns),
+        getAll: (ns) => store.getAll(ns),
+        listNamespaces: () => store.listNamespaces()
+      }
+    };
+    const result = this.evaluateJavaScriptBlock(script, enhancedContext);
+    if (pendingOps.length > 0 && store.getConfig().storage === "file" && store.getConfig().auto_save) {
+      await store.save();
+    }
+    logger.debug(`Memory EXEC_JS: Executed custom script with ${pendingOps.length} operations`);
+    return result;
+  }
+  /**
+   * Compute value from config using value, value_js, transform, or transform_js
+   */
+  async computeValue(config, context) {
+    let value;
+    if (config.value_js && typeof config.value_js === "string") {
+      value = this.evaluateJavaScript(config.value_js, context);
+    } else {
+      value = config.value;
+    }
+    if (config.transform && typeof config.transform === "string") {
+      const rendered = await this.liquid.parseAndRender(config.transform, {
+        ...context,
+        value
+      });
+      value = rendered;
+    }
+    if (config.transform_js && typeof config.transform_js === "string") {
+      value = this.evaluateJavaScript(config.transform_js, { ...context, value });
+    }
+    return value;
+  }
+  /**
+   * Evaluate JavaScript expression in context using SandboxJS for secure execution
+   */
+  evaluateJavaScript(expression, context) {
+    if (!this.sandbox) {
+      this.sandbox = this.createSecureSandbox();
+    }
+    try {
+      const log2 = (...args) => {
+        logger.info(`\u{1F50D} [memory-js] ${args.map((a) => JSON.stringify(a)).join(" ")}`);
+      };
+      const scope = {
+        ...context,
+        log: log2
+      };
+      const exec = this.sandbox.compile(`return (${expression});`);
+      return exec(scope).run();
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to evaluate value_js: ${errorMsg}`);
+    }
+  }
+  /**
+   * Evaluate JavaScript block (multi-line script) using SandboxJS for secure execution
+   * Unlike evaluateJavaScript, this supports full scripts with statements, not just expressions
+   */
+  evaluateJavaScriptBlock(script, context) {
+    if (!this.sandbox) {
+      this.sandbox = this.createSecureSandbox();
+    }
+    try {
+      const log2 = (...args) => {
+        logger.info(`\u{1F50D} [memory-js] ${args.map((a) => JSON.stringify(a)).join(" ")}`);
+      };
+      const scope = {
+        ...context,
+        log: log2
+      };
+      const exec = this.sandbox.compile(script);
+      const result = exec(scope).run();
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      logger.error(`[memory-js] Script execution error: ${errorMsg}`);
+      throw new Error(`Failed to execute memory_js: ${errorMsg}`);
+    }
+  }
+  /**
+   * Build template context for Liquid and JS evaluation
+   */
+  buildTemplateContext(prInfo, dependencyResults, memoryStore) {
+    const context = {};
+    context.pr = {
+      number: prInfo.number,
+      title: prInfo.title,
+      body: prInfo.body,
+      author: prInfo.author,
+      base: prInfo.base,
+      head: prInfo.head,
+      totalAdditions: prInfo.totalAdditions,
+      totalDeletions: prInfo.totalDeletions,
+      files: prInfo.files.map((f) => ({
+        filename: f.filename,
+        status: f.status,
+        additions: f.additions,
+        deletions: f.deletions,
+        changes: f.changes
+      }))
+    };
+    if (dependencyResults) {
+      const outputs = {};
+      for (const [checkName, result] of dependencyResults.entries()) {
+        const summary = result;
+        outputs[checkName] = summary.output !== void 0 ? summary.output : summary;
+      }
+      context.outputs = outputs;
+    }
+    if (memoryStore) {
+      context.memory = {
+        get: (key, ns) => memoryStore.get(key, ns),
+        has: (key, ns) => memoryStore.has(key, ns),
+        list: (ns) => memoryStore.list(ns),
+        getAll: (ns) => memoryStore.getAll(ns)
+      };
+    }
+    return context;
+  }
+  getSupportedConfigKeys() {
+    return [
+      "type",
+      "operation",
+      "key",
+      "value",
+      "value_js",
+      "memory_js",
+      "transform",
+      "transform_js",
+      "namespace",
+      "depends_on",
+      "group",
+      "command",
+      "on",
+      "if",
+      "fail_if",
+      "on_fail",
+      "on_success"
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+  getRequirements() {
+    return [
+      "No external dependencies required",
+      "Used for state management and persistent storage across checks"
+    ];
+  }
+};
+
 // src/providers/check-provider-registry.ts
 var CheckProviderRegistry = class _CheckProviderRegistry {
   providers = /* @__PURE__ */ new Map();
@@ -5130,6 +6756,8 @@ var CheckProviderRegistry = class _CheckProviderRegistry {
     this.register(new HttpClientProvider());
     this.register(new NoopCheckProvider());
     this.register(new LogCheckProvider());
+    this.register(new MemoryCheckProvider());
+    this.register(new GitHubOpsProvider());
     try {
       this.register(new ClaudeCodeCheckProvider());
     } catch (error) {
@@ -5427,7 +7055,7 @@ var DependencyResolver = class {
 };
 
 // src/failure-condition-evaluator.ts
-import Sandbox2 from "@nyariv/sandboxjs";
+import Sandbox4 from "@nyariv/sandboxjs";
 var FailureConditionEvaluator = class _FailureConditionEvaluator {
   sandbox;
   constructor() {
@@ -5437,7 +7065,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
    */
   createSecureSandbox() {
     const globals = {
-      ...Sandbox2.SAFE_GLOBALS,
+      ...Sandbox4.SAFE_GLOBALS,
       // Allow Math for calculations
       Math,
       // Allow console for debugging (in controlled environment)
@@ -5447,7 +7075,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
         error: console.error
       }
     };
-    const prototypeWhitelist = new Map(Sandbox2.SAFE_PROTOTYPES);
+    const prototypeWhitelist = new Map(Sandbox4.SAFE_PROTOTYPES);
     const arrayMethods = /* @__PURE__ */ new Set([
       "some",
       "every",
@@ -5480,7 +7108,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
     prototypeWhitelist.set(String.prototype, stringMethods);
     const objectMethods = /* @__PURE__ */ new Set(["hasOwnProperty", "toString", "valueOf"]);
     prototypeWhitelist.set(Object.prototype, objectMethods);
-    return new Sandbox2({
+    return new Sandbox4({
       globals,
       prototypeWhitelist
     });
@@ -5488,13 +7116,14 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
   /**
    * Evaluate simple fail_if condition
    */
-  async evaluateSimpleCondition(checkName, checkSchema, checkGroup, reviewSummary, expression, previousOutputs) {
+  async evaluateSimpleCondition(checkName, checkSchema, checkGroup, reviewSummary, expression, previousOutputs, authorAssociation) {
     const context = this.buildEvaluationContext(
       checkName,
       checkSchema,
       checkGroup,
       reviewSummary,
-      previousOutputs
+      previousOutputs,
+      authorAssociation
     );
     try {
       try {
@@ -5509,6 +7138,38 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
       } catch {
       }
       const res = this.evaluateExpression(expression, context);
+      if (res === true) {
+        try {
+          addEvent("fail_if.triggered", {
+            check: checkName,
+            scope: "check",
+            name: `${checkName}_fail_if`,
+            expression,
+            severity: "error"
+          });
+        } catch {
+        }
+        try {
+          const { emitNdjsonSpanWithEvents: emitNdjsonSpanWithEvents2 } = (init_fallback_ndjson(), __toCommonJS(fallback_ndjson_exports));
+          emitNdjsonSpanWithEvents2(
+            "visor.fail_if",
+            { check: checkName, scope: "check", name: `${checkName}_fail_if` },
+            [
+              {
+                name: "fail_if.triggered",
+                attrs: {
+                  check: checkName,
+                  scope: "check",
+                  name: `${checkName}_fail_if`,
+                  expression,
+                  severity: "error"
+                }
+              }
+            ]
+          );
+        } catch {
+        }
+      }
       return res;
     } catch (error) {
       console.warn(`Failed to evaluate fail_if expression: ${error}`);
@@ -5566,6 +7227,8 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
       output: {
         issues: []
       },
+      // Author association (used by permission helpers)
+      authorAssociation: contextData?.authorAssociation,
       // Utility metadata
       metadata: {
         checkName,
@@ -5591,13 +7254,14 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
   /**
    * Evaluate all failure conditions for a check result
    */
-  async evaluateConditions(checkName, checkSchema, checkGroup, reviewSummary, globalConditions, checkConditions, previousOutputs) {
+  async evaluateConditions(checkName, checkSchema, checkGroup, reviewSummary, globalConditions, checkConditions, previousOutputs, authorAssociation) {
     const context = this.buildEvaluationContext(
       checkName,
       checkSchema,
       checkGroup,
       reviewSummary,
-      previousOutputs
+      previousOutputs,
+      authorAssociation
     );
     const results = [];
     if (globalConditions) {
@@ -5631,9 +7295,54 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
   async evaluateConditionSet(conditions, context, source) {
     const results = [];
     for (const [conditionName, condition] of Object.entries(conditions)) {
+      try {
+        addEvent("fail_if.evaluated", {
+          check: context.checkName,
+          scope: source,
+          name: conditionName,
+          expression: this.extractExpression(condition)
+        });
+      } catch {
+      }
+      try {
+        const { emitNdjsonSpanWithEvents: emitNdjsonSpanWithEvents2 } = (init_fallback_ndjson(), __toCommonJS(fallback_ndjson_exports));
+        emitNdjsonSpanWithEvents2(
+          "visor.fail_if",
+          { check: context.checkName || "unknown", scope: source, name: conditionName },
+          [
+            {
+              name: "fail_if.evaluated",
+              attrs: {
+                check: context.checkName,
+                scope: source,
+                name: conditionName,
+                expression: this.extractExpression(condition)
+              }
+            }
+          ]
+        );
+      } catch {
+      }
       try {
         const result = await this.evaluateSingleCondition(conditionName, condition, context);
         results.push(result);
+        if (result.failed) {
+          try {
+            addEvent("fail_if.triggered", {
+              check: context.checkName,
+              scope: source,
+              name: conditionName,
+              expression: result.expression,
+              severity: result.severity,
+              halt_execution: result.haltExecution
+            });
+          } catch {
+          }
+          try {
+            addFailIfTriggered(context.checkName || "unknown", source);
+          } catch {
+          }
+        }
       } catch (error) {
         results.push({
           conditionName,
@@ -5721,6 +7430,16 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
       };
       const hasIssueWith = hasIssue;
       const hasFileWith = hasFileMatching;
+      const permissionHelpers = createPermissionHelpers(
+        context.authorAssociation,
+        detectLocalMode()
+      );
+      const hasMinPermission = permissionHelpers.hasMinPermission;
+      const isOwner = permissionHelpers.isOwner;
+      const isMember = permissionHelpers.isMember;
+      const isCollaborator = permissionHelpers.isCollaborator;
+      const isContributor = permissionHelpers.isContributor;
+      const isFirstTimer = permissionHelpers.isFirstTimer;
       const output = context.output || {};
       const issues = output.issues || [];
       const suggestions = [];
@@ -5751,11 +7470,20 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
       const env = context.env || {};
       const outputs = context.outputs || {};
       const debugData = context.debug || null;
+      const memoryStore = MemoryStore.getInstance();
+      const memoryAccessor = {
+        get: (key, ns) => memoryStore.get(key, ns),
+        has: (key, ns) => memoryStore.has(key, ns),
+        list: (ns) => memoryStore.list(ns),
+        getAll: (ns) => memoryStore.getAll(ns)
+      };
       const scope = {
         // Primary context variables
         output,
         outputs,
         debug: debugData,
+        // Memory accessor for fail_if expressions
+        memory: memoryAccessor,
         // Legacy compatibility variables
         issues,
         suggestions,
@@ -5789,7 +7517,14 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
         hasFileMatching,
         hasSuggestion,
         hasIssueWith,
-        hasFileWith
+        hasFileWith,
+        // Permission helpers
+        hasMinPermission,
+        isOwner,
+        isMember,
+        isCollaborator,
+        isContributor,
+        isFirstTimer
       };
       const raw = condition.trim();
       if (!this.sandbox) {
@@ -5838,7 +7573,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
   /**
    * Build the evaluation context for expressions
    */
-  buildEvaluationContext(checkName, checkSchema, checkGroup, reviewSummary, previousOutputs) {
+  buildEvaluationContext(checkName, checkSchema, checkGroup, reviewSummary, previousOutputs, authorAssociation) {
     const { issues, debug } = reviewSummary;
     const reviewSummaryWithOutput = reviewSummary;
     const {
@@ -5936,6 +7671,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
       }
     } catch {
     }
+    const memoryStore = MemoryStore.getInstance();
     const context = {
       output: aggregatedOutput,
       outputs: (() => {
@@ -5947,10 +7683,18 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
         }
         return outputs;
       })(),
+      // Add memory accessor for fail_if expressions
+      memory: {
+        get: (key, ns) => memoryStore.get(key, ns),
+        has: (key, ns) => memoryStore.has(key, ns),
+        list: (ns) => memoryStore.list(ns),
+        getAll: (ns) => memoryStore.getAll(ns)
+      },
       // Add basic context info for failure conditions
       checkName,
       schema: checkSchema,
-      group: checkGroup
+      group: checkGroup,
+      authorAssociation
     };
     if (debug) {
       context.debug = {
@@ -6278,7 +8022,7 @@ Please check your configuration and try again.`
     sections.push("---");
     sections.push("");
     sections.push(
-      "*Generated by [Visor](https://github.com/probelabs/visor) - AI-powered code review*"
+      "*Powered by [Visor](https://probelabs.com/visor) from [Probelabs](https://probelabs.com)*"
     );
     return sections.join("\n");
   }
@@ -6480,7 +8224,8 @@ Please check your configuration and try again.`
 
 // src/check-execution-engine.ts
 init_logger();
-import Sandbox3 from "@nyariv/sandboxjs";
+import Sandbox5 from "@nyariv/sandboxjs";
+init_fallback_ndjson();
 function getSafeEnvironmentVariables() {
   const safeEnvVars = [
     "CI",
@@ -6518,11 +8263,22 @@ var CheckExecutionEngine = class _CheckExecutionEngine {
   webhookContext;
   routingSandbox;
   executionStats = /* @__PURE__ */ new Map();
-  constructor(workingDirectory) {
+  // Event override to simulate alternate event (used during routing goto)
+  routingEventOverride;
+  // Cached GitHub context for context elevation when running in Actions
+  actionContext;
+  constructor(workingDirectory, octokit) {
     this.workingDirectory = workingDirectory || process.cwd();
     this.gitAnalyzer = new GitRepositoryAnalyzer(this.workingDirectory);
     this.providerRegistry = CheckProviderRegistry.getInstance();
     this.failureEvaluator = new FailureConditionEvaluator();
+    if (octokit) {
+      const repoEnv = process.env.GITHUB_REPOSITORY || "";
+      const [owner, repo] = repoEnv.split("/");
+      if (owner && repo) {
+        this.actionContext = { owner, repo, octokit };
+      }
+    }
     this.mockOctokit = this.createMockOctokit();
     this.reviewer = new PRReviewer(this.mockOctokit);
   }
@@ -6532,13 +8288,13 @@ var CheckExecutionEngine = class _CheckExecutionEngine {
   getRoutingSandbox() {
     if (this.routingSandbox) return this.routingSandbox;
     const globals = {
-      ...Sandbox3.SAFE_GLOBALS,
+      ...Sandbox5.SAFE_GLOBALS,
       Math,
       JSON,
       console: { log: console.log }
     };
-    const prototypeWhitelist = new Map(Sandbox3.SAFE_PROTOTYPES);
-    this.routingSandbox = new Sandbox3({ globals, prototypeWhitelist });
+    const prototypeWhitelist = new Map(Sandbox5.SAFE_PROTOTYPES);
+    this.routingSandbox = new Sandbox5({ globals, prototypeWhitelist });
     return this.routingSandbox;
   }
   redact(str, limit = 200) {
@@ -6578,10 +8334,12 @@ var CheckExecutionEngine = class _CheckExecutionEngine {
     let loopCount = 0;
     const seed = `${checkName}-${prInfo.number || "local"}`;
     const allAncestors = DependencyResolver.getAllDependencies(checkName, dependencyGraph.nodes);
+    let currentRouteOutput = void 0;
     const evalRunJs = async (expr, error) => {
       if (!expr) return [];
       try {
         const sandbox = this.getRoutingSandbox();
+        const eventObj = { name: prInfo.eventType || "manual" };
         const scope = {
           step: { id: checkName, tags: checkConfig.tags || [], group: checkConfig.group },
           attempt,
@@ -6593,6 +8351,7 @@ var CheckExecutionEngine = class _CheckExecutionEngine {
             parent: foreachContext.parent
           } : null,
           outputs: Object.fromEntries((dependencyResults || /* @__PURE__ */ new Map()).entries()),
+          output: currentRouteOutput,
           pr: {
             number: prInfo.number,
             title: prInfo.title,
@@ -6601,10 +8360,15 @@ var CheckExecutionEngine = class _CheckExecutionEngine {
             base: prInfo.base
           },
           files: prInfo.files,
-          env: getSafeEnvironmentVariables()
+          env: getSafeEnvironmentVariables(),
+          permissions: createPermissionHelpers(
+            resolveAssociationFromEvent(prInfo.eventContext, prInfo.authorAssociation),
+            detectLocalMode()
+          ),
+          event: eventObj
         };
         const code = `
-          const step = scope.step; const attempt = scope.attempt; const loop = scope.loop; const error = scope.error; const foreach = scope.foreach; const outputs = scope.outputs; const pr = scope.pr; const files = scope.files; const env = scope.env; const log = (...a)=>console.log('\u{1F50D} Debug:',...a);
+          const step = scope.step; const attempt = scope.attempt; const loop = scope.loop; const error = scope.error; const foreach = scope.foreach; const outputs = scope.outputs; const output = scope.output; const pr = scope.pr; const files = scope.files; const env = scope.env; const event = scope.event; const log = (...a)=>console.log('\u{1F50D} Debug:',...a); const hasMinPermission = scope.permissions.hasMinPermission; const isOwner = scope.permissions.isOwner; const isMember = scope.permissions.isMember; const isCollaborator = scope.permissions.isCollaborator; const isContributor = scope.permissions.isContributor; const isFirstTimer = scope.permissions.isFirstTimer;
           const __fn = () => {
 ${expr}
 };
@@ -6628,6 +8392,7 @@ ${expr}
       if (!expr) return null;
       try {
         const sandbox = this.getRoutingSandbox();
+        const eventObj = { name: prInfo.eventType || "manual" };
         const scope = {
           step: { id: checkName, tags: checkConfig.tags || [], group: checkConfig.group },
           attempt,
@@ -6639,6 +8404,7 @@ ${expr}
             parent: foreachContext.parent
           } : null,
           outputs: Object.fromEntries((dependencyResults || /* @__PURE__ */ new Map()).entries()),
+          output: currentRouteOutput,
           pr: {
             number: prInfo.number,
             title: prInfo.title,
@@ -6647,10 +8413,15 @@ ${expr}
             base: prInfo.base
           },
           files: prInfo.files,
-          env: getSafeEnvironmentVariables()
+          env: getSafeEnvironmentVariables(),
+          permissions: createPermissionHelpers(
+            resolveAssociationFromEvent(prInfo.eventContext, prInfo.authorAssociation),
+            detectLocalMode()
+          ),
+          event: eventObj
         };
         const code = `
-          const step = scope.step; const attempt = scope.attempt; const loop = scope.loop; const error = scope.error; const foreach = scope.foreach; const outputs = scope.outputs; const pr = scope.pr; const files = scope.files; const env = scope.env; const log = (...a)=>console.log('\u{1F50D} Debug:',...a);
+          const step = scope.step; const attempt = scope.attempt; const loop = scope.loop; const error = scope.error; const foreach = scope.foreach; const outputs = scope.outputs; const output = scope.output; const pr = scope.pr; const files = scope.files; const env = scope.env; const event = scope.event; const log = (...a)=>console.log('\u{1F50D} Debug:',...a); const hasMinPermission = scope.permissions.hasMinPermission; const isOwner = scope.permissions.isOwner; const isMember = scope.permissions.isMember; const isCollaborator = scope.permissions.isCollaborator; const isContributor = scope.permissions.isContributor; const isFirstTimer = scope.permissions.isFirstTimer;
           const __fn = () => {
 ${expr}
 };
@@ -6686,7 +8457,7 @@ ${expr}
       dfs(name);
       return Array.from(new Set(acc));
     };
-    const executeNamedCheckInline = async (target) => {
+    const executeNamedCheckInline = async (target, opts) => {
       const targetCfg = config?.checks?.[target];
       if (!targetCfg) {
         throw new Error(`on_* referenced unknown check '${target}'`);
@@ -6710,6 +8481,10 @@ ${expr}
       const providerType = targetCfg.type || "ai";
       const prov = this.providerRegistry.getProviderOrThrow(providerType);
       this.setProviderWebhookContext(prov);
+      const enrichedEventContext = {
+        ...prInfo.eventContext,
+        ...this.actionContext?.octokit ? { octokit: this.actionContext.octokit } : {}
+      };
       const provCfg = {
         type: providerType,
         prompt: targetCfg.prompt,
@@ -6718,15 +8493,17 @@ ${expr}
         schema: targetCfg.schema,
         group: targetCfg.group,
         checkName: target,
-        eventContext: prInfo.eventContext,
+        eventContext: enrichedEventContext,
         transform: targetCfg.transform,
         transform_js: targetCfg.transform_js,
         env: targetCfg.env,
         forEach: targetCfg.forEach,
+        // Include provider-specific keys (e.g., op/values for github)
+        ...targetCfg,
         ai: {
+          ...targetCfg.ai || {},
           timeout: providerConfig.ai?.timeout || 6e5,
-          debug: !!debug,
-          ...targetCfg.ai || {}
+          debug: !!debug
         }
       };
       const targetDeps = getAllDepsFromConfig(target);
@@ -6750,7 +8527,34 @@ ${expr}
         const execStr = provCfg.exec;
         if (execStr) log2(`\u{1F527} Debug: inline exec '${target}' command: ${execStr}`);
       }
-      const r = await prov.execute(prInfo, provCfg, depResults, sessionInfo);
+      let prInfoForInline = prInfo;
+      const prevEventOverride = this.routingEventOverride;
+      if (opts?.eventOverride) {
+        const elevated = await this.elevateContextToPullRequest(
+          { ...prInfo, eventType: opts.eventOverride },
+          opts.eventOverride,
+          log2,
+          debug
+        );
+        if (elevated) {
+          prInfoForInline = elevated;
+        } else {
+          prInfoForInline = { ...prInfo, eventType: opts.eventOverride };
+        }
+        this.routingEventOverride = opts.eventOverride;
+        const msg = `\u21AA goto_event: inline '${target}' with event=${opts.eventOverride}${elevated ? " (elevated to PR context)" : ""}`;
+        if (debug) log2(`\u{1F527} Debug: ${msg}`);
+        try {
+          (init_logger(), __toCommonJS(logger_exports)).logger.info(msg);
+        } catch {
+        }
+      }
+      let r;
+      try {
+        r = await prov.execute(prInfoForInline, provCfg, depResults, sessionInfo);
+      } finally {
+        this.routingEventOverride = prevEventOverride;
+      }
       const enrichedIssues = (r.issues || []).map((issue) => ({
         ...issue,
         checkName: target,
@@ -6767,7 +8571,18 @@ ${expr}
     };
     while (true) {
       try {
+        try {
+          emitNdjsonFallback("visor.provider", {
+            "visor.check.id": checkName,
+            "visor.provider.type": providerConfig.type || "ai"
+          });
+        } catch {
+        }
         const res = await provider.execute(prInfo, providerConfig, dependencyResults, sessionInfo);
+        try {
+          currentRouteOutput = res?.output;
+        } catch {
+        }
         const hasSoftFailure = (res.issues || []).some(
           (i) => i.severity === "error" || i.severity === "critical"
         );
@@ -6786,6 +8601,12 @@ ${expr}
           runList = Array.from(new Set(runList));
           if (debug) log2(`\u{1F527} Debug: on_fail.run (soft) list = [${runList.join(", ")}]`);
           if (runList.length > 0) {
+            try {
+              (init_logger(), __toCommonJS(logger_exports)).logger.info(
+                `\u25B6 on_fail.run: scheduling [${runList.join(", ")}] after '${checkName}'`
+              );
+            } catch {
+            }
             loopCount++;
             if (loopCount > maxLoops) {
               throw new Error(
@@ -6801,6 +8622,12 @@ ${expr}
           if (!target && onFail.goto) target = onFail.goto;
           if (debug) log2(`\u{1F527} Debug: on_fail.goto (soft) target = ${target}`);
           if (target) {
+            try {
+              (init_logger(), __toCommonJS(logger_exports)).logger.info(
+                `\u21AA on_fail.goto: jumping to '${target}' from '${checkName}'`
+              );
+            } catch {
+            }
             if (!allAncestors.includes(target)) {
               if (debug)
                 log2(
@@ -6813,7 +8640,7 @@ ${expr}
                   `Routing loop budget exceeded (max_loops=${maxLoops}) during on_fail goto`
                 );
               }
-              await executeNamedCheckInline(target);
+              await executeNamedCheckInline(target, { eventOverride: onFail.goto_event });
             }
           }
           const retryMax = onFail.retry?.max ?? 0;
@@ -6836,10 +8663,17 @@ ${expr}
           return res;
         }
         let needRerun = false;
+        let rerunEventOverride;
         if (onSuccess) {
           const dynamicRun = await evalRunJs(onSuccess.run_js);
           const runList = [...onSuccess.run || [], ...dynamicRun].filter(Boolean);
           if (runList.length > 0) {
+            try {
+              (init_logger(), __toCommonJS(logger_exports)).logger.info(
+                `\u25B6 on_success.run: scheduling [${Array.from(new Set(runList)).join(", ")}] after '${checkName}'`
+              );
+            } catch {
+            }
             loopCount++;
             if (loopCount > maxLoops) {
               throw new Error(
@@ -6849,15 +8683,106 @@ ${expr}
             for (const stepId of Array.from(new Set(runList))) {
               await executeNamedCheckInline(stepId);
             }
+          } else {
+            try {
+              const assoc = resolveAssociationFromEvent(
+                prInfo?.eventContext,
+                prInfo.authorAssociation
+              );
+              const perms = createPermissionHelpers(assoc, detectLocalMode());
+              const allowedMember = perms.hasMinPermission("MEMBER");
+              let intent;
+              try {
+                intent = res?.output?.intent;
+              } catch {
+              }
+              (init_logger(), __toCommonJS(logger_exports)).logger.info(
+                `\u23ED on_success.run: none after '${checkName}' (event=${prInfo.eventType || "manual"}, intent=${intent || "n/a"}, assoc=${assoc || "unknown"}, memberOrHigher=${allowedMember})`
+              );
+            } catch {
+            }
           }
           let target = await evalGotoJs(onSuccess.goto_js);
           if (!target && onSuccess.goto) target = onSuccess.goto;
           if (target) {
+            try {
+              (init_logger(), __toCommonJS(logger_exports)).logger.info(
+                `\u21AA on_success.goto: jumping to '${target}' from '${checkName}'`
+              );
+            } catch {
+            }
             if (!allAncestors.includes(target)) {
-              if (debug)
-                log2(
-                  `\u26A0\uFE0F Debug: on_success.goto '${target}' is not an ancestor of '${checkName}' \u2014 skipping`
-                );
+              const prevEventOverride2 = this.routingEventOverride;
+              if (onSuccess.goto_event) {
+                this.routingEventOverride = onSuccess.goto_event;
+              }
+              try {
+                const cfgChecks = config?.checks || {};
+                const forwardSet = /* @__PURE__ */ new Set();
+                if (cfgChecks[target]) forwardSet.add(target);
+                const dependsOn = (name, root) => {
+                  const seen = /* @__PURE__ */ new Set();
+                  const dfs = (n) => {
+                    if (seen.has(n)) return false;
+                    seen.add(n);
+                    const deps = cfgChecks[n]?.depends_on || [];
+                    if (deps.includes(root)) return true;
+                    return deps.some((d) => dfs(d));
+                  };
+                  return dfs(name);
+                };
+                const ev = onSuccess.goto_event || prInfo.eventType || "issue_comment";
+                for (const name of Object.keys(cfgChecks)) {
+                  if (name === target) continue;
+                  const onArr = cfgChecks[name]?.on;
+                  const eventMatches = !onArr || Array.isArray(onArr) && onArr.includes(ev);
+                  if (!eventMatches) continue;
+                  if (dependsOn(name, target)) forwardSet.add(name);
+                }
+                const order = [];
+                const inSet = (n) => forwardSet.has(n);
+                const tempMarks = /* @__PURE__ */ new Set();
+                const permMarks = /* @__PURE__ */ new Set();
+                const stack = [];
+                const visit = (n) => {
+                  if (permMarks.has(n)) return;
+                  if (tempMarks.has(n)) {
+                    const idx = stack.indexOf(n);
+                    const cyclePath = idx >= 0 ? [...stack.slice(idx), n] : [n];
+                    throw new Error(
+                      `Cycle detected in forward-run dependency subset: ${cyclePath.join(" -> ")}`
+                    );
+                  }
+                  tempMarks.add(n);
+                  stack.push(n);
+                  const deps = (cfgChecks[n]?.depends_on || []).filter(inSet);
+                  for (const d of deps) visit(d);
+                  stack.pop();
+                  tempMarks.delete(n);
+                  permMarks.add(n);
+                  order.push(n);
+                };
+                for (const n of forwardSet) visit(n);
+                for (const stepId of order) {
+                  if (!this.executionStats.has(stepId)) this.initializeCheckStats(stepId);
+                  const childStart = this.recordIterationStart(stepId);
+                  const childRes = await executeNamedCheckInline(stepId, {
+                    eventOverride: onSuccess.goto_event
+                  });
+                  const childIssues = (childRes.issues || []).map((i) => ({ ...i }));
+                  const childSuccess = !this.hasFatal(childIssues);
+                  const childOutput = childRes?.output;
+                  this.recordIterationComplete(
+                    stepId,
+                    childStart,
+                    childSuccess,
+                    childIssues,
+                    childOutput
+                  );
+                }
+              } finally {
+                this.routingEventOverride = prevEventOverride2;
+              }
             } else {
               loopCount++;
               if (loopCount > maxLoops) {
@@ -6865,14 +8790,22 @@ ${expr}
                   `Routing loop budget exceeded (max_loops=${maxLoops}) during on_success goto`
                 );
               }
-              await executeNamedCheckInline(target);
+              await executeNamedCheckInline(target, { eventOverride: onSuccess.goto_event });
               needRerun = true;
+              rerunEventOverride = onSuccess.goto_event;
             }
           }
         }
         if (needRerun) {
           if (debug) log2(`\u{1F504} Debug: Re-running '${checkName}' after on_success.goto`);
+          try {
+            (init_logger(), __toCommonJS(logger_exports)).logger.info(`\u{1F501} Re-running '${checkName}' after goto`);
+          } catch {
+          }
+          const prev = this.routingEventOverride;
+          if (rerunEventOverride) this.routingEventOverride = rerunEventOverride;
           attempt++;
+          this.routingEventOverride = prev;
           continue;
         }
         return res;
@@ -6885,6 +8818,12 @@ ${expr}
         let runList = [...onFail.run || [], ...dynamicRun].filter(Boolean);
         runList = Array.from(new Set(runList));
         if (runList.length > 0) {
+          try {
+            (init_logger(), __toCommonJS(logger_exports)).logger.info(
+              `\u25B6 on_fail.run: scheduling [${runList.join(", ")}] after '${checkName}'`
+            );
+          } catch {
+          }
           loopCount++;
           if (loopCount > maxLoops) {
             throw new Error(
@@ -6899,6 +8838,12 @@ ${expr}
         let target = await evalGotoJs(onFail.goto_js, lastError);
         if (!target && onFail.goto) target = onFail.goto;
         if (target) {
+          try {
+            (init_logger(), __toCommonJS(logger_exports)).logger.info(
+              `\u21AA on_fail.goto: jumping to '${target}' from '${checkName}'`
+            );
+          } catch {
+          }
           if (!allAncestors.includes(target)) {
             if (debug)
               log2(
@@ -6911,7 +8856,7 @@ ${expr}
                 `Routing loop budget exceeded (max_loops=${maxLoops}) during on_fail goto`
               );
             }
-            await executeNamedCheckInline(target);
+            await executeNamedCheckInline(target, { eventOverride: onFail.goto_event });
           }
         }
         const retryMax = onFail.retry?.max ?? 0;
@@ -6988,6 +8933,11 @@ ${expr}
     const startTime = Date.now();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     try {
+      if (options.config?.memory) {
+        const memoryStore = MemoryStore.getInstance(options.config.memory);
+        await memoryStore.initialize();
+        logger.debug("Memory store initialized");
+      }
       this.webhookContext = options.webhookContext;
       const logFn = (msg) => logger.info(msg);
       if (options.githubChecks?.enabled && options.githubChecks.octokit) {
@@ -7284,6 +9234,21 @@ ${expr}
       );
     }
     checks = tagFilteredChecks;
+    if (!this.actionContext) {
+      try {
+        const repoEnv = process.env.GITHUB_REPOSITORY || "";
+        const [owner, repo] = repoEnv.split("/");
+        const token = process.env["INPUT_GITHUB-TOKEN"] || process.env["GITHUB_TOKEN"];
+        if (owner && repo) {
+          this.actionContext = { owner, repo };
+          if (token) {
+            const { Octokit } = await import("@octokit/rest");
+            this.actionContext.octokit = new Octokit({ auth: token });
+          }
+        }
+      } catch {
+      }
+    }
     if (checks.length === 0) {
       logger.warn("\u26A0\uFE0F No checks remain after tag filtering");
       return {
@@ -7298,10 +9263,14 @@ ${expr}
       const checkConfig = config.checks[checkName];
       return checkConfig?.depends_on && checkConfig.depends_on.length > 0;
     });
-    if (checks.length > 1 || hasDependencies) {
+    const hasRouting = checks.some((checkName) => {
+      const c = config.checks[checkName];
+      return Boolean(c?.on_success || c?.on_fail);
+    });
+    if (checks.length > 1 || hasDependencies || hasRouting) {
       if (debug) {
         logger.debug(
-          `\u{1F527} Debug: Using grouped dependency-aware execution for ${checks.length} checks (has dependencies: ${hasDependencies})`
+          `\u{1F527} Debug: Using grouped dependency-aware execution for ${checks.length} checks (has dependencies: ${hasDependencies}, has routing: ${hasRouting})`
         );
       }
       return await this.executeGroupedDependencyAwareChecks(
@@ -7384,7 +9353,12 @@ ${expr}
       }
     }
     if (config && (config.fail_if || checkConfig.fail_if)) {
-      const failureResults = await this.evaluateFailureConditions(checkName, result, config);
+      const failureResults = await this.evaluateFailureConditions(
+        checkName,
+        result,
+        config,
+        prInfo
+      );
       if (failureResults.length > 0) {
         const failureIssues = failureResults.filter((f) => f.failed).map((f) => ({
           file: "system",
@@ -7402,6 +9376,7 @@ ${expr}
       checkName,
       content,
       group: checkConfig.group || "default",
+      output: result.output,
       debug: result.debug,
       issues: result.issues
       // Include structured issues
@@ -7487,8 +9462,24 @@ ${expr}
    */
   async convertReviewSummaryToGroupedResults(reviewSummary, checks, config, prInfo) {
     const groupedResults = {};
-    const contentMap = reviewSummary.__contents;
-    for (const checkName of checks) {
+    const agg = reviewSummary;
+    const contentMap = agg.__contents;
+    const outputMap = agg.__outputs;
+    const allCheckNames = [];
+    const seen = /* @__PURE__ */ new Set();
+    const pushUnique = (n) => {
+      if (!n) return;
+      if (!seen.has(n)) {
+        seen.add(n);
+        allCheckNames.push(n);
+      }
+    };
+    for (const n of checks) pushUnique(n);
+    if (contentMap) for (const n of Object.keys(contentMap)) pushUnique(n);
+    if (outputMap) for (const n of Object.keys(outputMap)) pushUnique(n);
+    for (const issue of reviewSummary.issues || []) pushUnique(issue.checkName);
+    if (Array.isArray(agg.__executed)) for (const n of agg.__executed) pushUnique(n);
+    for (const checkName of allCheckNames) {
       const checkConfig = config?.checks?.[checkName];
       if (!checkConfig) continue;
       const checkIssues = (reviewSummary.issues || []).filter(
@@ -7499,17 +9490,38 @@ ${expr}
         debug: reviewSummary.debug
       };
       if (contentMap?.[checkName]) {
-        const summaryWithContent = checkSummary;
-        summaryWithContent.content = contentMap[checkName];
+        checkSummary.content = contentMap[checkName];
+      }
+      if (outputMap && Object.prototype.hasOwnProperty.call(outputMap, checkName)) {
+        checkSummary.output = outputMap[checkName];
+      }
+      let content = "";
+      let issuesForCheck = [...checkIssues];
+      try {
+        content = await this.renderCheckContent(checkName, checkSummary, checkConfig, prInfo);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`\u274C Failed to render content for check '${checkName}': ${msg}`);
+        issuesForCheck = [
+          ...issuesForCheck,
+          {
+            file: "system",
+            line: 0,
+            ruleId: `${checkName}/render-error`,
+            message: `Template rendering failed: ${msg}`,
+            severity: "error",
+            category: "logic"
+          }
+        ];
       }
-      const content = await this.renderCheckContent(checkName, checkSummary, checkConfig, prInfo);
       const checkResult = {
         checkName,
         content,
         group: checkConfig.group || "default",
+        output: checkSummary.output,
         debug: reviewSummary.debug,
-        issues: checkIssues
-        // Include structured issues
+        issues: issuesForCheck
+        // Include structured issues + rendering error if any
       };
       const group = checkResult.group;
       if (!groupedResults[group]) {
@@ -7575,13 +9587,20 @@ ${expr}
    * @returns true if the check should run, false if it should be skipped
    */
   async evaluateCheckCondition(checkName, condition, prInfo, results, debug) {
+    const override = this.routingEventOverride;
+    const eventName = override ? override.startsWith("pr_") ? "pull_request" : override === "issue_comment" ? "issue_comment" : override.startsWith("issue_") ? "issues" : "manual" : "issue_comment";
+    const commenterAssoc = resolveAssociationFromEvent(
+      prInfo?.eventContext,
+      prInfo.authorAssociation
+    );
     const shouldRun = await this.failureEvaluator.evaluateIfCondition(checkName, condition, {
       branch: prInfo.head,
       baseBranch: prInfo.base,
       filesChanged: prInfo.files.map((f) => f.filename),
-      event: "issue_comment",
+      event: eventName,
       environment: getSafeEnvironmentVariables(),
-      previousResults: results
+      previousResults: results,
+      authorAssociation: commenterAssoc
     });
     if (!shouldRun && debug) {
       logger.debug(`\u{1F527} Debug: Skipping check '${checkName}' - if condition evaluated to false`);
@@ -7596,7 +9615,7 @@ ${expr}
     if (typeof directContent === "string" && directContent.trim()) {
       return directContent.trim();
     }
-    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-KDECAJTV.mjs");
+    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-AFKRYROF.mjs");
     const fs5 = await import("fs/promises");
     const path5 = await import("path");
     const liquid = createExtendedLiquid2({
@@ -7615,6 +9634,7 @@ ${expr}
       schemaName = checkConfig.schema || "plain";
     }
     let templateContent;
+    let enrichAssistantContext = false;
     if (checkConfig.template) {
       if (checkConfig.template.content) {
         templateContent = checkConfig.template.content;
@@ -7633,16 +9653,109 @@ ${expr}
       }
       const templatePath = path5.join(__dirname, `../output/${sanitizedSchema}/template.liquid`);
       templateContent = await fs5.readFile(templatePath, "utf-8");
+      if (sanitizedSchema === "issue-assistant") {
+        enrichAssistantContext = true;
+      }
     }
     const filteredIssues = (reviewSummary.issues || []).filter(
       (issue) => !(issue.file === "system" && issue.line === 0)
     );
     const templateData = {
       issues: filteredIssues,
-      checkName
+      checkName,
+      // Expose structured output for custom schemas/templates (e.g., overview)
+      // This allows templates to render fields like output.text or output.tags
+      output: reviewSummary.output
     };
-    const rendered = await liquid.parseAndRender(templateContent, templateData);
-    return rendered.trim();
+    if (enrichAssistantContext) {
+      let authorAssociation;
+      let eventName = "manual";
+      let eventAction;
+      try {
+        const anyInfo = _prInfo;
+        authorAssociation = resolveAssociationFromEvent(
+          anyInfo?.eventContext,
+          anyInfo?.authorAssociation
+        );
+        eventName = anyInfo?.eventContext?.event_name || anyInfo?.eventType || "manual";
+        eventAction = anyInfo?.eventContext?.action;
+      } catch {
+      }
+      templateData.authorAssociation = authorAssociation;
+      templateData.event = { name: eventName, action: eventAction };
+    }
+    const { withPermissionsContext } = await import("./liquid-extensions-AFKRYROF.mjs");
+    let authorAssociationForFilters;
+    try {
+      const anyInfo = _prInfo;
+      authorAssociationForFilters = resolveAssociationFromEvent(
+        anyInfo?.eventContext,
+        anyInfo?.authorAssociation
+      );
+    } catch {
+    }
+    let rendered;
+    if (typeof withPermissionsContext === "function") {
+      rendered = await withPermissionsContext(
+        { authorAssociation: authorAssociationForFilters },
+        async () => await liquid.parseAndRender(templateContent, templateData)
+      );
+      if (rendered === void 0 || rendered === null) {
+        rendered = await liquid.parseAndRender(templateContent, templateData);
+      }
+    } else {
+      rendered = await liquid.parseAndRender(templateContent, templateData);
+    }
+    const finalRendered = rendered.trim();
+    try {
+      const { emitMermaidFromMarkdown } = await import("./mermaid-telemetry-LZGDD35I.mjs");
+      emitMermaidFromMarkdown(checkName, finalRendered, "content");
+    } catch {
+    }
+    return finalRendered;
+  }
+  /**
+   * Attempt to elevate an issue/issue_comment context to full PR context when routing via goto_event.
+   * Returns a new PRInfo with files/diff when possible; otherwise returns null.
+   */
+  async elevateContextToPullRequest(prInfo, targetEvent, log2, debug) {
+    try {
+      if (targetEvent !== "pr_opened" && targetEvent !== "pr_updated") return null;
+      const isIssueContext = prInfo.isIssue === true;
+      const ctx = prInfo.eventContext || {};
+      const isPRThread = Boolean(ctx?.issue?.pull_request);
+      if (!isIssueContext || !isPRThread) return null;
+      let owner = this.actionContext?.owner;
+      let repo = this.actionContext?.repo;
+      if (!owner || !repo) {
+        const repoEnv = process.env.GITHUB_REPOSITORY || "";
+        [owner, repo] = repoEnv.split("/");
+      }
+      if (!owner || !repo) return null;
+      const prNumber = ctx?.issue?.number || prInfo.number;
+      if (!prNumber) return null;
+      let octokit = this.actionContext?.octokit;
+      if (!octokit) {
+        const token = process.env["INPUT_GITHUB-TOKEN"] || process.env["GITHUB_TOKEN"];
+        if (!token) return null;
+        const { Octokit } = await import("@octokit/rest");
+        octokit = new Octokit({ auth: token });
+      }
+      const analyzer = new PRAnalyzer(octokit);
+      const elevated = await analyzer.fetchPRDiff(owner, repo, prNumber, void 0, targetEvent);
+      elevated.eventContext = prInfo.eventContext || ctx;
+      elevated.isPRContext = true;
+      elevated.includeCodeContext = true;
+      if (debug)
+        log2?.(`\u{1F527} Debug: Elevated context to PR #${prNumber} for goto_event=${targetEvent}`);
+      return elevated;
+    } catch (e) {
+      if (debug) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log2?.(`\u26A0\uFE0F Debug: Context elevation to PR failed: ${msg}`);
+      }
+      return null;
+    }
   }
   /**
    * Execute multiple checks with dependency awareness - intelligently parallel and sequential
@@ -7828,10 +9941,12 @@ ${expr}
             message: extendedCheckConfig.message,
             env: checkConfig.env,
             forEach: checkConfig.forEach,
+            // Pass through any provider-specific keys (e.g., op/values for github provider)
+            ...checkConfig,
             ai: {
+              ...checkConfig.ai || {},
               timeout: timeout || 6e5,
-              debug,
-              ...checkConfig.ai || {}
+              debug
             }
           };
           const dependencyResults = /* @__PURE__ */ new Map();
@@ -8008,12 +10123,21 @@ ${expr}
                     transform_js: childCfg.transform_js,
                     env: childCfg.env,
                     forEach: childCfg.forEach,
+                    // Include provider-specific keys like op/values for non-AI providers
+                    ...childCfg,
                     ai: {
+                      ...childCfg.ai || {},
                       timeout: timeout || 6e5,
-                      debug,
-                      ...childCfg.ai || {}
+                      debug
                     }
                   };
+                  try {
+                    emitNdjsonSpanWithEvents("visor.check", { "visor.check.id": checkName }, [
+                      { name: "check.started" },
+                      { name: "check.completed" }
+                    ]);
+                  } catch {
+                  }
                   const childDepResults = /* @__PURE__ */ new Map();
                   const childAllDeps = DependencyResolver.getAllDependencies(
                     childName,
@@ -8136,6 +10260,18 @@ ${expr}
                 }
               };
               const itemTasks = forEachItems.map((item, itemIndex) => async () => {
+                try {
+                  emitNdjsonSpanWithEvents(
+                    "visor.foreach.item",
+                    {
+                      "visor.check.id": checkName,
+                      "visor.foreach.index": itemIndex,
+                      "visor.foreach.total": forEachItems.length
+                    },
+                    []
+                  );
+                } catch {
+                }
                 const forEachDependencyResults = /* @__PURE__ */ new Map();
                 for (const [depName, depResult] of dependencyResults) {
                   if (forEachParents.includes(depName)) {
@@ -8738,6 +10874,13 @@ ${expr}
               debug,
               results
             );
+            try {
+              emitNdjsonSpanWithEvents("visor.check", { "visor.check.id": checkName }, [
+                { name: "check.started" },
+                { name: "check.completed" }
+              ]);
+            } catch {
+            }
             if (config && (config.fail_if || checkConfig.fail_if)) {
               const failureResults = await this.evaluateFailureConditions(
                 checkName,
@@ -8905,6 +11048,13 @@ ${error.stack || ""}` : String(error);
             reviewSummaryWithOutput.forEachItems = normalizedOutput;
             reviewSummaryWithOutput.isForEach = true;
           }
+          try {
+            emitNdjsonSpanWithEvents("visor.check", { "visor.check.id": checkName }, [
+              { name: "check.started" },
+              { name: "check.completed" }
+            ]);
+          } catch {
+          }
           results.set(checkName, reviewResult);
         } else {
           const errorSummary = {
@@ -9018,6 +11168,12 @@ ${error.stack || ""}` : String(error);
           `\u{1F527} Debug: Starting check: ${checkName} with prompt type: ${typeof checkConfig.prompt}`
         );
         if (checkConfig.if) {
+          const override = this.routingEventOverride;
+          const eventName = override ? override.startsWith("pr_") ? "pull_request" : override === "issue_comment" ? "issue_comment" : override.startsWith("issue_") ? "issues" : "manual" : "issue_comment";
+          const commenterAssoc = resolveAssociationFromEvent(
+            prInfo?.eventContext,
+            prInfo.authorAssociation
+          );
           const shouldRun = await this.failureEvaluator.evaluateIfCondition(
             checkName,
             checkConfig.if,
@@ -9025,11 +11181,12 @@ ${error.stack || ""}` : String(error);
               branch: prInfo.head,
               baseBranch: prInfo.base,
               filesChanged: prInfo.files.map((f) => f.filename),
-              event: "issue_comment",
-              // Command triggered from comment
+              event: eventName,
+              // honor routing override if present
               environment: getSafeEnvironmentVariables(),
-              previousResults: /* @__PURE__ */ new Map()
+              previousResults: /* @__PURE__ */ new Map(),
               // No previous results in parallel execution
+              authorAssociation: commenterAssoc
             }
           );
           if (!shouldRun) {
@@ -9171,6 +11328,7 @@ ${error.stack || ""}` : String(error);
     const aggregatedIssues = [];
     const debugInfo = [];
     const contentMap = {};
+    const outputsMap = {};
     const stats = DependencyResolver.getExecutionStats(dependencyGraph);
     const executionInfo = [
       stoppedEarly ? `\u{1F6D1} Dependency-aware execution stopped early (fail-fast):` : `\u{1F50D} Dependency-aware execution completed:`,
@@ -9182,6 +11340,7 @@ ${error.stack || ""}` : String(error);
       stoppedEarly ? `  - Stopped early due to fail-fast behavior` : ``
     ].filter(Boolean);
     debugInfo.push(...executionInfo);
+    const processed = /* @__PURE__ */ new Set();
     for (const executionGroup of dependencyGraph.executionOrder) {
       for (const checkName of executionGroup.parallel) {
         const result = results.get(checkName);
@@ -9199,6 +11358,7 @@ ${error.stack || ""}` : String(error);
             `\u2705 Check "${checkName}" completed: ${(result.issues || []).length} issues found (level ${executionGroup.level})`
           );
         }
+        processed.add(checkName);
         const nonInternalIssues = (result.issues || []).filter(
           (issue) => !issue.ruleId?.endsWith("/__skipped")
         );
@@ -9208,7 +11368,29 @@ ${error.stack || ""}` : String(error);
         if (typeof resultContent === "string" && resultContent.trim()) {
           contentMap[checkName] = resultContent.trim();
         }
+        if (resultSummary.output !== void 0) {
+          outputsMap[checkName] = resultSummary.output;
+        }
+      }
+    }
+    for (const [checkName, result] of results.entries()) {
+      if (processed.has(checkName)) continue;
+      if (!result) continue;
+      const nonInternalIssues = (result.issues || []).filter(
+        (issue) => !issue.ruleId?.endsWith("/__skipped")
+      );
+      aggregatedIssues.push(...nonInternalIssues);
+      const resultSummary = result;
+      const resultContent = resultSummary.content;
+      if (typeof resultContent === "string" && resultContent.trim()) {
+        contentMap[checkName] = resultContent.trim();
+      }
+      if (resultSummary.output !== void 0) {
+        outputsMap[checkName] = resultSummary.output;
       }
+      debugInfo.push(
+        `\u2705 (dynamic) Check "${checkName}" included: ${(result.issues || []).length} issues found`
+      );
     }
     if (debug) {
       console.error(
@@ -9267,6 +11449,10 @@ ${result.debug.rawResponse}`).join("\n\n"),
     if (Object.keys(contentMap).length > 0) {
       summary.__contents = contentMap;
     }
+    if (Object.keys(outputsMap).length > 0) {
+      summary.__outputs = outputsMap;
+    }
+    summary.__executed = Array.from(results.keys());
     return summary;
   }
   /**
@@ -9590,7 +11776,7 @@ ${result.value.result.debug.rawResponse}`;
   /**
    * Evaluate failure conditions for a check result
    */
-  async evaluateFailureConditions(checkName, reviewSummary, config) {
+  async evaluateFailureConditions(checkName, reviewSummary, config, prInfo) {
     if (!config) {
       return [];
     }
@@ -9609,7 +11795,50 @@ ${result.value.result.debug.rawResponse}`;
           reviewSummary,
           globalFailIf
         );
+        try {
+          addEvent("fail_if.evaluated", {
+            check: checkName,
+            scope: "global",
+            name: "global_fail_if",
+            expression: globalFailIf
+          });
+        } catch {
+        }
         if (failed) {
+          try {
+            addEvent("fail_if.triggered", {
+              check: checkName,
+              scope: "global",
+              name: "global_fail_if",
+              expression: globalFailIf,
+              severity: "error"
+            });
+          } catch {
+          }
+          try {
+            addFailIfTriggered(checkName, "global");
+          } catch {
+          }
+          try {
+            const { emitNdjsonSpanWithEvents: emitNdjsonSpanWithEvents2 } = (init_fallback_ndjson(), __toCommonJS(fallback_ndjson_exports));
+            emitNdjsonSpanWithEvents2(
+              "visor.fail_if",
+              { check: checkName, scope: "global", name: "global_fail_if" },
+              [
+                {
+                  name: "fail_if.triggered",
+                  attrs: {
+                    check: checkName,
+                    scope: "global",
+                    name: "global_fail_if",
+                    expression: globalFailIf,
+                    severity: "error"
+                  }
+                }
+              ]
+            );
+          } catch {
+          }
           logger.warn(`\u26A0\uFE0F  Check "${checkName}" - global fail_if condition met: ${globalFailIf}`);
           results.push({
             conditionName: "global_fail_if",
@@ -9631,7 +11860,78 @@ ${result.value.result.debug.rawResponse}`;
           reviewSummary,
           checkFailIf
         );
+        try {
+          addEvent("fail_if.evaluated", {
+            check: checkName,
+            scope: "check",
+            name: `${checkName}_fail_if`,
+            expression: checkFailIf
+          });
+        } catch {
+        }
+        try {
+          const { emitNdjsonSpanWithEvents: emitNdjsonSpanWithEvents2 } = (init_fallback_ndjson(), __toCommonJS(fallback_ndjson_exports));
+          emitNdjsonSpanWithEvents2(
+            "visor.fail_if",
+            { check: checkName, scope: "check", name: `${checkName}_fail_if` },
+            [
+              {
+                name: "fail_if.evaluated",
+                attrs: {
+                  check: checkName,
+                  scope: "check",
+                  name: `${checkName}_fail_if`,
+                  expression: checkFailIf
+                }
+              }
+            ]
+          );
+        } catch {
+        }
         if (failed) {
+          try {
+            addEvent("fail_if.triggered", {
+              check: checkName,
+              scope: "check",
+              name: `${checkName}_fail_if`,
+              expression: checkFailIf,
+              severity: "error"
+            });
+          } catch {
+          }
+          try {
+            addEvent("fail_if.evaluated", {
+              check: checkName,
+              scope: "check",
+              name: `${checkName}_fail_if`,
+              expression: checkFailIf
+            });
+          } catch {
+          }
+          try {
+            addFailIfTriggered(checkName, "check");
+          } catch {
+          }
+          try {
+            const { emitNdjsonSpanWithEvents: emitNdjsonSpanWithEvents2 } = (init_fallback_ndjson(), __toCommonJS(fallback_ndjson_exports));
+            emitNdjsonSpanWithEvents2(
+              "visor.fail_if",
+              { check: checkName, scope: "check", name: `${checkName}_fail_if` },
+              [
+                {
+                  name: "fail_if.triggered",
+                  attrs: {
+                    check: checkName,
+                    scope: "check",
+                    name: `${checkName}_fail_if`,
+                    expression: checkFailIf,
+                    severity: "error"
+                  }
+                }
+              ]
+            );
+          } catch {
+          }
           logger.warn(`\u26A0\uFE0F  Check "${checkName}" - fail_if condition met: ${checkFailIf}`);
           results.push({
             conditionName: `${checkName}_fail_if`,
@@ -9645,6 +11945,31 @@ ${result.value.result.debug.rawResponse}`;
           logger.debug(`\u2713 Check "${checkName}" - fail_if condition passed`);
         }
       }
+      try {
+        const { emitNdjsonSpanWithEvents: emitNdjsonSpanWithEvents2 } = (init_fallback_ndjson(), __toCommonJS(fallback_ndjson_exports));
+        const hadTriggered = results.some((r) => r.failed === true);
+        emitNdjsonSpanWithEvents2(
+          "visor.fail_if",
+          {
+            check: checkName,
+            scope: hadTriggered ? checkFailIf ? "check" : "global" : checkFailIf ? "check" : "global"
+          },
+          [
+            {
+              name: "fail_if.evaluated",
+              attrs: { check: checkName, scope: checkFailIf ? "check" : "global" }
+            }
+          ].concat(
+            hadTriggered ? [
+              {
+                name: "fail_if.triggered",
+                attrs: { check: checkName, scope: checkFailIf ? "check" : "global" }
+              }
+            ] : []
+          )
+        );
+      } catch {
+      }
       return results;
     }
     const globalConditions = config.failure_conditions;
@@ -9655,7 +11980,10 @@ ${result.value.result.debug.rawResponse}`;
       checkGroup,
       reviewSummary,
       globalConditions,
-      checkConditions
+      checkConditions,
+      void 0,
+      // previousOutputs
+      prInfo?.authorAssociation
     );
   }
   /**
@@ -9778,6 +12106,7 @@ ${result.value.result.debug.rawResponse}`;
           { issues: checkIssues },
           options.config
         );
+        const execErrorIssue = checkIssues.find((i) => i.ruleId?.startsWith("command/"));
         await this.githubCheckService.completeCheckRun(
           options.githubChecks.owner,
           options.githubChecks.repo,
@@ -9785,7 +12114,7 @@ ${result.value.result.debug.rawResponse}`;
           checkName,
           failureResults,
           checkIssues,
-          void 0,
+          execErrorIssue ? execErrorIssue.message : void 0,
           // executionError
           prInfo.files.map((f) => f.filename),
           // filesChangedInCommit
@@ -10161,8 +12490,6 @@ ${result.value.result.debug.rawResponse}`;
 };
 
 export {
-  logger,
-  init_logger,
   CheckExecutionEngine
 };
-//# sourceMappingURL=chunk-N2PPFOSF.mjs.map
+//# sourceMappingURL=chunk-LJHRU3WQ.mjs.map