@probelabs/visor 0.1.113 → 0.1.122

package/dist/sdk/{chunk-23L3QRYX.mjs → chunk-VPEQOQ7G.mjs}

@@ -6,21 +6,21 @@ import {
 import {
   commandExecutor,
   init_command_executor
-} from "./chunk-AUT26LHW.mjs";
+} from "./chunk-J2QWVDXK.mjs";
 import {
   getPromptStateManager,
   init_prompt_state
-} from "./chunk-HTOKWMPO.mjs";
+} from "./chunk-HQL734ZI.mjs";
 import {
   DependencyResolver,
   WorkflowRegistry,
   init_dependency_resolver,
   init_workflow_registry
-} from "./chunk-QR7MOMJH.mjs";
+} from "./chunk-J6EVEXC2.mjs";
 import {
   config_exports,
   init_config
-} from "./chunk-QY2XYPEV.mjs";
+} from "./chunk-CUNPH6TR.mjs";
 import {
   checkLoopBudget,
   evaluateGoto,
@@ -28,11 +28,11 @@ import {
   init_routing,
   init_snapshot_store,
   snapshot_store_exports
-} from "./chunk-AIVFBIS4.mjs";
+} from "./chunk-35NT3725.mjs";
 import {
   FailureConditionEvaluator,
   init_failure_condition_evaluator
-} from "./chunk-SIWNBRTK.mjs";
+} from "./chunk-SWEEZ5D5.mjs";
 import {
   compileAndRun,
   createSecureSandbox,
@@ -55,7 +55,7 @@ import {
 import {
   createExtendedLiquid,
   init_liquid_extensions
-} from "./chunk-AK6BVWIT.mjs";
+} from "./chunk-7GUAFV6L.mjs";
 import {
   createPermissionHelpers,
   detectLocalMode,
@@ -66,11 +66,11 @@ import {
   MemoryStore,
   init_memory_store,
   memory_store_exports
-} from "./chunk-7UK3NIIT.mjs";
+} from "./chunk-IHZOSIF4.mjs";
 import {
   init_logger,
   logger
-} from "./chunk-AGIZJ4UZ.mjs";
+} from "./chunk-3NMLT3YS.mjs";
 import {
   context,
   init_lazy_otel,
@@ -352,8 +352,8 @@ var init_ai_review_service = __esm({
       sessionRegistry;
       constructor(config = {}) {
         this.config = {
-          timeout: 6e5,
-          // Increased timeout to 10 minutes for AI responses
+          timeout: 12e5,
+          // Increased timeout to 20 minutes for AI responses
           ...config
         };
         this.sessionRegistry = SessionRegistry.getInstance();
@@ -448,12 +448,10 @@ var init_ai_review_service = __esm({
             }
           }
           if (!this.config.apiKey) {
-            const errorMessage = "No API key configured. Please set GOOGLE_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY environment variable, or configure AWS credentials for Bedrock (AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY).";
+            log("\u26A0\uFE0F No API key configured - ProbeAgent will attempt CLI fallback (claude-code/codex)");
             if (debugInfo) {
-              debugInfo.errors = [errorMessage];
-              debugInfo.rawResponse = "API call attempted in debug without API key (test mode)";
-            } else {
-              throw new Error(errorMessage);
+              debugInfo.errors = debugInfo.errors || [];
+              debugInfo.errors.push("No API key configured - attempting CLI fallback");
             }
           }
         }
@@ -1605,6 +1603,9 @@ ${"=".repeat(60)}
             options.model = this.config.model;
           }
           const agent = new ProbeAgent(options);
+          if (typeof agent.initialize === "function") {
+            await agent.initialize();
+          }
           log("\u{1F680} Calling ProbeAgent...");
           let schemaString = void 0;
           let effectiveSchema = typeof schema === "object" ? "custom" : schema;
@@ -3763,10 +3764,18 @@ var init_ai_check_provider = __esm({
               if (info && typeof info.workspacePath === "string") {
                 workspaceRoot = info.workspacePath;
                 mainProjectPath = info.mainProjectPath;
-                folders.push(info.workspacePath);
               }
             } catch {
             }
+            if (mainProjectPath) {
+              folders.push(mainProjectPath);
+              logger.debug(
+                `[AI Provider] Including main project FIRST in allowedFolders: ${mainProjectPath}`
+              );
+            }
+            if (workspaceRoot) {
+              folders.push(workspaceRoot);
+            }
             const projectPaths = [];
             try {
               const projects = workspace.listProjects?.() || [];
@@ -3778,27 +3787,16 @@ var init_ai_check_provider = __esm({
               }
             } catch {
             }
-            if (projectPaths.length === 0 && mainProjectPath) {
-              folders.push(mainProjectPath);
-              logger.debug(
-                `[AI Provider] No external projects - including main project as fallback: ${mainProjectPath}`
-              );
-            } else if (mainProjectPath) {
-              logger.debug(
-                `[AI Provider] Excluding main project (visor) from allowedFolders: ${mainProjectPath}`
-              );
-            }
             const unique = Array.from(new Set(folders.filter((p) => typeof p === "string" && p)));
             if (unique.length > 0 && workspaceRoot) {
               aiConfig.allowedFolders = unique;
-              aiConfig.path = workspaceRoot;
-              aiConfig.cwd = workspaceRoot;
-              aiConfig.workspacePath = workspaceRoot;
+              const aiCwd = mainProjectPath || workspaceRoot;
+              aiConfig.path = aiCwd;
+              aiConfig.cwd = aiCwd;
+              aiConfig.workspacePath = aiCwd;
               logger.debug(`[AI Provider] Workspace isolation enabled:`);
-              logger.debug(`[AI Provider]   workspaceRoot (cwd): ${workspaceRoot}`);
-              logger.debug(
-                `[AI Provider]   mainProjectPath (excluded unless fallback): ${mainProjectPath || "N/A"}`
-              );
+              logger.debug(`[AI Provider]   cwd (mainProjectPath): ${aiCwd}`);
+              logger.debug(`[AI Provider]   workspaceRoot: ${workspaceRoot}`);
               logger.debug(`[AI Provider]   allowedFolders: ${JSON.stringify(unique)}`);
             }
           } else if (parentCtx && typeof parentCtx.workingDirectory === "string") {
@@ -3966,10 +3964,15 @@ ${processedPrompt}` : processedPrompt;
           const stepName = config.checkName || "unknown";
           const mock = sessionInfo?.hooks?.mockForStep?.(String(stepName));
           if (mock !== void 0) {
-            if (mock && typeof mock === "object" && ("issues" in mock || "content" in mock)) {
-              return mock;
-            }
-            return { issues: [], output: mock };
+            const ms = mock;
+            const issuesArr = Array.isArray(ms?.issues) ? ms.issues : [];
+            const out = ms && typeof ms === "object" && "output" in ms ? ms.output : ms;
+            const summary = {
+              issues: issuesArr,
+              output: out,
+              ...typeof ms?.content === "string" ? { content: String(ms.content) } : {}
+            };
+            return summary;
           }
         } catch {
         }
@@ -6428,7 +6431,17 @@ var init_command_check_provider = __esm({
         }
         try {
           const stepName = config.checkName || "unknown";
+          if (process.env.VISOR_DEBUG === "true") {
+            logger.debug(
+              `[Command] Mock check: stepName=${stepName}, context=${!!context2}, hooks=${!!context2?.hooks}, mockForStep=${!!context2?.hooks?.mockForStep}`
+            );
+          }
           const rawMock = context2?.hooks?.mockForStep?.(String(stepName));
+          if (process.env.VISOR_DEBUG === "true") {
+            logger.debug(
+              `[Command] Mock result: ${rawMock !== void 0 ? "found" : "not found"}, value=${JSON.stringify(rawMock)?.slice(0, 200)}`
+            );
+          }
           if (rawMock !== void 0) {
             let mock;
             if (typeof rawMock === "number") {
@@ -6453,6 +6466,16 @@ var init_command_check_provider = __esm({
               out = mock;
             }
             const code = isCommandMock ? typeof m.exit_code === "number" ? m.exit_code : typeof m.exit === "number" ? m.exit : 0 : 0;
+            let outputWithMeta;
+            if (isCommandMock) {
+              if (out && typeof out === "object" && !Array.isArray(out)) {
+                outputWithMeta = { ...out, exit_code: code };
+              } else {
+                outputWithMeta = { value: out, exit_code: code };
+              }
+            } else {
+              outputWithMeta = out;
+            }
             if (code !== 0) {
               return {
                 issues: [
@@ -6465,10 +6488,10 @@ var init_command_check_provider = __esm({
                     category: "logic"
                   }
                 ],
-                output: out
+                output: outputWithMeta
               };
             }
-            return { issues: [], output: out };
+            return { issues: [], output: outputWithMeta };
           }
         } catch {
         }
@@ -10476,22 +10499,41 @@ async function handleWavePlanning(context2, state, transition) {
       if (gotoEvent) {
         eventOverrides.set(target, gotoEvent);
       }
+      const sourceCheck = request.sourceCheck;
+      if (sourceCheck && request.origin === "run") {
+        if (!state.allowedFailedDeps) {
+          state.allowedFailedDeps = /* @__PURE__ */ new Map();
+        }
+        const allowedSet = state.allowedFailedDeps.get(target) || /* @__PURE__ */ new Set();
+        allowedSet.add(sourceCheck);
+        state.allowedFailedDeps.set(target, allowedSet);
+        if (context2.debug) {
+          logger.info(
+            `[WavePlanning] Allowing ${target} to run despite failed dependency ${sourceCheck}`
+          );
+        }
+      }
+      const origin = request.origin;
       const dependencies = findTransitiveDependencies(target, context2);
       for (const dep of dependencies) {
         const stats = state.stats.get(dep);
         const hasSucceeded = !!stats && (stats.successfulRuns || 0) > 0;
+        const hasRun = !!stats && (stats.totalRuns || 0) > 0;
+        if (origin === "run" && hasRun) {
+          continue;
+        }
         if (!hasSucceeded) {
           checksToRun.add(dep);
         }
       }
       let shouldIncludeDependents = true;
       try {
-        const origin = request.origin;
+        const origin2 = request.origin;
         const cfg = context2.config.checks?.[target];
         const targetType = String(cfg?.type || "").toLowerCase();
         const execCtx = context2.executionContext || {};
         const hasWebhook = !!execCtx.webhookContext;
-        if (hasWebhook && (origin === "goto" || origin === "goto_js") && targetType === "human-input") {
+        if (hasWebhook && (origin2 === "goto" || origin2 === "goto_js") && targetType === "human-input") {
           shouldIncludeDependents = false;
         }
       } catch {
@@ -10829,8 +10871,15 @@ var history_snapshot_exports = {};
 __export(history_snapshot_exports, {
   buildOutputHistoryFromJournal: () => buildOutputHistoryFromJournal
 });
+function getHistoryLimit() {
+  const raw = process.env.VISOR_TEST_HISTORY_LIMIT || process.env.VISOR_OUTPUT_HISTORY_LIMIT;
+  if (!raw) return void 0;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
 function buildOutputHistoryFromJournal(context2) {
   const outputHistory = /* @__PURE__ */ new Map();
+  const limit = getHistoryLimit();
   try {
     const snapshot = context2.journal.beginSnapshot();
     const allEntries = context2.journal.readVisible(context2.sessionId, snapshot, void 0);
@@ -10852,7 +10901,13 @@ function buildOutputHistoryFromJournal(context2) {
         }
       } catch {
       }
-      if (payload !== void 0) outputHistory.get(checkId).push(payload);
+      if (payload !== void 0) {
+        const arr = outputHistory.get(checkId);
+        arr.push(payload);
+        if (limit && arr.length > limit) {
+          arr.splice(0, arr.length - limit);
+        }
+      }
     }
   } catch (error) {
     logger.debug(`[LevelDispatch] Error building output history: ${error}`);
@@ -10981,7 +11036,7 @@ var init_dependency_gating = __esm({
 // src/state-machine/dispatch/template-renderer.ts
 async function renderTemplateContent(checkId, checkConfig, reviewSummary) {
   try {
-    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-PKWCKK7E.mjs");
+    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-DFDEBMUI.mjs");
     const fs8 = await import("fs/promises");
     const path9 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
@@ -11274,7 +11329,7 @@ async function executeCheckWithForEachItems(checkId, forEachParent, forEachItems
         __outputHistory: outputHistory,
         ai: {
           ...checkConfig.ai || {},
-          timeout: checkConfig.ai?.timeout || 6e5,
+          timeout: checkConfig.ai?.timeout || 12e5,
           debug: !!context2.debug
         }
       };
@@ -11754,7 +11809,7 @@ async function executeInvocation(item, context2, scope, prInfo, dependencyResult
       __outputHistory: outputHistory,
       ai: {
         ...stepConfig.ai || {},
-        timeout: stepConfig.ai?.timeout || 6e5,
+        timeout: stepConfig.ai?.timeout || 12e5,
         debug: !!context2.debug
       }
     };
@@ -12230,7 +12285,7 @@ async function executeSingleCheck(checkId, context2, state, emitEvent, transitio
       __outputHistory: outputHistory,
       ai: {
         ...checkConfig.ai || {},
-        timeout: checkConfig.ai?.timeout || 6e5,
+        timeout: checkConfig.ai?.timeout || 12e5,
         debug: !!context2.debug
       }
     };
@@ -12540,8 +12595,15 @@ function recordOnFinishRoutingEvent(args) {
   if (args.gotoEvent) attrs.goto_event = args.gotoEvent;
   addEvent("visor.routing", attrs);
 }
+function getHistoryLimit2() {
+  const raw = process.env.VISOR_TEST_HISTORY_LIMIT || process.env.VISOR_OUTPUT_HISTORY_LIMIT;
+  if (!raw) return void 0;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
 function buildOutputHistoryFromJournal2(context2) {
   const outputHistory = /* @__PURE__ */ new Map();
+  const limit = getHistoryLimit2();
   try {
     const snapshot = context2.journal.beginSnapshot();
     const allEntries = context2.journal.readVisible(context2.sessionId, snapshot, void 0);
@@ -12551,7 +12613,13 @@ function buildOutputHistoryFromJournal2(context2) {
         outputHistory.set(checkId, []);
       }
       const payload = entry.result.output !== void 0 ? entry.result.output : entry.result;
-      if (payload !== void 0) outputHistory.get(checkId).push(payload);
+      if (payload !== void 0) {
+        const arr = outputHistory.get(checkId);
+        arr.push(payload);
+        if (limit && arr.length > limit) {
+          arr.splice(0, arr.length - limit);
+        }
+      }
     }
   } catch (error) {
     logger.debug(`[LevelDispatch] Error building output history: ${error}`);
@@ -12964,7 +13032,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
         __outputHistory: outputHistory,
         ai: {
           ...checkConfig.ai || {},
-          timeout: checkConfig.ai?.timeout || 6e5,
+          timeout: checkConfig.ai?.timeout || 12e5,
           debug: !!context2.debug
         }
       };
@@ -13177,7 +13245,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
         let schemaObj = (typeof checkConfig.schema === "object" ? checkConfig.schema : void 0) || checkConfig.output_schema;
         if (!schemaObj && typeof checkConfig.schema === "string") {
           try {
-            const { loadRendererSchema } = await import("./renderer-schema-LPKN5UJS.mjs");
+            const { loadRendererSchema } = await import("./renderer-schema-CKFB5NDB.mjs");
             schemaObj = await loadRendererSchema(checkConfig.schema);
           } catch {
           }
@@ -13510,7 +13578,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
           }
         }
         try {
-          const { evaluateTransitions } = await import("./routing-6N45MJ4F.mjs");
+          const { evaluateTransitions } = await import("./routing-KZ345OFG.mjs");
           const transTarget = await evaluateTransitions(
             onFinish.transitions,
             forEachParent,
@@ -13570,7 +13638,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
             `[LevelDispatch] Error evaluating on_finish transitions for ${forEachParent}: ${e instanceof Error ? e.message : String(e)}`
           );
         }
-        const { evaluateGoto: evaluateGoto2 } = await import("./routing-6N45MJ4F.mjs");
+        const { evaluateGoto: evaluateGoto2 } = await import("./routing-KZ345OFG.mjs");
         if (context2.debug) {
           logger.info(
             `[LevelDispatch] Evaluating on_finish.goto_js for forEach parent: ${forEachParent}`
@@ -13740,10 +13808,20 @@ async function executeSingleCheck2(checkId, context2, state, emitEvent, transiti
   const dependencies = checkConfig?.depends_on || [];
   const depList = Array.isArray(dependencies) ? dependencies : [dependencies];
   const failedChecks = state.failedChecks;
+  const allowedFailedDeps = state.allowedFailedDeps?.get(checkId);
   const tokens = depList.filter(Boolean);
   const groupSatisfied = (token) => {
     const options = token.includes("|") ? token.split("|").map((s) => s.trim()).filter(Boolean) : [token];
     for (const opt of options) {
+      const isAllowedFailedDep = !!(allowedFailedDeps && allowedFailedDeps.has(opt));
+      if (isAllowedFailedDep) {
+        if (context2.debug) {
+          logger.info(
+            `[LevelDispatch] Allowing ${checkId} to run despite failed dependency ${opt} (on_fail.run)`
+          );
+        }
+        return true;
+      }
       const depCfg = context2.config.checks?.[opt];
       const cont = !!(depCfg && depCfg.continue_on_failure === true);
       const st = state.stats.get(opt);
@@ -13982,7 +14060,7 @@ async function executeSingleCheck2(checkId, context2, state, emitEvent, transiti
       checksMeta,
       ai: {
         ...checkConfig2.ai || {},
-        timeout: checkConfig2.ai?.timeout || 6e5,
+        timeout: checkConfig2.ai?.timeout || 12e5,
         debug: !!context2.debug
       }
     };
@@ -14155,7 +14233,7 @@ async function executeSingleCheck2(checkId, context2, state, emitEvent, transiti
       let schemaObj = (typeof checkConfig2.schema === "object" ? checkConfig2.schema : void 0) || checkConfig2.output_schema;
       if (!schemaObj && typeof checkConfig2.schema === "string") {
         try {
-          const { loadRendererSchema } = await import("./renderer-schema-LPKN5UJS.mjs");
+          const { loadRendererSchema } = await import("./renderer-schema-CKFB5NDB.mjs");
           schemaObj = await loadRendererSchema(checkConfig2.schema);
         } catch {
         }
@@ -14697,7 +14775,7 @@ function updateStats2(results, state, isForEachIteration = false) {
 }
 async function renderTemplateContent2(checkId, checkConfig, reviewSummary) {
   try {
-    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-PKWCKK7E.mjs");
+    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-DFDEBMUI.mjs");
     const fs8 = await import("fs/promises");
     const path9 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
@@ -15056,6 +15134,25 @@ var init_runner = __esm({
           }
         } catch {
         }
+        if (event.type === "CheckCompleted") {
+          try {
+            const hook = this.context.executionContext?.hooks?.onCheckComplete;
+            if (typeof hook === "function") {
+              const checkConfig = this.context.config?.checks?.[event.checkId];
+              hook({
+                checkId: event.checkId,
+                result: event.result,
+                checkConfig: checkConfig ? {
+                  type: checkConfig.type,
+                  group: checkConfig.group,
+                  criticality: checkConfig.criticality,
+                  schema: checkConfig.schema
+                } : void 0
+              });
+            }
+          } catch {
+          }
+        }
         if (this.context.debug && event.type !== "StateTransition") {
           logger.debug(`[StateMachine] Event: ${event.type}`);
         }
@@ -16093,25 +16190,76 @@ var init_worktree_manager = __esm({
         }
         if (fs7.existsSync(worktreePath)) {
           logger.debug(`Worktree already exists: ${worktreePath}`);
-          if (options.clean) {
-            logger.debug(`Cleaning existing worktree`);
-            await this.cleanWorktree(worktreePath);
-          }
           const metadata2 = await this.loadMetadata(worktreePath);
           if (metadata2) {
-            this.activeWorktrees.set(worktreeId, metadata2);
-            return {
-              id: worktreeId,
-              path: worktreePath,
-              ref: metadata2.ref,
-              commit: metadata2.commit,
-              metadata: metadata2,
-              locked: false
-            };
+            if (metadata2.ref === ref) {
+              if (options.clean) {
+                logger.debug(`Cleaning existing worktree`);
+                await this.cleanWorktree(worktreePath);
+              }
+              this.activeWorktrees.set(worktreeId, metadata2);
+              return {
+                id: worktreeId,
+                path: worktreePath,
+                ref: metadata2.ref,
+                commit: metadata2.commit,
+                metadata: metadata2,
+                locked: false
+              };
+            } else {
+              logger.info(
+                `Worktree exists with different ref (${metadata2.ref} -> ${ref}), updating...`
+              );
+              try {
+                const bareRepoPath2 = metadata2.bare_repo_path || await this.getOrCreateBareRepo(
+                  repository,
+                  repoUrl,
+                  options.token,
+                  options.fetchDepth,
+                  options.cloneTimeoutMs
+                );
+                await this.fetchRef(bareRepoPath2, ref);
+                const newCommit = await this.getCommitShaForRef(bareRepoPath2, ref);
+                const checkoutCmd = `git -C ${this.escapeShellArg(worktreePath)} checkout --detach ${this.escapeShellArg(newCommit)}`;
+                const checkoutResult = await this.executeGitCommand(checkoutCmd, { timeout: 6e4 });
+                if (checkoutResult.exitCode !== 0) {
+                  throw new Error(`Failed to checkout new ref: ${checkoutResult.stderr}`);
+                }
+                const updatedMetadata = {
+                  ...metadata2,
+                  ref,
+                  commit: newCommit,
+                  created_at: (/* @__PURE__ */ new Date()).toISOString()
+                };
+                await this.saveMetadata(worktreePath, updatedMetadata);
+                if (options.clean) {
+                  logger.debug(`Cleaning updated worktree`);
+                  await this.cleanWorktree(worktreePath);
+                }
+                this.activeWorktrees.set(worktreeId, updatedMetadata);
+                logger.info(`Successfully updated worktree to ${ref} (${newCommit})`);
+                return {
+                  id: worktreeId,
+                  path: worktreePath,
+                  ref,
+                  commit: newCommit,
+                  metadata: updatedMetadata,
+                  locked: false
+                };
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.warn(`Failed to update worktree, will recreate: ${errorMessage}`);
+                await fsp.rm(worktreePath, { recursive: true, force: true });
+              }
+            }
+          } else {
+            logger.info(`Removing stale directory (no metadata): ${worktreePath}`);
+            await fsp.rm(worktreePath, { recursive: true, force: true });
           }
         }
         await this.fetchRef(bareRepoPath, ref);
         const commit = await this.getCommitShaForRef(bareRepoPath, ref);
+        await this.pruneWorktrees(bareRepoPath);
         logger.info(`Creating worktree for ${repository}@${ref} (${commit})`);
         const createCmd = `git -C ${this.escapeShellArg(
           bareRepoPath
@@ -16144,6 +16292,20 @@ var init_worktree_manager = __esm({
           locked: false
         };
       }
+      /**
+       * Prune stale worktree entries from a bare repository.
+       * This removes entries for worktrees whose directories no longer exist.
+       */
+      async pruneWorktrees(bareRepoPath) {
+        logger.debug(`Pruning stale worktrees for ${bareRepoPath}`);
+        const pruneCmd = `git -C ${this.escapeShellArg(bareRepoPath)} worktree prune`;
+        const result = await this.executeGitCommand(pruneCmd, { timeout: 1e4 });
+        if (result.exitCode !== 0) {
+          logger.warn(`Failed to prune worktrees: ${result.stderr}`);
+        } else {
+          logger.debug(`Successfully pruned stale worktrees`);
+        }
+      }
       /**
        * Fetch a specific ref in bare repository
        */
@@ -16504,6 +16666,53 @@ var init_git_checkout_provider = __esm({
       async execute(prInfo, config, dependencyResults, context2) {
         const checkoutConfig = config;
         const issues = [];
+        try {
+          const stepName = config.checkName || "git-checkout";
+          if (process.env.VISOR_DEBUG === "true") {
+            logger.debug(
+              `[GitCheckout] Mock check: stepName=${stepName}, context=${!!context2}, hooks=${!!context2?.hooks}, mockForStep=${!!context2?.hooks?.mockForStep}`
+            );
+          }
+          const mock = context2?.hooks?.mockForStep?.(String(stepName));
+          if (process.env.VISOR_DEBUG === "true") {
+            logger.debug(
+              `[GitCheckout] Mock result: ${mock !== void 0 ? "found" : "not found"}, value=${JSON.stringify(mock)}`
+            );
+          }
+          if (mock !== void 0) {
+            if (mock && typeof mock === "object") {
+              const mockOutput = mock;
+              if (mockOutput.success === false) {
+                const errorMsg = String(mockOutput.error || "Mocked checkout failure");
+                if (process.env.VISOR_DEBUG === "true") {
+                  logger.debug(`[GitCheckout] Returning mock failure: ${errorMsg}`);
+                }
+                return {
+                  issues: [
+                    {
+                      file: "git-checkout",
+                      line: 0,
+                      ruleId: "git-checkout/error",
+                      message: `Failed to checkout code: ${errorMsg}`,
+                      severity: "error",
+                      category: "logic"
+                    }
+                  ],
+                  output: mockOutput
+                };
+              }
+              if (process.env.VISOR_DEBUG === "true") {
+                logger.debug(`[GitCheckout] Returning mock success: ${JSON.stringify(mockOutput)}`);
+              }
+              return { issues: [], output: mockOutput };
+            }
+            if (process.env.VISOR_DEBUG === "true") {
+              logger.debug(`[GitCheckout] Returning primitive mock: ${String(mock)}`);
+            }
+            return { issues: [], output: { success: true, path: String(mock) } };
+          }
+        } catch {
+        }
         try {
           const templateContext = this.buildTemplateContext(
             prInfo,
@@ -16658,7 +16867,7 @@ var init_git_checkout_provider = __esm({
       }
       async isAvailable() {
         try {
-          const { commandExecutor: commandExecutor2 } = await import("./command-executor-TYUV6HUS.mjs");
+          const { commandExecutor: commandExecutor2 } = await import("./command-executor-Q7MHJKZJ.mjs");
           const result = await commandExecutor2.execute("git --version", { timeout: 5e3 });
           return result.exitCode === 0;
         } catch (_error) {
@@ -16869,4 +17078,4 @@ export {
   StateMachineRunner,
   init_runner
 };
-//# sourceMappingURL=chunk-23L3QRYX.mjs.map
+//# sourceMappingURL=chunk-VPEQOQ7G.mjs.map