@probelabs/visor 0.1.166-ee → 0.1.167-ee

package/dist/sdk/{chunk-P5P6BOO7.mjs → chunk-3LXYZ2OQ.mjs}

@@ -33,7 +33,7 @@ import {
 import {
   config_exports,
   init_config
-} from "./chunk-DEAPFYNX.mjs";
+} from "./chunk-KYBKVKBS.mjs";
 import {
   ExecutionJournal,
   checkLoopBudget,
@@ -3965,7 +3965,7 @@ async function executeWorkflowAsTool(workflowId, args, context2, argsOverrides)
     ...args,
     ...argsOverrides
   };
-  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-BE2SVYWW.mjs");
+  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-PI7VJT25.mjs");
   const provider = new WorkflowCheckProvider2();
   const checkConfig = {
     type: "workflow",
@@ -8457,7 +8457,29 @@ async function executeCheckGroup(checks, context2, state, maxParallelism, emitEv
     } catch {
     }
     if (pool.length >= maxParallelism) {
-      await Promise.race(pool);
+      const activeCount = pool.filter((p) => !p._settled).length;
+      logger.info(
+        `[LevelDispatch] Check pool full (${activeCount}/${maxParallelism} active). Check "${checkId}" queued, waiting for a slot...`
+      );
+      const queuedAt = Date.now();
+      const reminder = setInterval(() => {
+        const waited = Math.round((Date.now() - queuedAt) / 1e3);
+        const stillActive = pool.filter((p) => !p._settled).length;
+        logger.info(
+          `[LevelDispatch] Check "${checkId}" still queued (${waited}s). ${stillActive}/${maxParallelism} slots busy.`
+        );
+      }, 15e3);
+      try {
+        await Promise.race(pool);
+      } finally {
+        clearInterval(reminder);
+      }
+      const waitedMs = Date.now() - queuedAt;
+      if (waitedMs > 100) {
+        logger.info(
+          `[LevelDispatch] Check "${checkId}" dequeued after ${Math.round(waitedMs / 1e3)}s wait.`
+        );
+      }
       pool.splice(
         0,
         pool.length,
@@ -12746,6 +12768,223 @@ var init_workspace_manager = __esm({
   }
 });
 
+// src/utils/fair-concurrency-limiter.ts
+var FairConcurrencyLimiter;
+var init_fair_concurrency_limiter = __esm({
+  "src/utils/fair-concurrency-limiter.ts"() {
+    "use strict";
+    init_logger();
+    FairConcurrencyLimiter = class _FairConcurrencyLimiter {
+      maxConcurrent;
+      globalActive = 0;
+      // Per-session FIFO queues
+      sessionQueues = /* @__PURE__ */ new Map();
+      // Round-robin order of sessions with waiting entries
+      roundRobinSessions = [];
+      roundRobinIndex = 0;
+      // Per-session active count (for stats)
+      sessionActive = /* @__PURE__ */ new Map();
+      constructor(maxConcurrent) {
+        this.maxConcurrent = maxConcurrent;
+      }
+      static getInstance(maxConcurrent) {
+        const key = Symbol.for("visor.fairConcurrencyLimiter");
+        let instance = globalThis[key];
+        if (!instance) {
+          instance = new _FairConcurrencyLimiter(maxConcurrent);
+          globalThis[key] = instance;
+          logger.info(`[FairLimiter] Created global fair concurrency limiter (max: ${maxConcurrent})`);
+        } else if (instance.maxConcurrent !== maxConcurrent) {
+          const old = instance.maxConcurrent;
+          instance.maxConcurrent = maxConcurrent;
+          logger.info(`[FairLimiter] Updated max concurrency: ${old} -> ${maxConcurrent}`);
+          instance._processQueue();
+        }
+        return instance;
+      }
+      /**
+       * Try to acquire a slot immediately (non-blocking).
+       */
+      tryAcquire(sessionId) {
+        if (this.globalActive >= this.maxConcurrent) {
+          return false;
+        }
+        this.globalActive++;
+        const sid = sessionId || "__anonymous__";
+        this.sessionActive.set(sid, (this.sessionActive.get(sid) || 0) + 1);
+        return true;
+      }
+      /**
+       * Acquire a slot, waiting in a fair queue if necessary.
+       * Sessions are served round-robin so no single session can starve others.
+       */
+      async acquire(sessionId, _debug, queueTimeout) {
+        const sid = sessionId || "__anonymous__";
+        if (this.tryAcquire(sid)) {
+          return true;
+        }
+        const totalQueued = this._totalQueued();
+        const sessionsWaiting = this.sessionQueues.size;
+        const sessionQueueLen = this.sessionQueues.get(sid)?.length || 0;
+        logger.info(
+          `[FairLimiter] Slot unavailable (${this.globalActive}/${this.maxConcurrent} active). Session "${sid}" queued (${sessionQueueLen} own + ${totalQueued} total across ${sessionsWaiting} sessions). Waiting...`
+        );
+        const queuedAt = Date.now();
+        const effectiveTimeout = queueTimeout ?? 12e4;
+        return new Promise((resolve9, reject) => {
+          const entry = { resolve: resolve9, reject, queuedAt };
+          entry.reminder = setInterval(() => {
+            const waited = Math.round((Date.now() - queuedAt) / 1e3);
+            const curQueued = this._totalQueued();
+            const curSessions = this._waitingSessions();
+            logger.info(
+              `[FairLimiter] Session "${sid}" still waiting (${waited}s). ${this.globalActive}/${this.maxConcurrent} active, ${curQueued} queued across ${curSessions} sessions.`
+            );
+          }, 15e3);
+          let queue = this.sessionQueues.get(sid);
+          if (!queue) {
+            queue = [];
+            this.sessionQueues.set(sid, queue);
+            this.roundRobinSessions.push(sid);
+          }
+          queue.push(entry);
+          if (effectiveTimeout > 0) {
+            setTimeout(() => {
+              const q = this.sessionQueues.get(sid);
+              if (q) {
+                const idx = q.indexOf(entry);
+                if (idx !== -1) {
+                  q.splice(idx, 1);
+                  if (q.length === 0) {
+                    this.sessionQueues.delete(sid);
+                    this._removeFromRoundRobin(sid);
+                  }
+                  this._clearReminder(entry);
+                  reject(
+                    new Error(
+                      `[FairLimiter] Queue timeout: session "${sid}" waited ${effectiveTimeout}ms for a slot`
+                    )
+                  );
+                }
+              }
+            }, effectiveTimeout);
+          }
+        });
+      }
+      /**
+       * Release a slot and grant the next one fairly (round-robin across sessions).
+       */
+      release(sessionId, _debug) {
+        const sid = sessionId || "__anonymous__";
+        this.globalActive = Math.max(0, this.globalActive - 1);
+        const active = this.sessionActive.get(sid);
+        if (active !== void 0) {
+          if (active <= 1) {
+            this.sessionActive.delete(sid);
+          } else {
+            this.sessionActive.set(sid, active - 1);
+          }
+        }
+        this._processQueue();
+      }
+      /**
+       * Round-robin queue processing: cycle through sessions and grant one slot per session per round.
+       */
+      _processQueue() {
+        const toGrant = [];
+        while (this.globalActive < this.maxConcurrent && this.roundRobinSessions.length > 0) {
+          if (this.roundRobinIndex >= this.roundRobinSessions.length) {
+            this.roundRobinIndex = 0;
+          }
+          const sid = this.roundRobinSessions[this.roundRobinIndex];
+          const queue = this.sessionQueues.get(sid);
+          if (!queue || queue.length === 0) {
+            this.sessionQueues.delete(sid);
+            this.roundRobinSessions.splice(this.roundRobinIndex, 1);
+            continue;
+          }
+          const entry = queue.shift();
+          if (queue.length === 0) {
+            this.sessionQueues.delete(sid);
+            this.roundRobinSessions.splice(this.roundRobinIndex, 1);
+          } else {
+            this.roundRobinIndex++;
+          }
+          this.globalActive++;
+          this.sessionActive.set(sid, (this.sessionActive.get(sid) || 0) + 1);
+          toGrant.push({ entry, sid });
+        }
+        for (const { entry, sid } of toGrant) {
+          this._clearReminder(entry);
+          const waitedMs = Date.now() - entry.queuedAt;
+          if (waitedMs > 100) {
+            logger.info(
+              `[FairLimiter] Session "${sid}" acquired slot after ${Math.round(waitedMs / 1e3)}s wait.`
+            );
+          }
+          setImmediate(() => entry.resolve(true));
+        }
+      }
+      getStats() {
+        const perSession = {};
+        const allSessions = /* @__PURE__ */ new Set([...this.sessionActive.keys(), ...this.sessionQueues.keys()]);
+        for (const sid of allSessions) {
+          perSession[sid] = {
+            active: this.sessionActive.get(sid) || 0,
+            queued: this.sessionQueues.get(sid)?.length || 0
+          };
+        }
+        return {
+          globalActive: this.globalActive,
+          maxConcurrent: this.maxConcurrent,
+          queueSize: this._totalQueued(),
+          waitingSessions: this._waitingSessions(),
+          perSession
+        };
+      }
+      cleanup() {
+        for (const queue of this.sessionQueues.values()) {
+          for (const entry of queue) {
+            this._clearReminder(entry);
+          }
+        }
+        this.sessionQueues.clear();
+        this.roundRobinSessions = [];
+        this.roundRobinIndex = 0;
+        const key = Symbol.for("visor.fairConcurrencyLimiter");
+        delete globalThis[key];
+      }
+      shutdown() {
+        this.cleanup();
+      }
+      // -- helpers --
+      _totalQueued() {
+        let n = 0;
+        for (const q of this.sessionQueues.values()) n += q.length;
+        return n;
+      }
+      _waitingSessions() {
+        return this.roundRobinSessions.length;
+      }
+      _removeFromRoundRobin(sid) {
+        const idx = this.roundRobinSessions.indexOf(sid);
+        if (idx !== -1) {
+          this.roundRobinSessions.splice(idx, 1);
+          if (this.roundRobinIndex > idx) {
+            this.roundRobinIndex--;
+          }
+        }
+      }
+      _clearReminder(entry) {
+        if (entry.reminder) {
+          clearInterval(entry.reminder);
+          entry.reminder = void 0;
+        }
+      }
+    };
+  }
+});
+
 // src/state-machine/context/build-engine-context.ts
 var build_engine_context_exports = {};
 __export(build_engine_context_exports, {
@@ -12801,15 +13040,30 @@ function buildEngineContextForRun(workingDirectory, config, prInfo, debug, maxPa
   const journal = new ExecutionJournal();
   const memory = MemoryStore.getInstance(clonedConfig.memory);
   let sharedConcurrencyLimiter = void 0;
-  if (clonedConfig.max_ai_concurrency && _DelegationManager) {
-    sharedConcurrencyLimiter = new _DelegationManager({
-      maxConcurrent: clonedConfig.max_ai_concurrency,
-      maxPerSession: 999
-      // No per-session limit needed for global AI gating
-    });
-    logger.debug(
-      `[EngineContext] Created shared AI concurrency limiter (max: ${clonedConfig.max_ai_concurrency})`
-    );
+  const sessionId = generateHumanId();
+  if (clonedConfig.max_ai_concurrency) {
+    const fairLimiter = FairConcurrencyLimiter.getInstance(clonedConfig.max_ai_concurrency);
+    sharedConcurrencyLimiter = {
+      async acquire(parentSessionId, _dbg, queueTimeout) {
+        const sid = parentSessionId || sessionId;
+        return fairLimiter.acquire(sid, _dbg, queueTimeout);
+      },
+      release(parentSessionId, _dbg) {
+        const sid = parentSessionId || sessionId;
+        return fairLimiter.release(sid, _dbg);
+      },
+      tryAcquire(parentSessionId) {
+        const sid = parentSessionId || sessionId;
+        return fairLimiter.tryAcquire(sid);
+      },
+      getStats() {
+        return fairLimiter.getStats();
+      },
+      shutdown() {
+      },
+      cleanup() {
+      }
+    };
   }
   return {
     mode: "state-machine",
@@ -12819,7 +13073,7 @@ function buildEngineContextForRun(workingDirectory, config, prInfo, debug, maxPa
     memory,
     workingDirectory,
     originalWorkingDirectory: workingDirectory,
-    sessionId: generateHumanId(),
+    sessionId,
     event: prInfo.eventType,
     debug,
     maxParallelism,
@@ -12873,7 +13127,6 @@ async function initializeWorkspace(context2) {
     return context2;
   }
 }
-var _DelegationManager;
 var init_build_engine_context = __esm({
   "src/state-machine/context/build-engine-context.ts"() {
     "use strict";
@@ -12882,14 +13135,7 @@ var init_build_engine_context = __esm({
     init_human_id();
     init_logger();
     init_workspace_manager();
-    _DelegationManager = null;
-    try {
-      const probe = __require("@probelabs/probe");
-      if (probe && typeof probe.DelegationManager === "function") {
-        _DelegationManager = probe.DelegationManager;
-      }
-    } catch {
-    }
+    init_fair_concurrency_limiter();
   }
 });
 
@@ -13033,7 +13279,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const map = options?.webhookContext?.webhookData;
             if (map) {
-              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-PU67PWTU.mjs");
+              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-CWLPAM5U.mjs");
               const reg = CheckProviderRegistry2.getInstance();
               const p = reg.getProvider("http_input");
               if (p && typeof p.setWebhookContext === "function") p.setWebhookContext(map);
@@ -13146,7 +13392,7 @@ var init_state_machine_execution_engine = __esm({
           logger.info("[StateMachine] Using state machine engine");
         }
         if (!config) {
-          const { ConfigManager } = await import("./config-D6WF2U4B.mjs");
+          const { ConfigManager } = await import("./config-DP5QU3XC.mjs");
           const configManager = new ConfigManager();
           config = await configManager.getDefaultConfig();
           logger.debug("[StateMachine] Using default configuration (no config provided)");
@@ -13156,7 +13402,7 @@ var init_state_machine_execution_engine = __esm({
           tag_filter: tagFilter
         } : config;
         try {
-          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-PU67PWTU.mjs");
+          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-CWLPAM5U.mjs");
           const registry = CheckProviderRegistry2.getInstance();
           registry.setCustomTools(configWithTagFilter.tools || {});
         } catch (error) {
@@ -13220,7 +13466,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const webhookData = this.executionContext?.webhookContext?.webhookData;
             if (webhookData instanceof Map) {
-              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-4TCT2P7A.mjs");
+              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-6NUB2IHV.mjs");
               const slackCtx = extractSlackContext2(webhookData);
               if (slackCtx) {
                 const payload = Array.from(webhookData.values())[0];
@@ -13249,7 +13495,7 @@ var init_state_machine_execution_engine = __esm({
         if (Array.isArray(configWithTagFilter.frontends) && configWithTagFilter.frontends.length > 0) {
           try {
             const { EventBus } = await import("./event-bus-5K3Y2FCS.mjs");
-            const { FrontendsHost } = await import("./host-QYPOS4R6.mjs");
+            const { FrontendsHost } = await import("./host-BTHRY6NS.mjs");
             const bus = new EventBus();
             context2.eventBus = bus;
             frontendsHost = new FrontendsHost(bus, logger);
@@ -39826,7 +40072,27 @@ async function acquirePromptLock() {
     activePrompt = true;
     return;
   }
-  await new Promise((resolve9) => waiters.push(resolve9));
+  console.error(
+    `[human-input] Prompt queued, waiting for active prompt to finish (${waiters.length} already waiting).`
+  );
+  const queuedAt = Date.now();
+  const reminder = setInterval(() => {
+    const waited = Math.round((Date.now() - queuedAt) / 1e3);
+    console.error(
+      `[human-input] Still waiting for prompt lock (${waited}s, ${waiters.length} in queue).`
+    );
+  }, 1e4);
+  try {
+    await new Promise((resolve9) => waiters.push(resolve9));
+  } finally {
+    clearInterval(reminder);
+    const waitedMs = Date.now() - queuedAt;
+    if (waitedMs > 100) {
+      console.error(
+        `[human-input] Prompt lock acquired after ${Math.round(waitedMs / 1e3)}s wait.`
+      );
+    }
+  }
   activePrompt = true;
 }
 function releasePromptLock() {
@@ -40908,8 +41174,8 @@ function buildBuiltinGlobals(opts) {
   const asyncFunctionNames = /* @__PURE__ */ new Set();
   const scheduleFn = async (args = {}) => {
     try {
-      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-5FVFYH2A.mjs");
-      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-4TCT2P7A.mjs");
+      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-KKQ4W7KU.mjs");
+      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-6NUB2IHV.mjs");
       const parentCtx = opts.sessionInfo?._parentContext;
       const webhookData = parentCtx?.prInfo?.eventContext?.webhookData;
       const visorCfg = parentCtx?.config;
@@ -44054,4 +44320,4 @@ undici/lib/fetch/body.js:
 undici/lib/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-P5P6BOO7.mjs.map
+//# sourceMappingURL=chunk-3LXYZ2OQ.mjs.map