@probelabs/visor 0.1.186 → 0.1.187

package/dist/sdk/sdk.js

@@ -1529,7 +1529,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@probelabs/visor",
-      version: "0.1.186",
+      version: "0.1.187",
       main: "dist/index.js",
       bin: {
         visor: "./dist/index.js"
@@ -1630,7 +1630,7 @@ var require_package = __commonJS({
         "@apidevtools/swagger-parser": "^12.1.0",
         "@grammyjs/runner": "^2.0.3",
         "@modelcontextprotocol/sdk": "^1.25.3",
-        "@nyariv/sandboxjs": "github:probelabs/SandboxJS#23c4bb611f7d05f3cb8c523917b5f57103e48108",
+        "@nyariv/sandboxjs": "github:probelabs/SandboxJS#d0d8c8ab3113d3b73e08b79b88a4b834ba3fae11",
         "@octokit/action": "^8.0.2",
         "@octokit/auth-app": "^8.1.0",
         "@octokit/core": "^7.0.3",
@@ -1649,7 +1649,7 @@ var require_package = __commonJS({
         "@opentelemetry/sdk-node": "^0.203.0",
         "@opentelemetry/sdk-trace-base": "^1.30.1",
         "@opentelemetry/semantic-conventions": "^1.30.1",
-        "@probelabs/probe": "^0.6.0-rc311",
+        "@probelabs/probe": "^0.6.0-rc318",
         "@types/commander": "^2.12.0",
         "@types/uuid": "^10.0.0",
         "@utcp/file": "^1.1.0",
@@ -8756,6 +8756,126 @@ var init_policy_gate = __esm({
   }
 });
 
+// src/state-machine/dispatch/debounce-manager.ts
+function effectiveDebounceMs(requested) {
+  const override = process.env.VISOR_DEBOUNCE_OVERRIDE;
+  if (override !== void 0) {
+    const ms = parseInt(override, 10);
+    if (!isNaN(ms) && ms >= 0) return ms;
+  }
+  return requested;
+}
+function getDebounceManager() {
+  if (!__instance) __instance = new DebounceManager();
+  return __instance;
+}
+var DebounceManager, __instance;
+var init_debounce_manager = __esm({
+  "src/state-machine/dispatch/debounce-manager.ts"() {
+    "use strict";
+    init_logger();
+    DebounceManager = class {
+      pending = /* @__PURE__ */ new Map();
+      /** Waiters that were superseded and should resolve as 'debounced' */
+      superseded = /* @__PURE__ */ new Map();
+      /** Keys currently executing — prevents parallel runs */
+      executing = /* @__PURE__ */ new Set();
+      /**
+       * Enqueue an execution. Returns 'executed' if this invocation won the
+       * debounce race, or 'debounced' if it was superseded by a later one
+       * or if the function is already executing for this key.
+       */
+      enqueue(key, debounceMs, fn) {
+        if (this.executing.has(key)) {
+          logger.info(`[DebounceManager] ${key}: already executing, skipping this invocation`);
+          return Promise.resolve({ outcome: "debounced" });
+        }
+        const actualMs = effectiveDebounceMs(debounceMs);
+        return new Promise(
+          (resolve17, reject) => {
+            const existing = this.pending.get(key);
+            if (existing) {
+              clearTimeout(existing.timer);
+              if (!this.superseded.has(key)) {
+                this.superseded.set(key, []);
+              }
+              this.superseded.get(key).push(existing.resolve);
+              existing.invocations++;
+              logger.info(
+                `[DebounceManager] ${key}: invocation #${existing.invocations}, resetting ${actualMs}ms timer`
+              );
+            } else {
+              logger.info(
+                `[DebounceManager] ${key}: first invocation, starting ${actualMs}ms debounce`
+              );
+            }
+            const invocations = existing ? existing.invocations : 1;
+            const firstTime = existing ? existing.firstInvocationTime : Date.now();
+            const timer = setTimeout(async () => {
+              this.pending.delete(key);
+              const waiters2 = this.superseded.get(key) || [];
+              this.superseded.delete(key);
+              for (const w of waiters2) {
+                w({ outcome: "debounced" });
+              }
+              const elapsed = Date.now() - firstTime;
+              logger.info(
+                `[DebounceManager] ${key}: executing after ${invocations} invocation(s) over ${elapsed}ms`
+              );
+              this.executing.add(key);
+              try {
+                const result = await fn();
+                resolve17({ outcome: "executed", result });
+              } catch (err) {
+                reject(err);
+              } finally {
+                this.executing.delete(key);
+                logger.info(`[DebounceManager] ${key}: execution finished`);
+              }
+            }, actualMs);
+            this.pending.set(key, {
+              timer,
+              invocations,
+              firstInvocationTime: firstTime,
+              resolve: resolve17,
+              reject,
+              fn
+            });
+          }
+        );
+      }
+      /** Cancel a pending debounce. All waiters resolve as 'debounced'. */
+      cancel(key) {
+        const entry = this.pending.get(key);
+        if (!entry) return false;
+        clearTimeout(entry.timer);
+        this.pending.delete(key);
+        entry.resolve({ outcome: "debounced" });
+        const waiters2 = this.superseded.get(key) || [];
+        this.superseded.delete(key);
+        for (const w of waiters2) {
+          w({ outcome: "debounced" });
+        }
+        return true;
+      }
+      /** Cancel all pending debounces. */
+      clear() {
+        for (const [key] of this.pending) {
+          this.cancel(key);
+        }
+      }
+      /** Number of pending debounce keys. */
+      get size() {
+        return this.pending.size;
+      }
+      /** Check if a key is currently executing. */
+      isExecuting(key) {
+        return this.executing.has(key);
+      }
+    };
+  }
+});
+
 // src/state-machine/dispatch/history-snapshot.ts
 var history_snapshot_exports = {};
 __export(history_snapshot_exports, {
@@ -9192,12 +9312,11 @@ var SessionRegistry;
 var init_session_registry = __esm({
   "src/session-registry.ts"() {
     "use strict";
+    init_logger();
     SessionRegistry = class _SessionRegistry {
       static instance;
       sessions = /* @__PURE__ */ new Map();
-      exitHandlerRegistered = false;
       constructor() {
-        this.registerExitHandlers();
       }
       /**
        * Get the singleton instance of SessionRegistry
@@ -9212,7 +9331,7 @@ var init_session_registry = __esm({
        * Register a ProbeAgent session
        */
       registerSession(sessionId, agent) {
-        console.error(`\u{1F504} Registering AI session: ${sessionId}`);
+        logger.debug(`[SessionRegistry] Registering AI session: ${sessionId}`);
         this.sessions.set(sessionId, agent);
       }
       /**
@@ -9221,23 +9340,24 @@ var init_session_registry = __esm({
       getSession(sessionId) {
         const agent = this.sessions.get(sessionId);
         if (agent) {
-          console.error(`\u267B\uFE0F  Reusing AI session: ${sessionId}`);
+          logger.debug(`[SessionRegistry] Reusing AI session: ${sessionId}`);
         }
         return agent;
       }
       /**
        * Remove a session from the registry
        */
-      unregisterSession(sessionId) {
+      async unregisterSession(sessionId) {
         if (this.sessions.has(sessionId)) {
-          console.error(`\u{1F5D1}\uFE0F  Unregistering AI session: ${sessionId}`);
           const agent = this.sessions.get(sessionId);
           this.sessions.delete(sessionId);
           if (agent && typeof agent.cleanup === "function") {
             try {
-              agent.cleanup();
+              await agent.cleanup();
             } catch (error) {
-              console.error(`\u26A0\uFE0F  Warning: Failed to cleanup ProbeAgent: ${error}`);
+              logger.warn(
+                `[SessionRegistry] Failed to cleanup ProbeAgent session ${sessionId}: ${error}`
+              );
             }
           }
         }
@@ -9245,17 +9365,26 @@ var init_session_registry = __esm({
       /**
        * Clear all sessions (useful for cleanup)
        */
-      clearAllSessions() {
-        console.error(`\u{1F9F9} Clearing all AI sessions (${this.sessions.size} sessions)`);
-        for (const [, agent] of this.sessions.entries()) {
-          if (agent && typeof agent.cleanup === "function") {
-            try {
-              agent.cleanup();
-            } catch {
-            }
-          }
+      async clearAllSessions() {
+        if (this.sessions.size === 0) {
+          return;
         }
+        logger.debug(`[SessionRegistry] Clearing all AI sessions (${this.sessions.size} sessions)`);
+        const sessions = Array.from(this.sessions.entries());
         this.sessions.clear();
+        await Promise.allSettled(
+          sessions.map(async ([sessionId, agent]) => {
+            if (agent && typeof agent.cleanup === "function") {
+              try {
+                await agent.cleanup();
+              } catch (error) {
+                logger.warn(
+                  `[SessionRegistry] Failed to cleanup ProbeAgent session ${sessionId}: ${error}`
+                );
+              }
+            }
+          })
+        );
       }
       /**
        * Get all active session IDs
@@ -9280,7 +9409,7 @@ var init_session_registry = __esm({
       async cloneSession(sourceSessionId, newSessionId, checkName) {
         const sourceAgent = this.sessions.get(sourceSessionId);
         if (!sourceAgent) {
-          console.error(`\u26A0\uFE0F  Cannot clone session: ${sourceSessionId} not found`);
+          logger.warn(`[SessionRegistry] Cannot clone session: ${sourceSessionId} not found`);
           return void 0;
         }
         try {
@@ -9303,69 +9432,34 @@ var init_session_registry = __esm({
                 clonedAgent._traceFilePath = tracerResult.filePath;
               }
             } catch (traceError) {
-              console.error(
-                "\u26A0\uFE0F  Warning: Failed to initialize tracing for cloned session:",
-                traceError
+              logger.warn(
+                `[SessionRegistry] Failed to initialize tracing for cloned session ${newSessionId}: ${traceError}`
               );
             }
           }
           if (sourceAgent._mcpInitialized && typeof clonedAgent.initialize === "function") {
             try {
               await clonedAgent.initialize();
-              console.error(`\u{1F527} Initialized MCP tools for cloned session`);
+              logger.debug(
+                `[SessionRegistry] Initialized MCP tools for cloned session ${newSessionId}`
+              );
             } catch (initError) {
-              console.error(`\u26A0\uFE0F  Warning: Failed to initialize cloned agent: ${initError}`);
+              logger.warn(
+                `[SessionRegistry] Failed to initialize cloned agent ${newSessionId}: ${initError}`
+              );
             }
           }
           const historyLength = clonedAgent.history?.length || 0;
-          console.error(
-            `\u{1F4CB} Cloned session ${sourceSessionId} \u2192 ${newSessionId} using ProbeAgent.clone() (${historyLength} messages, internal messages filtered)`
+          logger.debug(
+            `[SessionRegistry] Cloned session ${sourceSessionId} -> ${newSessionId} using ProbeAgent.clone() (${historyLength} messages, internal messages filtered)`
           );
           this.registerSession(newSessionId, clonedAgent);
           return clonedAgent;
         } catch (error) {
-          console.error(`\u26A0\uFE0F  Failed to clone session ${sourceSessionId}:`, error);
+          logger.warn(`[SessionRegistry] Failed to clone session ${sourceSessionId}: ${error}`);
           return void 0;
         }
       }
-      /**
-       * Register process exit handlers to cleanup sessions on exit
-       */
-      registerExitHandlers() {
-        if (this.exitHandlerRegistered) {
-          return;
-        }
-        const cleanupAndExit = (signal) => {
-          if (this.sessions.size > 0) {
-            console.error(`
-\u{1F9F9} [${signal}] Cleaning up ${this.sessions.size} active AI sessions...`);
-            this.clearAllSessions();
-          }
-        };
-        process.on("exit", () => {
-          if (this.sessions.size > 0) {
-            console.error(`\u{1F9F9} [exit] Cleaning up ${this.sessions.size} active AI sessions...`);
-            for (const [, agent] of this.sessions.entries()) {
-              if (agent && typeof agent.cleanup === "function") {
-                try {
-                  agent.cleanup();
-                } catch {
-                }
-              }
-            }
-            this.sessions.clear();
-          }
-        });
-        process.on("SIGINT", () => {
-          cleanupAndExit("SIGINT");
-          process.exit(0);
-        });
-        process.on("SIGTERM", () => {
-          cleanupAndExit("SIGTERM");
-          process.exit(0);
-        });
-        this.exitHandlerRegistered = true;
-      }
     };
   }
 });
@@ -9465,6 +9559,136 @@ var init_comment_metadata = __esm({
   }
 });
 
+// src/utils/user-facing-error.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function stripWrapperPrefixes(text) {
+  let cleaned = text.trim();
+  const wrapperPatterns = [
+    /^AI analysis failed:\s*/i,
+    /^Claude Code analysis failed:\s*/i,
+    /^ProbeAgent execution failed:\s*/i,
+    /^Workflow step '[^']+' failed:\s*/i,
+    /^Error:\s*/i
+  ];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const pattern of wrapperPatterns) {
+      const next = cleaned.replace(pattern, "");
+      if (next !== cleaned) {
+        cleaned = next.trim();
+        changed = true;
+      }
+    }
+  }
+  return cleaned;
+}
+function collectErrorStrings(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0, out = []) {
+  if (value == null || depth > 3) return out;
+  if (typeof value === "string") {
+    if (value.trim()) out.push(value.trim());
+    return out;
+  }
+  if (typeof value !== "object") {
+    out.push(String(value));
+    return out;
+  }
+  if (seen.has(value)) return out;
+  seen.add(value);
+  const obj = value;
+  const candidateKeys = ["message", "responseBody", "error", "details", "body", "cause"];
+  for (const key of candidateKeys) {
+    if (key in obj) collectErrorStrings(obj[key], seen, depth + 1, out);
+  }
+  return out;
+}
+function matchUserFacingErrorMessage(raw) {
+  if (/no api key provided and neither claude nor codex command found/i.test(raw)) {
+    return "No API key provided and neither claude nor codex command found.";
+  }
+  if (/budget limit exceeded|budget exceeded/i.test(raw)) {
+    return "The AI provider budget limit was exceeded before a response could be generated. Please retry later or switch model/provider.";
+  }
+  if (/currently experiencing high demand|status.?unavailable|spikes in demand are usually temporary/i.test(
+    raw
+  )) {
+    return "The AI provider is currently experiencing high demand and did not generate a response. Please retry shortly.";
+  }
+  if (/rate limit/i.test(raw)) {
+    return "The AI provider rate limit was reached before a response could be generated. Please retry shortly.";
+  }
+  if (/401|authentication|api key|invalid api key|unauthorized/i.test(raw)) {
+    return "The AI provider request was rejected before a response could be generated. Please check credentials and provider access.";
+  }
+  if (/403|forbidden/i.test(raw)) {
+    return "The AI provider rejected the request before a response could be generated. This is usually caused by budget limits, access policy, or model permissions.";
+  }
+  if (/^request timed out$/i.test(raw) || /timed out|timeout/i.test(raw) && /(failed to get response from ai model|ai request|probeagent|provider|model|streamtext)/i.test(
+    raw
+  )) {
+    return "The AI request timed out before a response could be generated. Please retry.";
+  }
+  if (/no output generated|failed to get response from ai model/i.test(raw)) {
+    return "The AI provider failed before generating any response. This is usually caused by a provider-side limit, rate limit, or outage. Please retry.";
+  }
+  return null;
+}
+function formatUserFacingExecutionError(error) {
+  const collected = collectErrorStrings(error);
+  const raw = normalizeWhitespace(collected.join(" | ") || String(error ?? "Unknown error"));
+  const matched = matchUserFacingErrorMessage(raw);
+  if (matched) return matched;
+  const cleaned = normalizeWhitespace(stripWrapperPrefixes(raw));
+  return cleaned || "The request failed before a response could be generated. Please retry.";
+}
+function formatUserFacingExecutionMessage(message) {
+  return formatUserFacingExecutionError(message);
+}
+function issuePriority(issue) {
+  const ruleId = String(issue.ruleId || "");
+  const message = String(issue.message || "");
+  if (ruleId.startsWith("system/") || ruleId.endsWith("/error")) return 0;
+  if (ruleId.includes("timeout") || /timed out|timeout/i.test(message)) return 1;
+  if (ruleId.includes("contract/guarantee_failed") && /output\??\.\s*text|\btext\b.*length\s*>\s*0|\btext\b.*trim/i.test(message)) {
+    return 2;
+  }
+  return 3;
+}
+function formatGuaranteeFailureMessage(issue) {
+  const ruleId = String(issue.ruleId || "");
+  const message = String(issue.message || "");
+  if (!ruleId.includes("contract/guarantee_failed")) return null;
+  if (/output\??\.\s*text|\btext\b.*length\s*>\s*0|\btext\b.*trim/i.test(message)) {
+    return "The assistant failed to produce a response. This is usually caused by a provider-side limit, outage, or invalid structured output. Please retry.";
+  }
+  return null;
+}
+function summarizeUserFacingIssues(issues) {
+  if (!Array.isArray(issues) || issues.length === 0) return null;
+  const candidates = issues.filter(
+    (issue) => !!issue && typeof issue === "object" && String(issue.severity || "").toLowerCase() === "error"
+  );
+  if (candidates.length === 0) return null;
+  const prioritized = [...candidates].sort((a, b) => issuePriority(a) - issuePriority(b));
+  const seen = /* @__PURE__ */ new Set();
+  const messages = [];
+  for (const issue of prioritized) {
+    const formatted = formatGuaranteeFailureMessage(issue) || formatUserFacingExecutionMessage(String(issue.message || "Execution error"));
+    if (!formatted || seen.has(formatted)) continue;
+    seen.add(formatted);
+    messages.push(formatted);
+    if (messages.length >= 2) break;
+  }
+  return messages.length > 0 ? messages.join("\n") : null;
+}
+var init_user_facing_error = __esm({
+  "src/utils/user-facing-error.ts"() {
+    "use strict";
+  }
+});
+
 // src/slack/markdown.ts
 async function renderMermaidToPng(mermaidCode) {
   const tmpDir = os.tmpdir();
@@ -9523,6 +9747,10 @@ async function renderMermaidToPng(mermaidCode) {
       proc.stderr?.on("data", (data) => {
         stderr += data.toString();
       });
+      proc.stderr?.on("error", () => {
+      });
+      proc.stdout?.on("error", () => {
+      });
       proc.on("close", (code) => {
         if (code === 0) {
           resolve17({ success: true });
@@ -9716,16 +9944,36 @@ function createProbeTracerAdapter(fallbackTracer) {
     "negotiated_timeout.observer_exhausted",
     "negotiated_timeout.abort_summary"
   ]);
+  const isSpanWorthyEvent = (name) => SPAN_WORTHY_EVENTS.has(name) || name.startsWith("task.");
   const emitEvent = (name, attrs) => {
     try {
       const flat = flattenAttrs(attrs);
-      if (SPAN_WORTHY_EVENTS.has(name)) {
+      if (isSpanWorthyEvent(name)) {
         try {
+          const startHr = process.hrtime();
           const tracer = trace.getTracer("visor");
           const childSpan = tracer.startSpan(`probe.event.${name}`, {
             attributes: { "probe.event.name": name, ...flat }
           });
           childSpan.end();
+          try {
+            const activeParent = trace.getActiveSpan?.();
+            const parentCtx = activeParent?.spanContext?.();
+            const childCtx = childSpan.spanContext?.();
+            const endHr = process.hrtime();
+            emitNdjsonFullSpan({
+              name: `probe.event.${name}`,
+              traceId: childCtx?.traceId || parentCtx?.traceId,
+              spanId: childCtx?.spanId,
+              parentSpanId: parentCtx?.spanId,
+              startTime: [startHr[0], startHr[1]],
+              endTime: [endHr[0], endHr[1]],
+              attributes: { "probe.event.name": name, ...flat },
+              events: [],
+              status: { code: 1 }
+            });
+          } catch {
+          }
         } catch {
         }
       }
@@ -9916,6 +10164,15 @@ function createProbeTracerAdapter(fallbackTracer) {
         }
       }
     },
+    recordTaskEvent: (phase, attrs) => {
+      emitEvent(`task.${phase}`, attrs);
+      if (fallback && typeof fallback.recordTaskEvent === "function") {
+        try {
+          fallback.recordTaskEvent(phase, attrs);
+        } catch {
+        }
+      }
+    },
     createToolSpan: (toolName, attrs) => {
       let fallbackSpan = null;
       if (fallback && typeof fallback.createToolSpan === "function") {
@@ -10123,6 +10380,7 @@ var init_ai_review_service = __esm({
     init_tracer_init();
     init_diff_processor();
     init_comment_metadata();
+    init_user_facing_error();
     init_markdown();
     PROBE_GRACEFUL_MARGIN_MS = 9e4;
     MIN_TIMEOUT_FOR_MARGIN_MS = PROBE_GRACEFUL_MARGIN_MS + 3e4;
@@ -10541,8 +10799,8 @@ var init_ai_review_service = __esm({
       /**
        * Cleanup a session from the registry
        */
-      cleanupSession(sessionId) {
-        this.sessionRegistry.unregisterSession(sessionId);
+      async cleanupSession(sessionId) {
+        await this.sessionRegistry.unregisterSession(sessionId);
       }
       /**
        * Build a custom prompt for AI review with XML-formatted data
@@ -11947,9 +12205,7 @@ ${"=".repeat(60)}
           return { response, effectiveSchema, sessionId };
         } catch (error) {
           console.error("\u274C ProbeAgent failed:", error);
-          throw new Error(
-            `ProbeAgent execution failed: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
+          throw new Error(formatUserFacingExecutionError(error));
         } finally {
           Object.keys(originalEnv).forEach((key) => {
             if (originalEnv[key] === void 0) {
@@ -14431,7 +14687,7 @@ var init_workflow_executor = __esm({
             if (step.if) {
               const shouldRun = this.evaluateCondition(step.if, {
                 inputs: executionContext.inputs,
-                outputs: Object.fromEntries(stepResults),
+                outputs: this.unwrapOutputs(stepResults),
                 pr: runOptions.prInfo
               });
               if (!shouldRun) {
@@ -14594,18 +14850,14 @@ var init_workflow_executor = __esm({
                 throw new Error("Expression mapping requires expression field");
               }
               const sandbox = createSecureSandbox();
+              const unwrappedExpr = this.unwrapOutputs(stepResults);
               return compileAndRun(
                 sandbox,
                 typedMapping.expression,
                 {
                   inputs: executionContext.inputs,
-                  outputs: Object.fromEntries(stepResults),
-                  steps: Object.fromEntries(
-                    Array.from(stepResults.entries()).map(([id, result]) => [
-                      id,
-                      result.output
-                    ])
-                  )
+                  outputs: unwrappedExpr,
+                  steps: unwrappedExpr
                 },
                 { injectLog: true, logPrefix: "workflow.input.expression" }
               );
@@ -14618,7 +14870,7 @@ var init_workflow_executor = __esm({
           if (typedMapping.template) {
             return await this.liquid.parseAndRender(typedMapping.template, {
               inputs: executionContext.inputs,
-              outputs: Object.fromEntries(stepResults)
+              outputs: this.unwrapOutputs(stepResults)
             });
           }
         }
@@ -14645,32 +14897,44 @@ var init_workflow_executor = __esm({
         for (const output of workflow.outputs) {
           if (output.value_js) {
             const sandbox = createSecureSandbox();
+            const unwrapped = this.unwrapOutputs(stepResults);
             outputs[output.name] = compileAndRun(
               sandbox,
               output.value_js,
               {
                 inputs: executionContext.inputs,
-                steps: Object.fromEntries(
-                  Array.from(stepResults.entries()).map(([id, result]) => [id, result.output])
-                ),
-                outputs: Object.fromEntries(stepResults),
+                steps: unwrapped,
+                outputs: unwrapped,
                 pr: prInfo
               },
               { injectLog: true, logPrefix: `workflow.output.${output.name}` }
             );
           } else if (output.value) {
+            const unwrappedLiquid = this.unwrapOutputs(stepResults);
             outputs[output.name] = await this.liquid.parseAndRender(output.value, {
               inputs: executionContext.inputs,
-              steps: Object.fromEntries(
-                Array.from(stepResults.entries()).map(([id, result]) => [id, result.output])
-              ),
-              outputs: Object.fromEntries(stepResults),
+              steps: unwrappedLiquid,
+              outputs: unwrappedLiquid,
               pr: prInfo
             });
           }
         }
         return outputs;
       }
+      /**
+       * Unwrap step outputs from ReviewSummary wrappers.
+       * Script steps and MCP steps store results as { issues: [], output: <actual> }.
+       * Workflow value_js/if/Liquid should see the unwrapped output, consistent with
+       * how script step contexts already unwrap via buildProviderTemplateContext.
+       */
+      unwrapOutputs(stepResults) {
+        const unwrapped = {};
+        for (const [id, result] of stepResults.entries()) {
+          const summary = result;
+          unwrapped[id] = summary.output !== void 0 ? summary.output : summary;
+        }
+        return unwrapped;
+      }
       /**
        * Aggregate results from all steps
        */
@@ -16495,6 +16759,14 @@ var init_config_schema = __esm({
               },
               description: 'Tags for categorizing and filtering checks (e.g., ["local", "fast", "security"])'
             },
+            debounce: {
+              type: "number",
+              description: "Debounce window in milliseconds. When set, multiple invocations of this step (across concurrent engine instances) within the window are coalesced \u2014 only the last invocation actually executes after the window expires. Useful for steps that should run once after a burst of triggers settles.\n\nThe debounce key defaults to the step's fully-qualified check ID. Use `debounce_key` to group different steps under the same debounce."
+            },
+            debounce_key: {
+              type: "string",
+              description: "Custom debounce key. Steps sharing the same key share the same debounce window."
+            },
             criticality: {
               type: "string",
               enum: ["external", "internal", "policy", "info"],
@@ -16704,7 +16976,7 @@ var init_config_schema = __esm({
               description: "Arguments/inputs for the workflow"
             },
             overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-31208-src_types_config.ts-0-63102%3E%3E",
               description: "Override specific step configurations in the workflow"
             },
             output_mapping: {
@@ -16720,7 +16992,7 @@ var init_config_schema = __esm({
               description: "Config file path - alternative to workflow ID (loads a Visor config file as workflow)"
             },
             workflow_overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-31208-src_types_config.ts-0-63102%3E%3E",
               description: "Alias for overrides - workflow step overrides (backward compatibility)"
             },
             ref: {
@@ -17448,7 +17720,7 @@ var init_config_schema = __esm({
               description: "Custom output name (defaults to workflow name)"
             },
             overrides: {
-              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-31208-src_types_config.ts-0-63102%3E%3E",
               description: "Step overrides"
             },
             output_mapping: {
@@ -17463,13 +17735,13 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
-        "Record<string,Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422>>": {
+        "Record<string,Partial<interface-src_types_config.ts-15521-31208-src_types_config.ts-0-63102>>": {
           type: "object",
           additionalProperties: {
-            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E"
+            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-15521-31208-src_types_config.ts-0-63102%3E"
           }
         },
-        "Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422>": {
+        "Partial<interface-src_types_config.ts-15521-31208-src_types_config.ts-0-63102>": {
           type: "object",
           additionalProperties: false
         },
@@ -18841,7 +19113,7 @@ var init_config_schema = __esm({
             },
             workflow: {
               type: "string",
-              description: "Workflow/check ID to run"
+              description: "Workflow/check ID to run. Omit to treat inputs.text as a user message through the full pipeline."
             },
             inputs: {
               $ref: "#/definitions/Record%3Cstring%2Cunknown%3E",
@@ -18884,7 +19156,7 @@ var init_config_schema = __esm({
               description: "Timezone for schedule (default: UTC or scheduler default)"
             }
           },
-          required: ["schedule", "workflow"],
+          required: ["schedule"],
           additionalProperties: false,
           description: "Static cron job defined in YAML configuration These are always executed by the scheduler daemon",
           patternProperties: {
@@ -21228,6 +21500,7 @@ var init_workflow_check_provider = __esm({
     init_liquid_extensions();
     path15 = __toESM(require("path"));
     yaml5 = __toESM(require("js-yaml"));
+    init_user_facing_error();
     WorkflowCheckProvider = class extends CheckProvider {
       registry;
       executor;
@@ -21845,6 +22118,18 @@ var init_workflow_check_provider = __esm({
             scoreCount++;
           }
         }
+        for (const checkStats of result.statistics?.checks || []) {
+          if (checkStats.errorMessage) {
+            allIssues.push({
+              file: "system",
+              line: 0,
+              ruleId: "system/error",
+              message: formatUserFacingExecutionMessage(checkStats.errorMessage),
+              severity: "error",
+              category: "logic"
+            });
+          }
+        }
         const outputs = await this.computeWorkflowOutputsFromState(
           workflow,
           inputs,
@@ -22161,7 +22446,7 @@ function createWorkflowToolDefinition(workflow, argsOverrides, nameOverride) {
     for (const key of Object.keys(argsOverrides)) {
       delete filteredProperties[key];
     }
-    const filteredRequired = baseRequired ? baseRequired.filter((r) => !argsOverrides[r]) : void 0;
+    const filteredRequired = baseRequired ? baseRequired.filter((r) => !(r in argsOverrides)) : void 0;
     inputSchema = {
       ...baseSchema,
       properties: filteredProperties,
@@ -23495,283 +23780,19 @@ var init_github_auth = __esm({
   }
 });
 
-// src/debug-visualizer/trace-reader.ts
-var trace_reader_exports = {};
-__export(trace_reader_exports, {
-  buildExecutionTree: () => buildExecutionTree,
-  computeTimeline: () => computeTimeline,
-  extractStateSnapshots: () => extractStateSnapshots,
-  parseNDJSONTrace: () => parseNDJSONTrace
-});
-async function parseNDJSONTrace(filePath) {
-  const spans = [];
-  let lineNumber = 0;
-  const fileStream = fs16.createReadStream(filePath);
-  const rl = readline.createInterface({
-    input: fileStream,
-    crlfDelay: Infinity
-  });
-  for await (const line of rl) {
-    lineNumber++;
-    if (!line.trim()) {
-      continue;
-    }
-    try {
-      const rawSpan = JSON.parse(line);
-      const processedSpan = processRawSpan(rawSpan);
-      spans.push(processedSpan);
-    } catch (error) {
-      console.warn(`[trace-reader] Malformed JSON at line ${lineNumber}: ${error}`);
-    }
-  }
-  if (spans.length === 0) {
-    throw new Error("No valid spans found in trace file");
-  }
-  const tree = buildExecutionTree(spans);
-  const snapshots = extractStateSnapshots(spans);
-  const timeline = computeTimeline(spans);
-  const sortedSpans = [...spans].sort((a, b) => compareTimeValues(a.startTime, b.startTime));
-  const firstSpan = sortedSpans[0];
-  const lastSpan = sortedSpans[sortedSpans.length - 1];
-  const startTimeMs = timeValueToMillis(firstSpan.startTime);
-  const endTimeMs = timeValueToMillis(lastSpan.endTime);
-  return {
-    runId: tree.checkId,
-    traceId: firstSpan.traceId,
-    spans,
-    tree,
-    timeline,
-    snapshots,
-    metadata: {
-      startTime: timeValueToISO(firstSpan.startTime),
-      endTime: timeValueToISO(lastSpan.endTime),
-      duration: endTimeMs - startTimeMs,
-      totalSpans: spans.length,
-      totalSnapshots: snapshots.length
-    }
-  };
-}
-function processRawSpan(rawSpan) {
-  const traceId = rawSpan.traceId || "";
-  const spanId = rawSpan.spanId || "";
-  const parentSpanId = rawSpan.parentSpanId || void 0;
-  const name = rawSpan.name || "unknown";
-  const startTime = rawSpan.startTime || [0, 0];
-  const endTime = rawSpan.endTime || rawSpan.startTime || [0, 0];
-  const startMs = timeValueToMillis(startTime);
-  const endMs = timeValueToMillis(endTime);
-  const duration = endMs - startMs;
-  const attributes = rawSpan.attributes || {};
-  const events = (rawSpan.events || []).map((evt) => ({
-    name: evt.name || "unknown",
-    time: evt.time || [0, 0],
-    timestamp: evt.timestamp || timeValueToISO(evt.time || [0, 0]),
-    attributes: evt.attributes || {}
-  }));
-  const status = rawSpan.status?.code === 2 ? "error" : "ok";
-  return {
-    traceId,
-    spanId,
-    parentSpanId,
-    name,
-    startTime,
-    endTime,
-    duration,
-    attributes,
-    events,
-    status
-  };
-}
-function buildExecutionTree(spans) {
-  const nodeMap = /* @__PURE__ */ new Map();
-  for (const span of spans) {
-    const node = createExecutionNode(span);
-    nodeMap.set(span.spanId, node);
-  }
-  let rootNode;
-  const orphans = [];
-  for (const span of spans) {
-    const node = nodeMap.get(span.spanId);
-    if (!span.parentSpanId) {
-      rootNode = node;
-    } else {
-      const parent = nodeMap.get(span.parentSpanId);
-      if (parent) {
-        parent.children.push(node);
-      } else {
-        orphans.push(node);
-      }
-    }
-  }
-  if (!rootNode) {
-    console.warn("[trace-reader] No root span found, creating synthetic root");
-    rootNode = {
-      checkId: "synthetic-root",
-      type: "run",
-      status: "completed",
-      children: Array.from(nodeMap.values()).filter((n) => !n.span.parentSpanId),
-      span: spans[0],
-      // Use first span as placeholder
-      state: {}
-    };
-  }
-  if (orphans.length > 0 && rootNode) {
-    rootNode.children.push(...orphans);
-  }
-  return rootNode;
-}
-function createExecutionNode(span) {
-  const attrs = span.attributes;
-  const checkId = attrs["visor.check.id"] || attrs["visor.run.id"] || span.spanId;
-  let type = "unknown";
-  if (span.name === "visor.run") {
-    type = "run";
-  } else if (span.name === "visor.check") {
-    type = "check";
-  } else if (span.name.startsWith("visor.provider.")) {
-    type = "provider";
-  }
-  let status = "completed";
-  if (span.status === "error") {
-    status = "error";
-  } else if (attrs["visor.check.skipped"] === true) {
-    status = "skipped";
-  }
-  const state = {};
-  if (attrs["visor.check.input.context"]) {
-    try {
-      state.inputContext = JSON.parse(attrs["visor.check.input.context"]);
-    } catch {
-      state.inputContext = attrs["visor.check.input.context"];
-    }
-  }
-  if (attrs["visor.check.output"]) {
-    try {
-      state.output = JSON.parse(attrs["visor.check.output"]);
-    } catch {
-      state.output = attrs["visor.check.output"];
-    }
-  }
-  if (span.status === "error" || attrs["visor.check.error"]) {
-    state.errors = [attrs["visor.check.error"] || "Unknown error"];
-  }
-  state.metadata = {
-    type: attrs["visor.check.type"],
-    duration: span.duration,
-    provider: attrs["visor.provider.type"]
-  };
-  return {
-    checkId,
-    type,
-    status,
-    children: [],
-    span,
-    state
-  };
-}
-function extractStateSnapshots(spans) {
-  const snapshots = [];
-  for (const span of spans) {
-    for (const event of span.events) {
-      if (event.name === "state.snapshot") {
-        const attrs = event.attributes || {};
-        const snapshot = {
-          checkId: attrs["visor.snapshot.check_id"] || span.attributes["visor.check.id"] || "unknown",
-          timestamp: attrs["visor.snapshot.timestamp"] || event.timestamp || timeValueToISO(event.time),
-          timestampNanos: event.time,
-          outputs: parseJSON(attrs["visor.snapshot.outputs"], {}),
-          memory: parseJSON(attrs["visor.snapshot.memory"], {})
-        };
-        snapshots.push(snapshot);
-      }
-    }
-  }
-  snapshots.sort((a, b) => compareTimeValues(a.timestampNanos, b.timestampNanos));
-  return snapshots;
-}
-function computeTimeline(spans) {
-  const events = [];
-  for (const span of spans) {
-    const checkId = span.attributes["visor.check.id"] || span.spanId;
-    events.push({
-      type: "check.started",
-      checkId,
-      timestamp: timeValueToISO(span.startTime),
-      timestampNanos: span.startTime,
-      metadata: {
-        name: span.name,
-        type: span.attributes["visor.check.type"]
-      }
-    });
-    events.push({
-      type: span.status === "error" ? "check.failed" : "check.completed",
-      checkId,
-      timestamp: timeValueToISO(span.endTime),
-      timestampNanos: span.endTime,
-      duration: span.duration,
-      status: span.status,
-      metadata: {
-        name: span.name
-      }
-    });
-    for (const evt of span.events) {
-      events.push({
-        type: evt.name === "state.snapshot" ? "state.snapshot" : "event",
-        checkId: evt.attributes?.["visor.snapshot.check_id"] || checkId,
-        timestamp: evt.timestamp || timeValueToISO(evt.time),
-        timestampNanos: evt.time,
-        metadata: {
-          eventName: evt.name,
-          attributes: evt.attributes
-        }
-      });
-    }
-  }
-  events.sort((a, b) => compareTimeValues(a.timestampNanos, b.timestampNanos));
-  return events;
-}
-function timeValueToMillis(timeValue) {
-  const [seconds, nanos] = timeValue;
-  return seconds * 1e3 + nanos / 1e6;
-}
-function timeValueToISO(timeValue) {
-  const millis = timeValueToMillis(timeValue);
-  return new Date(millis).toISOString();
-}
-function compareTimeValues(a, b) {
-  if (a[0] !== b[0]) {
-    return a[0] - b[0];
-  }
-  return a[1] - b[1];
-}
-function parseJSON(value, defaultValue) {
-  if (typeof value !== "string") {
-    return defaultValue;
-  }
-  try {
-    return JSON.parse(value);
-  } catch {
-    return defaultValue;
-  }
-}
-var fs16, readline;
-var init_trace_reader = __esm({
-  "src/debug-visualizer/trace-reader.ts"() {
-    "use strict";
-    fs16 = __toESM(require("fs"));
-    readline = __toESM(require("readline"));
-  }
-});
-
 // src/agent-protocol/trace-serializer.ts
 var trace_serializer_exports = {};
 __export(trace_serializer_exports, {
+  buildTraceHeaderLines: () => buildTraceHeaderLines,
+  buildTraceReport: () => buildTraceReport,
+  extractProbeTaskSummary: () => extractProbeTaskSummary,
   fetchTraceSpans: () => fetchTraceSpans,
   findTraceFile: () => findTraceFile,
   readTraceIdFromFile: () => readTraceIdFromFile,
   renderSpanTree: () => renderSpanTree,
   renderSpanYaml: () => renderSpanYaml,
   renderTraceTree: () => renderTraceTree,
+  resolveTraceSpans: () => resolveTraceSpans,
   serializeTraceForPrompt: () => serializeTraceForPrompt
 });
 function resolveBackendConfig(overrides) {
@@ -23782,7 +23803,8 @@ function resolveBackendConfig(overrides) {
     grafanaDatasourceId: overrides?.grafanaDatasourceId || process.env.GRAFANA_TEMPO_DATASOURCE_ID,
     jaegerUrl: overrides?.jaegerUrl || process.env.JAEGER_URL,
     traceDir: overrides?.traceDir || process.env.VISOR_TRACE_DIR || "output/traces",
-    authToken: overrides?.authToken || process.env.GRAFANA_TOKEN
+    authToken: overrides?.authToken || process.env.GRAFANA_TOKEN,
+    targetTraceId: overrides?.targetTraceId
   };
 }
 function getAutoBackendOrder() {
@@ -23943,6 +23965,60 @@ async function fetchTraceSpans(traceRef, config) {
   }
   return [];
 }
+async function resolveTraceSpans(traceIdOrPath, backendConfig, fallbackTraceId) {
+  const cfg = resolveBackendConfig(backendConfig);
+  const backendOrder = getBackendOrder(cfg);
+  const isFilePath = isTraceFilePath(traceIdOrPath);
+  const localTracePath = isFilePath ? traceIdOrPath : void 0;
+  const remoteTraceId = fallbackTraceId || (!isFilePath ? traceIdOrPath : await readTraceIdFromFile(traceIdOrPath) || void 0);
+  const preferLocalFirst = backendOrder[0] === "file";
+  logger.debug(
+    `[TraceSerializer] serializeTraceForPrompt ref=${traceIdOrPath} remoteTraceId=${remoteTraceId || "-"} backendOrder=${backendOrder.join(">")}`
+  );
+  if (preferLocalFirst && localTracePath) {
+    logger.debug(`[TraceSerializer] Trying local trace file first: ${localTracePath}`);
+    const spans = await fetchTraceSpans(localTracePath, {
+      ...cfg,
+      type: "file",
+      targetTraceId: remoteTraceId
+    });
+    if (spans.length > 0) {
+      return { spans, source: "file", remoteTraceId, localTracePath };
+    }
+  }
+  if (remoteTraceId) {
+    logger.debug(`[TraceSerializer] Trying remote trace backends for trace_id=${remoteTraceId}`);
+    const remoteCfg = resolveBackendConfig(backendConfig);
+    const remoteOrder = getBackendOrder(remoteCfg).filter((kind) => kind !== "file");
+    for (const backend of remoteOrder) {
+      if (backend === "grafana") {
+        const spans = await fetchFromGrafanaTempo(remoteTraceId, remoteCfg);
+        if (spans && spans.length > 0) {
+          return { spans, source: "grafana", remoteTraceId, localTracePath };
+        }
+        continue;
+      }
+      if (backend === "jaeger") {
+        const spans = await fetchFromJaeger(remoteTraceId, remoteCfg);
+        if (spans && spans.length > 0) {
+          return { spans, source: "jaeger", remoteTraceId, localTracePath };
+        }
+      }
+    }
+  }
+  if (localTracePath) {
+    logger.debug(`[TraceSerializer] Falling back to local trace file: ${localTracePath}`);
+    const spans = await fetchTraceSpans(localTracePath, {
+      ...cfg,
+      type: "file",
+      targetTraceId: remoteTraceId
+    });
+    if (spans.length > 0) {
+      return { spans, source: "file", remoteTraceId, localTracePath };
+    }
+  }
+  return { spans: [], source: null, remoteTraceId, localTracePath };
+}
 async function fetchFromGrafanaTempo(traceId, cfg) {
   let grafanaUrl = cfg.grafanaUrl;
   if (!grafanaUrl) {
@@ -24018,9 +24094,29 @@ async function fetchFromLocalFiles(traceRef, cfg) {
   const traceFile = isTraceFilePath(traceRef) ? traceRef : await findTraceFile(traceRef, cfg.traceDir);
   if (!traceFile) return null;
   try {
-    const { parseNDJSONTrace: parseNDJSONTrace2 } = await Promise.resolve().then(() => (init_trace_reader(), trace_reader_exports));
-    const trace2 = await parseNDJSONTrace2(traceFile);
-    return parseLocalNDJSONSpans(trace2.spans);
+    const targetTraceId = cfg.targetTraceId || (!isTraceFilePath(traceRef) ? traceRef : await readTraceIdFromFile(traceFile) || void 0);
+    const rawSpans = [];
+    const rl = readline.createInterface({
+      input: fs16.createReadStream(traceFile, { encoding: "utf8" }),
+      crlfDelay: Infinity
+    });
+    try {
+      for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (!targetTraceId || parsed.traceId === targetTraceId) {
+            rawSpans.push(parsed);
+          }
+        } catch {
+        }
+      }
+    } finally {
+      rl.close();
+    }
+    if (rawSpans.length === 0) return [];
+    return parseLocalNDJSONSpans(rawSpans);
   } catch (err) {
     logger.debug(`[TraceSerializer] Local file parse failed: ${err}`);
     return null;
@@ -24045,15 +24141,27 @@ async function httpGet(url, authToken, timeoutMs) {
 }
 async function findTraceFile(traceId, traceDir) {
   const dir = traceDir || process.env.VISOR_TRACE_DIR || "output/traces";
-  if (!fs17.existsSync(dir)) return null;
-  const files = fs17.readdirSync(dir).filter((f) => f.endsWith(".ndjson"));
+  if (!fs16.existsSync(dir)) return null;
+  const files = fs16.readdirSync(dir).filter((f) => f.endsWith(".ndjson"));
   for (const file of files) {
     const filePath = path19.join(dir, file);
     try {
-      const firstLine = await readFirstLine(filePath);
-      if (!firstLine) continue;
-      const parsed = JSON.parse(firstLine);
-      if (parsed.traceId === traceId) return filePath;
+      const rl = readline.createInterface({
+        input: fs16.createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity
+      });
+      try {
+        for await (const line of rl) {
+          if (!line.trim()) continue;
+          const parsed = JSON.parse(line);
+          if (parsed.traceId === traceId) {
+            rl.close();
+            return filePath;
+          }
+        }
+      } finally {
+        rl.close();
+      }
     } catch {
     }
   }
@@ -24061,8 +24169,8 @@ async function findTraceFile(traceId, traceDir) {
 }
 async function readTraceIdFromFile(traceFile) {
   try {
-    const rl = readline2.createInterface({
-      input: fs17.createReadStream(traceFile, { encoding: "utf8" }),
+    const rl = readline.createInterface({
+      input: fs16.createReadStream(traceFile, { encoding: "utf8" }),
       crlfDelay: Infinity
     });
     for await (const line of rl) {
@@ -24082,25 +24190,6 @@ async function readTraceIdFromFile(traceFile) {
   }
   return null;
 }
-async function readFirstLine(filePath) {
-  return new Promise((resolve17, reject) => {
-    const stream = fs17.createReadStream(filePath, { encoding: "utf-8" });
-    const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
-    let resolved = false;
-    rl.on("line", (line) => {
-      if (!resolved) {
-        resolved = true;
-        rl.close();
-        stream.destroy();
-        resolve17(line.trim() || null);
-      }
-    });
-    rl.on("close", () => {
-      if (!resolved) resolve17(null);
-    });
-    rl.on("error", reject);
-  });
-}
 function isNoiseSpan(span) {
   return NOISE_SPAN_NAMES.has(span.name);
 }
@@ -24258,6 +24347,454 @@ function getLifecycleSpanInfo(name) {
   }
   return null;
 }
+function parseTaskStatusSnapshot(raw) {
+  if (!raw || !raw.includes("<task_status>")) return [];
+  const items = [];
+  const taskRegex = /<task\s+id="([^"]+)"\s+status="([^"]+)"(?:\s+priority="[^"]*")?>([\s\S]*?)<\/task>/g;
+  let match;
+  while ((match = taskRegex.exec(raw)) !== null) {
+    items.push({
+      id: match[1],
+      status: match[2],
+      title: match[3].replace(/\s+/g, " ").trim()
+    });
+  }
+  return items;
+}
+function parseTaskIds(value) {
+  if (!value) return [];
+  return String(value).split(",").map((part) => part.trim()).filter(Boolean);
+}
+function parseBatchItemsJson(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(String(value));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((item) => item && typeof item.id === "string");
+  } catch {
+    return [];
+  }
+}
+function isTaskTelemetrySpan(span) {
+  const toolName = span.attributes["tool.name"] || span.attributes["visor.tool.name"];
+  if (toolName === "task") return true;
+  return /(?:^probe\.event\.)?task\.[a-z_]+$/.test(normalizeSpanName(span.name));
+}
+function summarizeTaskTelemetrySpans(spans) {
+  const ordered = [...spans].sort((a, b) => {
+    if (a.startTimeMs !== b.startTimeMs) return a.startTimeMs - b.startTimeMs;
+    if (a.endTimeMs !== b.endTimeMs) return a.endTimeMs - b.endTimeMs;
+    return a.spanId.localeCompare(b.spanId);
+  });
+  const tasks = /* @__PURE__ */ new Map();
+  let tasksEnabled = false;
+  let snapshotCount = 0;
+  let eventCount = 0;
+  let sawSnapshot = false;
+  const upsertTask = (id, patch) => {
+    const existing = tasks.get(id) || { id, title: "", status: "pending" };
+    const next = {
+      id,
+      title: patch.title ?? existing.title,
+      status: patch.status ?? existing.status
+    };
+    tasks.set(id, next);
+  };
+  for (const span of ordered) {
+    const name = normalizeSpanName(span.name);
+    const attrs = span.attributes;
+    const toolName = attrs["tool.name"] || attrs["visor.tool.name"];
+    if (toolName === "task") {
+      const snapshot = parseTaskStatusSnapshot(String(attrs["tool.result"] || ""));
+      if (snapshot.length > 0) {
+        tasksEnabled = true;
+        snapshotCount += 1;
+        sawSnapshot = true;
+        tasks.clear();
+        for (const task of snapshot) {
+          tasks.set(task.id, {
+            id: task.id,
+            title: task.title,
+            status: task.status
+          });
+        }
+      }
+    }
+    const taskEventMatch = name.match(/(?:^probe\.event\.)?task\.([a-z_]+)$/);
+    if (!taskEventMatch) continue;
+    tasksEnabled = true;
+    eventCount += 1;
+    const eventType = taskEventMatch[1];
+    const taskId = attrs["task.id"] ? String(attrs["task.id"]) : "";
+    const taskTitle = attrs["task.title"] ? String(attrs["task.title"]).trim() : "";
+    const newStatus = attrs["task.new_status"] ? String(attrs["task.new_status"]) : "";
+    const taskIds = parseTaskIds(attrs["task.ids"]);
+    switch (eventType) {
+      case "created":
+        if (taskId) upsertTask(taskId, { title: taskTitle, status: "pending" });
+        break;
+      case "updated":
+        if (taskId) {
+          upsertTask(taskId, {
+            title: taskTitle || void 0,
+            status: newStatus && newStatus !== "unchanged" ? newStatus : void 0
+          });
+        }
+        break;
+      case "completed":
+        if (taskId) upsertTask(taskId, { title: taskTitle || void 0, status: "completed" });
+        break;
+      case "deleted":
+        if (taskId) upsertTask(taskId, { title: taskTitle || void 0, status: "deleted" });
+        break;
+      case "batch_created": {
+        const items = parseBatchItemsJson(attrs["task.items_json"]);
+        if (items.length > 0) {
+          for (const item of items)
+            upsertTask(item.id, { title: item.title || "", status: item.status || "pending" });
+        } else {
+          for (const id of taskIds) upsertTask(id, { status: "pending" });
+        }
+        break;
+      }
+      case "batch_updated": {
+        const items = parseBatchItemsJson(attrs["task.items_json"]);
+        if (items.length > 0) {
+          for (const item of items)
+            upsertTask(item.id, {
+              title: item.title || void 0,
+              status: item.status || void 0
+            });
+        } else {
+          for (const id of taskIds) {
+            upsertTask(id, {
+              status: newStatus && newStatus !== "unchanged" ? newStatus : void 0
+            });
+          }
+        }
+        break;
+      }
+      case "batch_completed": {
+        const items = parseBatchItemsJson(attrs["task.items_json"]);
+        if (items.length > 0) {
+          for (const item of items)
+            upsertTask(item.id, { title: item.title || void 0, status: "completed" });
+        } else {
+          for (const id of taskIds) upsertTask(id, { status: "completed" });
+        }
+        break;
+      }
+      case "batch_deleted": {
+        const items = parseBatchItemsJson(attrs["task.items_json"]);
+        if (items.length > 0) {
+          for (const item of items)
+            upsertTask(item.id, { title: item.title || void 0, status: "deleted" });
+        } else {
+          for (const id of taskIds) upsertTask(id, { status: "deleted" });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!tasksEnabled) return null;
+  return {
+    tasksEnabled,
+    source: sawSnapshot ? "snapshot" : "events",
+    eventCount,
+    snapshotCount,
+    tasks: [...tasks.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    scopes: []
+  };
+}
+function titleCaseWords(raw) {
+  return raw.split(/[\s_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getTaskScopeCheckId(span) {
+  const concreteName = getConcreteCheckName(span);
+  if (!concreteName) return null;
+  return concreteName.replace(/^visor\.check\./, "");
+}
+function isTaskScopeNode(span) {
+  const checkId = getTaskScopeCheckId(span);
+  if (checkId) return !TASK_SCOPE_EXCLUDED_CHECKS.has(checkId);
+  const normalized = normalizeSpanName(span.name);
+  return normalized === "search.delegate" || normalized.startsWith("engineer.");
+}
+function getTaskScopeLabel(span) {
+  if (!span) return ROOT_TASK_SCOPE_LABEL;
+  const checkId = getTaskScopeCheckId(span);
+  if (checkId) {
+    if (checkId === "explore-code") return "Code Explorer";
+    return titleCaseWords(checkId);
+  }
+  const normalized = normalizeSpanName(span.name);
+  if (normalized === "search.delegate") return "Search Delegate";
+  if (normalized.startsWith("engineer.")) {
+    return `Engineer ${titleCaseWords(normalized.slice("engineer.".length))}`;
+  }
+  return titleCaseWords(normalized);
+}
+function collectTaskSpansForScope(node, stopAtNestedScopes) {
+  const spans = [];
+  const visit = (current, isRoot) => {
+    if (!isRoot && stopAtNestedScopes && isTaskScopeNode(current.span)) return;
+    if (isTaskTelemetrySpan(current.span)) spans.push(current.span);
+    for (const child of current.children) visit(child, false);
+  };
+  visit(node, true);
+  return spans;
+}
+function findImmediateNestedTaskScopeNodes(node) {
+  const scopes = [];
+  const visit = (current, isRoot) => {
+    if (!isRoot && isTaskScopeNode(current.span)) {
+      scopes.push(current);
+      return;
+    }
+    for (const child of current.children) visit(child, false);
+  };
+  visit(node, true);
+  return scopes;
+}
+function isSubAgentScope(span) {
+  const checkId = getTaskScopeCheckId(span);
+  if (checkId && SUB_AGENT_SCOPE_CHECKS.has(checkId)) return true;
+  const normalized = normalizeSpanName(span.name);
+  return normalized.startsWith("engineer.") || normalized === "search.delegate";
+}
+function getSubAgentStatus(node) {
+  const normalized = normalizeSpanName(node.span.name);
+  if (normalized.endsWith(".completed")) return "completed";
+  if (normalized.endsWith(".started") || normalized.endsWith(".progress")) return "in_progress";
+  let hasCompleted = false;
+  let hasProgress = false;
+  const visit = (current) => {
+    const n = normalizeSpanName(current.span.name);
+    if (n.endsWith(".completed")) hasCompleted = true;
+    if (n.endsWith(".progress")) hasProgress = true;
+    for (const child of current.children) visit(child);
+  };
+  visit(node);
+  if (hasCompleted) return "completed";
+  if (hasProgress) return "in_progress";
+  return "pending";
+}
+function buildProbeTaskScopeSummary(node, label, isRootScope = false, allSpans) {
+  const nestedScopeNodes = findImmediateNestedTaskScopeNodes(node);
+  if (!isRootScope && isSubAgentScope(node.span)) {
+    const localTasks = summarizeTaskTelemetrySpans(collectTaskSpansForScope(node, true));
+    const hasMeaningfulTitles = localTasks && localTasks.tasks.some(
+      (t) => t.title && t.title.length > 3 && !/^(task|engineer|code.?explorer)\s*/i.test(t.title)
+    );
+    if (hasMeaningfulTitles) {
+      return {
+        label: isRootScope ? ROOT_TASK_SCOPE_LABEL : label,
+        source: localTasks.source,
+        eventCount: localTasks.eventCount,
+        snapshotCount: localTasks.snapshotCount,
+        tasks: localTasks.tasks,
+        children: []
+      };
+    }
+    const status = getSubAgentStatus(node);
+    const scopeLabel = getTaskScopeLabel(node.span);
+    return {
+      label: isRootScope ? ROOT_TASK_SCOPE_LABEL : label,
+      source: "events",
+      eventCount: 0,
+      snapshotCount: 0,
+      tasks: [{ id: `__scope_${node.span.spanId}`, title: scopeLabel, status, synthetic: true }],
+      children: []
+    };
+  }
+  const local = summarizeTaskTelemetrySpans(collectTaskSpansForScope(node, true));
+  const children = [];
+  const subAgentGroups = /* @__PURE__ */ new Map();
+  const nonSubAgentNodes = [];
+  for (const child of nestedScopeNodes) {
+    if (isSubAgentScope(child.span)) {
+      const checkId = getTaskScopeCheckId(child.span) || normalizeSpanName(child.span.name);
+      const group = subAgentGroups.get(checkId) || [];
+      group.push(child);
+      subAgentGroups.set(checkId, group);
+    } else {
+      nonSubAgentNodes.push(child);
+    }
+  }
+  for (const child of nonSubAgentNodes) {
+    const childScope = buildProbeTaskScopeSummary(
+      child,
+      getTaskScopeLabel(child.span),
+      false,
+      allSpans
+    );
+    if (childScope) children.push(childScope);
+  }
+  for (const [checkId, nodes] of subAgentGroups) {
+    const scopeLabel = checkId === "engineer-task" ? "Engineer" : checkId === "explore-code" ? "Code Explorer" : titleCaseWords(checkId);
+    const tasks = [];
+    for (const n of nodes) {
+      const iterScope = buildProbeTaskScopeSummary(n, scopeLabel, false, allSpans);
+      if (iterScope && iterScope.tasks.length > 0) {
+        tasks.push(...iterScope.tasks);
+      } else {
+        const status = getSubAgentStatus(n);
+        tasks.push({
+          id: `__scope_${n.span.spanId}`,
+          title: scopeLabel,
+          status,
+          synthetic: true
+        });
+      }
+    }
+    const dedupedTasks = [];
+    for (const task of tasks) {
+      const prev = dedupedTasks[dedupedTasks.length - 1];
+      if (prev && prev.title === task.title && prev.status === task.status) continue;
+      dedupedTasks.push(task);
+    }
+    children.push({
+      label: scopeLabel,
+      source: "events",
+      eventCount: nodes.length,
+      snapshotCount: 0,
+      tasks: dedupedTasks,
+      children: []
+    });
+  }
+  if (!local && children.length === 0) return null;
+  return {
+    label: isRootScope ? ROOT_TASK_SCOPE_LABEL : label,
+    source: local?.source ?? "events",
+    eventCount: local?.eventCount ?? 0,
+    snapshotCount: local?.snapshotCount ?? 0,
+    tasks: local?.tasks ?? [],
+    children
+  };
+}
+function buildTaskSummaryRoot(spans) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    nodeMap.set(span.spanId, { span, children: [] });
+  }
+  const roots = [];
+  for (const span of spans) {
+    const node = nodeMap.get(span.spanId);
+    if (span.parentSpanId && nodeMap.has(span.parentSpanId)) {
+      nodeMap.get(span.parentSpanId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  const sortChildren = (node) => {
+    node.children.sort((a, b) => a.span.startTimeMs - b.span.startTimeMs);
+    node.children.forEach(sortChildren);
+  };
+  roots.forEach(sortChildren);
+  return {
+    span: {
+      traceId: spans[0]?.traceId || "",
+      spanId: "__task-root__",
+      name: "__task_root__",
+      startTimeMs: roots[0]?.span.startTimeMs || 0,
+      endTimeMs: roots[roots.length - 1]?.span.endTimeMs || 0,
+      durationMs: 0,
+      attributes: {},
+      events: [],
+      status: "ok"
+    },
+    children: roots
+  };
+}
+function flattenTaskScopes(scopes) {
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  const visit = (scope) => {
+    for (const task of scope.tasks) {
+      if (task.synthetic) continue;
+      if (seen.has(task.id)) continue;
+      seen.add(task.id);
+      items.push(task);
+    }
+    for (const child of scope.children) visit(child);
+  };
+  for (const scope of scopes) visit(scope);
+  return items;
+}
+function buildTemporalTaskScopes(spans) {
+  const ordered = [...spans].sort((a, b) => {
+    if (a.startTimeMs !== b.startTimeMs) return a.startTimeMs - b.startTimeMs;
+    if (a.endTimeMs !== b.endTimeMs) return a.endTimeMs - b.endTimeMs;
+    return a.spanId.localeCompare(b.spanId);
+  });
+  const grouped = /* @__PURE__ */ new Map();
+  const scopeOrder = [];
+  const ensureGroup = (label) => {
+    if (!grouped.has(label)) {
+      grouped.set(label, []);
+      scopeOrder.push(label);
+    }
+    return grouped.get(label);
+  };
+  for (let i = 0; i < ordered.length; i += 1) {
+    const span = ordered[i];
+    if (!isTaskTelemetrySpan(span)) continue;
+    let label = ROOT_TASK_SCOPE_LABEL;
+    for (let j = i - 1; j >= 0; j -= 1) {
+      if (isTaskScopeNode(ordered[j])) {
+        label = getTaskScopeLabel(ordered[j]);
+        break;
+      }
+    }
+    ensureGroup(label).push(span);
+  }
+  if (grouped.size === 0) return [];
+  const rootSummary = summarizeTaskTelemetrySpans(grouped.get(ROOT_TASK_SCOPE_LABEL) || []);
+  const children = [];
+  for (const label of scopeOrder) {
+    if (label === ROOT_TASK_SCOPE_LABEL) continue;
+    const summary = summarizeTaskTelemetrySpans(grouped.get(label) || []);
+    if (!summary) continue;
+    children.push({
+      label,
+      source: summary.source,
+      eventCount: summary.eventCount,
+      snapshotCount: summary.snapshotCount,
+      tasks: summary.tasks,
+      children: []
+    });
+  }
+  return [
+    {
+      label: ROOT_TASK_SCOPE_LABEL,
+      source: rootSummary?.source ?? "events",
+      eventCount: rootSummary?.eventCount ?? 0,
+      snapshotCount: rootSummary?.snapshotCount ?? 0,
+      tasks: rootSummary?.tasks ?? [],
+      children
+    }
+  ];
+}
+function formatTaskStatusMarker(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return "[~]";
+    case "blocked":
+    case "failed":
+    case "error":
+      return "[!]";
+    case "cancelled":
+    case "canceled":
+    case "deleted":
+      return "[-]";
+    default:
+      return "[ ]";
+  }
+}
 function buildRenderContext(allSpans) {
   const realSpanNames = /* @__PURE__ */ new Set();
   let hasChildWorkSpans = false;
@@ -24284,28 +24821,7 @@ function shouldSkipLifecycleSpan(span, renderContext) {
   return renderContext.realSpanNames.has(lifecycle.baseName);
 }
 async function serializeTraceForPrompt(traceIdOrPath, maxChars, backendConfig, taskResponse, fallbackTraceId) {
-  let spans = [];
-  const cfg = resolveBackendConfig(backendConfig);
-  const backendOrder = getBackendOrder(cfg);
-  const isFilePath = isTraceFilePath(traceIdOrPath);
-  const localTracePath = isFilePath ? traceIdOrPath : void 0;
-  const remoteTraceId = fallbackTraceId || (!isFilePath ? traceIdOrPath : await readTraceIdFromFile(traceIdOrPath) || void 0);
-  const preferLocalFirst = backendOrder[0] === "file";
-  logger.debug(
-    `[TraceSerializer] serializeTraceForPrompt ref=${traceIdOrPath} remoteTraceId=${remoteTraceId || "-"} backendOrder=${backendOrder.join(">")}`
-  );
-  if (preferLocalFirst && localTracePath) {
-    logger.debug(`[TraceSerializer] Trying local trace file first: ${localTracePath}`);
-    spans = await fetchTraceSpans(localTracePath, { ...cfg, type: "file" });
-  }
-  if (spans.length === 0 && remoteTraceId) {
-    logger.debug(`[TraceSerializer] Trying remote trace backends for trace_id=${remoteTraceId}`);
-    spans = await fetchTraceSpans(remoteTraceId, cfg);
-  }
-  if (spans.length === 0 && localTracePath) {
-    logger.debug(`[TraceSerializer] Falling back to local trace file: ${localTracePath}`);
-    spans = await fetchTraceSpans(localTracePath, { ...cfg, type: "file" });
-  }
+  const { spans } = await resolveTraceSpans(traceIdOrPath, backendConfig, fallbackTraceId);
   if (spans.length === 0) {
     return "(no trace data available)";
   }
@@ -24319,6 +24835,101 @@ async function serializeTraceForPrompt(traceIdOrPath, maxChars, backendConfig, t
     taskResponse
   });
 }
+function renderTraceTreeFromSpans(spans, maxChars, taskResponse) {
+  const tree = buildSpanTree(spans);
+  const routeIntentTopic = extractRouteIntentTopic(spans);
+  const fullOutput = (maxChars ?? 4e3) > 1e5;
+  return renderSpanYaml(tree, spans, {
+    maxChars: maxChars ?? 4e3,
+    fallbackIntent: routeIntentTopic,
+    fullOutput,
+    taskResponse
+  });
+}
+function formatTaskStatus(status) {
+  return status === "completed" ? "[x]" : status === "in_progress" ? "[~]" : status === "blocked" || status === "failed" || status === "error" ? "[!]" : status === "deleted" || status === "cancelled" || status === "canceled" ? "[-]" : "[ ]";
+}
+function formatTaskLabel(task) {
+  const title = String(task.title || "").trim();
+  return title || task.id || task.status;
+}
+function scopeHasRenderableTasks(scope) {
+  if (scope.tasks.some((task) => !task.synthetic)) return true;
+  return scope.children.some((child) => scopeHasRenderableTasks(child));
+}
+function appendTaskScopeLines(lines, scope, depth = 0) {
+  if (!scopeHasRenderableTasks(scope)) return;
+  const prefix = "  ".repeat(depth);
+  if (depth > 0 || scope.label !== ROOT_TASK_SCOPE_LABEL) {
+    lines.push(`${prefix}${scope.label}`);
+  }
+  for (const task of scope.tasks.filter((task2) => !task2.synthetic)) {
+    lines.push(`${prefix}  ${formatTaskStatus(task.status)} ${formatTaskLabel(task)}`);
+  }
+  for (const child of scope.children) {
+    appendTaskScopeLines(lines, child, depth + 1);
+  }
+}
+function buildTraceHeaderLines(traceData, taskSummary) {
+  const lines = [`Trace source: ${traceData.source || "unknown"}`];
+  if (!taskSummary || taskSummary.tasks.length === 0) {
+    lines.push("Tasks: no task telemetry found in this trace");
+    return lines;
+  }
+  const eventsSuffix = taskSummary.snapshotCount > 0 ? `, ${taskSummary.eventCount} task events, ${taskSummary.snapshotCount} snapshots` : `, ${taskSummary.eventCount} task events`;
+  lines.push(`Tasks: ${taskSummary.tasks.length} tracked (${taskSummary.source}${eventsSuffix})`);
+  if (taskSummary.scopes.length > 0) {
+    for (const scope of taskSummary.scopes) {
+      appendTaskScopeLines(lines, scope);
+    }
+  } else {
+    for (const task of taskSummary.tasks) {
+      lines.push(`  ${formatTaskStatus(task.status)} ${formatTaskLabel(task)}`);
+    }
+  }
+  return lines;
+}
+async function buildTraceReport(traceIdOrPath, maxChars, backendConfig, taskResponse, fallbackTraceId) {
+  const traceData = await resolveTraceSpans(traceIdOrPath, backendConfig, fallbackTraceId);
+  if (traceData.spans.length === 0) {
+    return null;
+  }
+  const taskSummary = extractProbeTaskSummary(traceData.spans);
+  const headerLines = buildTraceHeaderLines(traceData, taskSummary);
+  const headerText = headerLines.join("\n");
+  const tree = renderTraceTreeFromSpans(traceData.spans, maxChars, taskResponse);
+  return {
+    traceData,
+    tree,
+    taskSummary,
+    headerText,
+    text: `${headerText}
+
+${tree}`
+  };
+}
+function extractProbeTaskSummary(spans) {
+  const overall = summarizeTaskTelemetrySpans(spans);
+  if (!overall) return null;
+  const rootScope = buildProbeTaskScopeSummary(
+    buildTaskSummaryRoot(spans),
+    ROOT_TASK_SCOPE_LABEL,
+    true,
+    spans
+  );
+  let scopes = rootScope ? [rootScope] : [];
+  if (scopes.length === 0 || scopes[0].children.length === 0) {
+    const temporalScopes = buildTemporalTaskScopes(spans);
+    if (temporalScopes.length > 0 && temporalScopes[0].children.length > 0) {
+      scopes = temporalScopes;
+    }
+  }
+  return {
+    ...overall,
+    tasks: scopes.length > 0 ? flattenTaskScopes(scopes) : overall.tasks,
+    scopes
+  };
+}
 function renderSpanTree(tree, opts) {
   const maxChars = opts?.maxChars ?? 4e3;
   const maxDepth = opts?.maxDepth ?? 20;
@@ -24446,6 +25057,19 @@ function renderYamlNode(node, indent, lines, dedup, renderContext, fallbackInten
     const toolInput = extractToolInput(String(toolName), attrs);
     const toolResultLen = attrs["tool.result.length"] || attrs["tool.result.count"];
     const tn = String(toolName);
+    const taskSnapshot = tn === "task" ? parseTaskStatusSnapshot(String(attrs["tool.result"] || "")) : [];
+    if (tn === "task" && taskSnapshot.length > 0) {
+      lines.push(`${pad}tasks snapshot${childSuffix}:`);
+      for (const task of taskSnapshot) {
+        lines.push(
+          `${pad}  ${formatTaskStatusMarker(task.status)} ${task.id}: ${truncate(task.title, 100)}`
+        );
+      }
+      return;
+    }
+    if (tn === "task") {
+      return;
+    }
     const isSearchTool = tn === "search" || tn === "searchCode" || tn === "search_code";
     const numLen = toolResultLen ? Number(toolResultLen) : -1;
     const noResults = isSearchTool && numLen >= 0 && numLen < 500;
@@ -24459,10 +25083,12 @@ function renderYamlNode(node, indent, lines, dedup, renderContext, fallbackInten
     const action = attrs["dedup.action"] || "?";
     const reason = attrs["dedup.reason"] || "";
     const rewritten = attrs["dedup.rewritten"] || "";
+    const error = attrs["dedup.error"] || "";
     const prevCount = attrs["dedup.previous_count"] || "0";
     let detail = `${action}`;
     if (rewritten) detail += ` \u2192 "${truncate(String(rewritten), 60)}"`;
     if (reason) detail += ` (${truncate(String(reason), 80)})`;
+    if (error) detail += ` [error: ${truncate(String(error), 120)}]`;
     lines.push(
       `${pad}dedup("${truncate(String(query), 60)}") [${prevCount} prior]: ${detail} \u2014 ${duration}`
     );
@@ -24656,6 +25282,86 @@ function renderYamlNode(node, indent, lines, dedup, renderContext, fallbackInten
     }
     return;
   }
+  const taskEventMatch = name.match(/(?:^probe\.event\.)?task\.([a-z_]+)$/);
+  if (taskEventMatch) {
+    const eventType = taskEventMatch[1];
+    const taskId = attrs["task.id"] ? String(attrs["task.id"]) : "";
+    const taskTitle = attrs["task.title"] ? truncate(String(attrs["task.title"]), 80) : "";
+    const taskIds = attrs["task.ids"] ? truncate(String(attrs["task.ids"]), 120) : "";
+    const count = attrs["task.count"] ? Number(attrs["task.count"]) : void 0;
+    const totalCount = attrs["task.total_count"] ? Number(attrs["task.total_count"]) : void 0;
+    const incompleteCount = attrs["task.incomplete_count"] ? Number(attrs["task.incomplete_count"]) : void 0;
+    const completedCount = attrs["task.completed_count"] ? Number(attrs["task.completed_count"]) : void 0;
+    const remaining = attrs["task.incomplete_remaining"] ? Number(attrs["task.incomplete_remaining"]) : void 0;
+    const newStatus = attrs["task.new_status"] ? String(attrs["task.new_status"]) : "";
+    const fieldsUpdated = attrs["task.fields_updated"] ? truncate(String(attrs["task.fields_updated"]), 80) : "";
+    const error = attrs["task.error"] ? truncate(String(attrs["task.error"]), 100) : "";
+    const action = attrs["task.action"] ? String(attrs["task.action"]) : "";
+    switch (eventType) {
+      case "session_started":
+        lines.push(`${pad}tasks enabled \u2014 ${duration}`);
+        return;
+      case "created":
+        lines.push(`${pad}[ ] ${taskId}${taskTitle ? `: ${taskTitle}` : ""} \u2014 ${duration}`);
+        return;
+      case "batch_created": {
+        const totalSuffix = totalCount !== void 0 ? `, total ${totalCount}` : "";
+        lines.push(
+          `${pad}tasks created (${count ?? "?"}${totalSuffix}): ${taskIds || "unknown"} \u2014 ${duration}`
+        );
+        return;
+      }
+      case "updated": {
+        const statusSuffix = newStatus && newStatus !== "unchanged" ? ` -> ${newStatus}` : "";
+        const fieldSuffix = fieldsUpdated ? ` [${fieldsUpdated}]` : "";
+        lines.push(`${pad}task updated: ${taskId}${statusSuffix}${fieldSuffix} \u2014 ${duration}`);
+        return;
+      }
+      case "batch_updated":
+        lines.push(`${pad}tasks updated (${count ?? "?"}): ${taskIds || "unknown"} \u2014 ${duration}`);
+        return;
+      case "completed": {
+        const remainingSuffix = remaining !== void 0 ? ` (${remaining} remaining)` : "";
+        lines.push(
+          `${pad}[x] ${taskId}${taskTitle ? `: ${taskTitle}` : ""}${remainingSuffix} \u2014 ${duration}`
+        );
+        return;
+      }
+      case "batch_completed": {
+        const remainingSuffix = remaining !== void 0 ? `, ${remaining} remaining` : "";
+        lines.push(
+          `${pad}tasks completed (${count ?? "?"}${remainingSuffix}): ${taskIds || "unknown"} \u2014 ${duration}`
+        );
+        return;
+      }
+      case "deleted":
+        lines.push(`${pad}task deleted: ${taskId} \u2014 ${duration}`);
+        return;
+      case "batch_deleted":
+        lines.push(`${pad}tasks deleted (${count ?? "?"}): ${taskIds || "unknown"} \u2014 ${duration}`);
+        return;
+      case "listed": {
+        const stats = [];
+        if (totalCount !== void 0) stats.push(`${totalCount} total`);
+        if (incompleteCount !== void 0) stats.push(`${incompleteCount} incomplete`);
+        if (completedCount !== void 0) stats.push(`${completedCount} completed`);
+        lines.push(
+          `${pad}tasks listed${stats.length > 0 ? ` (${stats.join(", ")})` : ""} \u2014 ${duration}`
+        );
+        return;
+      }
+      case "validation_error":
+      case "error":
+        lines.push(`${pad}task.${eventType}: ${error || "unknown error"} \u2014 ${duration}`);
+        return;
+      case "unknown_action":
+        lines.push(`${pad}task.unknown_action: ${action || "unknown"} \u2014 ${duration}`);
+        return;
+      default:
+        lines.push(`${pad}task.${eventType}${taskId ? `: ${taskId}` : ""} \u2014 ${duration}`);
+        return;
+    }
+  }
   const errMark = node.span.status === "error" ? " \u2717" : "";
   const hasChildren = node.children.length > 0;
   lines.push(`${pad}${name}${childSuffix} \u2014 ${duration}${errMark}${hasChildren ? ":" : ""}`);
@@ -24935,9 +25641,11 @@ function formatSpanLine(span, parentSpan, fallbackIntent, fullOutput, dedup, has
     const action = attrs["dedup.action"] || "?";
     const reason = attrs["dedup.reason"] || "";
     const rewritten = attrs["dedup.rewritten"] || "";
+    const error = attrs["dedup.error"] || "";
     let detail = `${action}`;
     if (rewritten) detail += ` \u2192 "${truncate(String(rewritten), 50)}"`;
     if (reason) detail += ` \u2014 ${truncate(String(reason), 60)}`;
+    if (error) detail += ` [error: ${truncate(String(error), 80)}]`;
     return { line: `dedup("${truncate(String(query), 50)}") ${detail} (${duration})` };
   }
   if (name === "search.delegate") {
@@ -25122,6 +25830,72 @@ function formatSpanLine(span, parentSpan, fallbackIntent, fullOutput, dedup, has
     const reasonStr = reason ? `: ${truncate(String(reason), 80)}` : "";
     return { line: `graceful_stop${reasonStr} (${duration})` };
   }
+  const taskEventMatch = name.match(/(?:^probe\.event\.)?task\.([a-z_]+)$/);
+  if (taskEventMatch) {
+    const eventType = taskEventMatch[1];
+    const taskId = attrs["task.id"] ? String(attrs["task.id"]) : "";
+    const taskTitle = attrs["task.title"] ? truncate(String(attrs["task.title"]), 80) : "";
+    const taskIds = attrs["task.ids"] ? truncate(String(attrs["task.ids"]), 120) : "";
+    const count = attrs["task.count"] ? Number(attrs["task.count"]) : void 0;
+    const totalCount = attrs["task.total_count"] ? Number(attrs["task.total_count"]) : void 0;
+    const incompleteCount = attrs["task.incomplete_count"] ? Number(attrs["task.incomplete_count"]) : void 0;
+    const completedCount = attrs["task.completed_count"] ? Number(attrs["task.completed_count"]) : void 0;
+    const remaining = attrs["task.incomplete_remaining"] ? Number(attrs["task.incomplete_remaining"]) : void 0;
+    const newStatus = attrs["task.new_status"] ? String(attrs["task.new_status"]) : "";
+    const fieldsUpdated = attrs["task.fields_updated"] ? truncate(String(attrs["task.fields_updated"]), 80) : "";
+    const error = attrs["task.error"] ? truncate(String(attrs["task.error"]), 100) : "";
+    const action = attrs["task.action"] ? String(attrs["task.action"]) : "";
+    const tail = ` (${duration})`;
+    switch (eventType) {
+      case "session_started":
+        return { line: `tasks enabled${tail}` };
+      case "created":
+        return { line: `[ ] ${taskId}${taskTitle ? `: ${taskTitle}` : ""}${tail}` };
+      case "batch_created": {
+        const totalSuffix = totalCount !== void 0 ? `, total ${totalCount}` : "";
+        return {
+          line: `tasks created (${count ?? "?"}${totalSuffix}): ${taskIds || "unknown"}${tail}`
+        };
+      }
+      case "updated": {
+        const statusSuffix = newStatus && newStatus !== "unchanged" ? ` -> ${newStatus}` : "";
+        const fieldSuffix = fieldsUpdated ? ` [${fieldsUpdated}]` : "";
+        return { line: `task updated: ${taskId}${statusSuffix}${fieldSuffix}${tail}` };
+      }
+      case "batch_updated":
+        return { line: `tasks updated (${count ?? "?"}): ${taskIds || "unknown"}${tail}` };
+      case "completed": {
+        const remainingSuffix = remaining !== void 0 ? ` (${remaining} remaining)` : "";
+        return {
+          line: `[x] ${taskId}${taskTitle ? `: ${taskTitle}` : ""}${remainingSuffix}${tail}`
+        };
+      }
+      case "batch_completed": {
+        const remainingSuffix = remaining !== void 0 ? `, ${remaining} remaining` : "";
+        return {
+          line: `tasks completed (${count ?? "?"}${remainingSuffix}): ${taskIds || "unknown"}${tail}`
+        };
+      }
+      case "deleted":
+        return { line: `task deleted: ${taskId}${tail}` };
+      case "batch_deleted":
+        return { line: `tasks deleted (${count ?? "?"}): ${taskIds || "unknown"}${tail}` };
+      case "listed": {
+        const stats = [];
+        if (totalCount !== void 0) stats.push(`${totalCount} total`);
+        if (incompleteCount !== void 0) stats.push(`${incompleteCount} incomplete`);
+        if (completedCount !== void 0) stats.push(`${completedCount} completed`);
+        return { line: `tasks listed${stats.length > 0 ? ` (${stats.join(", ")})` : ""}${tail}` };
+      }
+      case "validation_error":
+      case "error":
+        return { line: `task.${eventType}: ${error || "unknown error"}${tail}` };
+      case "unknown_action":
+        return { line: `task.unknown_action: ${action || "unknown"}${tail}` };
+      default:
+        return { line: `task.${eventType}${taskId ? `: ${taskId}` : ""}${tail}` };
+    }
+  }
   return { line: `${name} (${duration})${span.status === "error" ? " \u2717" : ""}` };
 }
 function parseWorkspacePath(fullPath) {
@@ -25457,12 +26231,12 @@ function truncate(str, max) {
   if (head < 10) return str.slice(0, max - 3) + "...";
   return str.slice(0, head) + " ...[truncated]... " + str.slice(-tail);
 }
-var fs17, readline2, path19, NOISE_SPAN_NAMES, WRAPPER_SPAN_NAMES;
+var fs16, readline, path19, NOISE_SPAN_NAMES, WRAPPER_SPAN_NAMES, ROOT_TASK_SCOPE_LABEL, TASK_SCOPE_EXCLUDED_CHECKS, SUB_AGENT_SCOPE_CHECKS;
 var init_trace_serializer = __esm({
   "src/agent-protocol/trace-serializer.ts"() {
     "use strict";
-    fs17 = __toESM(require("fs"));
-    readline2 = __toESM(require("readline"));
+    fs16 = __toESM(require("fs"));
+    readline = __toESM(require("readline"));
     path19 = __toESM(require("path"));
     init_logger();
     NOISE_SPAN_NAMES = /* @__PURE__ */ new Set([
@@ -25476,6 +26250,20 @@ var init_trace_serializer = __esm({
       "visor.ai_check",
       "probe.delegation"
     ]);
+    ROOT_TASK_SCOPE_LABEL = "Main Agent";
+    TASK_SCOPE_EXCLUDED_CHECKS = /* @__PURE__ */ new Set([
+      "chat",
+      "route-intent",
+      "classify",
+      "build-config",
+      "generate-response",
+      "setup-projects",
+      "checkout-docs",
+      "route-projects",
+      "project-items",
+      "checkout-projects"
+    ]);
+    SUB_AGENT_SCOPE_CHECKS = /* @__PURE__ */ new Set(["engineer-task", "explore-code"]);
   }
 });
 
@@ -25603,6 +26391,67 @@ function formatProgressMetadata(timing) {
   }
   return `_Metadata: ${parts.join(" | ")}_`;
 }
+function formatTaskStatusMarker2(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return "[~]";
+    case "blocked":
+    case "failed":
+    case "error":
+      return "[!]";
+    case "deleted":
+    case "cancelled":
+    case "canceled":
+      return "[-]";
+    default:
+      return "[ ]";
+  }
+}
+function formatTaskLabel2(task) {
+  const title = String(task.title || "").trim();
+  return title || task.id || task.status;
+}
+function scopeHasRenderableTasks2(scope) {
+  if (scope.tasks.some((task) => !task.synthetic)) return true;
+  return scope.children.some((child) => scopeHasRenderableTasks2(child));
+}
+function appendTaskScopeLines2(lines, scope, depth = 0) {
+  if (!scopeHasRenderableTasks2(scope)) return;
+  const prefix = "  ".repeat(depth);
+  if (depth > 0 || scope.label !== "Main Agent") {
+    lines.push(`${prefix}${scope.label}`);
+  }
+  const visibleTasks = scope.tasks.filter((task) => !task.synthetic).slice(0, 8);
+  for (const task of visibleTasks) {
+    lines.push(`${prefix}\u2022 ${formatTaskStatusMarker2(task.status)} ${formatTaskLabel2(task)}`);
+  }
+  const hiddenCount = scope.tasks.filter((task) => !task.synthetic).length - visibleTasks.length;
+  if (hiddenCount > 0) {
+    lines.push(`${prefix}\u2022 ... ${hiddenCount} more`);
+  }
+  for (const child of scope.children) {
+    appendTaskScopeLines2(lines, child, depth + 1);
+  }
+}
+function formatTaskSummary(summary) {
+  if (!summary || summary.tasks.length === 0) return void 0;
+  const lines = ["*Tasks*"];
+  if (summary.scopes.length > 0) {
+    for (const scope of summary.scopes) appendTaskScopeLines2(lines, scope);
+  } else {
+    const visibleTasks = summary.tasks.filter((task) => !task.synthetic).slice(0, 8);
+    for (const task of visibleTasks) {
+      lines.push(`\u2022 ${formatTaskStatusMarker2(task.status)} ${formatTaskLabel2(task)}`);
+    }
+    const hiddenCount = summary.tasks.filter((task) => !task.synthetic).length - visibleTasks.length;
+    if (hiddenCount > 0) {
+      lines.push(`\u2022 ... ${hiddenCount} more`);
+    }
+  }
+  return lines.length > 1 ? lines.join("\n") : void 0;
+}
 function formatSkillList(skills) {
   const normalized = dedupeStrings(skills);
   if (normalized.length <= 4) return normalized.join(", ");
@@ -25615,7 +26464,7 @@ function dedupeStrings(values) {
 async function extractTraceSkillMetadata(traceRef, traceId) {
   if (!traceRef && !traceId) return void 0;
   try {
-    const spans = await fetchTraceSpans(traceId || traceRef);
+    const spans = await fetchTraceSpans(traceRef || traceId, { targetTraceId: traceId });
     if (!spans.length) return void 0;
     const routeIntentSpan = spans.find(
       (span) => span.attributes["visor.check.id"] === "route-intent"
@@ -25634,8 +26483,12 @@ async function extractTraceSkillMetadata(traceRef, traceId) {
       (Array.isArray(routeIntentOutput?.skills) ? routeIntentOutput.skills : void 0) || (Array.isArray(classifyOutput?.skills) ? classifyOutput.skills : void 0)
     );
     const finalActivatedSkills = activatedSkills.length > 0 ? activatedSkills : fallbackActivatedSkills;
-    if (!finalActivatedSkills.length) return void 0;
-    return { activatedSkills: finalActivatedSkills };
+    const taskSummary = extractProbeTaskSummary(spans);
+    if (!finalActivatedSkills.length && !taskSummary) return void 0;
+    return {
+      activatedSkills: finalActivatedSkills.length ? finalActivatedSkills : void 0,
+      taskSummary: taskSummary || void 0
+    };
   } catch (err) {
     logger.debug(
       `[TaskLiveUpdates] Failed to extract skill metadata from trace: ${err instanceof Error ? err.message : String(err)}`
@@ -25691,7 +26544,7 @@ function extractProgressField(text, label) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var import_crypto5, DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS, DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS, DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS, DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS, DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS, DEFAULT_TASK_LIVE_UPDATE_MODEL, DEFAULT_TASK_LIVE_UPDATE_STALL_NOTICE, DEFAULT_TASK_LIVE_UPDATE_PROMPT, TaskLiveUpdateManager;
+var import_crypto5, DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS, DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS, DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS, DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS, DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS, DEFAULT_TASK_LIVE_UPDATE_MODEL, DEFAULT_TASK_LIVE_UPDATE_STALL_NOTICE, GENERIC_COMPLETION_FALLBACK, DEFAULT_TASK_LIVE_UPDATE_PROMPT, TaskLiveUpdateManager;
 var init_task_live_updates = __esm({
   "src/agent-protocol/task-live-updates.ts"() {
     "use strict";
@@ -25705,6 +26558,7 @@ var init_task_live_updates = __esm({
     DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS = 60;
     DEFAULT_TASK_LIVE_UPDATE_MODEL = "gemini-3.1-flash-lite-preview";
     DEFAULT_TASK_LIVE_UPDATE_STALL_NOTICE = "_No new meaningful progress is visible yet. Some steps can stay quiet for up to 5 minutes before there is new news._";
+    GENERIC_COMPLETION_FALLBACK = "Execution completed";
     DEFAULT_TASK_LIVE_UPDATE_PROMPT = `You are generating a short live progress update for a user while an AI task is still running.
 
 This is NOT the final answer.
@@ -25787,6 +26641,9 @@ Good update example:
       firstTickTimer;
       metadataRefreshTimer;
       running = false;
+      inflightTick;
+      inflightMetadataRefresh;
+      inflightPublishes = /* @__PURE__ */ new Set();
       started = false;
       completed = false;
       startedAt = /* @__PURE__ */ new Date();
@@ -25822,6 +26679,14 @@ Good update example:
         if (this.completed) return;
         this.completed = true;
         this.stop();
+        await this.waitForInflightSinkPublishes();
+        const cleanedFinalText = finalText.trim();
+        if (!this.lastPostedMessage && cleanedFinalText === GENERIC_COMPLETION_FALLBACK) {
+          logger.info(
+            `[TaskLiveUpdates] Suppressing generic final update for task ${this.ctx.taskId}: no progress update was posted`
+          );
+          return;
+        }
         try {
           logger.info(`[TaskLiveUpdates] Publishing final success update for task ${this.ctx.taskId}`);
           const result = await this.ctx.sink.complete(this.decorateText(finalText));
@@ -25837,6 +26702,7 @@ Good update example:
         if (this.completed) return;
         this.completed = true;
         this.stop();
+        await this.waitForInflightSinkPublishes();
         try {
           logger.info(`[TaskLiveUpdates] Publishing final failure update for task ${this.ctx.taskId}`);
           const result = await this.ctx.sink.fail(this.decorateText(finalText));
@@ -25863,6 +26729,16 @@ Good update example:
         }
       }
       async tick() {
+        if (this.inflightTick) return this.inflightTick;
+        const promise = this.runTick().finally(() => {
+          if (this.inflightTick === promise) {
+            this.inflightTick = void 0;
+          }
+        });
+        this.inflightTick = promise;
+        return promise;
+      }
+      async runTick() {
         if (this.completed || this.running) return;
         const traceState = this.getTraceState();
         if (!traceState.traceRef && !traceState.traceId) {
@@ -25935,11 +26811,18 @@ Good update example:
               elapsedSeconds: Math.max(0, Math.floor((Date.now() - this.startedAt.getTime()) / 1e3)),
               previousUpdateAt: this.lastUpdateAt,
               secondsSincePreviousUpdate: this.lastUpdateAt ? Math.max(0, Math.floor((Date.now() - this.lastUpdateAt.getTime()) / 1e3)) : void 0,
-              activatedSkills: this.lastSkillMetadata?.activatedSkills
+              activatedSkills: this.lastSkillMetadata?.activatedSkills,
+              taskSummary: this.lastSkillMetadata?.taskSummary
             },
             traceState.traceId
           );
-          const result = await this.ctx.sink.update(message);
+          if (this.completed) {
+            logger.debug(
+              `[TaskLiveUpdates] Aborting progress publish for task ${this.ctx.taskId}: task already completed before sink update`
+            );
+            return;
+          }
+          const result = await this.trackPublish(this.ctx.sink.update(message));
           this.recordSinkRef(result);
           this.ctx.appendHistory?.(cleaned, "progress");
           this.lastUpdateText = cleaned;
@@ -25967,15 +26850,31 @@ Good update example:
           this.timer.unref();
         }
         this.metadataRefreshTimer = setInterval(() => {
-          void this.refreshProgressMetadata();
+          void this.scheduleMetadataRefresh();
         }, DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS * 1e3);
         if (typeof this.metadataRefreshTimer?.unref === "function") {
           this.metadataRefreshTimer.unref();
         }
       }
+      async waitForInflightSinkPublishes() {
+        const pending = [...this.inflightPublishes];
+        if (pending.length === 0) return;
+        try {
+          await Promise.allSettled(pending);
+        } catch {
+        }
+      }
       recordSinkRef(result) {
         if (result?.ref) this.ctx.onPostedRef?.(result.ref);
       }
+      async trackPublish(publish) {
+        this.inflightPublishes.add(publish);
+        try {
+          return await publish;
+        } finally {
+          this.inflightPublishes.delete(publish);
+        }
+      }
       getTraceState() {
         const resolved = this.ctx.resolveTraceState?.();
         return {
@@ -25990,16 +26889,30 @@ Good update example:
 
 \`task_id: ${this.ctx.taskId}\``;
       }
-      decorateProgressText(text, timing, traceId) {
+      decorateProgressText(text, timing, _traceId) {
         const normalized = normalizeProgressSummary(text);
+        const taskSummary = formatTaskSummary(timing.taskSummary);
         const blocks = [
           "*Live Update*",
           "_Current task is still running. This message updates in place until the final answer is ready._",
           this.lastUpdateKind === "stall" ? DEFAULT_TASK_LIVE_UPDATE_STALL_NOTICE : "",
+          taskSummary,
           normalized,
-          formatProgressMetadata(timing)
+          formatProgressMetadata(timing),
+          `\`task_id: ${this.ctx.taskId}\``,
+          "`live_update: true`"
         ].filter(Boolean);
-        return this.decorateText(blocks.join("\n\n"), traceId);
+        return blocks.join("\n\n");
+      }
+      scheduleMetadataRefresh() {
+        if (this.inflightMetadataRefresh) return this.inflightMetadataRefresh;
+        const promise = this.refreshProgressMetadata().finally(() => {
+          if (this.inflightMetadataRefresh === promise) {
+            this.inflightMetadataRefresh = void 0;
+          }
+        });
+        this.inflightMetadataRefresh = promise;
+        return promise;
       }
       async refreshProgressMetadata() {
         if (this.completed || this.running || !this.lastUpdateText) return;
@@ -26010,7 +26923,8 @@ Good update example:
             elapsedSeconds: Math.max(0, Math.floor((Date.now() - this.startedAt.getTime()) / 1e3)),
             previousUpdateAt: this.lastUpdateAt,
             secondsSincePreviousUpdate: this.lastUpdateAt ? Math.max(0, Math.floor((Date.now() - this.lastUpdateAt.getTime()) / 1e3)) : void 0,
-            activatedSkills: this.lastSkillMetadata?.activatedSkills
+            activatedSkills: this.lastSkillMetadata?.activatedSkills,
+            taskSummary: this.lastSkillMetadata?.taskSummary
           },
           traceState.traceId
         );
@@ -26020,7 +26934,7 @@ Good update example:
           logger.debug(
             `[TaskLiveUpdates] Refreshing metadata-only live update for task ${this.ctx.taskId}`
           );
-          const result = await this.ctx.sink.update(message);
+          const result = await this.trackPublish(this.ctx.sink.update(message));
           this.recordSinkRef(result);
           this.lastPostedMessage = message;
         } catch (err) {
@@ -26056,7 +26970,8 @@ Good update example:
             elapsedSeconds: Math.max(0, Math.floor((Date.now() - this.startedAt.getTime()) / 1e3)),
             previousUpdateAt: this.lastUpdateAt,
             secondsSincePreviousUpdate: this.lastUpdateAt ? Math.max(0, Math.floor((Date.now() - this.lastUpdateAt.getTime()) / 1e3)) : void 0,
-            activatedSkills: this.lastSkillMetadata?.activatedSkills
+            activatedSkills: this.lastSkillMetadata?.activatedSkills,
+            taskSummary: this.lastSkillMetadata?.taskSummary
           },
           traceId
         );
@@ -26064,7 +26979,8 @@ Good update example:
           this.lastStallFallbackAt = now;
           return;
         }
-        const result = await this.ctx.sink.update(message);
+        if (this.completed) return;
+        const result = await this.trackPublish(this.ctx.sink.update(message));
         this.recordSinkRef(result);
         if (!this.lastUpdateText) {
           this.ctx.appendHistory?.(baseText, "progress");
@@ -26093,7 +27009,7 @@ async function resolveTaskTraceReference(metadata) {
   return {
     traceId,
     traceFile,
-    primaryRef: traceId || traceFile || void 0
+    primaryRef: traceFile || traceId || void 0
   };
 }
 var init_task_trace_resolution = __esm({
@@ -26187,14 +27103,15 @@ async function evaluateTask(taskId, store, config) {
   if (traceFile || traceId) {
     try {
       const traceRef = traceFile || traceId;
-      traceTree = await serializeTraceForPrompt(
+      const report = await buildTraceReport(
         traceRef,
         1e6,
         { traceDir: config?.traceDir },
         responseText !== "No response available" ? responseText : void 0,
         traceId
       );
-      if (traceTree === "(no trace data available)") {
+      traceTree = report?.text;
+      if (!traceTree || traceTree === "(no trace data available)") {
         traceTree = void 0;
       }
     } catch (err) {
@@ -26357,6 +27274,77 @@ var track_execution_exports = {};
 __export(track_execution_exports, {
   trackExecution: () => trackExecution
 });
+function unwrapJsonText(text) {
+  if (text.startsWith("{") && text.includes('"text"')) {
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed?.text === "string" && parsed.text.trim().length > 0) {
+        return parsed.text.trim();
+      }
+    } catch {
+      try {
+        const sanitized = text.replace(
+          /[\x00-\x1F\x7F]/g,
+          (ch) => "\\u" + ch.charCodeAt(0).toString(16).padStart(4, "0")
+        );
+        const parsed = JSON.parse(sanitized);
+        if (typeof parsed?.text === "string" && parsed.text.trim().length > 0) {
+          return parsed.text.trim();
+        }
+      } catch {
+      }
+    }
+  }
+  return text;
+}
+function isToolOutput(text) {
+  if (/^[├│└─┬┘┤┼]{1,3}/.test(text)) return true;
+  if (text.startsWith("[task:")) return true;
+  return false;
+}
+function extractTextFromEntries(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const outputs = entries[i];
+    if (!Array.isArray(outputs)) continue;
+    for (let j = outputs.length - 1; j >= 0; j--) {
+      const text = outputs[j]?.text;
+      if (typeof text === "string" && text.trim().length > 0) {
+        return unwrapJsonText(text.trim());
+      }
+    }
+  }
+  return void 0;
+}
+function extractBestResponseText(history, allKeys) {
+  const topLevelEntries = Object.entries(history).filter(([key]) => !key.includes(".")).map(([, v]) => v);
+  const topLevelText = extractTextFromEntries(topLevelEntries);
+  if (topLevelText && !isToolOutput(topLevelText)) {
+    logger.info(
+      `[TaskTracking] Extracted responseText (${topLevelText.length} chars): "${topLevelText.substring(0, 100)}..."`
+    );
+    return topLevelText;
+  }
+  const genResponseKeys = allKeys.filter(
+    (k) => k.endsWith(".generate-response") || k === "generate-response"
+  );
+  if (genResponseKeys.length > 0) {
+    const genEntries = genResponseKeys.map((k) => history[k]);
+    const genText = extractTextFromEntries(genEntries);
+    if (genText && !isToolOutput(genText)) {
+      logger.info(
+        `[TaskTracking] Fallback to generate-response entry (${genText.length} chars): "${genText.substring(0, 100)}..."`
+      );
+      return genText;
+    }
+  }
+  if (topLevelText) {
+    logger.warn(
+      `[TaskTracking] Using tool output as responseText (${topLevelText.length} chars) \u2014 no better candidate found`
+    );
+    return topLevelText;
+  }
+  return "Execution completed";
+}
 function getPackageVersion() {
   try {
     return require_package()?.version || "dev";
@@ -26435,7 +27423,7 @@ async function trackExecution(opts, executor) {
           };
         }
         return {
-          traceRef: current?.metadata?.trace_id || current?.metadata?.trace_file || initialResolvedTrace.primaryRef,
+          traceRef: current?.metadata?.trace_file || current?.metadata?.trace_id || initialResolvedTrace.primaryRef,
           traceId: current?.metadata?.trace_id
         };
       },
@@ -26488,18 +27476,13 @@ async function trackExecution(opts, executor) {
       try {
         const history = result?.reviewSummary?.history;
         if (history) {
-          const entries = Object.values(history);
-          for (let i = entries.length - 1; i >= 0; i--) {
-            const outputs = entries[i];
-            if (!Array.isArray(outputs)) continue;
-            for (let j = outputs.length - 1; j >= 0; j--) {
-              const text = outputs[j]?.text;
-              if (typeof text === "string" && text.trim().length > 0) {
-                responseText = text.trim();
-                break;
-              }
-            }
-            if (responseText !== "Execution completed") break;
+          const allKeys = Object.keys(history);
+          responseText = extractBestResponseText(history, allKeys);
+        }
+        if (responseText === "Execution completed") {
+          const issueSummary = summarizeUserFacingIssues(result?.reviewSummary?.issues);
+          if (issueSummary) {
+            responseText = issueSummary;
           }
         }
       } catch {
@@ -26573,6 +27556,7 @@ var init_track_execution = __esm({
     init_instance_id();
     init_task_live_updates();
     init_task_trace_resolution();
+    init_user_facing_error();
   }
 });
 
@@ -26755,7 +27739,11 @@ var init_scheduler = __esm({
         if (!import_node_cron.default.validate(job.schedule)) {
           throw new Error(`Invalid cron expression: ${job.schedule}`);
         }
-        if (job.workflow !== "default") {
+        if (!job.workflow) {
+          if (!job.inputs?.text) {
+            throw new Error("Cron job without a workflow must have inputs.text set");
+          }
+        } else if (job.workflow !== "default") {
           const allChecks = Object.keys(this.visorConfig.checks || {});
           if (!allChecks.includes(job.workflow)) {
             throw new Error(`Workflow "${job.workflow}" not found in configuration`);
@@ -26778,7 +27766,7 @@ var init_scheduler = __esm({
           const nextRun = getNextRunTime(job.schedule, job.timezone || this.defaultTimezone);
           const description = job.description ? ` (${job.description})` : "";
           logger.debug(
-            `[Scheduler] Scheduled static cron job '${jobId}'${description}: ${job.schedule} \u2192 ${job.workflow}, next run: ${nextRun.toISOString()}`
+            `[Scheduler] Scheduled static cron job '${jobId}'${description}: ${job.schedule} \u2192 ${job.workflow || "(reminder)"}, next run: ${nextRun.toISOString()}`
           );
         } catch {
         }
@@ -28698,6 +29686,116 @@ var init_schedule_tool_handler = __esm({
   }
 });
 
+// src/utils/oauth2-token-cache.ts
+var oauth2_token_cache_exports = {};
+__export(oauth2_token_cache_exports, {
+  OAuth2TokenCache: () => OAuth2TokenCache
+});
+var OAuth2TokenCache;
+var init_oauth2_token_cache = __esm({
+  "src/utils/oauth2-token-cache.ts"() {
+    "use strict";
+    init_logger();
+    init_env_resolver();
+    OAuth2TokenCache = class _OAuth2TokenCache {
+      static instance;
+      cache = /* @__PURE__ */ new Map();
+      static getInstance() {
+        if (!_OAuth2TokenCache.instance) {
+          _OAuth2TokenCache.instance = new _OAuth2TokenCache();
+        }
+        return _OAuth2TokenCache.instance;
+      }
+      /** Visible for testing */
+      static resetInstance() {
+        _OAuth2TokenCache.instance = void 0;
+      }
+      /**
+       * Get a valid Bearer token for the given config.
+       * Returns a cached token if still valid, otherwise fetches a new one.
+       */
+      async getToken(config) {
+        const clientId = String(EnvironmentResolver.resolveValue(config.client_id));
+        const clientSecret = String(EnvironmentResolver.resolveValue(config.client_secret));
+        const tokenUrl = String(EnvironmentResolver.resolveValue(config.token_url));
+        const bufferMs = (config.token_ttl_buffer ?? 300) * 1e3;
+        const cacheKey = `${tokenUrl}|${clientId}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached && cached.expires_at - bufferMs > Date.now()) {
+          logger.verbose("[oauth2] Using cached token");
+          return cached.access_token;
+        }
+        if (cached?.refreshPromise) {
+          logger.verbose("[oauth2] Awaiting in-flight token refresh");
+          return cached.refreshPromise;
+        }
+        const refreshPromise = this.fetchToken(tokenUrl, clientId, clientSecret, config.scopes);
+        if (cached) {
+          cached.refreshPromise = refreshPromise;
+        } else {
+          this.cache.set(cacheKey, {
+            access_token: "",
+            expires_at: 0,
+            refreshPromise
+          });
+        }
+        try {
+          const token = await refreshPromise;
+          return token;
+        } finally {
+          const entry = this.cache.get(cacheKey);
+          if (entry) {
+            entry.refreshPromise = void 0;
+          }
+        }
+      }
+      async fetchToken(tokenUrl, clientId, clientSecret, scopes) {
+        logger.verbose(`[oauth2] Fetching token from ${tokenUrl}`);
+        const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
+        const bodyParams = new URLSearchParams({ grant_type: "client_credentials" });
+        if (scopes?.length) {
+          bodyParams.set("scope", scopes.join(" "));
+        }
+        const response = await fetch(tokenUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Authorization: `Basic ${credentials}`
+          },
+          body: bodyParams.toString()
+        });
+        if (!response.ok) {
+          let errorDetail = "";
+          try {
+            errorDetail = await response.text();
+          } catch {
+          }
+          throw new Error(
+            `OAuth2 token request failed: HTTP ${response.status} ${response.statusText}${errorDetail ? ` - ${errorDetail.substring(0, 200)}` : ""}`
+          );
+        }
+        const data = await response.json();
+        if (!data.access_token) {
+          throw new Error("OAuth2 token response missing access_token");
+        }
+        const expiresIn = data.expires_in ?? 3600;
+        const expiresAt = Date.now() + expiresIn * 1e3;
+        const cacheKey = `${tokenUrl}|${clientId}`;
+        this.cache.set(cacheKey, {
+          access_token: data.access_token,
+          expires_at: expiresAt
+        });
+        logger.verbose(`[oauth2] Token acquired, expires in ${expiresIn}s`);
+        return data.access_token;
+      }
+      /** Clear all cached tokens (for testing or credential rotation) */
+      clear() {
+        this.cache.clear();
+      }
+    };
+  }
+});
+
 // src/utils/issue-normalizer.ts
 function extractIssuesFromOutput(output, defaultRuleId) {
   if (output === null || output === void 0) {
@@ -28888,7 +29986,7 @@ var utcp_check_provider_exports = {};
 __export(utcp_check_provider_exports, {
   UtcpCheckProvider: () => UtcpCheckProvider
 });
-var fs19, path21, UtcpCheckProvider;
+var fs18, path21, UtcpCheckProvider;
 var init_utcp_check_provider = __esm({
   "src/providers/utcp-check-provider.ts"() {
     "use strict";
@@ -28898,7 +29996,7 @@ var init_utcp_check_provider = __esm({
     init_sandbox();
     init_env_resolver();
     init_issue_normalizer();
-    fs19 = __toESM(require("fs"));
+    fs18 = __toESM(require("fs"));
     path21 = __toESM(require("path"));
     UtcpCheckProvider = class _UtcpCheckProvider extends CheckProvider {
       liquid;
@@ -29152,20 +30250,20 @@ var init_utcp_check_provider = __esm({
             `Path traversal detected: "${manual}" resolves outside the project directory. UTCP manual paths must be within the project directory.`
           );
         }
-        if (fs19.existsSync(resolvedPath)) {
-          const realPath = fs19.realpathSync(resolvedPath);
+        if (fs18.existsSync(resolvedPath)) {
+          const realPath = fs18.realpathSync(resolvedPath);
           if (realPath !== cwd && !realPath.startsWith(cwdPrefix)) {
             throw new Error(
               `Symlink traversal detected: "${manual}" points outside the project directory via symlink.`
             );
           }
         }
-        if (!fs19.existsSync(resolvedPath)) {
+        if (!fs18.existsSync(resolvedPath)) {
           throw new Error(`UTCP manual file not found: ${resolvedPath}`);
         }
         let content;
         try {
-          content = fs19.readFileSync(resolvedPath, "utf-8");
+          content = fs18.readFileSync(resolvedPath, "utf-8");
         } catch (err) {
           throw new Error(
             `Failed to read UTCP manual file: ${resolvedPath}: ${err instanceof Error ? err.message : "Unknown error"}`
@@ -29923,9 +31021,24 @@ var init_mcp_custom_sse_server = __esm({
           }
           return record;
         };
+        const fixRequiredFields = (obj) => {
+          if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+          const record = obj;
+          if (Array.isArray(record.required) && record.properties && typeof record.properties === "object") {
+            const validProps = Object.keys(record.properties);
+            record.required = record.required.filter((r) => validProps.includes(r));
+          }
+          for (const key of Object.keys(record)) {
+            if (typeof record[key] === "object" && record[key] !== null) {
+              fixRequiredFields(record[key]);
+            }
+          }
+          return record;
+        };
         const normalizeInputSchema = (schema) => {
           if (schema && schema.type === "object") {
             fixArraySchemas(schema);
+            fixRequiredFields(schema);
             return schema;
           }
           return {
@@ -29934,7 +31047,10 @@ var init_mcp_custom_sse_server = __esm({
             required: []
           };
         };
-        const regularTools = await this.toolExecutor.listMcpTools();
+        const regularTools = (await this.toolExecutor.listMcpTools()).map((tool) => ({
+          ...tool,
+          inputSchema: normalizeInputSchema(tool.inputSchema)
+        }));
         const workflowTools = Array.from(this.tools.values()).filter(isWorkflowTool).map((tool) => ({
           name: tool.name,
           description: tool.description || `Execute ${tool.name}`,
@@ -30319,6 +31435,11 @@ var init_mcp_custom_sse_server = __esm({
           if (authType === "bearer" && tool.auth.token) {
             const token = String(EnvironmentResolver.resolveValue(tool.auth.token));
             resolvedHeaders["Authorization"] = `Bearer ${token}`;
+          } else if (authType === "oauth2_client_credentials" && tool.auth.token_url) {
+            const { OAuth2TokenCache: OAuth2TokenCache2 } = await Promise.resolve().then(() => (init_oauth2_token_cache(), oauth2_token_cache_exports));
+            const tokenCache = OAuth2TokenCache2.getInstance();
+            const token = await tokenCache.getToken(tool.auth);
+            resolvedHeaders["Authorization"] = `Bearer ${token}`;
           }
         }
         if (this.debug) {
@@ -30599,6 +31720,7 @@ var init_ai_check_provider = __esm({
     init_schedule_tool();
     init_task_progress_tool();
     init_schedule_tool_handler();
+    init_user_facing_error();
     AICheckProvider = class _AICheckProvider extends CheckProvider {
       aiReviewService;
       liquidEngine;
@@ -32201,13 +33323,14 @@ ${processedPrompt}` : processedPrompt;
           }
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
+          const userFacingMessage = formatUserFacingExecutionError(error);
           console.error(`\u274C AI Check Provider Error for check: ${errorMessage}`);
           const isCriticalError = errorMessage.includes("API rate limit") || errorMessage.includes("403") || errorMessage.includes("401") || errorMessage.includes("authentication") || errorMessage.includes("API key");
           if (isCriticalError) {
             console.error(`\u{1F6A8} CRITICAL ERROR: AI provider authentication or rate limit issue detected`);
             console.error(`\u{1F6A8} This check cannot proceed without valid API credentials`);
           }
-          throw new Error(`AI analysis failed: ${errorMessage}`);
+          throw new Error(userFacingMessage);
         } finally {
           if (customToolsServer) {
             try {
@@ -33102,114 +34225,8 @@ var init_template_context = __esm({
   }
 });
 
-// src/utils/oauth2-token-cache.ts
-var OAuth2TokenCache;
-var init_oauth2_token_cache = __esm({
-  "src/utils/oauth2-token-cache.ts"() {
-    "use strict";
-    init_logger();
-    init_env_resolver();
-    OAuth2TokenCache = class _OAuth2TokenCache {
-      static instance;
-      cache = /* @__PURE__ */ new Map();
-      static getInstance() {
-        if (!_OAuth2TokenCache.instance) {
-          _OAuth2TokenCache.instance = new _OAuth2TokenCache();
-        }
-        return _OAuth2TokenCache.instance;
-      }
-      /** Visible for testing */
-      static resetInstance() {
-        _OAuth2TokenCache.instance = void 0;
-      }
-      /**
-       * Get a valid Bearer token for the given config.
-       * Returns a cached token if still valid, otherwise fetches a new one.
-       */
-      async getToken(config) {
-        const clientId = String(EnvironmentResolver.resolveValue(config.client_id));
-        const clientSecret = String(EnvironmentResolver.resolveValue(config.client_secret));
-        const tokenUrl = String(EnvironmentResolver.resolveValue(config.token_url));
-        const bufferMs = (config.token_ttl_buffer ?? 300) * 1e3;
-        const cacheKey = `${tokenUrl}|${clientId}`;
-        const cached = this.cache.get(cacheKey);
-        if (cached && cached.expires_at - bufferMs > Date.now()) {
-          logger.verbose("[oauth2] Using cached token");
-          return cached.access_token;
-        }
-        if (cached?.refreshPromise) {
-          logger.verbose("[oauth2] Awaiting in-flight token refresh");
-          return cached.refreshPromise;
-        }
-        const refreshPromise = this.fetchToken(tokenUrl, clientId, clientSecret, config.scopes);
-        if (cached) {
-          cached.refreshPromise = refreshPromise;
-        } else {
-          this.cache.set(cacheKey, {
-            access_token: "",
-            expires_at: 0,
-            refreshPromise
-          });
-        }
-        try {
-          const token = await refreshPromise;
-          return token;
-        } finally {
-          const entry = this.cache.get(cacheKey);
-          if (entry) {
-            entry.refreshPromise = void 0;
-          }
-        }
-      }
-      async fetchToken(tokenUrl, clientId, clientSecret, scopes) {
-        logger.verbose(`[oauth2] Fetching token from ${tokenUrl}`);
-        const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
-        const bodyParams = new URLSearchParams({ grant_type: "client_credentials" });
-        if (scopes?.length) {
-          bodyParams.set("scope", scopes.join(" "));
-        }
-        const response = await fetch(tokenUrl, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            Authorization: `Basic ${credentials}`
-          },
-          body: bodyParams.toString()
-        });
-        if (!response.ok) {
-          let errorDetail = "";
-          try {
-            errorDetail = await response.text();
-          } catch {
-          }
-          throw new Error(
-            `OAuth2 token request failed: HTTP ${response.status} ${response.statusText}${errorDetail ? ` - ${errorDetail.substring(0, 200)}` : ""}`
-          );
-        }
-        const data = await response.json();
-        if (!data.access_token) {
-          throw new Error("OAuth2 token response missing access_token");
-        }
-        const expiresIn = data.expires_in ?? 3600;
-        const expiresAt = Date.now() + expiresIn * 1e3;
-        const cacheKey = `${tokenUrl}|${clientId}`;
-        this.cache.set(cacheKey, {
-          access_token: data.access_token,
-          expires_at: expiresAt
-        });
-        logger.verbose(`[oauth2] Token acquired, expires in ${expiresIn}s`);
-        return data.access_token;
-      }
-      /** Clear all cached tokens (for testing or credential rotation) */
-      clear() {
-        this.cache.clear();
-      }
-    };
-  }
-});
-
 // src/providers/http-client-provider.ts
-var fs22, path23, HttpClientProvider;
+var fs21, path23, HttpClientProvider;
 var init_http_client_provider = __esm({
   "src/providers/http-client-provider.ts"() {
     "use strict";
@@ -33221,7 +34238,7 @@ var init_http_client_provider = __esm({
     init_oauth2_token_cache();
     init_logger();
     init_rate_limiter();
-    fs22 = __toESM(require("fs"));
+    fs21 = __toESM(require("fs"));
     path23 = __toESM(require("path"));
     HttpClientProvider = class extends CheckProvider {
       liquid;
@@ -33355,8 +34372,8 @@ var init_http_client_provider = __esm({
                 `[http_client] Resolved relative output_file to workspace: ${resolvedOutputFile}`
               );
             }
-            if (skipIfExists && fs22.existsSync(resolvedOutputFile)) {
-              const stats = fs22.statSync(resolvedOutputFile);
+            if (skipIfExists && fs21.existsSync(resolvedOutputFile)) {
+              const stats = fs21.statSync(resolvedOutputFile);
               logger.verbose(`[http_client] File cached: ${resolvedOutputFile} (${stats.size} bytes)`);
               return {
                 issues: [],
@@ -33587,12 +34604,12 @@ var init_http_client_provider = __esm({
             };
           }
           const parentDir = path23.dirname(outputFile);
-          if (parentDir && !fs22.existsSync(parentDir)) {
-            fs22.mkdirSync(parentDir, { recursive: true });
+          if (parentDir && !fs21.existsSync(parentDir)) {
+            fs21.mkdirSync(parentDir, { recursive: true });
           }
           const arrayBuffer = await response.arrayBuffer();
           const buffer = Buffer.from(arrayBuffer);
-          fs22.writeFileSync(outputFile, buffer);
+          fs21.writeFileSync(outputFile, buffer);
           const contentType = response.headers.get("content-type") || "application/octet-stream";
           logger.verbose(`[http_client] Downloaded: ${outputFile} (${buffer.length} bytes)`);
           return {
@@ -53822,6 +54839,14 @@ var init_mcp_check_provider = __esm({
             }
           );
           const transport = createTransport();
+          if ("stderr" in transport && transport.stderr) {
+            const stderrStream = transport.stderr;
+            if (typeof stderrStream.on === "function") {
+              stderrStream.on("error", (err) => {
+                logger.debug(`MCP transport stderr error (${transportName}): ${err.message}`);
+              });
+            }
+          }
           try {
             let timeoutId;
             try {
@@ -54178,7 +55203,7 @@ async function interactivePrompt(options) {
     } catch {
     }
     if (multiline) {
-      rl = readline3.createInterface({
+      rl = readline2.createInterface({
         input: process.stdin,
         output: process.stdout,
         terminal: true
@@ -54291,7 +55316,7 @@ async function interactivePrompt(options) {
 }
 async function simplePrompt(prompt) {
   return new Promise((resolve17) => {
-    const rl = readline3.createInterface({
+    const rl = readline2.createInterface({
       input: process.stdin,
       output: process.stdout
     });
@@ -54310,11 +55335,11 @@ async function simplePrompt(prompt) {
     });
   });
 }
-var readline3, activePrompt, waiters;
+var readline2, activePrompt, waiters;
 var init_interactive_prompt = __esm({
   "src/utils/interactive-prompt.ts"() {
     "use strict";
-    readline3 = __toESM(require("readline"));
+    readline2 = __toESM(require("readline"));
     activePrompt = false;
     waiters = [];
   }
@@ -54531,7 +55556,7 @@ var init_stdin_reader = __esm({
 });
 
 // src/providers/human-input-check-provider.ts
-var fs24, path25, HumanInputCheckProvider;
+var fs23, path25, HumanInputCheckProvider;
 var init_human_input_check_provider = __esm({
   "src/providers/human-input-check-provider.ts"() {
     "use strict";
@@ -54540,7 +55565,7 @@ var init_human_input_check_provider = __esm({
     init_prompt_state();
     init_liquid_extensions();
     init_stdin_reader();
-    fs24 = __toESM(require("fs"));
+    fs23 = __toESM(require("fs"));
     path25 = __toESM(require("path"));
     HumanInputCheckProvider = class _HumanInputCheckProvider extends CheckProvider {
       liquid;
@@ -54722,12 +55747,12 @@ var init_human_input_check_provider = __esm({
             return null;
           }
           try {
-            await fs24.promises.access(normalizedPath, fs24.constants.R_OK);
-            const stats = await fs24.promises.stat(normalizedPath);
+            await fs23.promises.access(normalizedPath, fs23.constants.R_OK);
+            const stats = await fs23.promises.stat(normalizedPath);
             if (!stats.isFile()) {
               return null;
             }
-            const content = await fs24.promises.readFile(normalizedPath, "utf-8");
+            const content = await fs23.promises.readFile(normalizedPath, "utf-8");
             return content.trim();
           } catch {
             return null;
@@ -55784,6 +56809,11 @@ var init_script_check_provider = __esm({
                 env,
                 stderr: "pipe"
               });
+              if (transport.stderr) {
+                transport.stderr.on("error", (err) => {
+                  logger.debug(`MCP transport stderr error: ${err.message}`);
+                });
+              }
               await Promise.race([
                 client.connect(transport),
                 new Promise(
@@ -55881,16 +56911,48 @@ var init_script_check_provider = __esm({
   }
 });
 
+// src/utils/child-process-error-handler.ts
+function isChildProcessIOError(error) {
+  if (!(error instanceof Error)) return false;
+  const errno = error.code;
+  if (errno && TRANSIENT_IO_CODES.has(errno)) return true;
+  const msg = error.message;
+  if (msg.includes("read EIO") || msg.includes("write EPIPE")) return true;
+  if (msg.includes("ERR_STREAM_DESTROYED")) return true;
+  return false;
+}
+var TRANSIENT_IO_CODES, GUARD;
+var init_child_process_error_handler = __esm({
+  "src/utils/child-process-error-handler.ts"() {
+    "use strict";
+    init_logger();
+    TRANSIENT_IO_CODES = /* @__PURE__ */ new Set(["EIO", "EPIPE", "ECONNRESET"]);
+    GUARD = Symbol.for("visor.childProcessErrorHandler");
+    if (!globalThis[GUARD]) {
+      globalThis[GUARD] = true;
+      process.on("uncaughtException", (error, origin) => {
+        if (isChildProcessIOError(error)) {
+          logger.warn(
+            `[child-process-error-handler] Suppressed transient I/O error (${origin}): ${error.message}`
+          );
+          return;
+        }
+      });
+    }
+  }
+});
+
 // src/utils/worktree-manager.ts
-var fs25, fsp, path26, crypto4, WorktreeManager, worktreeManager;
+var fs24, fsp, path26, crypto4, WorktreeManager, worktreeManager;
 var init_worktree_manager = __esm({
   "src/utils/worktree-manager.ts"() {
     "use strict";
-    fs25 = __toESM(require("fs"));
+    fs24 = __toESM(require("fs"));
     fsp = __toESM(require("fs/promises"));
     path26 = __toESM(require("path"));
     crypto4 = __toESM(require("crypto"));
     init_command_executor();
+    init_child_process_error_handler();
     init_logger();
     WorktreeManager = class _WorktreeManager {
       static instance;
@@ -55941,12 +57003,12 @@ var init_worktree_manager = __esm({
         }
         const reposDir = this.getReposDir();
         const worktreesDir = this.getWorktreesDir();
-        if (!fs25.existsSync(reposDir)) {
-          fs25.mkdirSync(reposDir, { recursive: true });
+        if (!fs24.existsSync(reposDir)) {
+          fs24.mkdirSync(reposDir, { recursive: true });
           logger.debug(`Created repos directory: ${reposDir}`);
         }
-        if (!fs25.existsSync(worktreesDir)) {
-          fs25.mkdirSync(worktreesDir, { recursive: true });
+        if (!fs24.existsSync(worktreesDir)) {
+          fs24.mkdirSync(worktreesDir, { recursive: true });
           logger.debug(`Created worktrees directory: ${worktreesDir}`);
         }
       }
@@ -55980,7 +57042,7 @@ var init_worktree_manager = __esm({
         const reposDir = this.getReposDir();
         const repoName = repository.replace(/\//g, "-");
         const bareRepoPath = path26.join(reposDir, `${repoName}.git`);
-        if (fs25.existsSync(bareRepoPath)) {
+        if (fs24.existsSync(bareRepoPath)) {
           logger.debug(`Bare repository already exists: ${bareRepoPath}`);
           const verifyResult = await this.verifyBareRepoRemote(bareRepoPath, repoUrl);
           if (verifyResult === "timeout") {
@@ -56049,6 +57111,7 @@ var init_worktree_manager = __esm({
             const result = await this.executeGitCommand(updateCmd, { timeout: 9e4 });
             if (result.exitCode === 0) {
               logger.debug(`Successfully updated bare repository`);
+              await this.gcBareRepo(bareRepoPath);
               return;
             }
             logger.warn(`Bare repo update attempt ${attempt}/2 failed: ${result.stderr}`);
@@ -56062,6 +57125,36 @@ var init_worktree_manager = __esm({
         }
         logger.warn(`Failed to update bare repository after 2 attempts (will rely on per-ref fetch)`);
       }
+      /**
+       * Consolidate pack files after fetch to prevent unbounded pack accumulation.
+       * Each `git fetch` creates a new pack file; without periodic repacking these
+       * pile up and waste disk (especially on COW filesystems like BTRFS).
+       */
+      async gcBareRepo(bareRepoPath) {
+        try {
+          const packDir = path26.join(bareRepoPath, "objects", "pack");
+          if (!fs24.existsSync(packDir)) return;
+          const packFiles = fs24.readdirSync(packDir).filter((f) => f.endsWith(".pack"));
+          if (packFiles.length <= 3) return;
+          if (packFiles.length > 10) {
+            logger.info(`Repacking bare repo (${packFiles.length} packs): ${bareRepoPath}`);
+            const repackCmd = `git -C ${this.escapeShellArg(bareRepoPath)} repack -a -d --unpack-unreachable=now`;
+            const result = await this.executeGitCommand(repackCmd, { timeout: 3e5 });
+            if (result.exitCode === 0) {
+              logger.info(`Repack complete for ${bareRepoPath}`);
+              const pruneCmd = `git -C ${this.escapeShellArg(bareRepoPath)} prune --expire=now`;
+              await this.executeGitCommand(pruneCmd, { timeout: 6e4 });
+            } else {
+              logger.warn(`Repack failed: ${result.stderr}`);
+            }
+          } else {
+            const gcCmd = `git -C ${this.escapeShellArg(bareRepoPath)} gc --auto`;
+            await this.executeGitCommand(gcCmd, { timeout: 12e4 });
+          }
+        } catch (error) {
+          logger.debug(`gc/repack non-fatal error: ${error}`);
+        }
+      }
       /**
        * Verify that a bare repository has the correct remote URL.
        * This prevents reusing corrupted repos that were cloned from a different repository.
@@ -56154,7 +57247,7 @@ var init_worktree_manager = __esm({
           worktreePath = this.validatePath(options.workingDirectory);
         }
         let refreshFailedNeedsRecreate = false;
-        if (fs25.existsSync(worktreePath)) {
+        if (fs24.existsSync(worktreePath)) {
           logger.debug(`Worktree already exists: ${worktreePath}`);
           const metadata2 = await this.loadMetadata(worktreePath);
           if (metadata2) {
@@ -56483,9 +57576,13 @@ var init_worktree_manager = __esm({
        * Remove a worktree
        */
       async removeWorktree(worktreeId) {
-        const metadata = this.activeWorktrees.get(worktreeId);
+        let metadata = this.activeWorktrees.get(worktreeId);
+        if (!metadata) {
+          const worktreePath = path26.join(this.getWorktreesDir(), worktreeId);
+          metadata = await this.loadMetadata(worktreePath) || void 0;
+        }
         if (!metadata) {
-          logger.warn(`Worktree not found in active list: ${worktreeId}`);
+          logger.warn(`Worktree metadata not found: ${worktreeId}`);
           return;
         }
         const { bare_repo_path, worktree_path } = metadata;
@@ -56494,15 +57591,15 @@ var init_worktree_manager = __esm({
         const result = await this.executeGitCommand(removeCmd, { timeout: 3e4 });
         if (result.exitCode !== 0) {
           logger.warn(`Failed to remove worktree via git: ${result.stderr}`);
-          if (fs25.existsSync(worktree_path)) {
+          if (fs24.existsSync(worktree_path)) {
             logger.debug(`Manually removing worktree directory`);
-            fs25.rmSync(worktree_path, { recursive: true, force: true });
+            fs24.rmSync(worktree_path, { recursive: true, force: true });
           }
         }
         const metadataPath = this.getMetadataPath(worktree_path);
         try {
-          if (fs25.existsSync(metadataPath)) {
-            fs25.unlinkSync(metadataPath);
+          if (fs24.existsSync(metadataPath)) {
+            fs24.unlinkSync(metadataPath);
           }
         } catch {
         }
@@ -56522,7 +57619,7 @@ var init_worktree_manager = __esm({
        */
       async saveMetadata(worktreePath, metadata) {
         const metadataPath = this.getMetadataPath(worktreePath);
-        fs25.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf8");
+        fs24.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf8");
       }
       /**
        * Load worktree metadata
@@ -56530,12 +57627,12 @@ var init_worktree_manager = __esm({
       async loadMetadata(worktreePath) {
         const metadataPath = this.getMetadataPath(worktreePath);
         const legacyPath = path26.join(worktreePath, ".visor-metadata.json");
-        const pathToRead = fs25.existsSync(metadataPath) ? metadataPath : fs25.existsSync(legacyPath) ? legacyPath : null;
+        const pathToRead = fs24.existsSync(metadataPath) ? metadataPath : fs24.existsSync(legacyPath) ? legacyPath : null;
         if (!pathToRead) {
           return null;
         }
         try {
-          const content = fs25.readFileSync(pathToRead, "utf8");
+          const content = fs24.readFileSync(pathToRead, "utf8");
           return JSON.parse(content);
         } catch (error) {
           logger.warn(`Failed to load metadata: ${error}`);
@@ -56547,10 +57644,10 @@ var init_worktree_manager = __esm({
        */
       async listWorktrees() {
         const worktreesDir = this.getWorktreesDir();
-        if (!fs25.existsSync(worktreesDir)) {
+        if (!fs24.existsSync(worktreesDir)) {
           return [];
         }
-        const entries = fs25.readdirSync(worktreesDir, { withFileTypes: true });
+        const entries = fs24.readdirSync(worktreesDir, { withFileTypes: true });
         const worktrees = [];
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
@@ -56638,6 +57735,10 @@ var init_worktree_manager = __esm({
             process.exit(143);
           });
           process.on("uncaughtException", async (error) => {
+            if (isChildProcessIOError(error)) {
+              logger.warn(`Ignoring transient child-process I/O error: ${error.message}`);
+              return;
+            }
             logger.error(`Uncaught exception, cleaning up worktrees: ${error}`);
             await this.cleanupProcessWorktrees();
             process.exit(1);
@@ -60138,6 +61239,36 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
             wave: state.wave
           },
           async (span) => {
+            if (checkConfig.debounce && checkConfig.debounce > 0) {
+              const debounceKey = checkConfig.debounce_key || checkId;
+              const debounceResult = await getDebounceManager().enqueue(
+                debounceKey,
+                checkConfig.debounce,
+                async () => {
+                  const r = await executeWithSandboxRouting(
+                    checkId,
+                    checkConfig,
+                    context2,
+                    prInfo,
+                    dependencyResults,
+                    checkConfig.timeout || checkConfig.ai?.timeout || 18e5,
+                    () => provider.execute(prInfo, providerConfig, dependencyResults, executionContext)
+                  );
+                  try {
+                    captureCheckOutput(span, r.output);
+                  } catch {
+                  }
+                  return r;
+                }
+              );
+              if (debounceResult.outcome === "debounced") {
+                logger.info(
+                  `[LevelDispatch] ${checkId}: debounced (superseded by later invocation)`
+                );
+                return { issues: [], output: { debounced: true } };
+              }
+              return debounceResult.result;
+            }
             const res = await executeWithSandboxRouting(
               checkId,
               checkConfig,
@@ -61289,6 +62420,34 @@ async function executeSingleCheck2(checkId, context2, state, emitEvent, transiti
           wave: state.wave
         },
         async (span) => {
+          if (checkConfig2.debounce && checkConfig2.debounce > 0) {
+            const debounceKey = checkConfig2.debounce_key || checkId;
+            const debounceResult = await getDebounceManager().enqueue(
+              debounceKey,
+              checkConfig2.debounce,
+              async () => {
+                const r = await executeWithSandboxRouting(
+                  checkId,
+                  checkConfig2,
+                  context2,
+                  prInfo,
+                  dependencyResults,
+                  checkConfig2.timeout || checkConfig2.ai?.timeout || 18e5,
+                  () => provider.execute(prInfo, providerConfig, dependencyResults, executionContext)
+                );
+                try {
+                  captureCheckOutput(span, r.output);
+                } catch {
+                }
+                return r;
+              }
+            );
+            if (debounceResult.outcome === "debounced") {
+              logger.info(`[LevelDispatch] ${checkId}: debounced (superseded by later invocation)`);
+              return { issues: [], output: { debounced: true } };
+            }
+            return debounceResult.result;
+          }
           const res = await executeWithSandboxRouting(
             checkId,
             checkConfig2,
@@ -61422,13 +62581,10 @@ async function executeSingleCheck2(checkId, context2, state, emitEvent, transiti
     }
     let isForEach = result.isForEach;
     let forEachItems2 = result.forEachItems;
-    logger.info(
-      `[LevelDispatch][DEBUG] After execution ${checkId}: checkConfig.forEach=${checkConfig2.forEach}, output type=${typeof result.output}, isArray=${Array.isArray(result.output)}`
-    );
     if (checkConfig2.forEach === true) {
       const output = result.output;
-      logger.info(
-        `[LevelDispatch][DEBUG] Processing forEach=true for ${checkId}, output=${JSON.stringify(output)?.substring(0, 200)}`
+      logger.debug(
+        `[LevelDispatch] Processing forEach=true for ${checkId}, output=${JSON.stringify(output)?.substring(0, 200)}`
       );
       if (output === void 0) {
         logger.error(`[LevelDispatch] forEach check "${checkId}" produced undefined output`);
@@ -62026,6 +63182,7 @@ var init_level_dispatch = __esm({
     init_workflow_inputs();
     init_sandbox_routing();
     init_policy_gate();
+    init_debounce_manager();
     init_liquid_extensions();
   }
 });
@@ -62573,12 +63730,12 @@ var init_runner = __esm({
 });
 
 // src/utils/file-exclusion.ts
-var import_ignore, fs26, path27, DEFAULT_EXCLUSION_PATTERNS, FileExclusionHelper;
+var import_ignore, fs25, path27, DEFAULT_EXCLUSION_PATTERNS, FileExclusionHelper;
 var init_file_exclusion = __esm({
   "src/utils/file-exclusion.ts"() {
     "use strict";
     import_ignore = __toESM(require("ignore"));
-    fs26 = __toESM(require("fs"));
+    fs25 = __toESM(require("fs"));
     path27 = __toESM(require("path"));
     DEFAULT_EXCLUSION_PATTERNS = [
       "dist/",
@@ -62624,8 +63781,8 @@ var init_file_exclusion = __esm({
           if (additionalPatterns && additionalPatterns.length > 0) {
             this.gitignore.add(additionalPatterns);
           }
-          if (fs26.existsSync(gitignorePath)) {
-            const rawContent = fs26.readFileSync(gitignorePath, "utf8");
+          if (fs25.existsSync(gitignorePath)) {
+            const rawContent = fs25.readFileSync(gitignorePath, "utf8");
             const gitignoreContent = rawContent.replace(/[\r\n]+/g, "\n").replace(/[\x00-\x09\x0B-\x1F\x7F]/g, "").split("\n").filter((line) => line.length < 1e3).join("\n").trim();
             this.gitignore.add(gitignoreContent);
             if (process.env.VISOR_DEBUG === "true") {
@@ -62657,13 +63814,13 @@ var git_repository_analyzer_exports = {};
 __export(git_repository_analyzer_exports, {
   GitRepositoryAnalyzer: () => GitRepositoryAnalyzer
 });
-var import_simple_git2, path28, fs27, MAX_PATCH_SIZE, GitRepositoryAnalyzer;
+var import_simple_git2, path28, fs26, MAX_PATCH_SIZE, GitRepositoryAnalyzer;
 var init_git_repository_analyzer = __esm({
   "src/git-repository-analyzer.ts"() {
     "use strict";
     import_simple_git2 = require("simple-git");
     path28 = __toESM(require("path"));
-    fs27 = __toESM(require("fs"));
+    fs26 = __toESM(require("fs"));
     init_file_exclusion();
     MAX_PATCH_SIZE = 50 * 1024;
     GitRepositoryAnalyzer = class {
@@ -62959,7 +64116,7 @@ ${file.patch}`).join("\n\n");
         let content;
         let truncated = false;
         try {
-          if (includeContext && status !== "added" && fs27.existsSync(filePath)) {
+          if (includeContext && status !== "added" && fs26.existsSync(filePath)) {
             const diff = await this.git.diff(["--", filename]).catch(() => "");
             if (diff) {
               const result = this.truncatePatch(diff, filename);
@@ -62969,7 +64126,7 @@ ${file.patch}`).join("\n\n");
               additions = lines.filter((line) => line.startsWith("+")).length;
               deletions = lines.filter((line) => line.startsWith("-")).length;
             }
-          } else if (status !== "added" && fs27.existsSync(filePath)) {
+          } else if (status !== "added" && fs26.existsSync(filePath)) {
             const diff = await this.git.diff(["--", filename]).catch(() => "");
             if (diff) {
               const lines = diff.split("\n");
@@ -62977,17 +64134,17 @@ ${file.patch}`).join("\n\n");
               deletions = lines.filter((line) => line.startsWith("-")).length;
             }
           }
-          if (status === "added" && fs27.existsSync(filePath)) {
+          if (status === "added" && fs26.existsSync(filePath)) {
             try {
-              const stats = fs27.statSync(filePath);
+              const stats = fs26.statSync(filePath);
               if (stats.isFile() && stats.size < 1024 * 1024) {
                 if (includeContext) {
-                  content = fs27.readFileSync(filePath, "utf8");
+                  content = fs26.readFileSync(filePath, "utf8");
                   const result = this.truncatePatch(content, filename);
                   patch = result.patch;
                   truncated = result.truncated;
                 }
-                const fileContent = includeContext ? content : fs27.readFileSync(filePath, "utf8");
+                const fileContent = includeContext ? content : fs26.readFileSync(filePath, "utf8");
                 additions = fileContent.split("\n").length;
               }
             } catch {
@@ -63078,10 +64235,11 @@ function shellEscape(str) {
 function sanitizePathComponent(name) {
   return name.replace(/\.\./g, "").replace(/[\/\\]/g, "-").replace(/^\.+/, "").trim() || "unnamed";
 }
-var fsp2, path29, WorkspaceManager;
+var fs27, fsp2, path29, WorkspaceManager;
 var init_workspace_manager = __esm({
   "src/utils/workspace-manager.ts"() {
     "use strict";
+    fs27 = __toESM(require("fs"));
     fsp2 = __toESM(require("fs/promises"));
     path29 = __toESM(require("path"));
     init_command_executor();
@@ -63284,12 +64442,7 @@ var init_workspace_manager = __esm({
           }
         }
         try {
-          const entries = await fsp2.readdir(this.workspacePath, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.name !== mainProjectName) {
-              this.usedNames.add(entry.name);
-            }
-          }
+          await this.loadExistingProjects(mainProjectName);
         } catch {
         }
         this.registerCleanupHandlers();
@@ -63434,6 +64587,41 @@ var init_workspace_manager = __esm({
           return false;
         }
       }
+      /**
+       * Rehydrate existing symlinked projects in a persisted workspace so future
+       * runs update them in place instead of allocating project-2, project-3, etc.
+       */
+      async loadExistingProjects(mainProjectName) {
+        const entries = await fsp2.readdir(this.workspacePath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.name === mainProjectName) {
+            continue;
+          }
+          const entryPath = path29.join(this.workspacePath, entry.name);
+          this.usedNames.add(entry.name);
+          if (!entry.isSymbolicLink()) {
+            continue;
+          }
+          try {
+            const targetPath = await fsp2.realpath(entryPath);
+            const metadataPath = `${targetPath.replace(/\/?$/, "")}.metadata.json`;
+            if (!fs27.existsSync(metadataPath)) {
+              continue;
+            }
+            const metadata = JSON.parse(await fsp2.readFile(metadataPath, "utf8"));
+            if (!metadata.repository) {
+              continue;
+            }
+            this.projects.set(entry.name, {
+              name: entry.name,
+              path: entryPath,
+              worktreePath: metadata.worktree_path || targetPath,
+              repository: metadata.repository
+            });
+          } catch {
+          }
+        }
+      }
       /**
        * Clean up stale workspace directories older than maxAge.
        * Call periodically (e.g. at socket-runner startup) to prevent disk bloat.
@@ -63449,6 +64637,17 @@ var init_workspace_manager = __esm({
             try {
               const stat2 = await fsp2.stat(dirPath);
               if (now - stat2.mtimeMs > maxAgeMs) {
+                const topGitPath = path29.join(dirPath, ".git");
+                try {
+                  const topGitStat = await fsp2.stat(topGitPath);
+                  if (topGitStat.isDirectory()) {
+                    logger.warn(
+                      `[Workspace] Skipping ${dirPath} \u2014 it is a real git repository, not a visor workspace`
+                    );
+                    continue;
+                  }
+                } catch {
+                }
                 try {
                   const subdirs = await fsp2.readdir(dirPath, { withFileTypes: true });
                   for (const sub of subdirs) {
@@ -63460,7 +64659,19 @@ var init_workspace_manager = __esm({
                       const match = gitContent.match(/gitdir:\s*(.+)/);
                       if (match) {
                         const worktreeGitDir = match[1].trim();
+                        if (!worktreeGitDir.includes("/.git/worktrees/")) {
+                          logger.warn(
+                            `[Workspace] Skipping worktree removal for ${subPath} \u2014 gitdir does not point to a worktree`
+                          );
+                          continue;
+                        }
                         const repoGitDir = worktreeGitDir.replace(/\/\.git\/worktrees\/.*$/, "");
+                        if (!repoGitDir.startsWith(basePath)) {
+                          logger.warn(
+                            `[Workspace] Skipping worktree removal for ${subPath} \u2014 parent repo ${repoGitDir} is outside workspace`
+                          );
+                          continue;
+                        }
                         await commandExecutor.execute(
                           `git -C ${shellEscape(repoGitDir)} worktree remove ${shellEscape(subPath)} --force`,
                           { timeout: 1e4 }
@@ -65792,8 +67003,11 @@ var init_client = __esm({
           console.warn("Slack auth.test failed (non-fatal); bot user id unavailable");
           return "UNKNOWN_BOT";
         }
+        if (resp.bot_id) this._botId = String(resp.bot_id);
         return String(resp.user_id);
       }
+      /** The bot's bot_id (from auth.test), used to detect own bot_message events */
+      _botId;
       /**
        * Fetch user info from Slack API.
        * Returns user profile including guest status flags, email, display name, and timezone.
@@ -65829,6 +67043,31 @@ var init_client = __esm({
        * Open a DM channel with a user.
        * Returns the DM channel ID.
        */
+      /**
+       * Resolve a channel name (e.g. "function-cve-alerts") to a channel ID.
+       * Uses conversations.list with pagination. Results are cached for the process lifetime.
+       */
+      channelNameCache = /* @__PURE__ */ new Map();
+      async resolveChannelName(name) {
+        const normalized = name.startsWith("#") ? name.slice(1) : name;
+        if (this.channelNameCache.has(normalized)) return this.channelNameCache.get(normalized);
+        let cursor;
+        do {
+          const params = {
+            types: "public_channel,private_channel",
+            limit: 200
+          };
+          if (cursor) params.cursor = cursor;
+          const resp = await this.api("conversations.list", params);
+          if (!resp?.ok) break;
+          for (const ch of resp.channels || []) {
+            this.channelNameCache.set(ch.name, ch.id);
+            if (ch.name === normalized) return ch.id;
+          }
+          cursor = resp.response_metadata?.next_cursor;
+        } while (cursor);
+        return void 0;
+      }
       async openDM(userId) {
         try {
           const resp = await this.api("conversations.open", { users: userId });
@@ -66007,6 +67246,7 @@ var init_slack_frontend = __esm({
     init_lazy_otel();
     init_task_live_updates();
     init_logger();
+    init_user_facing_error();
     SlackFrontend = class {
       name = "slack";
       subs = [];
@@ -66256,7 +67496,7 @@ var init_slack_frontend = __esm({
         if (checkId) text += `
 Check: ${checkId}`;
         if (message) text += `
-${message}`;
+${formatUserFacingExecutionMessage(message)}`;
         if (this.isTelemetryEnabled(ctx)) {
           const suffix = this.getExecutionReferenceSuffix();
           if (suffix) {
@@ -66443,17 +67683,13 @@ ${suffix}`;
             text = (text || "") + "\n\n" + out._rawOutput.trim();
           }
           if (!text) {
-            const issues = result?.issues || [];
-            const errorIssues = issues.filter(
-              (i) => i.severity === "error" && (i.ruleId?.startsWith("system/") || i.ruleId?.endsWith("/error"))
-            );
-            if (errorIssues.length > 0) {
-              const errorMessages = errorIssues.map((i) => i.message).join("\n");
+            const errorMessages = summarizeUserFacingIssues(result?.issues || []);
+            if (errorMessages) {
               text = `:warning: Something went wrong while processing your request:
 ${errorMessages}`;
               this.errorNotified = true;
               ctx.logger.warn(
-                `[slack-frontend] posting error fallback for ${checkId}: ${errorIssues.length} system error(s)`
+                `[slack-frontend] posting error fallback for ${checkId}: issue-derived error message`
               );
             }
           }
@@ -67222,6 +68458,7 @@ var init_telegram_frontend = __esm({
     init_client2();
     init_markdown2();
     init_task_live_updates();
+    init_user_facing_error();
     TelegramFrontend = class {
       name = "telegram";
       subs = [];
@@ -67385,7 +68622,7 @@ var init_telegram_frontend = __esm({
         if (checkId) text += `
 Check: ${checkId}`;
         if (message) text += `
-${message}`;
+${formatUserFacingExecutionMessage(message)}`;
         await telegram.sendMessage({
           chat_id: chatId,
           text,
@@ -67437,6 +68674,13 @@ ${message}`;
           if (out && typeof out._rawOutput === "string" && out._rawOutput.trim().length > 0) {
             text = (text || "") + "\n\n" + out._rawOutput.trim();
           }
+          if (!text) {
+            const issueSummary = summarizeUserFacingIssues(result?.issues || []);
+            if (issueSummary) {
+              text = issueSummary;
+              this.errorNotified = true;
+            }
+          }
           if (!text) {
             ctx.logger.info(
               `[telegram-frontend] skip posting reply for ${checkId}: no renderable text`
@@ -75950,6 +77194,7 @@ var init_email_frontend = __esm({
     "use strict";
     init_client3();
     init_markdown3();
+    init_user_facing_error();
     EmailFrontend = class {
       name = "email";
       subs = [];
@@ -76028,12 +77273,14 @@ var init_email_frontend = __esm({
         if (checkId) text += `
 Check: ${checkId}`;
         if (message) text += `
-${message}`;
+${formatUserFacingExecutionMessage(message)}`;
         const sendOpts = {
           to: ev.from,
           subject: ev.subject ? addRePrefix(ev.subject) : `Visor: ${title}`,
           text,
-          html: wrapInEmailTemplate(`<p><strong>${title}</strong></p><p>${message}</p>`)
+          html: wrapInEmailTemplate(
+            `<p><strong>${title}</strong></p><p>${formatUserFacingExecutionMessage(message)}</p>`
+          )
         };
         if (ev.messageId) {
           sendOpts.inReplyTo = ev.messageId;
@@ -76083,6 +77330,13 @@ ${message}`;
           if (out && typeof out._rawOutput === "string" && out._rawOutput.trim().length > 0) {
             text = (text || "") + "\n\n" + out._rawOutput.trim();
           }
+          if (!text) {
+            const issueSummary = summarizeUserFacingIssues(result?.issues || []);
+            if (issueSummary) {
+              text = issueSummary;
+              this.errorNotified = true;
+            }
+          }
           if (!text) {
             ctx.logger.info(`[email-frontend] skip posting reply for ${checkId}: no renderable text`);
             return;
@@ -76392,6 +77646,7 @@ var init_whatsapp_frontend = __esm({
     "use strict";
     init_client4();
     init_markdown4();
+    init_user_facing_error();
     WhatsAppFrontend = class {
       name = "whatsapp";
       subs = [];
@@ -76470,7 +77725,7 @@ var init_whatsapp_frontend = __esm({
         if (checkId) text += `
 Check: ${checkId}`;
         if (message) text += `
-${message}`;
+${formatUserFacingExecutionMessage(message)}`;
         await whatsapp.sendMessage({
           to: from,
           text,
@@ -76522,6 +77777,13 @@ ${message}`;
           if (out && typeof out._rawOutput === "string" && out._rawOutput.trim().length > 0) {
             text = (text || "") + "\n\n" + out._rawOutput.trim();
           }
+          if (!text) {
+            const issueSummary = summarizeUserFacingIssues(result?.issues || []);
+            if (issueSummary) {
+              text = issueSummary;
+              this.errorNotified = true;
+            }
+          }
           if (!text) {
             ctx.logger.info(
               `[whatsapp-frontend] skip posting reply for ${checkId}: no renderable text`
@@ -76720,6 +77982,7 @@ var init_teams_frontend = __esm({
     init_client5();
     init_markdown5();
     init_task_live_updates();
+    init_user_facing_error();
     TeamsFrontend = class {
       name = "teams";
       subs = [];
@@ -76799,7 +78062,7 @@ var init_teams_frontend = __esm({
         if (_checkId) text += `
 Check: ${_checkId}`;
         if (message) text += `
-${message}`;
+${formatUserFacingExecutionMessage(message)}`;
         await teams.sendMessage({
           conversationReference: conversationRef,
           text,
@@ -76852,6 +78115,13 @@ ${message}`;
           if (out && typeof out._rawOutput === "string" && out._rawOutput.trim().length > 0) {
             text = (text || "") + "\n\n" + out._rawOutput.trim();
           }
+          if (!text) {
+            const issueSummary = summarizeUserFacingIssues(result?.issues || []);
+            if (issueSummary) {
+              text = issueSummary;
+              this.errorNotified = true;
+            }
+          }
           if (!text) {
             ctx.logger.info(`[teams-frontend] skip posting reply for ${checkId}: no renderable text`);
             return;
@@ -78799,7 +80069,7 @@ var init_state_machine_execution_engine = __esm({
           const gitAnalyzer = new GitRepositoryAnalyzer2(options.workingDirectory);
           logger.info("Analyzing local git repository...");
           const repositoryInfo = await gitAnalyzer.analyzeRepository();
-          const hasConversation = !!this.executionContext?.conversation;
+          const hasConversation = !!this.executionContext?.conversation || this.webhookContextHasConversation(options?.webhookContext);
           if (!repositoryInfo.isGitRepository && !hasConversation) {
             return this.createErrorResult(
               repositoryInfo,
@@ -79198,7 +80468,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const { SessionRegistry: SessionRegistry2 } = await Promise.resolve().then(() => (init_session_registry(), session_registry_exports));
             const sessionRegistry = SessionRegistry2.getInstance();
-            sessionRegistry.clearAllSessions();
+            await sessionRegistry.clearAllSessions();
           } catch (error) {
             logger.debug(`[StateMachine] Failed to cleanup sessions: ${error}`);
           }
@@ -79387,6 +80657,20 @@ var init_state_machine_execution_engine = __esm({
         const { convertToReviewSummary: convertToReviewSummary2 } = (init_summary(), __toCommonJS(summary_exports));
         return convertToReviewSummary2(groupedResults, statistics);
       }
+      webhookContextHasConversation(webhookContext) {
+        try {
+          const webhookData = webhookContext?.webhookData;
+          if (!(webhookData instanceof Map)) return false;
+          for (const payload of webhookData.values()) {
+            const value = payload;
+            if (value?.conversation || value?.slack_conversation || value?.mcp_conversation || value?.telegram_conversation || value?.teams_conversation || value?.whatsapp_conversation || value?.email_conversation) {
+              return true;
+            }
+          }
+        } catch {
+        }
+        return false;
+      }
       /**
        * Evaluate failure conditions for a check result
        *