@probelabs/visor 0.1.182-ee → 0.1.183-ee

package/dist/sdk/{chunk-TQQNSHQV.mjs → chunk-UXB4XWEE.mjs}

@@ -31,11 +31,11 @@ import {
   init_utcp_check_provider,
   normalizeIssue,
   normalizeIssueArray
-} from "./chunk-7XRSCOKE.mjs";
+} from "./chunk-P2K4VOMU.mjs";
 import {
   getPromptStateManager,
   init_prompt_state
-} from "./chunk-7VTZDC2X.mjs";
+} from "./chunk-MEB2TTIE.mjs";
 import {
   init_tracer_init,
   initializeTracer
@@ -48,17 +48,17 @@ import {
 import {
   commandExecutor,
   init_command_executor
-} from "./chunk-RHKPFJLG.mjs";
+} from "./chunk-S5FSRHMY.mjs";
 import {
   DependencyResolver,
   WorkflowRegistry,
   init_dependency_resolver,
   init_workflow_registry
-} from "./chunk-J27D43HS.mjs";
+} from "./chunk-54KOAC4W.mjs";
 import {
   config_exports,
   init_config
-} from "./chunk-ZOF5QT6U.mjs";
+} from "./chunk-7W5QCO4Y.mjs";
 import {
   ExecutionJournal,
   checkLoopBudget,
@@ -67,14 +67,16 @@ import {
   init_routing,
   init_snapshot_store,
   snapshot_store_exports
-} from "./chunk-ANUT54HW.mjs";
+} from "./chunk-WKLJ57WF.mjs";
 import {
   FailureConditionEvaluator,
   init_failure_condition_evaluator
-} from "./chunk-DHETLQIX.mjs";
+} from "./chunk-GA2TYKSR.mjs";
 import {
   addEvent,
+  emitImmediateSpan,
   emitNdjsonFallback,
+  emitNdjsonFullSpan,
   emitNdjsonSpanWithEvents,
   fallback_ndjson_exports,
   init_fallback_ndjson,
@@ -82,20 +84,20 @@ import {
   setSpanAttributes,
   trace_helpers_exports,
   withActiveSpan
-} from "./chunk-7ERVRLDV.mjs";
+} from "./chunk-XOAEKFKB.mjs";
 import {
   generateHumanId,
   init_human_id
-} from "./chunk-QXT47ZHR.mjs";
+} from "./chunk-G7GSN3SK.mjs";
 import {
   addDiagramBlock,
   init_metrics,
   metrics_exports
-} from "./chunk-34QX63WK.mjs";
+} from "./chunk-FWWLD555.mjs";
 import {
   createExtendedLiquid,
   init_liquid_extensions
-} from "./chunk-PQWZ6NFL.mjs";
+} from "./chunk-4BN2XI4X.mjs";
 import {
   createPermissionHelpers,
   detectLocalMode,
@@ -112,18 +114,18 @@ import {
   MemoryStore,
   init_memory_store,
   memory_store_exports
-} from "./chunk-UFHOIB3R.mjs";
+} from "./chunk-RI4ONH5X.mjs";
 import {
   init_logger,
   logger,
   logger_exports
-} from "./chunk-FT3I25QV.mjs";
+} from "./chunk-ZPYODGYA.mjs";
 import {
   context,
   init_lazy_otel,
   lazy_otel_exports,
   trace
-} from "./chunk-UCMJJ3IM.mjs";
+} from "./chunk-B2OUZAWY.mjs";
 import {
   __commonJS,
   __esm,
@@ -238,6 +240,11 @@ function getCurrentDateXml() {
 }
 function createProbeTracerAdapter(fallbackTracer) {
   const fallback = fallbackTracer && typeof fallbackTracer === "object" ? fallbackTracer : null;
+  const LIVE_LIFECYCLE_SPANS = /* @__PURE__ */ new Set(["visor.ai_check", "ai.request", "search.delegate"]);
+  const PROBE_LIFECYCLE_ALIASES = {
+    "ai.request": "probe.ai_request",
+    "search.delegate": "probe.search_delegate"
+  };
   const flattenAttrs = (attrs) => {
     if (!attrs) return attrs;
     const out = {};
@@ -265,8 +272,13 @@ function createProbeTracerAdapter(fallbackTracer) {
     "delegation.start",
     "delegation.complete",
     "graceful_stop.invoked",
+    "graceful_stop.initiated",
     "probe.timeout_configured",
-    "negotiated_timeout.observer"
+    "negotiated_timeout.observer",
+    "negotiated_timeout.observer_extended",
+    "negotiated_timeout.observer_declined",
+    "negotiated_timeout.observer_exhausted",
+    "negotiated_timeout.abort_summary"
   ]);
   const emitEvent = (name, attrs) => {
     try {
@@ -288,13 +300,94 @@ function createProbeTracerAdapter(fallbackTracer) {
     } catch {
     }
   };
+  const emitLifecycle = (name, phase, attrs) => {
+    emitImmediateSpan(`${name}.${phase}`, {
+      "probe.lifecycle.target": name,
+      ...flattenAttrs(attrs)
+    });
+    const alias = PROBE_LIFECYCLE_ALIASES[name];
+    if (alias) {
+      emitImmediateSpan(`${alias}.${phase}`, {
+        "probe.lifecycle.target": name,
+        ...flattenAttrs(attrs)
+      });
+    }
+  };
   return {
-    withSpan: async (name, fn, attrs) => withActiveSpan(name, attrs, async (span) => {
-      if (fallback && typeof fallback.withSpan === "function") {
-        return await fallback.withSpan(name, async () => fn(span), attrs);
+    withSpan: async (name, fn, attrs, onResult) => {
+      const startHr = process.hrtime();
+      if (LIVE_LIFECYCLE_SPANS.has(name)) {
+        emitLifecycle(name, "started", attrs);
+      }
+      try {
+        const result = await withActiveSpan(name, attrs, async (span) => {
+          let innerResult;
+          if (fallback && typeof fallback.withSpan === "function") {
+            innerResult = await fallback.withSpan(name, async () => fn(span), attrs);
+          } else {
+            innerResult = await fn(span);
+          }
+          const extraAttrs = {};
+          if (onResult) {
+            try {
+              const capturingSpan = {
+                setAttributes: (a) => {
+                  Object.assign(extraAttrs, a);
+                  try {
+                    span.setAttributes(a);
+                  } catch {
+                  }
+                },
+                setAttribute: (k, v) => {
+                  extraAttrs[k] = v;
+                  try {
+                    span.setAttribute(k, v);
+                  } catch {
+                  }
+                },
+                addEvent: (...args) => {
+                  try {
+                    span.addEvent(...args);
+                  } catch {
+                  }
+                }
+              };
+              onResult(capturingSpan, innerResult);
+            } catch {
+            }
+          }
+          try {
+            const endHr = process.hrtime();
+            const ctx = span.spanContext?.() || {};
+            const parentCtx = span.parentSpanContext || span._parentSpanContext;
+            emitNdjsonFullSpan({
+              name,
+              traceId: ctx.traceId,
+              spanId: ctx.spanId,
+              parentSpanId: parentCtx?.spanId,
+              startTime: [startHr[0], startHr[1]],
+              endTime: [endHr[0], endHr[1]],
+              attributes: { ...flattenAttrs(attrs), ...flattenAttrs(extraAttrs) },
+              events: [],
+              status: { code: 1 }
+            });
+          } catch {
+          }
+          return innerResult;
+        });
+        if (LIVE_LIFECYCLE_SPANS.has(name)) {
+          emitLifecycle(name, "completed");
+        }
+        return result;
+      } catch (error) {
+        if (LIVE_LIFECYCLE_SPANS.has(name)) {
+          emitLifecycle(name, "failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        throw error;
       }
-      return await fn(span);
-    }),
+    },
     recordEvent: (name, attrs) => {
       emitEvent(name, attrs);
       if (fallback && typeof fallback.recordEvent === "function") {
@@ -328,6 +421,11 @@ function createProbeTracerAdapter(fallbackTracer) {
         "tool.success": success,
         ...metadata || {}
       });
+      emitImmediateSpan(success ? "probe.tool.completed" : "probe.tool.failed", {
+        "tool.name": toolName,
+        "tool.duration_ms": durationMs,
+        "tool.success": success
+      });
       if (fallback && typeof fallback.recordToolResult === "function") {
         try {
           fallback.recordToolResult(toolName, result, success, durationMs, metadata);
@@ -337,6 +435,11 @@ function createProbeTracerAdapter(fallbackTracer) {
     },
     recordToolDecision: (toolName, params, metadata) => {
       const paramsStr = typeof params === "string" ? params : JSON.stringify(params || {});
+      emitImmediateSpan("probe.tool.started", {
+        "tool.name": toolName,
+        "tool.params.length": paramsStr.length,
+        ...flattenAttrs(metadata)
+      });
       emitEvent("tool.decision", {
         "tool.name": toolName,
         "tool.params": paramsStr.substring(0, 5e3),
@@ -377,6 +480,76 @@ function createProbeTracerAdapter(fallbackTracer) {
         }
       }
     },
+    createToolSpan: (toolName, attrs) => {
+      let fallbackSpan = null;
+      if (fallback && typeof fallback.createToolSpan === "function") {
+        try {
+          fallbackSpan = fallback.createToolSpan(toolName, attrs);
+        } catch {
+        }
+      }
+      emitImmediateSpan("probe.tool.started", {
+        "tool.name": toolName,
+        ...flattenAttrs(attrs)
+      });
+      const tracer = trace.getTracer("visor");
+      const span = tracer.startSpan(`probe.tool.${toolName}`, {
+        attributes: {
+          "tool.name": toolName,
+          ...flattenAttrs(attrs)
+        }
+      });
+      return {
+        setAttributes: (spanAttrs) => {
+          try {
+            if (spanAttrs) span.setAttributes(spanAttrs);
+          } catch {
+          }
+          if (fallbackSpan?.setAttributes) {
+            try {
+              fallbackSpan.setAttributes(spanAttrs);
+            } catch {
+            }
+          }
+        },
+        setStatus: (status) => {
+          try {
+            span.setStatus(status);
+          } catch {
+          }
+          if (fallbackSpan?.setStatus) {
+            try {
+              fallbackSpan.setStatus(status);
+            } catch {
+            }
+          }
+        },
+        addEvent: (eventName, eventAttrs) => {
+          try {
+            span.addEvent(eventName, flattenAttrs(eventAttrs) || {});
+          } catch {
+          }
+          if (fallbackSpan?.addEvent) {
+            try {
+              fallbackSpan.addEvent(eventName, eventAttrs);
+            } catch {
+            }
+          }
+        },
+        end: () => {
+          try {
+            span.end();
+          } catch {
+          }
+          if (fallbackSpan?.end) {
+            try {
+              fallbackSpan.end();
+            } catch {
+            }
+          }
+        }
+      };
+    },
     createDelegationSpan: (sessionId, task) => {
       let fallbackSpan = null;
       if (fallback && typeof fallback.createDelegationSpan === "function") {
@@ -398,10 +571,19 @@ function createProbeTracerAdapter(fallbackTracer) {
       }
       if (!span && fallbackSpan) return fallbackSpan;
       if (!span) return null;
+      const accumulated = {
+        "delegation.session_id": sessionId,
+        "delegation.task": task
+      };
+      const delegStartHr = process.hrtime();
+      let delegStatus = 1;
       return {
         setAttributes: (attrs) => {
           try {
-            if (attrs) span.setAttributes(attrs);
+            if (attrs) {
+              Object.assign(accumulated, attrs);
+              span.setAttributes(attrs);
+            }
           } catch {
           }
           if (fallbackSpan && typeof fallbackSpan.setAttributes === "function") {
@@ -413,6 +595,8 @@ function createProbeTracerAdapter(fallbackTracer) {
         },
         setStatus: (status) => {
           try {
+            const code = status?.code;
+            if (code === 2) delegStatus = 2;
             span.setStatus(status);
           } catch {
           }
@@ -434,6 +618,23 @@ function createProbeTracerAdapter(fallbackTracer) {
             } catch {
             }
           }
+          try {
+            const delegEndHr = process.hrtime();
+            const ctx = span.spanContext?.() || {};
+            emitNdjsonFullSpan({
+              name: "probe.delegation",
+              traceId: ctx.traceId,
+              spanId: ctx.spanId,
+              parentSpanId: void 0,
+              // delegation spans are roots within probe
+              startTime: [delegStartHr[0], delegStartHr[1]],
+              endTime: [delegEndHr[0], delegEndHr[1]],
+              attributes: flattenAttrs(accumulated) || {},
+              events: [],
+              status: { code: delegStatus }
+            });
+          } catch {
+          }
         }
       };
     },
@@ -481,6 +682,7 @@ var init_ai_review_service = __esm({
     init_logger();
     init_lazy_otel();
     init_trace_helpers();
+    init_fallback_ndjson();
     init_tracer_init();
     init_diff_processor();
     init_comment_metadata();
@@ -1295,7 +1497,24 @@ ${this.escapeXml(processedFallbackDiff)}
     <text>${this.escapeXml(String(current.text || ""))}</text>
     <timestamp>${this.escapeXml(String(current.timestamp || ""))}</timestamp>
     <origin>${this.escapeXml(String(current.origin || ""))}</origin>${this.formatFilesXml(current.files)}
-  </current>
+  </current>`;
+          const activeTasks = prInfo?.activeTasks;
+          if (Array.isArray(activeTasks) && activeTasks.length > 0) {
+            xml += `
+  <active_tasks hint="These tasks are already in progress in this thread. If the current message is asking about the same thing as an active task, inform the user that you are already working on it. If it is a different question or a follow-up, proceed normally.">`;
+            for (const t of activeTasks) {
+              xml += `
+    <task>
+      <id>${this.escapeXml(String(t.id || ""))}</id>
+      <state>${this.escapeXml(String(t.state || ""))}</state>
+      <started>${this.escapeXml(String(t.created_at || ""))}</started>
+      <trigger_message>${this.escapeXml(String(t.trigger_message || ""))}</trigger_message>
+    </task>`;
+            }
+            xml += `
+  </active_tasks>`;
+          }
+          xml += `
 </slack_context>`;
           return xml;
         } catch {
@@ -1817,6 +2036,15 @@ ${"=".repeat(60)}
           if (!systemPrompt && schema !== "code-review" && !this.config.promptType) {
             systemPrompt = "You are general assistant, follow user instructions.";
           }
+          if (systemPrompt && (this.config.aiTimeout || this.config.timeoutBehavior)) {
+            systemPrompt += `
+
+IMPORTANT \u2014 Time-limit behavior:
+If you receive a message that the time limit has been reached or your operation is being interrupted, this means YOUR ALLOCATED TIME BUDGET for this task has been exhausted. The system is NOT shutting down or going offline.
+- Frame it as: "I ran out of the allocated time for this task."
+- NEVER say "the system is shutting down", "try again when the system is back online", or similar misleading language.
+- Summarize what you accomplished, what you didn't finish, and any actionable recommendations the user can follow up on.`;
+          }
           log(
             `\u{1F527} AIReviewService config: allowEdit=${this.config.allowEdit}, allowBash=${this.config.allowBash}, promptType=${this.config.promptType}`
           );
@@ -2383,12 +2611,21 @@ ${"=".repeat(60)}
               );
             }
           }
+          const buildPlainTextOutput = (text, rawOutput) => {
+            const trimmed = typeof text === "string" ? text.trim() : "";
+            const out = {};
+            if (trimmed) {
+              out.text = trimmed;
+              out.content = trimmed;
+            }
+            if (rawOutput) out._rawOutput = rawOutput;
+            return out;
+          };
           if (_schema === "plain" || !_schema) {
             log(
               `\u{1F4CB} ${_schema === "plain" ? "Plain" : "No"} schema detected - treating raw response as text output`
             );
-            const trimmed = typeof response === "string" ? response.trim() : "";
-            const out = trimmed ? { text: trimmed } : {};
+            const out = buildPlainTextOutput(response);
             return {
               issues: [],
               // Expose assistant-style content via output.text so downstream formatters
@@ -2427,9 +2664,10 @@ ${"=".repeat(60)}
               if (!recovered) {
                 if (response.toLowerCase().includes("i cannot") || response.toLowerCase().includes("unable to")) {
                   console.error("\u{1F6AB} AI refused to analyze - returning refusal as output");
-                  const trimmed2 = responseForParsing.trim();
-                  const out = trimmed2 ? { text: trimmed2 } : {};
-                  if (rawOutputBlocks.length > 0) out._rawOutput = rawOutputBlocks.join("\n\n");
+                  const out = buildPlainTextOutput(
+                    responseForParsing,
+                    rawOutputBlocks.length > 0 ? rawOutputBlocks.join("\n\n") : void 0
+                  );
                   return {
                     issues: [],
                     output: out,
@@ -2437,9 +2675,10 @@ ${"=".repeat(60)}
                   };
                 }
                 log("\u{1F527} Treating response as plain text (no JSON extraction)");
-                const trimmed = responseForParsing.trim();
-                const fallbackOut = { text: trimmed };
-                if (rawOutputBlocks.length > 0) fallbackOut._rawOutput = rawOutputBlocks.join("\n\n");
+                const fallbackOut = buildPlainTextOutput(
+                  responseForParsing,
+                  rawOutputBlocks.length > 0 ? rawOutputBlocks.join("\n\n") : void 0
+                );
                 return {
                   issues: [],
                   output: fallbackOut,
@@ -4295,7 +4534,7 @@ async function executeWorkflowAsTool(workflowId, args, context2, argsOverrides)
     ...args,
     ...argsOverrides
   };
-  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-EXMC6JIS.mjs");
+  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-X2UREEH7.mjs");
   const provider = new WorkflowCheckProvider2();
   const checkConfig = {
     type: "workflow",
@@ -6289,6 +6528,12 @@ function addEvent2(name, attrs) {
     helpers.addEvent(name, attrs);
   }
 }
+function emitImmediateSpan2(name, attrs, options) {
+  const helpers = getTraceHelpers();
+  if (helpers) {
+    helpers.emitImmediateSpan(name, attrs, options);
+  }
+}
 function setSpanError(err) {
   const helpers = getTraceHelpers();
   if (helpers) {
@@ -7503,7 +7748,7 @@ var init_env_filter = __esm({
 });
 
 // src/sandbox/trace-ingester.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
 function getTracer() {
   try {
     const helpers = (init_trace_helpers(), __toCommonJS(trace_helpers_exports));
@@ -7519,16 +7764,27 @@ function getOtelContext() {
     return null;
   }
 }
-function ingestChildTrace(filePath) {
-  let content;
-  try {
-    content = readFileSync3(filePath, "utf8");
-  } catch {
-    return;
-  }
-  const lines = content.split("\n");
+function buildFallbackSpanContext(child) {
+  if (!child.traceId || !child.spanId) return null;
+  return {
+    traceId: child.traceId,
+    spanId: child.spanId,
+    traceFlags: 1,
+    isRemote: true
+  };
+}
+function computeSpanKey(child) {
+  if (child.traceId && child.spanId) return `${child.traceId}:${child.spanId}`;
+  const timing = JSON.stringify({
+    name: child.name,
+    startTime: child.startTime,
+    endTime: child.endTime
+  });
+  return `fallback:${timing}`;
+}
+function parseLines(text) {
   const spans = [];
-  for (const line of lines) {
+  for (const line of text.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -7536,61 +7792,186 @@ function ingestChildTrace(filePath) {
     } catch {
     }
   }
-  if (spans.length === 0) return;
+  return spans;
+}
+function emitChildSpan(tracer, otel, parentContext, child) {
+  if (!child.name) return;
+  if (child.name === "visor.run" || child.name === "visor.event") return;
+  if (!child.traceId && !child.startTime) return;
+  try {
+    const spanOptions = {
+      attributes: {
+        "visor.sandbox.child_span": true,
+        "visor.sandbox.original_trace_id": child.traceId || "",
+        "visor.sandbox.original_span_id": child.spanId || "",
+        "visor.sandbox.original_parent_span_id": child.parentSpanId || "",
+        ...child.attributes || {}
+      }
+    };
+    if (child.startTime) {
+      spanOptions.startTime = child.startTime;
+    }
+    const span = tracer.startSpan(child.name, spanOptions, parentContext);
+    if (Array.isArray(child.events)) {
+      for (const evt of child.events) {
+        const evtAttrs = evt.attributes || evt.attrs || {};
+        if (evt.time) span.addEvent(evt.name, evtAttrs, evt.time);
+        else span.addEvent(evt.name, evtAttrs);
+      }
+    }
+    if (child.status?.code === 2) {
+      try {
+        span.setStatus({
+          code: otel?.SpanStatusCode?.ERROR || 2,
+          message: child.status.message
+        });
+      } catch {
+      }
+    }
+    if (child.endTime) span.end(child.endTime);
+    else span.end();
+    if (otel?.trace?.setSpan) {
+      return otel.trace.setSpan(parentContext, span);
+    }
+    const fallbackSpanContext = buildFallbackSpanContext(child);
+    if (fallbackSpanContext && otel?.trace?.setSpanContext) {
+      return otel.trace.setSpanContext(parentContext, fallbackSpanContext);
+    }
+    return parentContext;
+  } catch {
+    const fallbackSpanContext = buildFallbackSpanContext(child);
+    if (fallbackSpanContext && otel?.trace?.setSpanContext) {
+      try {
+        return otel.trace.setSpanContext(parentContext, fallbackSpanContext);
+      } catch {
+      }
+    }
+    return parentContext;
+  }
+}
+function ingestRecords(records, seenKeys, parentContext, replayContexts) {
+  if (records.length === 0) return 0;
   const tracer = getTracer();
   if (!tracer) {
-    logger.info(`[trace-ingester] ${spans.length} child spans (OTel unavailable)`);
-    return;
+    logger.info(`[trace-ingester] ${records.length} child spans (OTel unavailable)`);
+    return 0;
   }
   const otel = getOtelContext();
-  for (const child of spans) {
-    if (!child.name) continue;
-    if (child.name === "visor.run" || child.name === "visor.event") continue;
-    if (!child.traceId && !child.startTime) continue;
-    try {
-      const spanOptions = {
-        attributes: {
-          "visor.sandbox.child_span": true,
-          ...child.attributes || {}
-        }
-      };
-      if (child.startTime) {
-        spanOptions.startTime = child.startTime;
-      }
-      const span = tracer.startSpan(`child: ${child.name}`, spanOptions);
-      if (Array.isArray(child.events)) {
-        for (const evt of child.events) {
-          const evtAttrs = evt.attributes || evt.attrs || {};
-          if (evt.time) {
-            span.addEvent(evt.name, evtAttrs, evt.time);
-          } else {
-            span.addEvent(evt.name, evtAttrs);
-          }
-        }
+  const effectiveParentContext = parentContext || otel?.context?.active?.();
+  const replayParentContexts = replayContexts ?? /* @__PURE__ */ new Map();
+  let ingested = 0;
+  const pending = records.filter((child) => {
+    const key = computeSpanKey(child);
+    if (seenKeys.has(key)) return false;
+    seenKeys.add(key);
+    return true;
+  });
+  while (pending.length > 0) {
+    let emittedInPass = 0;
+    for (let i = 0; i < pending.length; ) {
+      const child = pending[i];
+      const hasKnownParent = !child.parentSpanId || replayParentContexts.has(child.parentSpanId);
+      const parentCtx = child.parentSpanId ? replayParentContexts.get(child.parentSpanId) || effectiveParentContext : effectiveParentContext;
+      if (!hasKnownParent && pending.some((candidate) => candidate.spanId === child.parentSpanId)) {
+        i += 1;
+        continue;
       }
-      if (child.status && child.status.code === 2) {
-        try {
-          const { SpanStatusCode } = otel || {};
-          span.setStatus({
-            code: SpanStatusCode?.ERROR || 2,
-            message: child.status.message
-          });
-        } catch {
-        }
+      const replayContext = emitChildSpan(tracer, otel, parentCtx, child);
+      if (child.spanId && replayContext) {
+        replayParentContexts.set(child.spanId, replayContext);
       }
-      if (child.endTime) {
-        span.end(child.endTime);
-      } else {
-        span.end();
+      pending.splice(i, 1);
+      ingested += 1;
+      emittedInPass += 1;
+    }
+    if (emittedInPass === 0) {
+      for (const child of pending.splice(0)) {
+        const replayContext = emitChildSpan(tracer, otel, effectiveParentContext, child);
+        if (child.spanId && replayContext) {
+          replayParentContexts.set(child.spanId, replayContext);
+        }
+        ingested += 1;
       }
-    } catch {
+      break;
     }
   }
+  return ingested;
 }
+var ChildTraceTailer;
 var init_trace_ingester = __esm({
   "src/sandbox/trace-ingester.ts"() {
     "use strict";
     init_logger();
+    ChildTraceTailer = class {
+      filePath;
+      pollIntervalMs;
+      seenKeys;
+      parentContext;
+      replayContexts;
+      offset = 0;
+      partialLine = "";
+      timer = null;
+      activePoll = null;
+      constructor(filePath, options) {
+        this.filePath = filePath;
+        this.pollIntervalMs = options?.pollIntervalMs ?? 500;
+        this.seenKeys = options?.seenKeys ?? /* @__PURE__ */ new Set();
+        this.parentContext = options?.parentContext;
+        this.replayContexts = /* @__PURE__ */ new Map();
+      }
+      start() {
+        if (this.timer) return;
+        this.timer = setInterval(() => {
+          if (!this.activePoll) {
+            this.activePoll = this.pollOnce().finally(() => {
+              this.activePoll = null;
+            });
+          }
+        }, this.pollIntervalMs);
+        this.timer.unref?.();
+      }
+      async stop() {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+        }
+        if (this.activePoll) {
+          await this.activePoll;
+        }
+        await this.pollOnce(true);
+      }
+      async pollOnce(finalSweep = false) {
+        if (!existsSync6(this.filePath)) return;
+        let buf;
+        try {
+          buf = readFileSync3(this.filePath);
+        } catch {
+          return;
+        }
+        if (buf.length < this.offset) {
+          this.offset = 0;
+          this.partialLine = "";
+        }
+        if (buf.length === this.offset && !finalSweep) {
+          return;
+        }
+        const chunk = buf.subarray(this.offset).toString("utf8");
+        this.offset = buf.length;
+        if (!chunk && !finalSweep) return;
+        const combined = this.partialLine + chunk;
+        const endsWithNewline = combined.endsWith("\n");
+        const lines = combined.split("\n");
+        this.partialLine = endsWithNewline ? "" : lines.pop() || "";
+        const completedText = lines.join("\n");
+        const records = parseLines(completedText);
+        ingestRecords(records, this.seenKeys, this.parentContext, this.replayContexts);
+        if (finalSweep && this.partialLine.trim()) {
+          const trailing = parseLines(this.partialLine);
+          this.partialLine = "";
+          ingestRecords(trailing, this.seenKeys, this.parentContext, this.replayContexts);
+        }
+      }
+    };
   }
 });
 
@@ -7599,7 +7980,7 @@ var check_runner_exports = {};
 __export(check_runner_exports, {
   CheckRunner: () => CheckRunner
 });
-import { writeFileSync as writeFileSync4, existsSync as existsSync6, unlinkSync as unlinkSync3 } from "fs";
+import { writeFileSync as writeFileSync4, existsSync as existsSync7, unlinkSync as unlinkSync3 } from "fs";
 import { join as join7 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function serializePRInfo(prInfo) {
@@ -7647,11 +8028,13 @@ var init_check_runner = __esm({
        * 5. Return as ReviewSummary
        */
       static async runCheck(sandboxManager, sandboxName, sandboxConfig, checkConfig, prInfo, dependencyResults, timeoutMs, workspaceDefaults, serviceEnvVars) {
+        const checkName = checkConfig.name || "unknown";
+        const engineerCheck = checkName === "engineer-task";
         return withActiveSpan2(
           "visor.sandbox.runCheck",
           {
             "visor.sandbox.name": sandboxName,
-            "visor.check.name": checkConfig.name || "unknown"
+            "visor.check.name": checkName
           },
           async () => {
             const dependencyOutputs = {};
@@ -7676,6 +8059,7 @@ var init_check_runner = __esm({
             }
             const workdir = sandboxConfig.workdir === "host" ? sandboxManager.getRepoPath() : sandboxConfig.workdir || "/workspace";
             let hostTracePath;
+            let traceTailer;
             if (!sandboxConfig.read_only) {
               const traceFileName = `.visor-trace-${randomUUID3().slice(0, 8)}.ndjson`;
               hostTracePath = join7(sandboxManager.getRepoPath(), traceFileName);
@@ -7705,21 +8089,68 @@ var init_check_runner = __esm({
             }
             const command = `echo ${b64Payload} | base64 -d | node ${visorPath}/index.js --run-check -`;
             logger.info(`Executing check in sandbox '${sandboxName}'`);
-            const result = await sandboxManager.exec(sandboxName, {
-              command,
-              env,
-              timeoutMs: timeoutMs || 6e5,
-              maxBuffer: 50 * 1024 * 1024
+            emitImmediateSpan2("visor.sandbox.child.started", {
+              "visor.sandbox.name": sandboxName,
+              "visor.check.name": checkName,
+              "visor.trace.relay": hostTracePath ? "file-tail" : "disabled"
             });
+            if (engineerCheck) {
+              emitImmediateSpan2("visor.engineer.child_spawned", {
+                "visor.sandbox.name": sandboxName,
+                "visor.check.name": checkName,
+                "visor.trace.relay": hostTracePath ? "file-tail" : "disabled"
+              });
+            }
             if (hostTracePath) {
               try {
-                if (existsSync6(hostTracePath)) {
-                  ingestChildTrace(hostTracePath);
-                  unlinkSync3(hostTracePath);
-                }
+                const { context: otContext } = (init_lazy_otel(), __toCommonJS(lazy_otel_exports));
+                traceTailer = new ChildTraceTailer(hostTracePath, {
+                  parentContext: otContext?.active?.()
+                });
               } catch {
+                traceTailer = new ChildTraceTailer(hostTracePath);
+              }
+              traceTailer.start();
+            }
+            emitImmediateSpan2("visor.sandbox.child.waiting", {
+              "visor.sandbox.name": sandboxName,
+              "visor.check.name": checkName
+            });
+            if (engineerCheck) {
+              emitImmediateSpan2("visor.engineer.waiting_on_child", {
+                "visor.sandbox.name": sandboxName,
+                "visor.check.name": checkName
+              });
+            }
+            let result;
+            try {
+              result = await sandboxManager.exec(sandboxName, {
+                command,
+                env,
+                timeoutMs: timeoutMs || 6e5,
+                maxBuffer: 50 * 1024 * 1024
+              });
+              emitImmediateSpan2("visor.sandbox.child.completed", {
+                "visor.sandbox.name": sandboxName,
+                "visor.check.name": checkName
+              });
+            } catch (error) {
+              emitImmediateSpan2("visor.sandbox.child.failed", {
+                "visor.sandbox.name": sandboxName,
+                "visor.check.name": checkName,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              throw error;
+            } finally {
+              if (traceTailer) {
                 try {
-                  if (existsSync6(hostTracePath)) unlinkSync3(hostTracePath);
+                  await traceTailer.stop();
+                } catch {
+                }
+              }
+              if (hostTracePath) {
+                try {
+                  if (existsSync7(hostTracePath)) unlinkSync3(hostTracePath);
                 } catch {
                 }
               }
@@ -7826,6 +8257,7 @@ function extractProjectMeta(dependencyResults) {
 }
 async function executeWithSandboxRouting(checkId, checkConfig, context2, prInfo, dependencyResults, timeout, hostExecute, projectMeta) {
   const sandboxManager = context2.sandboxManager;
+  const engineerCheck = checkId === "engineer-task";
   if (!sandboxManager) {
     return hostExecute();
   }
@@ -7834,8 +8266,30 @@ async function executeWithSandboxRouting(checkId, checkConfig, context2, prInfo,
     context2.config.sandbox
   );
   if (!sandboxName) {
+    emitImmediateSpan("visor.sandbox.routing.host", {
+      "visor.check.id": checkId,
+      "visor.sandbox.selected": ""
+    });
+    if (engineerCheck) {
+      emitImmediateSpan("visor.engineer.sandbox_resolved", {
+        "visor.check.id": checkId,
+        "visor.sandbox.selected": "",
+        "visor.sandbox.mode": "host"
+      });
+    }
     return hostExecute();
   }
+  emitImmediateSpan("visor.sandbox.routing.selected", {
+    "visor.check.id": checkId,
+    "visor.sandbox.selected": sandboxName
+  });
+  if (engineerCheck) {
+    emitImmediateSpan("visor.engineer.sandbox_resolved", {
+      "visor.check.id": checkId,
+      "visor.sandbox.selected": sandboxName,
+      "visor.sandbox.mode": "sandbox"
+    });
+  }
   const sandboxConfig = context2.config.sandboxes?.[sandboxName];
   if (!sandboxConfig) {
     throw new Error(`Sandbox '${sandboxName}' not found in sandboxes configuration`);
@@ -7888,6 +8342,7 @@ var init_sandbox_routing = __esm({
   "src/state-machine/dispatch/sandbox-routing.ts"() {
     "use strict";
     init_logger();
+    init_trace_helpers();
   }
 });
 
@@ -8097,7 +8552,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-P6KDYILF.mjs");
+    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-E3AKRX7P.mjs");
     const fs13 = await import("fs/promises");
     const path15 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
@@ -9777,6 +10232,33 @@ var init_execution_invoker = __esm({
 });
 
 // src/state-machine/states/level-dispatch.ts
+function isEngineerCheck(checkId) {
+  return checkId === "engineer-task";
+}
+function startCheckProgressTelemetry(checkId, providerType, attrs) {
+  const intervalMs = Math.max(
+    5e3,
+    parseInt(process.env.VISOR_CHECK_PROGRESS_INTERVAL_MS || "30000", 10) || 3e4
+  );
+  const startedAt = Date.now();
+  const timer = setInterval(() => {
+    const progressAttrs = {
+      "visor.check.id": checkId,
+      "visor.check.type": providerType,
+      "visor.check.elapsed_ms": Date.now() - startedAt,
+      ...attrs
+    };
+    emitImmediateSpan(`visor.check.${checkId}.progress`, progressAttrs);
+    if (isEngineerCheck(checkId)) {
+      emitImmediateSpan("visor.engineer.progress", progressAttrs);
+    }
+  }, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+  return timer;
+}
+function stopCheckProgressTelemetry(timer) {
+  if (timer) clearInterval(timer);
+}
 async function renderTemplateArgs(args, dependencyResults, context2) {
   if (!args || Object.keys(args).length === 0) {
     return args;
@@ -10486,32 +10968,84 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
         });
       } catch {
       }
-      const itemResult = await withActiveSpan(
-        `visor.check.${checkId}`,
-        {
+      emitImmediateSpan(`visor.check.${checkId}.started`, {
+        "visor.check.id": checkId,
+        "visor.check.type": providerType,
+        "visor.foreach.index": itemIndex,
+        session_id: context2.sessionId,
+        wave: state.wave
+      });
+      if (isEngineerCheck(checkId)) {
+        emitImmediateSpan("visor.engineer.started", {
           "visor.check.id": checkId,
           "visor.check.type": providerType,
-          "visor.foreach.index": itemIndex,
-          session_id: context2.sessionId,
-          wave: state.wave
-        },
-        async (span) => {
-          const res = await executeWithSandboxRouting(
-            checkId,
-            checkConfig,
-            context2,
-            prInfo,
-            dependencyResults,
-            checkConfig.timeout || checkConfig.ai?.timeout || 18e5,
-            () => provider.execute(prInfo, providerConfig, dependencyResults, executionContext)
-          );
-          try {
-            captureCheckOutput(span, res.output);
-          } catch {
+          "visor.foreach.index": itemIndex
+        });
+      }
+      const progressTimer = startCheckProgressTelemetry(checkId, providerType, {
+        "visor.foreach.index": itemIndex,
+        session_id: context2.sessionId,
+        wave: state.wave
+      });
+      let itemResult;
+      try {
+        itemResult = await withActiveSpan(
+          `visor.check.${checkId}`,
+          {
+            "visor.check.id": checkId,
+            "visor.check.type": providerType,
+            "visor.foreach.index": itemIndex,
+            session_id: context2.sessionId,
+            wave: state.wave
+          },
+          async (span) => {
+            const res = await executeWithSandboxRouting(
+              checkId,
+              checkConfig,
+              context2,
+              prInfo,
+              dependencyResults,
+              checkConfig.timeout || checkConfig.ai?.timeout || 18e5,
+              () => provider.execute(prInfo, providerConfig, dependencyResults, executionContext)
+            );
+            try {
+              captureCheckOutput(span, res.output);
+            } catch {
+            }
+            return res;
           }
-          return res;
+        );
+        emitImmediateSpan(`visor.check.${checkId}.completed`, {
+          "visor.check.id": checkId,
+          "visor.check.type": providerType,
+          "visor.foreach.index": itemIndex
+        });
+        if (isEngineerCheck(checkId)) {
+          emitImmediateSpan("visor.engineer.completed", {
+            "visor.check.id": checkId,
+            "visor.check.type": providerType,
+            "visor.foreach.index": itemIndex
+          });
         }
-      );
+      } catch (error) {
+        emitImmediateSpan(`visor.check.${checkId}.failed`, {
+          "visor.check.id": checkId,
+          "visor.check.type": providerType,
+          "visor.foreach.index": itemIndex,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        if (isEngineerCheck(checkId)) {
+          emitImmediateSpan("visor.engineer.failed", {
+            "visor.check.id": checkId,
+            "visor.check.type": providerType,
+            "visor.foreach.index": itemIndex,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        throw error;
+      } finally {
+        stopCheckProgressTelemetry(progressTimer);
+      }
       const enrichedIssues = (itemResult.issues || []).map((issue) => ({
         ...issue,
         checkName: checkId,
@@ -10552,7 +11086,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-KOIH75RZ.mjs");
+            const { loadRendererSchema } = await import("./renderer-schema-BT2IXMLW.mjs");
             schemaObj = await loadRendererSchema(checkConfig.schema);
           } catch {
           }
@@ -10890,7 +11424,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
           }
         }
         try {
-          const { evaluateTransitions } = await import("./routing-CVQT4KHX.mjs");
+          const { evaluateTransitions } = await import("./routing-H2PQ57OA.mjs");
           const transTarget = await evaluateTransitions(
             onFinish.transitions,
             forEachParent,
@@ -10950,7 +11484,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-CVQT4KHX.mjs");
+        const { evaluateGoto: evaluateGoto2 } = await import("./routing-H2PQ57OA.mjs");
         if (context2.debug) {
           logger.info(
             `[LevelDispatch] Evaluating on_finish.goto_js for forEach parent: ${forEachParent}`
@@ -11589,31 +12123,76 @@ async function executeSingleCheck2(checkId, context2, state, emitEvent, transiti
       });
     } catch {
     }
-    const result = await withActiveSpan(
-      `visor.check.${checkId}`,
-      {
+    emitImmediateSpan(`visor.check.${checkId}.started`, {
+      "visor.check.id": checkId,
+      "visor.check.type": providerType,
+      session_id: context2.sessionId,
+      wave: state.wave
+    });
+    if (isEngineerCheck(checkId)) {
+      emitImmediateSpan("visor.engineer.started", {
         "visor.check.id": checkId,
-        "visor.check.type": providerType,
-        session_id: context2.sessionId,
-        wave: state.wave
-      },
-      async (span) => {
-        const res = await executeWithSandboxRouting(
-          checkId,
-          checkConfig2,
-          context2,
-          prInfo,
-          dependencyResults,
-          checkConfig2.timeout || checkConfig2.ai?.timeout || 18e5,
-          () => provider.execute(prInfo, providerConfig, dependencyResults, executionContext)
-        );
-        try {
-          captureCheckOutput(span, res.output);
-        } catch {
+        "visor.check.type": providerType
+      });
+    }
+    const progressTimer = startCheckProgressTelemetry(checkId, providerType, {
+      session_id: context2.sessionId,
+      wave: state.wave
+    });
+    let result;
+    try {
+      result = await withActiveSpan(
+        `visor.check.${checkId}`,
+        {
+          "visor.check.id": checkId,
+          "visor.check.type": providerType,
+          session_id: context2.sessionId,
+          wave: state.wave
+        },
+        async (span) => {
+          const res = await executeWithSandboxRouting(
+            checkId,
+            checkConfig2,
+            context2,
+            prInfo,
+            dependencyResults,
+            checkConfig2.timeout || checkConfig2.ai?.timeout || 18e5,
+            () => provider.execute(prInfo, providerConfig, dependencyResults, executionContext)
+          );
+          try {
+            captureCheckOutput(span, res.output);
+          } catch {
+          }
+          return res;
         }
-        return res;
+      );
+      emitImmediateSpan(`visor.check.${checkId}.completed`, {
+        "visor.check.id": checkId,
+        "visor.check.type": providerType
+      });
+      if (isEngineerCheck(checkId)) {
+        emitImmediateSpan("visor.engineer.completed", {
+          "visor.check.id": checkId,
+          "visor.check.type": providerType
+        });
       }
-    );
+    } catch (error) {
+      emitImmediateSpan(`visor.check.${checkId}.failed`, {
+        "visor.check.id": checkId,
+        "visor.check.type": providerType,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (isEngineerCheck(checkId)) {
+        emitImmediateSpan("visor.engineer.failed", {
+          "visor.check.id": checkId,
+          "visor.check.type": providerType,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      throw error;
+    } finally {
+      stopCheckProgressTelemetry(progressTimer);
+    }
     try {
       const awaitingHumanInput = result?.awaitingHumanInput === true || result?.output && result.output.awaitingHumanInput === true;
       if (awaitingHumanInput) {
@@ -11643,7 +12222,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-KOIH75RZ.mjs");
+          const { loadRendererSchema } = await import("./renderer-schema-BT2IXMLW.mjs");
           schemaObj = await loadRendererSchema(checkConfig2.schema);
         } catch {
         }
@@ -12209,7 +12788,7 @@ function updateStats2(results, state, isForEachIteration = false) {
 }
 async function renderTemplateContent2(checkId, checkConfig, reviewSummary) {
   try {
-    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-P6KDYILF.mjs");
+    const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-E3AKRX7P.mjs");
     const fs13 = await import("fs/promises");
     const path15 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
@@ -13998,7 +14577,7 @@ var init_state_machine_execution_engine = __esm({
         }
         try {
           if (options.config?.memory) {
-            const { MemoryStore: MemoryStore2 } = await import("./memory-store-K5N7MC7U.mjs");
+            const { MemoryStore: MemoryStore2 } = await import("./memory-store-OHUIXCWJ.mjs");
             const memoryStore = MemoryStore2.getInstance(options.config.memory);
             await memoryStore.initialize();
             logger.debug("Memory store initialized");
@@ -14041,7 +14620,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const map = options?.webhookContext?.webhookData;
             if (map) {
-              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-I4BCWKRU.mjs");
+              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-WSEVHJEV.mjs");
               const reg = CheckProviderRegistry2.getInstance();
               const p = reg.getProvider("http_input");
               if (p && typeof p.setWebhookContext === "function") p.setWebhookContext(map);
@@ -14154,7 +14733,7 @@ var init_state_machine_execution_engine = __esm({
           logger.info("[StateMachine] Using state machine engine");
         }
         if (!config) {
-          const { ConfigManager } = await import("./config-JE4HKTWW.mjs");
+          const { ConfigManager } = await import("./config-PCP6O6Y6.mjs");
           const configManager = new ConfigManager();
           config = await configManager.getDefaultConfig();
           logger.debug("[StateMachine] Using default configuration (no config provided)");
@@ -14164,7 +14743,7 @@ var init_state_machine_execution_engine = __esm({
           tag_filter: tagFilter
         } : config;
         try {
-          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-I4BCWKRU.mjs");
+          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-WSEVHJEV.mjs");
           const registry = CheckProviderRegistry2.getInstance();
           registry.setCustomTools(configWithTagFilter.tools || {});
         } catch (error) {
@@ -14205,7 +14784,7 @@ var init_state_machine_execution_engine = __esm({
             logger.debug(
               `[PolicyEngine] Loading enterprise policy engine (engine=${configWithTagFilter.policy.engine})`
             );
-            const { loadEnterprisePolicyEngine } = await import("./loader-ZNKKJEZ3.mjs");
+            const { loadEnterprisePolicyEngine } = await import("./loader-WRGI244P.mjs");
             context2.policyEngine = await loadEnterprisePolicyEngine(configWithTagFilter.policy);
             logger.debug(
               `[PolicyEngine] Initialized: ${context2.policyEngine?.constructor?.name || "unknown"}`
@@ -14228,7 +14807,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-6QLZRTQA.mjs");
+              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-NBEO46RV.mjs");
               const slackCtx = extractSlackContext2(webhookData);
               if (slackCtx) {
                 const payload = Array.from(webhookData.values())[0];
@@ -14257,7 +14836,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-QBJ7TOWG.mjs");
+            const { FrontendsHost } = await import("./host-CFM2ASDI.mjs");
             const bus = new EventBus();
             context2.eventBus = bus;
             frontendsHost = new FrontendsHost(bus, logger);
@@ -14309,7 +14888,7 @@ var init_state_machine_execution_engine = __esm({
             }
             let runTraceId;
             try {
-              const { trace: lazyTrace, context: lazyCtx } = await import("./lazy-otel-5NH4ZJJM.mjs");
+              const { trace: lazyTrace, context: lazyCtx } = await import("./lazy-otel-5RDTVS5L.mjs");
               const activeSpan = lazyTrace.getSpan(lazyCtx.active());
               runTraceId = activeSpan?.spanContext()?.traceId;
             } catch {
@@ -14609,10 +15188,10 @@ var init_state_machine_execution_engine = __esm({
        * @returns Array of failure condition evaluation results
        */
       async evaluateFailureConditions(checkName, reviewSummary, config, previousOutputs, authorAssociation) {
-        const { FailureConditionEvaluator: FailureConditionEvaluator2 } = await import("./failure-condition-evaluator-5DZYMCGW.mjs");
+        const { FailureConditionEvaluator: FailureConditionEvaluator2 } = await import("./failure-condition-evaluator-IRFKTYZD.mjs");
         const evaluator = new FailureConditionEvaluator2();
-        const { addEvent: addEvent3 } = await import("./trace-helpers-WJXYVV4S.mjs");
-        const { addFailIfTriggered } = await import("./metrics-JTOG2HNO.mjs");
+        const { addEvent: addEvent3 } = await import("./trace-helpers-26ZCAE2V.mjs");
+        const { addFailIfTriggered } = await import("./metrics-MYUPQBBV.mjs");
         const checkConfig = config.checks?.[checkName];
         if (!checkConfig) {
           return [];
@@ -15432,7 +16011,7 @@ var init_scheduler = __esm({
         const endpoint = "/scheduler/trigger";
         webhookData.set(endpoint, syntheticPayload);
         try {
-          const { refreshGitHubCredentials } = await import("./github-auth-27SZGPEC.mjs");
+          const { refreshGitHubCredentials } = await import("./github-auth-BJQBLK2V.mjs");
           await refreshGitHubCredentials();
         } catch {
         }
@@ -15447,7 +16026,7 @@ var init_scheduler = __esm({
           inputs: schedule.workflowInputs
         });
         if (this.taskStore) {
-          const { trackExecution } = await import("./track-execution-MKIQXP2C.mjs");
+          const { trackExecution } = await import("./track-execution-3EC24C2X.mjs");
           await trackExecution(
             {
               taskStore: this.taskStore,
@@ -15557,7 +16136,7 @@ Please provide an updated response based on the reminder above. You may referenc
           }
         }
         try {
-          const { refreshGitHubCredentials } = await import("./github-auth-27SZGPEC.mjs");
+          const { refreshGitHubCredentials } = await import("./github-auth-BJQBLK2V.mjs");
           await refreshGitHubCredentials();
         } catch {
         }
@@ -15576,7 +16155,7 @@ Please provide an updated response based on the reminder above. You may referenc
             debug: process.env.VISOR_DEBUG === "true"
           });
           if (this.taskStore) {
-            const { trackExecution } = await import("./track-execution-MKIQXP2C.mjs");
+            const { trackExecution } = await import("./track-execution-3EC24C2X.mjs");
             await trackExecution(
               {
                 taskStore: this.taskStore,
@@ -15846,6 +16425,13 @@ async function handleScheduleAction(args, context2) {
   }
 }
 async function handleCreate(args, context2, store) {
+  if (context2.executionSource === "scheduler") {
+    return {
+      success: false,
+      message: "Scheduled runs cannot create new schedules",
+      error: "Creating schedules from a scheduler-triggered execution is not allowed to prevent recursive scheduling."
+    };
+  }
   if (!args.reminder_text && !args.workflow) {
     return {
       success: false,
@@ -16095,6 +16681,13 @@ function formatTrigger(trigger) {
   return `\`${trigger.id.substring(0, 8)}\` - channels: ${channels} \u2192 workflow: "${trigger.workflow}"${filterStr}${status}`;
 }
 async function handleCreateTrigger(args, context2, store) {
+  if (context2.executionSource === "scheduler") {
+    return {
+      success: false,
+      message: "Scheduled runs cannot create new triggers",
+      error: "Creating message triggers from a scheduler-triggered execution is not allowed to prevent recursive scheduling."
+    };
+  }
   const workflow = args.workflow || "default";
   if (context2.availableWorkflows && !context2.availableWorkflows.includes(workflow)) {
     return {
@@ -16532,6 +17125,7 @@ function slackChannelTypeToScheduleType(channelType) {
   }
 }
 function buildScheduleToolContext(sources, availableWorkflows, permissions, outputInfo) {
+  const executionSource = sources.schedulerContext ? "scheduler" : "user";
   if (sources.slackContext) {
     const contextType = `slack:${sources.slackContext.userId}`;
     const scheduleType = determineScheduleType(
@@ -16555,7 +17149,8 @@ function buildScheduleToolContext(sources, availableWorkflows, permissions, outp
       availableWorkflows,
       scheduleType: finalScheduleType,
       permissions,
-      allowedScheduleType
+      allowedScheduleType,
+      executionSource
     };
   }
   if (sources.githubContext) {
@@ -16567,8 +17162,9 @@ function buildScheduleToolContext(sources, availableWorkflows, permissions, outp
       availableWorkflows,
       scheduleType: "personal",
       permissions,
-      allowedScheduleType: "personal"
+      allowedScheduleType: "personal",
       // GitHub context only allows personal schedules
+      executionSource
     };
   }
   return {
@@ -16578,8 +17174,9 @@ function buildScheduleToolContext(sources, availableWorkflows, permissions, outp
     availableWorkflows,
     scheduleType: "personal",
     permissions,
-    allowedScheduleType: "personal"
+    allowedScheduleType: "personal",
     // CLI context only allows personal schedules
+    executionSource
   };
 }
 var init_schedule_tool = __esm({
@@ -16591,6 +17188,170 @@ var init_schedule_tool = __esm({
   }
 });
 
+// src/agent-protocol/task-progress-tool.ts
+function getTaskProgressToolDefinition() {
+  return {
+    name: "task_progress",
+    description: `Inspect the progress of tasks you are currently working on or have recently completed.
+
+Use this tool when:
+- A user asks about progress, status, or what you've been doing
+- You need to check if a similar task is already running
+- You want to see the execution trace (steps taken, tools called, AI decisions) of a task
+
+ACTIONS:
+- list: Show active and recent tasks in the current context (thread/channel)
+- trace: Get the detailed execution trace of a specific task \u2014 shows every step, tool call, and AI decision made so far
+
+The trace output is a structured tree showing the full execution flow including:
+- Workflow steps and their durations
+- AI model calls with token counts
+- Tool invocations with inputs and results
+- Search queries and their results
+- Errors and retries`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "trace"],
+          description: 'Action to perform: "list" to see tasks, "trace" to see execution details of a specific task'
+        },
+        task_id: {
+          type: "string",
+          description: 'Task ID to inspect (required for "trace" action). Use "list" first to find task IDs.'
+        }
+      },
+      required: ["action"]
+    }
+  };
+}
+function isTaskProgressTool(toolName) {
+  return toolName === "task_progress";
+}
+async function handleTaskProgressAction(args, context2, taskStore) {
+  try {
+    switch (args.action) {
+      case "list":
+        return await handleList2(context2, taskStore);
+      case "trace":
+        if (!args.task_id) {
+          return { success: false, error: 'task_id is required for the "trace" action' };
+        }
+        return await handleTrace(args.task_id, taskStore);
+      default:
+        return { success: false, error: `Unknown action: ${args.action}` };
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error(`[TaskProgressTool] Error: ${msg}`);
+    return { success: false, error: msg };
+  }
+}
+async function handleList2(context2, taskStore) {
+  const metadata = {};
+  if (context2.channelId) metadata.slack_channel = context2.channelId;
+  if (context2.threadTs) metadata.slack_thread_ts = context2.threadTs;
+  const activeResult = taskStore.listTasksRaw?.({
+    state: ["submitted", "working"],
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
+    limit: 20
+  }) || { rows: [] };
+  const recentResult = taskStore.listTasksRaw?.({
+    state: ["completed", "failed"],
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
+    limit: 10
+  }) || { rows: [] };
+  const lines = [];
+  if (activeResult.rows?.length > 0) {
+    lines.push("## Active Tasks");
+    for (const row of activeResult.rows) {
+      const trigger = row.metadata?.slack_trigger_text || (row.request_message || "").slice(0, 200);
+      const elapsed = timeSince(row.created_at);
+      lines.push(`- **${row.id}** [${row.state}] (${elapsed} ago)`);
+      lines.push(`  Workflow: ${row.workflow_id || "unknown"}`);
+      lines.push(`  Trigger: ${trigger}`);
+    }
+  } else {
+    lines.push("No active tasks in this context.");
+  }
+  if (recentResult.rows?.length > 0) {
+    lines.push("");
+    lines.push("## Recent Completed Tasks");
+    for (const row of recentResult.rows) {
+      const trigger = row.metadata?.slack_trigger_text || (row.request_message || "").slice(0, 200);
+      const elapsed = timeSince(row.created_at);
+      lines.push(`- **${row.id}** [${row.state}] (${elapsed} ago)`);
+      lines.push(`  Workflow: ${row.workflow_id || "unknown"}`);
+      lines.push(`  Trigger: ${trigger}`);
+    }
+  }
+  return { success: true, message: lines.join("\n") };
+}
+async function handleTrace(taskId, taskStore) {
+  const task = taskStore.getTask?.(taskId);
+  if (!task) {
+    return { success: false, error: `Task not found: ${taskId}` };
+  }
+  const traceId = task.metadata?.trace_id;
+  const traceFile = task.metadata?.trace_file;
+  if (!traceId && !traceFile) {
+    const trigger2 = task.metadata?.slack_trigger_text || "";
+    return {
+      success: true,
+      message: [
+        `## Task ${taskId}`,
+        `State: ${task.state}`,
+        `Created: ${task.created_at}`,
+        `Workflow: ${task.workflow_id || "unknown"}`,
+        trigger2 ? `Trigger: ${trigger2}` : "",
+        "",
+        "(No execution trace available for this task)"
+      ].filter(Boolean).join("\n")
+    };
+  }
+  const { serializeTraceForPrompt, readTraceIdFromFile } = await import("./trace-serializer-KKBJHM7J.mjs");
+  let resolvedTraceId = traceId;
+  if (!resolvedTraceId && traceFile) {
+    resolvedTraceId = await readTraceIdFromFile(traceFile);
+  }
+  const taskResponse = task.status?.message?.parts?.[0]?.text;
+  const traceTree = await serializeTraceForPrompt(
+    traceFile || resolvedTraceId || "",
+    8e3,
+    // generous limit so AI gets good context
+    void 0,
+    taskResponse,
+    resolvedTraceId || void 0
+  );
+  const trigger = task.metadata?.slack_trigger_text || "";
+  const elapsed = timeSince(task.created_at);
+  const lines = [
+    `## Task ${taskId}`,
+    `State: ${task.state}`,
+    `Started: ${elapsed} ago`,
+    `Workflow: ${task.workflow_id || "unknown"}`,
+    trigger ? `Trigger: ${trigger}` : "",
+    "",
+    "## Execution Trace",
+    traceTree
+  ];
+  return { success: true, message: lines.filter(Boolean).join("\n") };
+}
+function timeSince(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m`;
+  if (ms < 864e5) return `${Math.round(ms / 36e5)}h`;
+  return `${Math.round(ms / 864e5)}d`;
+}
+var init_task_progress_tool = __esm({
+  "src/agent-protocol/task-progress-tool.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
 // src/scheduler/cli-handler.ts
 var init_cli_handler = __esm({
   "src/scheduler/cli-handler.ts"() {
@@ -16779,9 +17540,11 @@ var init_mcp_custom_sse_server = __esm({
     init_custom_tool_executor();
     init_workflow_registry();
     init_schedule_tool();
+    init_task_progress_tool();
     init_schedule_tool_handler();
     init_env_resolver();
     init_rate_limiter();
+    init_sandbox();
     CustomToolsSSEServer = class _CustomToolsSSEServer {
       server = null;
       port = 0;
@@ -17481,6 +18244,7 @@ var init_mcp_custom_sse_server = __esm({
             try {
               if (isScheduleTool(toolName)) {
                 const webhookData = this.workflowContext?.executionContext?.webhookContext?.webhookData;
+                const webhookEventType = this.workflowContext?.executionContext?.webhookContext?.eventType;
                 const slackContext = webhookData ? extractSlackContext(webhookData) : null;
                 const visorCfg = this.workflowContext?.visorConfig;
                 const availableWorkflows = visorCfg?.checks ? Object.keys(visorCfg.checks) : void 0;
@@ -17499,6 +18263,9 @@ var init_mcp_custom_sse_server = __esm({
                       userName: slackContext.userName,
                       timezone: slackContext.timezone,
                       channelType: slackContext.channelType
+                    } : void 0,
+                    schedulerContext: webhookEventType === "schedule" ? {
+                      scheduleId: this.workflowContext?.executionContext?.inputs?.schedule?.id
                     } : void 0
                   },
                   availableWorkflows,
@@ -17544,6 +18311,28 @@ var init_mcp_custom_sse_server = __esm({
                 result = scheduleResult.success ? scheduleResult.message : `Error: ${scheduleResult.error}`;
                 break;
               }
+              if (isTaskProgressTool(toolName)) {
+                const webhookData = this.workflowContext?.executionContext?.webhookContext?.webhookData;
+                const slackCtx = webhookData ? extractSlackContext(webhookData) : null;
+                const taskStore = this.workflowContext?.taskStore || this.workflowContext?.executionContext?.taskStore || this.workflowContext?.executionContext?._parentContext?.taskStore || webhookData?.get?.("__taskStore");
+                if (!taskStore) {
+                  result = "Error: Task store not available in this context";
+                  break;
+                }
+                const progressResult = await handleTaskProgressAction(
+                  {
+                    action: args.action || "list",
+                    task_id: args.task_id
+                  },
+                  {
+                    channelId: slackCtx?.channel || void 0,
+                    threadTs: slackCtx?.threadTs || void 0
+                  },
+                  taskStore
+                );
+                result = progressResult.success ? progressResult.message : `Error: ${progressResult.error}`;
+                break;
+              }
               const tool = this.tools.get(toolName);
               if (tool && isWorkflowTool(tool)) {
                 if (this.gracefulStopRequested) {
@@ -17736,18 +18525,49 @@ var init_mcp_custom_sse_server = __esm({
             );
           }
           const contentType = response.headers.get("content-type");
+          let data;
           if (contentType && contentType.includes("application/json")) {
-            return await response.json();
+            data = await response.json();
+          } else {
+            const text = await response.text();
+            if (text.trim().startsWith("{") || text.trim().startsWith("[")) {
+              try {
+                data = JSON.parse(text);
+              } catch {
+                data = text;
+              }
+            } else {
+              data = text;
+            }
           }
-          const text = await response.text();
-          if (text.trim().startsWith("{") || text.trim().startsWith("[")) {
+          const transformJs = tool.transform_js;
+          if (transformJs && data !== void 0) {
             try {
-              return JSON.parse(text);
-            } catch {
-              return text;
+              const sandbox = createSecureSandbox();
+              const jsScope = {
+                output: data,
+                path: apiPath,
+                method,
+                query: queryParams,
+                args
+              };
+              data = compileAndRun(sandbox, transformJs, jsScope, {
+                injectLog: true,
+                logPrefix: `\u{1F50D} [${tool.type}:transform_js]`,
+                wrapFunction: true
+              });
+              if (this.debug) {
+                logger.debug(
+                  `[CustomToolsSSEServer:${this.sessionId}] Applied transform_js for http_client tool`
+                );
+              }
+            } catch (error) {
+              logger.error(
+                `[CustomToolsSSEServer:${this.sessionId}] transform_js failed: ${error instanceof Error ? error.message : "Unknown error"}`
+              );
             }
           }
-          return text;
+          return data;
         } catch (error) {
           clearTimeout(timeoutId);
           if (error instanceof Error && error.name === "AbortError") {
@@ -17770,7 +18590,7 @@ var init_mcp_custom_sse_server = __esm({
             `[CustomToolsSSEServer:${this.sessionId}] Executing UTCP tool '${utcpToolName}' with args: ${JSON.stringify(args)}`
           );
         }
-        const { UtcpCheckProvider: UtcpCheckProvider2 } = await import("./utcp-check-provider-JLIYF5HH.mjs");
+        const { UtcpCheckProvider: UtcpCheckProvider2 } = await import("./utcp-check-provider-WI3QZ3W6.mjs");
         return UtcpCheckProvider2.callTool(manual, utcpToolName, args, {
           variables: tool.__utcpVariables || {},
           plugins: tool.__utcpPlugins || ["http"],
@@ -17950,6 +18770,7 @@ var init_ai_check_provider = __esm({
     init_tool_resolver();
     init_sandbox();
     init_schedule_tool();
+    init_task_progress_tool();
     init_schedule_tool_handler();
     AICheckProvider = class _AICheckProvider extends CheckProvider {
       aiReviewService;
@@ -17996,6 +18817,12 @@ var init_ai_check_provider = __esm({
             } catch {
             }
           }
+          if (first.active_tasks && prInfo) {
+            try {
+              prInfo.activeTasks = first.active_tasks;
+            } catch {
+            }
+          }
           const transportCtx = slackConv ? { slack: { event: ev, conversation: slackConv } } : { telegram: { event: ev, conversation: telegramConv } };
           return { ...transportCtx, conversation: conv };
         } catch {
@@ -18977,8 +19804,20 @@ ${preview}`);
           const contextInfo = slackContext ? `user=${slackContext.userId}, channelType=${slackContext.channelType}` : "cli";
           logger.debug(`[AICheckProvider] Schedule tool requested (${contextInfo})`);
         }
+        const taskProgressToolRequested = !config.ai?.disableTools && customToolsToLoad.some(
+          (tool) => tool === "task_progress" || typeof tool === "object" && tool.tool === "task_progress"
+        );
+        if (taskProgressToolRequested) {
+          customToolsToLoad = customToolsToLoad.filter(
+            (tool) => tool !== "task_progress" && !(typeof tool === "object" && tool.tool === "task_progress")
+          );
+          if (!customToolsServerName) {
+            customToolsServerName = "__tools__";
+          }
+          logger.debug(`[AICheckProvider] Task progress tool requested`);
+        }
         const scheduleToolEnabled = scheduleToolRequested || config.ai?.enable_scheduler === true && !config.ai?.disableTools;
-        if ((customToolsToLoad.length > 0 || scheduleToolEnabled || httpClientEntriesFromMcp.length > 0) && (customToolsServerName || scheduleToolEnabled || httpClientEntriesFromMcp.length > 0) && !config.ai?.disableTools) {
+        if ((customToolsToLoad.length > 0 || scheduleToolEnabled || taskProgressToolRequested || httpClientEntriesFromMcp.length > 0) && (customToolsServerName || scheduleToolEnabled || taskProgressToolRequested || httpClientEntriesFromMcp.length > 0) && !config.ai?.disableTools) {
           if (!customToolsServerName) {
             customToolsServerName = "__tools__";
           }
@@ -19010,6 +19849,11 @@ ${preview}`);
               customTools.set(scheduleTool.name, scheduleTool);
               logger.debug(`[AICheckProvider] Added built-in schedule tool`);
             }
+            if (taskProgressToolRequested) {
+              const taskProgressTool = getTaskProgressToolDefinition();
+              customTools.set(taskProgressTool.name, taskProgressTool);
+              logger.debug(`[AICheckProvider] Added built-in task_progress tool`);
+            }
             for (const entry of httpClientEntriesFromMcp) {
               const httpTool = {
                 name: entry.name,
@@ -19055,7 +19899,7 @@ ${preview}`);
             if (utcpEntriesFromMcp.length > 0) {
               for (const entry of utcpEntriesFromMcp) {
                 try {
-                  const { UtcpCheckProvider: UtcpCheckProvider2 } = await import("./utcp-check-provider-JLIYF5HH.mjs");
+                  const { UtcpCheckProvider: UtcpCheckProvider2 } = await import("./utcp-check-provider-WI3QZ3W6.mjs");
                   const manual = entry.config.manual;
                   const variables = entry.config.variables;
                   const plugins = entry.config.plugins || ["http"];
@@ -19147,6 +19991,12 @@ ${preview}`);
                 executionContext: sessionInfo,
                 workspace: parentCtxForTools?.workspace
               };
+              if (taskProgressToolRequested) {
+                const taskStoreRef = parentCtxForTools?.taskStore || sessionInfo?.taskStore;
+                if (taskStoreRef) {
+                  workflowContext.taskStore = taskStoreRef;
+                }
+              }
               customToolsServer = new CustomToolsSSEServer(
                 customTools,
                 sessionId,
@@ -42466,10 +43316,11 @@ function buildBuiltinGlobals(opts) {
   const asyncFunctionNames = /* @__PURE__ */ new Set();
   const scheduleFn = async (args = {}) => {
     try {
-      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-AECLFHSY.mjs");
-      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-6QLZRTQA.mjs");
+      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-2DPNSU63.mjs");
+      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-NBEO46RV.mjs");
       const parentCtx = opts.sessionInfo?._parentContext;
       const webhookData = parentCtx?.prInfo?.eventContext?.webhookData;
+      const webhookEventType = parentCtx?.webhookContext?.eventType || parentCtx?.prInfo?.eventContext?.eventType;
       const visorCfg = parentCtx?.config;
       const slackContext = webhookData ? extractSlackContext2(webhookData) : null;
       const availableWorkflows = visorCfg?.checks ? Object.keys(visorCfg.checks) : void 0;
@@ -42477,7 +43328,8 @@ function buildBuiltinGlobals(opts) {
       const context2 = buildScheduleToolContext2(
         {
           slackContext: slackContext || void 0,
-          cliContext: slackContext ? void 0 : { userId: "script" }
+          cliContext: slackContext ? void 0 : { userId: "script" },
+          schedulerContext: webhookEventType === "schedule" ? { scheduleId: parentCtx?.inputs?.schedule?.id } : void 0
         },
         availableWorkflows,
         permissions
@@ -42596,7 +43448,7 @@ function buildBuiltinGlobals(opts) {
   if (opts.config.enable_bash === true) {
     const bashFn = async (args = {}) => {
       try {
-        const { CommandExecutor } = await import("./command-executor-3AHGIYQG.mjs");
+        const { CommandExecutor } = await import("./command-executor-YNJOS77A.mjs");
         const executor = CommandExecutor.getInstance();
         const command = String(args.command || "");
         if (!command) return "ERROR: command is required";
@@ -44051,7 +44903,20 @@ var init_git_checkout_provider = __esm({
           if (!resolvedRef || resolvedRef.trim().length === 0) {
             resolvedRef = "HEAD";
           }
-          const resolvedRepository = checkoutConfig.repository ? await this.liquid.parseAndRender(checkoutConfig.repository, templateContext) : process.env.GITHUB_REPOSITORY || "unknown/unknown";
+          let resolvedRepository = checkoutConfig.repository ? await this.liquid.parseAndRender(checkoutConfig.repository, templateContext) : process.env.GITHUB_REPOSITORY || "";
+          resolvedRepository = resolvedRepository.trim();
+          if (!resolvedRepository || resolvedRepository === "unknown/unknown") {
+            logger.warn(
+              `[GitCheckout] Skipping checkout: repository resolved to empty (template: "${checkoutConfig.repository}")`
+            );
+            const output2 = {
+              success: false,
+              skipped: true,
+              reason: "repository not configured",
+              error: "repository not configured"
+            };
+            return { issues: [], output: output2 };
+          }
           const resolvedToken = checkoutConfig.token ? await this.liquid.parseAndRender(checkoutConfig.token, templateContext) : void 0;
           const resolvedWorkingDirectory = checkoutConfig.working_directory ? await this.liquid.parseAndRender(checkoutConfig.working_directory, templateContext) : void 0;
           logger.info(`Checking out repository: ${resolvedRepository}@${resolvedRef}`);
@@ -44195,7 +45060,7 @@ var init_git_checkout_provider = __esm({
       }
       async isAvailable() {
         try {
-          const { commandExecutor: commandExecutor2 } = await import("./command-executor-3AHGIYQG.mjs");
+          const { commandExecutor: commandExecutor2 } = await import("./command-executor-YNJOS77A.mjs");
           const result = await commandExecutor2.execute("git --version", { timeout: 5e3 });
           return result.exitCode === 0;
         } catch (_error) {
@@ -46191,4 +47056,4 @@ undici/lib/fetch/body.js:
 undici/lib/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-TQQNSHQV.mjs.map
+//# sourceMappingURL=chunk-UXB4XWEE.mjs.map