@probelabs/visor 0.1.113 → 0.1.122

package/dist/sdk/sdk.js

@@ -211,6 +211,10 @@ var init_logger = __esm({
       isTTY = typeof process !== "undefined" ? !!process.stderr.isTTY : false;
       showTimestamps = true;
       // default: always show timestamps
+      sink;
+      sinkPassthrough = true;
+      sinkErrorMode = "throw";
+      sinkErrorHandler;
       configure(opts = {}) {
         let lvl = "info";
         if (opts.debug || process.env.VISOR_DEBUG === "true") {
@@ -231,6 +235,12 @@ var init_logger = __esm({
         const output = opts.outputFormat || process.env.VISOR_OUTPUT_FORMAT || "table";
         this.isJsonLike = output === "json" || output === "sarif";
       }
+      setSink(sink, opts = {}) {
+        this.sink = sink;
+        this.sinkPassthrough = opts.passthrough !== void 0 ? opts.passthrough : true;
+        this.sinkErrorMode = opts.errorMode || "throw";
+        this.sinkErrorHandler = opts.onError;
+      }
       shouldLog(level) {
         const desired = levelToNumber(level);
         const current = levelToNumber(this.level);
@@ -253,14 +263,38 @@ var init_logger = __esm({
         }
       }
       write(msg, level) {
+        const suffix = this.getTraceSuffix(msg);
+        const decoratedMsg = suffix ? `${msg}${suffix}` : msg;
+        const lvl = level || "info";
+        if (this.sink) {
+          try {
+            this.sink(decoratedMsg, lvl);
+          } catch (error) {
+            if (this.sinkErrorMode === "warn") {
+              try {
+                if (this.sinkErrorHandler) {
+                  this.sinkErrorHandler(error);
+                } else {
+                  const errMsg = error instanceof Error ? error.message : String(error);
+                  process.stderr.write(`[logger] sink failed: ${errMsg}
+`);
+                }
+              } catch {
+              }
+            }
+            if (this.sinkErrorMode === "throw") {
+              throw error;
+            }
+            return;
+          }
+          if (!this.sinkPassthrough) return;
+        }
         try {
-          const suffix = this.getTraceSuffix(msg);
-          const decoratedMsg = suffix ? `${msg}${suffix}` : msg;
           if (this.showTimestamps) {
             const ts = (/* @__PURE__ */ new Date()).toISOString();
-            const lvl = level ? level : void 0;
+            const lvl2 = level ? level : void 0;
             let tsToken = `[${ts}]`;
-            let lvlToken = lvl ? `[${lvl}]` : "";
+            let lvlToken = lvl2 ? `[${lvl2}]` : "";
             if (this.isTTY && !this.isJsonLike) {
               const reset = "\x1B[0m";
               const dim = "\x1B[2m";
@@ -278,14 +312,14 @@ var init_logger = __esm({
                 // bright black / gray
               };
               tsToken = `${dim}${tsToken}${reset}`;
-              if (lvl) {
-                const colour = colours[lvl] || "";
+              if (lvl2) {
+                const colour = colours[lvl2] || "";
                 if (colour) {
                   lvlToken = `${colour}${lvlToken}${reset}`;
                 }
               }
             }
-            const prefix = lvl ? `${tsToken} ${lvlToken}` : tsToken;
+            const prefix = lvl2 ? `${tsToken} ${lvlToken}` : tsToken;
             process.stderr.write(`${prefix} ${decoratedMsg}
 `);
           } else {
@@ -1163,22 +1197,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 {
@@ -3302,6 +3355,12 @@ function createMemoryHelpers() {
     }
   };
 }
+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 formatScopeLabel(scope) {
   if (!scope || scope.length === 0) return "";
   return scope.map((item) => `${item.check}:${item.index}`).join("|");
@@ -3902,7 +3961,9 @@ async function processOnFail(checkId, scope, result, checkConfig, context2, stat
             type: "ForwardRunRequested",
             target: targetCheck,
             scope: itemScope,
-            origin: "run"
+            origin: "run",
+            sourceCheck: checkId
+            // The failed check that triggered on_fail.run
           });
         }
       } else {
@@ -3919,7 +3980,9 @@ async function processOnFail(checkId, scope, result, checkConfig, context2, stat
           type: "ForwardRunRequested",
           target: targetCheck,
           scope,
-          origin: "run"
+          origin: "run",
+          sourceCheck: checkId
+          // The failed check that triggered on_fail.run
         });
       }
     }
@@ -3962,7 +4025,9 @@ async function processOnFail(checkId, scope, result, checkConfig, context2, stat
         type: "ForwardRunRequested",
         target: targetCheck,
         scope,
-        origin: "run_js"
+        origin: "run_js",
+        sourceCheck: checkId
+        // The failed check that triggered on_fail.run_js
       });
     }
   }
@@ -4109,6 +4174,7 @@ async function processOnFail(checkId, scope, result, checkConfig, context2, stat
 async function evaluateRunJs(runJs, checkId, checkConfig, result, context2, _state) {
   try {
     const sandbox = createSecureSandbox();
+    const historyLimit = getHistoryLimit();
     const snapshotId = context2.journal.beginSnapshot();
     const contextView = new (init_snapshot_store(), __toCommonJS(snapshot_store_exports)).ContextView(
       context2.journal,
@@ -4133,7 +4199,8 @@ async function evaluateRunJs(runJs, checkId, checkConfig, result, context2, _sta
       try {
         const history = contextView.getHistory(checkIdFromJournal);
         if (history && history.length > 0) {
-          outputsHistory[checkIdFromJournal] = history.map(
+          const trimmed = historyLimit && history.length > historyLimit ? history.slice(history.length - historyLimit) : history;
+          outputsHistory[checkIdFromJournal] = trimmed.map(
             (r) => r.output !== void 0 ? r.output : r
           );
         }
@@ -4215,6 +4282,7 @@ async function evaluateGoto(gotoJs, gotoStatic, checkId, checkConfig, result, co
   if (gotoJs) {
     try {
       const sandbox = createSecureSandbox();
+      const historyLimit = getHistoryLimit();
       const snapshotId = context2.journal.beginSnapshot();
       const contextView = new (init_snapshot_store(), __toCommonJS(snapshot_store_exports)).ContextView(
         context2.journal,
@@ -4239,7 +4307,8 @@ async function evaluateGoto(gotoJs, gotoStatic, checkId, checkConfig, result, co
         try {
           const history = contextView.getHistory(checkIdFromJournal);
           if (history && history.length > 0) {
-            outputsHistory[checkIdFromJournal] = history.map(
+            const trimmed = historyLimit && history.length > historyLimit ? history.slice(history.length - historyLimit) : history;
+            outputsHistory[checkIdFromJournal] = trimmed.map(
               (r) => r.output !== void 0 ? r.output : r
             );
           }
@@ -4342,6 +4411,7 @@ async function evaluateTransitions(transitions, checkId, checkConfig, result, co
   if (!transitions || transitions.length === 0) return void 0;
   try {
     const sandbox = createSecureSandbox();
+    const historyLimit = getHistoryLimit();
     const snapshotId = context2.journal.beginSnapshot();
     const ContextView2 = (init_snapshot_store(), __toCommonJS(snapshot_store_exports)).ContextView;
     const view = new ContextView2(context2.journal, context2.sessionId, snapshotId, [], void 0);
@@ -4358,7 +4428,10 @@ async function evaluateTransitions(transitions, checkId, checkConfig, result, co
       try {
         const hist = view.getHistory(cid);
         if (hist && hist.length > 0) {
-          outputsHistory[cid] = hist.map((r) => r.output !== void 0 ? r.output : r);
+          const trimmed = historyLimit && hist.length > historyLimit ? hist.slice(hist.length - historyLimit) : hist;
+          outputsHistory[cid] = trimmed.map(
+            (r) => r.output !== void 0 ? r.output : r
+          );
         }
       } catch {
       }
@@ -4516,8 +4589,15 @@ var history_snapshot_exports = {};
 __export(history_snapshot_exports, {
   buildOutputHistoryFromJournal: () => buildOutputHistoryFromJournal
 });
+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 buildOutputHistoryFromJournal(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);
@@ -4539,7 +4619,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}`);
@@ -5757,8 +5843,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();
@@ -5853,12 +5939,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");
             }
           }
         }
@@ -7010,6 +7094,9 @@ ${"=".repeat(60)}
             options.model = this.config.model;
           }
           const agent = new import_probe2.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;
@@ -9299,10 +9386,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?.() || [];
@@ -9314,27 +9409,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") {
@@ -9502,10 +9586,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 {
         }
@@ -11964,7 +12053,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") {
@@ -11989,6 +12088,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: [
@@ -12001,10 +12110,10 @@ var init_command_check_provider = __esm({
                     category: "logic"
                   }
                 ],
-                output: out
+                output: outputWithMeta
               };
             }
-            return { issues: [], output: out };
+            return { issues: [], output: outputWithMeta };
           }
         } catch {
         }
@@ -17417,7 +17526,7 @@ var init_config_schema = __esm({
               description: "Arguments/inputs for the workflow"
             },
             overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-40845%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-41044%3E%3E",
               description: "Override specific step configurations in the workflow"
             },
             output_mapping: {
@@ -17433,7 +17542,7 @@ var init_config_schema = __esm({
               description: "Config file path - alternative to workflow ID (loads a Visor config file as workflow)"
             },
             workflow_overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-40845%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-41044%3E%3E",
               description: "Alias for overrides - workflow step overrides (backward compatibility)"
             },
             ref: {
@@ -18063,7 +18172,7 @@ var init_config_schema = __esm({
               description: "Custom output name (defaults to workflow name)"
             },
             overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-40845%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-41044%3E%3E",
               description: "Step overrides"
             },
             output_mapping: {
@@ -18078,13 +18187,13 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
-        "Record<string,Partial<interface-src_types_config.ts-11359-23556-src_types_config.ts-0-40845>>": {
+        "Record<string,Partial<interface-src_types_config.ts-11359-23556-src_types_config.ts-0-41044>>": {
           type: "object",
           additionalProperties: {
-            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-40845%3E"
+            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-11359-23556-src_types_config.ts-0-41044%3E"
           }
         },
-        "Partial<interface-src_types_config.ts-11359-23556-src_types_config.ts-0-40845>": {
+        "Partial<interface-src_types_config.ts-11359-23556-src_types_config.ts-0-41044>": {
           type: "object",
           additionalProperties: false
         },
@@ -18655,6 +18764,14 @@ var init_config_schema = __esm({
               type: "string",
               description: "Base path for workspaces (default: /tmp/visor-workspaces)"
             },
+            name: {
+              type: "string",
+              description: "Workspace directory name (defaults to session id)"
+            },
+            main_project_name: {
+              type: "string",
+              description: "Main project folder name inside the workspace (defaults to original directory name)"
+            },
             cleanup_on_exit: {
               type: "boolean",
               description: "Clean up workspace on exit (default: true)"
@@ -20635,25 +20752,76 @@ var init_worktree_manager = __esm({
         }
         if (fs14.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
@@ -20686,6 +20854,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
        */
@@ -21046,6 +21228,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,
@@ -21548,7 +21777,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
         }
       };
@@ -22028,7 +22257,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
       }
     };
@@ -22504,7 +22733,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
       }
     };
@@ -22857,8 +23086,15 @@ function recordOnFinishRoutingEvent(args) {
   if (args.gotoEvent) attrs.goto_event = args.gotoEvent;
   addEvent("visor.routing", attrs);
 }
+function getHistoryLimit3() {
+  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 = getHistoryLimit3();
   try {
     const snapshot = context2.journal.beginSnapshot();
     const allEntries = context2.journal.readVisible(context2.sessionId, snapshot, void 0);
@@ -22868,7 +23104,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}`);
@@ -23281,7 +23523,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
         }
       };
@@ -24057,10 +24299,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);
@@ -24299,7 +24551,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
       }
     };
@@ -25373,6 +25625,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}`);
         }
@@ -26122,14 +26393,19 @@ var init_workspace_manager = __esm({
       constructor(sessionId, originalPath, config) {
         this.sessionId = sessionId;
         this.originalPath = originalPath;
+        const configuredName = config?.name || process.env.VISOR_WORKSPACE_NAME;
+        const configuredMainProjectName = config?.mainProjectName || process.env.VISOR_WORKSPACE_PROJECT;
         this.config = {
           enabled: true,
           basePath: process.env.VISOR_WORKSPACE_PATH || "/tmp/visor-workspaces",
           cleanupOnExit: true,
+          name: configuredName,
+          mainProjectName: configuredMainProjectName,
           ...config
         };
         this.basePath = this.config.basePath;
-        this.workspacePath = path18.join(this.basePath, sanitizePathComponent(this.sessionId));
+        const workspaceDirName = sanitizePathComponent(this.config.name || this.sessionId);
+        this.workspacePath = path18.join(this.basePath, workspaceDirName);
       }
       /**
        * Get or create a WorkspaceManager instance for a session
@@ -26186,7 +26462,10 @@ var init_workspace_manager = __esm({
         logger.info(`Initializing workspace: ${this.workspacePath}`);
         await fsp2.mkdir(this.workspacePath, { recursive: true });
         logger.debug(`Created workspace directory: ${this.workspacePath}`);
-        const mainProjectName = sanitizePathComponent(this.extractProjectName(this.originalPath));
+        const configuredMainProjectName = this.config.mainProjectName;
+        const mainProjectName = sanitizePathComponent(
+          configuredMainProjectName || this.extractProjectName(this.originalPath)
+        );
         this.usedNames.add(mainProjectName);
         const mainProjectPath = path18.join(this.workspacePath, mainProjectName);
         const isGitRepo = await this.isGitRepository(this.originalPath);
@@ -26462,12 +26741,21 @@ async function initializeWorkspace(context2) {
     const workspace = WorkspaceManager.getInstance(context2.sessionId, originalPath, {
       enabled: true,
       basePath: workspaceConfig?.base_path || process.env.VISOR_WORKSPACE_PATH || "/tmp/visor-workspaces",
-      cleanupOnExit: keepWorkspace ? false : workspaceConfig?.cleanup_on_exit !== false
+      cleanupOnExit: keepWorkspace ? false : workspaceConfig?.cleanup_on_exit !== false,
+      name: workspaceConfig?.name || process.env.VISOR_WORKSPACE_NAME,
+      mainProjectName: workspaceConfig?.main_project_name || process.env.VISOR_WORKSPACE_PROJECT
     });
     const info = await workspace.initialize();
     context2.workspace = workspace;
     context2.workingDirectory = info.mainProjectPath;
     context2.originalWorkingDirectory = originalPath;
+    try {
+      process.env.VISOR_WORKSPACE_ROOT = info.workspacePath;
+      process.env.VISOR_WORKSPACE_MAIN_PROJECT = info.mainProjectPath;
+      process.env.VISOR_WORKSPACE_MAIN_PROJECT_NAME = info.mainProjectName;
+      process.env.VISOR_ORIGINAL_WORKDIR = originalPath;
+    } catch {
+    }
     logger.info(`[Workspace] Initialized workspace: ${info.workspacePath}`);
     logger.debug(`[Workspace] Main project at: ${info.mainProjectPath}`);
     if (keepWorkspace) {
@@ -28381,6 +28669,7 @@ var init_slack_frontend = __esm({
       ackRef = null;
       ackName = "eyes";
       doneName = "thumbsup";
+      errorNotified = false;
       constructor(config) {
         this.cfg = config || {};
       }
@@ -28413,6 +28702,14 @@ var init_slack_frontend = __esm({
             });
           })
         );
+        this.subs.push(
+          bus.on("CheckErrored", async (env) => {
+            const ev = env && env.payload || env;
+            const message = ev?.error?.message || "Execution error";
+            await this.maybePostError(ctx, "Check failed", message, ev?.checkId).catch(() => {
+            });
+          })
+        );
         this.subs.push(
           bus.on("StateTransition", async (env) => {
             const ev = env && env.payload || env;
@@ -28422,6 +28719,14 @@ var init_slack_frontend = __esm({
             }
           })
         );
+        this.subs.push(
+          bus.on("Shutdown", async (env) => {
+            const ev = env && env.payload || env;
+            const message = ev?.error?.message || "Fatal error";
+            await this.maybePostError(ctx, "Run failed", message).catch(() => {
+            });
+          })
+        );
         this.subs.push(
           bus.on("CheckScheduled", async () => {
             await this.ensureAcknowledgement(ctx).catch(() => {
@@ -28532,6 +28837,47 @@ var init_slack_frontend = __esm({
         }
         return null;
       }
+      isTelemetryEnabled(ctx) {
+        try {
+          const anyCfg = ctx.config || {};
+          const slackCfg = anyCfg.slack || {};
+          const telemetryCfg = slackCfg.telemetry ?? this.cfg?.telemetry;
+          return telemetryCfg === true || telemetryCfg && typeof telemetryCfg === "object" && telemetryCfg.enabled === true;
+        } catch {
+          return false;
+        }
+      }
+      async maybePostError(ctx, title, message, checkId) {
+        if (this.errorNotified) return;
+        if (!this.isTelemetryEnabled(ctx)) return;
+        const slack = this.getSlack(ctx);
+        if (!slack) return;
+        const payload = this.getInboundSlackPayload(ctx);
+        const ev = payload?.event;
+        const channel = String(ev?.channel || "");
+        const threadTs = String(ev?.thread_ts || ev?.ts || ev?.event_ts || "");
+        if (!channel || !threadTs) return;
+        let text = `\u274C ${title}`;
+        if (checkId) text += `
+Check: ${checkId}`;
+        if (message) text += `
+${message}`;
+        const traceInfo = this.getTraceInfo();
+        if (traceInfo?.traceId) {
+          text += `
+
+\`trace_id: ${traceInfo.traceId}\``;
+        }
+        const formattedText = formatSlackText(text);
+        await slack.chat.postMessage({ channel, text: formattedText, thread_ts: threadTs });
+        try {
+          ctx.logger.info(
+            `[slack-frontend] posted error notice to ${channel} thread=${threadTs} check=${checkId || "run"}`
+          );
+        } catch {
+        }
+        this.errorNotified = true;
+      }
       async ensureAcknowledgement(ctx) {
         if (this.acked) return;
         const ref = this.getInboundSlackEvent(ctx);