@probelabs/visor 0.1.183-ee → 0.1.184-ee

package/dist/sdk/sdk.js

@@ -426,10 +426,11 @@ function configureLoggerFromCli(options) {
   } catch {
   }
 }
-var OTEL_SEVERITY, Logger, logger;
+var import_node_async_hooks, OTEL_SEVERITY, Logger, logger;
 var init_logger = __esm({
   "src/logger.ts"() {
     "use strict";
+    import_node_async_hooks = require("async_hooks");
     init_lazy_otel();
     OTEL_SEVERITY = {
       silent: 0,
@@ -445,6 +446,7 @@ var init_logger = __esm({
       // DEBUG
     };
     Logger = class {
+      taskContextStorage = new import_node_async_hooks.AsyncLocalStorage();
       level = "info";
       isJsonLike = false;
       isTTY = typeof process !== "undefined" ? !!process.stderr.isTTY : false;
@@ -491,9 +493,20 @@ var init_logger = __esm({
         }
         return true;
       }
-      getTraceSuffix(msg) {
+      withTaskContext(taskId, fn) {
+        const current = this.taskContextStorage.getStore() || {};
+        return this.taskContextStorage.run({ ...current, taskId }, fn);
+      }
+      getCurrentTaskId() {
+        return this.taskContextStorage.getStore()?.taskId;
+      }
+      getContextSuffix(msg) {
         if (!msg) return "";
-        if (msg.includes("trace_id=") || msg.includes("trace_id:")) return "";
+        if (msg.includes("task_id=") || msg.includes("task_id:") || msg.includes("trace_id=") || msg.includes("trace_id:")) {
+          return "";
+        }
+        const taskId = this.getCurrentTaskId();
+        if (taskId) return ` [task_id=${taskId}]`;
         try {
           const span = trace.getSpan(context.active()) || trace.getActiveSpan();
           const ctx = span?.spanContext?.();
@@ -518,12 +531,14 @@ var init_logger = __esm({
           if (!this.otelLogger) return;
           const span = trace.getSpan(context.active()) || trace.getActiveSpan();
           const spanCtx = span?.spanContext?.();
+          const taskId = this.getCurrentTaskId();
           this.otelLogger.emit({
             severityNumber: OTEL_SEVERITY[level] || 9,
             severityText: level.toUpperCase(),
             body: msg,
             attributes: {
               "visor.logger": true,
+              ...taskId ? { task_id: taskId } : {},
               ...spanCtx?.traceId ? { trace_id: spanCtx.traceId, span_id: spanCtx.spanId } : {}
             }
           });
@@ -531,7 +546,7 @@ var init_logger = __esm({
         }
       }
       write(msg, level) {
-        const suffix = this.getTraceSuffix(msg);
+        const suffix = this.getContextSuffix(msg);
         const decoratedMsg = suffix ? `${msg}${suffix}` : msg;
         const lvl = level || "info";
         this.emitOtelLog(msg, lvl);
@@ -1547,7 +1562,8 @@ var require_package = __commonJS({
       scripts: {
         "build:cli": "ncc build src/index.ts -o dist && cp -r defaults dist/ && cp -r output dist/ && cp -r docs dist/ && cp -r examples dist/ && cp -r src/debug-visualizer/ui dist/debug-visualizer/ && node scripts/inject-version.js && echo '#!/usr/bin/env node' | cat - dist/index.js > temp && mv temp dist/index.js && chmod +x dist/index.js",
         "build:sdk": "tsup src/sdk.ts --dts --sourcemap --format esm,cjs --out-dir dist/sdk",
-        build: "./scripts/build-oss.sh",
+        build: "npm run build:oss",
+        "build:oss": "./scripts/build-oss.sh",
         "build:ee": "npm run build:cli && npm run build:sdk",
         test: "jest && npm run test:yaml",
         "test:unit": "jest",
@@ -1633,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-rc308",
+        "@probelabs/probe": "^0.6.0-rc311",
         "@types/commander": "^2.12.0",
         "@types/uuid": "^10.0.0",
         "@utcp/file": "^1.1.0",
@@ -15738,6 +15754,17 @@ var init_config_schema = __esm({
                 }
               ],
               description: "Automatically evaluate completed tasks using an LLM judge. Requires task_tracking to be enabled. Runs asynchronously after task completion. Set to `true` for defaults, or provide an object to configure."
+            },
+            task_live_updates: {
+              anyOf: [
+                {
+                  type: "boolean"
+                },
+                {
+                  $ref: "#/definitions/TaskLiveUpdatesConfig"
+                }
+              ],
+              description: "Live progress updates for long-running tracked tasks on supported frontends."
             }
           },
           required: ["version"],
@@ -16610,7 +16637,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-61047%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E",
               description: "Override specific step configurations in the workflow"
             },
             output_mapping: {
@@ -16626,7 +16653,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-61047%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E",
               description: "Alias for overrides - workflow step overrides (backward compatibility)"
             },
             ref: {
@@ -17354,7 +17381,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-61047%3E%3E",
+              $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E",
               description: "Step overrides"
             },
             output_mapping: {
@@ -17369,13 +17396,13 @@ var init_config_schema = __esm({
             "^x-": {}
           }
         },
-        "Record<string,Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047>>": {
+        "Record<string,Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422>>": {
           type: "object",
           additionalProperties: {
-            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047%3E"
+            $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E"
           }
         },
-        "Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047>": {
+        "Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422>": {
           type: "object",
           additionalProperties: false
         },
@@ -19307,6 +19334,102 @@ var init_config_schema = __esm({
           patternProperties: {
             "^x-": {}
           }
+        },
+        TaskLiveUpdatesConfig: {
+          type: "object",
+          properties: {
+            enabled: {
+              type: "boolean",
+              description: "Enable live task progress updates (default: true when config object is present)"
+            },
+            interval_seconds: {
+              type: "number",
+              description: "Update interval in seconds (default: 10)"
+            },
+            model: {
+              type: "string",
+              description: "LLM model to use for progress summarization"
+            },
+            provider: {
+              type: "string",
+              description: "AI provider to use for progress summarization"
+            },
+            prompt: {
+              type: "string",
+              description: "Custom system prompt for the progress summarizer"
+            },
+            initial_message: {
+              type: "string",
+              description: "Immediate placeholder text posted before the first summary is generated"
+            },
+            max_trace_chars: {
+              type: "number",
+              description: "Maximum serialized trace characters passed into the summarizer (default: 12000)"
+            },
+            frontends: {
+              type: "object",
+              properties: {
+                slack: {
+                  type: "object",
+                  properties: {
+                    enabled: {
+                      type: "boolean"
+                    }
+                  },
+                  additionalProperties: false,
+                  patternProperties: {
+                    "^x-": {}
+                  }
+                },
+                telegram: {
+                  type: "object",
+                  properties: {
+                    enabled: {
+                      type: "boolean"
+                    }
+                  },
+                  additionalProperties: false,
+                  patternProperties: {
+                    "^x-": {}
+                  }
+                },
+                teams: {
+                  type: "object",
+                  properties: {
+                    enabled: {
+                      type: "boolean"
+                    }
+                  },
+                  additionalProperties: false,
+                  patternProperties: {
+                    "^x-": {}
+                  }
+                },
+                whatsapp: {
+                  type: "object",
+                  properties: {
+                    enabled: {
+                      type: "boolean"
+                    }
+                  },
+                  additionalProperties: false,
+                  patternProperties: {
+                    "^x-": {}
+                  }
+                }
+              },
+              additionalProperties: false,
+              description: "Per-frontend enablement overrides",
+              patternProperties: {
+                "^x-": {}
+              }
+            }
+          },
+          additionalProperties: false,
+          description: 'Live task progress updates for supported interactive frontends.\n\nWhen enabled, Visor posts a "working on it" placeholder and periodically updates the same message using a cheap internal LLM summary of the current execution trace. The final answer replaces that same message.',
+          patternProperties: {
+            "^x-": {}
+          }
         }
       }
     };
@@ -20784,6 +20907,7 @@ ${errors}`);
                   "sandbox",
                   "sandbox_defaults",
                   "policy",
+                  "task_live_updates",
                   // Workflow metadata fields used when configs are imported as reusable workflows
                   "id",
                   "name",
@@ -21764,10 +21888,10 @@ var init_workflow_check_provider = __esm({
           }
         }
         const outputKeys = Object.keys(outputs);
-        const nullOutputs = outputKeys.filter((k) => outputs[k] === null || outputs[k] === void 0);
-        if (nullOutputs.length > 0) {
+        const undefinedOutputs = outputKeys.filter((k) => outputs[k] === void 0);
+        if (undefinedOutputs.length > 0) {
           logger.warn(
-            `[WorkflowProvider] Workflow '${workflow.id}' has null/undefined outputs: [${nullOutputs.join(", ")}]. This may indicate value_js expressions are not finding expected data.`
+            `[WorkflowProvider] Workflow '${workflow.id}' has undefined outputs: [${undefinedOutputs.join(", ")}]. This may indicate value_js expressions are not finding expected data.`
           );
         }
         if (!outputs._rawOutput) {
@@ -24100,13 +24224,19 @@ async function serializeTraceForPrompt(traceIdOrPath, maxChars, backendConfig, t
   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" });
   }
   if (spans.length === 0) {
@@ -24196,6 +24326,19 @@ function renderSpanYaml(tree, allSpans, opts) {
 }
 function renderYamlNode(node, indent, lines, dedup, renderContext, fallbackIntent, fullOutput, maxLen, parentSpan) {
   if (shouldSkipLifecycleSpan(node.span, renderContext)) {
+    for (const child of node.children) {
+      renderYamlNode(
+        child,
+        indent,
+        lines,
+        dedup,
+        renderContext,
+        fallbackIntent,
+        fullOutput,
+        maxLen,
+        parentSpan
+      );
+    }
     return;
   }
   const pad = "  ".repeat(indent);
@@ -24474,7 +24617,7 @@ function renderYamlOutput(rawOutput, pad, label, spanName, dedup, lines, fullOut
   if (obj === null || obj === void 0 || typeof obj !== "object") return;
   if (typeof obj === "object" && !Array.isArray(obj)) {
     const keys = Object.keys(obj);
-    if (keys.length === 1 && typeof obj[keys[0]] === "object" && obj[keys[0]] !== null) {
+    if (keys.length === 1 && typeof obj[keys[0]] === "object" && obj[keys[0]] !== null && !Array.isArray(obj[keys[0]])) {
       obj = obj[keys[0]];
     }
     const objKeys = Object.keys(obj);
@@ -25008,7 +25151,7 @@ function formatJsonPreview(obj, maxLen) {
   const parts = [];
   let len = 2;
   for (const [key, val] of Object.entries(obj)) {
-    if (key === "raw" || key === "skills" || key === "tags") continue;
+    if (key === "raw" || key === "tags") continue;
     let valStr;
     if (val === null || val === void 0) continue;
     if (typeof val === "boolean") valStr = String(val);
@@ -25017,8 +25160,13 @@ function formatJsonPreview(obj, maxLen) {
       if (val.startsWith("{") || val.startsWith("[")) continue;
       const clean = val.replace(/\*\*/g, "").replace(/^#+\s*/gm, "").replace(/`/g, "").trim();
       valStr = `"${truncate(clean.split("\n")[0], Math.min(80, maxLen / 3))}"`;
-    } else if (Array.isArray(val)) valStr = `[${val.length}]`;
-    else if (typeof val === "object") valStr = `{${Object.keys(val).length} keys}`;
+    } else if (Array.isArray(val)) {
+      if (val.every((item) => typeof item === "string") && val.join(", ").length < Math.min(120, maxLen / 2)) {
+        valStr = `[${val.join(", ")}]`;
+      } else {
+        valStr = `[${val.length}]`;
+      }
+    } else if (typeof val === "object") valStr = `{${Object.keys(val).length} keys}`;
     else valStr = "...";
     const part = `${key}: ${valStr}`;
     if (len + part.length + 2 > maxLen) {
@@ -25264,6 +25412,629 @@ var init_trace_serializer = __esm({
   }
 });
 
+// src/agent-protocol/task-live-updates.ts
+function resolveTaskLiveUpdatesConfig(config) {
+  if (!config) return null;
+  if (config === true) {
+    return {
+      enabled: true,
+      intervalSeconds: DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS,
+      model: DEFAULT_TASK_LIVE_UPDATE_MODEL,
+      prompt: DEFAULT_TASK_LIVE_UPDATE_PROMPT,
+      initialMessage: "",
+      maxTraceChars: DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS
+    };
+  }
+  if (config.enabled === false) return null;
+  return {
+    enabled: true,
+    intervalSeconds: Math.max(
+      1,
+      Math.floor(config.interval_seconds || DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS)
+    ),
+    model: config.model || DEFAULT_TASK_LIVE_UPDATE_MODEL,
+    provider: config.provider,
+    prompt: config.prompt || DEFAULT_TASK_LIVE_UPDATE_PROMPT,
+    initialMessage: config.initial_message || "",
+    maxTraceChars: Math.max(
+      1e3,
+      Math.floor(config.max_trace_chars || DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS)
+    )
+  };
+}
+function isFrontendLiveUpdatesEnabled(config, frontend) {
+  if (!config) return false;
+  if (config === true) return true;
+  if (config.enabled === false) return false;
+  const frontendCfg = config.frontends?.[frontend];
+  if (frontendCfg?.enabled === false) return false;
+  return true;
+}
+async function defaultSerializeTrace(traceRef, maxChars, traceId) {
+  logger.debug(
+    `[TaskLiveUpdates] Serializing trace for progress update (traceRef=${traceRef}, traceId=${traceId || "-"}, sink=${process.env.VISOR_TELEMETRY_SINK || "auto"})`
+  );
+  return serializeTraceForPrompt(traceRef, maxChars, void 0, void 0, traceId);
+}
+async function summarizeTaskProgress(input) {
+  const { ProbeAgent: ProbeAgent2 } = require("@probelabs/probe");
+  const agentOptions = {
+    sessionId: `visor-task-progress-${Date.now()}-${import_crypto5.default.randomUUID().slice(0, 8)}`,
+    systemPrompt: input.config.prompt,
+    maxIterations: 1,
+    disableTools: true
+  };
+  if (input.config.model) agentOptions.model = input.config.model;
+  if (input.config.provider) agentOptions.provider = input.config.provider;
+  const agent = new ProbeAgent2(agentOptions);
+  if (typeof agent.initialize === "function") {
+    await agent.initialize();
+  }
+  const userPrompt = [
+    `<user_request>
+${input.requestText}
+</user_request>`,
+    input.previousUpdate ? `<previous_update>
+${input.previousUpdate}
+</previous_update>` : "<previous_update>(none)</previous_update>",
+    `<timing>
+started_at: ${input.startedAt.toISOString()}
+now: ${input.now.toISOString()}
+elapsed: ${formatDuration(input.elapsedSeconds)}
+last_update_at: ${input.previousUpdateAt ? input.previousUpdateAt.toISOString() : "(none)"}
+time_since_last_update: ${input.previousUpdateAt ? formatDuration(input.secondsSincePreviousUpdate || 0) : "(none)"}
+</timing>`,
+    `<execution_trace>
+${input.traceSnapshot}
+</execution_trace>`
+  ].join("\n\n");
+  const response = await agent.answer(userPrompt);
+  const cleaned = response.replace(/^```(?:markdown|md|text)?\s*\n?/i, "").replace(/\n?```\s*$/m, "").trim();
+  return cleaned || null;
+}
+function formatDuration(totalSeconds) {
+  const seconds = Math.max(0, Math.floor(totalSeconds));
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const remainingSeconds = seconds % 60;
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (remainingSeconds > 0 || parts.length === 0) parts.push(`${remainingSeconds}s`);
+  return parts.join(" ");
+}
+function normalizeProgressSummary(text) {
+  const wantedLabels = ["Progress", "Last done", "Now", "Waiting on"];
+  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const matched = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const match = line.match(/^-?\s*(Progress|Last done|Now|Waiting on|Timing)\s*:\s*(.+)$/i);
+    if (!match) continue;
+    const label = match[1].toLowerCase();
+    if (label === "timing") continue;
+    const canonical = wantedLabels.find((item) => item.toLowerCase() === label);
+    if (canonical && !matched.has(canonical)) {
+      matched.set(canonical, match[2].trim());
+    }
+  }
+  if (matched.size === wantedLabels.length) {
+    return wantedLabels.map((label) => `- ${label}: ${matched.get(label)}`).join("\n");
+  }
+  const withoutTiming = lines.filter((line) => !/^-?\s*(Timing|Metadata|Trace)\s*:/i.test(line));
+  return withoutTiming.join("\n");
+}
+function formatProgressMetadata(timing) {
+  const parts = [`elapsed ${formatDuration(timing.elapsedSeconds)}`];
+  if (timing.previousUpdateAt) {
+    parts.push(`previous update ${formatDuration(timing.secondsSincePreviousUpdate || 0)} ago`);
+    parts.push(`at ${timing.previousUpdateAt.toISOString()}`);
+  } else {
+    parts.push("first live update");
+  }
+  if (timing.activatedSkills && timing.activatedSkills.length > 0) {
+    parts.push(`activated skills ${formatSkillList(timing.activatedSkills)}`);
+  }
+  return `_Metadata: ${parts.join(" | ")}_`;
+}
+function formatSkillList(skills) {
+  const normalized = dedupeStrings(skills);
+  if (normalized.length <= 4) return normalized.join(", ");
+  return `${normalized.slice(0, 4).join(", ")} +${normalized.length - 4} more`;
+}
+function dedupeStrings(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values.map((value) => String(value || "").trim()).filter(Boolean))];
+}
+async function extractTraceSkillMetadata(traceRef, traceId) {
+  if (!traceRef && !traceId) return void 0;
+  try {
+    const spans = await fetchTraceSpans(traceId || traceRef);
+    if (!spans.length) return void 0;
+    const routeIntentSpan = spans.find(
+      (span) => span.attributes["visor.check.id"] === "route-intent"
+    );
+    const buildConfigSpan = spans.find(
+      (span) => span.attributes["visor.check.id"] === "build-config"
+    );
+    const classifySpan = spans.find((span) => span.attributes["visor.check.id"] === "classify");
+    const routeIntentOutput = parseJsonAttribute(routeIntentSpan?.attributes["visor.check.output"]);
+    const classifyOutput = parseJsonAttribute(classifySpan?.attributes["visor.check.output"]);
+    const buildConfigOutput = parseJsonAttribute(buildConfigSpan?.attributes["visor.check.output"]);
+    const activatedSkills = dedupeStrings(
+      Array.isArray(buildConfigOutput?.activated_skills) ? buildConfigOutput.activated_skills : void 0
+    );
+    const fallbackActivatedSkills = dedupeStrings(
+      (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 };
+  } catch (err) {
+    logger.debug(
+      `[TaskLiveUpdates] Failed to extract skill metadata from trace: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return void 0;
+  }
+}
+function parseJsonAttribute(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildStallFallbackSummary(traceSnapshot, previousUpdate) {
+  const lastDone = extractProgressField(previousUpdate, "Last done") || "continuing from the last completed analysis step";
+  const lower = traceSnapshot.toLowerCase();
+  let now = "waiting for the current analysis step to finish";
+  let waitingOn = "the current analysis step to complete";
+  if (lower.includes("search.delegate") || lower.includes("tool: search") || lower.includes("search(")) {
+    now = "running or waiting on the current code search step";
+    waitingOn = "search results and downstream analysis to finish";
+  } else if (lower.includes("extract(") || lower.includes("tool: extract")) {
+    now = "extracting the relevant code or documentation context";
+    waitingOn = "the extract step to finish and be interpreted";
+  } else if (lower.includes("engineer-task") || lower.includes("engineer")) {
+    now = "waiting on the current implementation or validation step";
+    waitingOn = "the engineer workflow to finish the current step";
+  } else if (lower.includes("ai.request") || lower.includes("gemini") || lower.includes("claude") || lower.includes("openai")) {
+    now = "waiting on the current model analysis step";
+    waitingOn = "the active model response to finish";
+  } else if (lower.includes("bash(") || lower.includes("go test") || lower.includes("npm test")) {
+    now = "running or waiting on command-based validation";
+    waitingOn = "the current command or test run to finish";
+  } else if (lower.includes("setup-projects") || lower.includes("build-config")) {
+    now = "preparing the workspace and loading the required context";
+    waitingOn = "workspace setup and context loading to finish";
+  }
+  return [
+    "- Progress: still working through the same step; no new completed action yet",
+    `- Last done: ${lastDone}`,
+    `- Now: ${now}`,
+    `- Waiting on: ${waitingOn}`
+  ].join("\n");
+}
+function extractProgressField(text, label) {
+  if (!text) return void 0;
+  const match = text.match(new RegExp(`(?:^|\\n)-?\\s*${escapeRegExp(label)}\\s*:\\s*(.+)$`, "im"));
+  return match?.[1]?.trim() || void 0;
+}
+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 init_task_live_updates = __esm({
+  "src/agent-protocol/task-live-updates.ts"() {
+    "use strict";
+    import_crypto5 = __toESM(require("crypto"));
+    init_logger();
+    init_trace_serializer();
+    DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS = 10;
+    DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS = 12e3;
+    DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS = 10;
+    DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS = 5;
+    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._";
+    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.
+Do NOT answer the user's original request.
+Do NOT write the final solution.
+Do NOT explain the topic in full.
+Do NOT provide a root cause, recommendation, summary of findings, or conclusion.
+Even if you think you already know the answer, do NOT give it here.
+
+You will receive:
+- the user's original request
+- the previous progress update, if any
+- timing metadata for this run
+- the latest execution trace snapshot
+
+Your job is to produce a concise status update that tells the user only:
+- the overall progress so far
+- the last meaningful action that finished
+- what the agent is doing right now
+- what it is likely waiting on, if anything
+
+Rules:
+- This is a STATUS UPDATE, not the final answer
+- Never answer the user's request directly
+- Never switch into explanation mode
+- Never write a complete answer, even partially
+- Keep it short: exactly 4 short bullet points
+- Use the exact bullet labels below
+- Do NOT generate timing metadata lines
+- Do NOT generate task_id lines
+- Timing metadata is provided only so you understand task pace and recency
+- The system will append timing and task metadata separately
+- Prefer concrete progress over generic wording
+- Mention the most recent completed action before the current action
+- Do not claim completion unless the task is actually done
+- Do not mention internal implementation details unless they help explain the current work
+- Avoid repeating the previous update verbatim
+- Do not use code fences
+- Plain markdown text only
+
+Required output format:
+- Progress: <very short overall progress statement, not a final answer>
+- Last done: <most recent completed action>
+- Now: <current action in progress>
+- Waiting on: <tool, search, model, user input, or "nothing blocking right now">
+
+Trace interpretation rules:
+- Translate internal trace phases into user-meaningful progress, do not just repeat raw span names
+- If the trace shows routing or classify work, describe that as understanding the request and choosing the right path
+- If the trace shows setup-projects, build-config, or loading context, describe that as preparing the workspace or gathering context
+- If the trace shows search, extract, code-explorer, or file inspection, describe that as investigating the codebase
+- If the trace shows engineer work, edits, tests, PR creation, or command execution, describe that as implementing or verifying changes
+- If the trace shows completion prompts, final answer generation, summarization, final validation, or output rendering, describe that as validating findings and preparing the final response
+- If the trace shows waiting on a long AI request, delegate, tool call, or sandboxed child task, describe that as waiting for analysis or validation to finish
+
+If you are tempted to answer the user's question, stop and convert that into:
+- what was learned so far
+- what was just completed
+- what is still being checked
+
+Bad update example:
+- "API rate limiting works by..."
+
+Good update example:
+- "Progress: identified the gateway components involved in rate limiting"
+- "Last done: found the middleware files and session manager entry points"
+- "Now: tracing the enforcement path through the gateway"
+- "Waiting on: search results for the limiter implementation details"`;
+    TaskLiveUpdateManager = class {
+      constructor(ctx, deps) {
+        this.ctx = ctx;
+        this.deps = {
+          summarizeProgress: deps?.summarizeProgress || summarizeTaskProgress,
+          serializeTrace: deps?.serializeTrace || defaultSerializeTrace,
+          extractSkillMetadata: deps?.extractSkillMetadata || extractTraceSkillMetadata
+        };
+      }
+      deps;
+      timer;
+      firstTickTimer;
+      metadataRefreshTimer;
+      running = false;
+      started = false;
+      completed = false;
+      startedAt = /* @__PURE__ */ new Date();
+      lastUpdateText;
+      lastUpdateAt;
+      lastTraceSnapshot;
+      lastPostedMessage;
+      lastStallFallbackAt;
+      lastUpdateKind = "semantic";
+      lastSkillMetadata;
+      async start() {
+        if (this.started) return;
+        this.started = true;
+        try {
+          const started = await this.ctx.sink.start();
+          this.recordSinkRef(started);
+          logger.info(
+            `[TaskLiveUpdates] Started for task ${this.ctx.taskId}; first update in ${DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS}s, interval=${this.ctx.config.intervalSeconds}s, provider=${this.ctx.config.provider || "default"}, model=${this.ctx.config.model}`
+          );
+        } catch (err) {
+          logger.warn(
+            `[TaskLiveUpdates] Failed to initialize live updates for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        this.firstTickTimer = setTimeout(() => {
+          void this.runFirstTick();
+        }, DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS * 1e3);
+        if (typeof this.firstTickTimer?.unref === "function") {
+          this.firstTickTimer.unref();
+        }
+      }
+      async complete(finalText) {
+        if (this.completed) return;
+        this.completed = true;
+        this.stop();
+        try {
+          logger.info(`[TaskLiveUpdates] Publishing final success update for task ${this.ctx.taskId}`);
+          const result = await this.ctx.sink.complete(this.decorateText(finalText));
+          this.recordSinkRef(result);
+          this.ctx.appendHistory?.(finalText, "completed");
+        } catch (err) {
+          logger.warn(
+            `[TaskLiveUpdates] Failed to publish final update for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      async fail(finalText) {
+        if (this.completed) return;
+        this.completed = true;
+        this.stop();
+        try {
+          logger.info(`[TaskLiveUpdates] Publishing final failure update for task ${this.ctx.taskId}`);
+          const result = await this.ctx.sink.fail(this.decorateText(finalText));
+          this.recordSinkRef(result);
+          this.ctx.appendHistory?.(finalText, "failed");
+        } catch (err) {
+          logger.warn(
+            `[TaskLiveUpdates] Failed to publish failure update for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      stop() {
+        if (this.firstTickTimer) {
+          clearTimeout(this.firstTickTimer);
+          this.firstTickTimer = void 0;
+        }
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = void 0;
+        }
+        if (this.metadataRefreshTimer) {
+          clearInterval(this.metadataRefreshTimer);
+          this.metadataRefreshTimer = void 0;
+        }
+      }
+      async tick() {
+        if (this.completed || this.running) return;
+        const traceState = this.getTraceState();
+        if (!traceState.traceRef && !traceState.traceId) {
+          logger.debug(
+            `[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: no trace reference available yet`
+          );
+          return;
+        }
+        this.running = true;
+        try {
+          const traceRef = traceState.traceRef || traceState.traceId;
+          const traceSnapshot = await this.deps.serializeTrace(
+            traceRef,
+            this.ctx.config.maxTraceChars,
+            traceState.traceId
+          );
+          if (this.completed) {
+            logger.debug(
+              `[TaskLiveUpdates] Aborting in-flight tick for task ${this.ctx.taskId}: task already completed`
+            );
+            return;
+          }
+          if (!traceSnapshot || traceSnapshot === "(no trace data available)") {
+            logger.debug(
+              `[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: no trace data available yet (traceRef=${traceRef})`
+            );
+            return;
+          }
+          if (traceSnapshot === this.lastTraceSnapshot) {
+            await this.maybePublishStallFallback(traceSnapshot, traceState.traceId);
+            logger.debug(
+              `[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: trace snapshot unchanged`
+            );
+            return;
+          }
+          const summary = await this.deps.summarizeProgress({
+            requestText: this.ctx.requestText,
+            previousUpdate: this.lastUpdateText,
+            traceSnapshot,
+            config: this.ctx.config,
+            startedAt: this.startedAt,
+            now: /* @__PURE__ */ new Date(),
+            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
+          });
+          if (this.completed) {
+            logger.debug(
+              `[TaskLiveUpdates] Aborting in-flight tick for task ${this.ctx.taskId}: task already completed after summarization`
+            );
+            return;
+          }
+          const cleaned = summary?.trim();
+          if (!cleaned || cleaned === this.lastUpdateText) {
+            await this.maybePublishStallFallback(traceSnapshot, traceState.traceId);
+            logger.debug(
+              `[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: summary empty or unchanged`
+            );
+            this.lastTraceSnapshot = traceSnapshot;
+            return;
+          }
+          logger.info(
+            `[TaskLiveUpdates] Publishing progress update for task ${this.ctx.taskId}: ${cleaned.slice(0, 160)}`
+          );
+          this.lastSkillMetadata = await this.deps.extractSkillMetadata(traceRef, traceState.traceId);
+          this.lastUpdateKind = "semantic";
+          const message = this.decorateProgressText(
+            cleaned,
+            {
+              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
+            },
+            traceState.traceId
+          );
+          const result = await this.ctx.sink.update(message);
+          this.recordSinkRef(result);
+          this.ctx.appendHistory?.(cleaned, "progress");
+          this.lastUpdateText = cleaned;
+          this.lastUpdateAt = /* @__PURE__ */ new Date();
+          this.lastTraceSnapshot = traceSnapshot;
+          this.lastPostedMessage = message;
+          this.lastStallFallbackAt = void 0;
+        } catch (err) {
+          logger.warn(
+            `[TaskLiveUpdates] Progress update failed for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        } finally {
+          this.running = false;
+        }
+      }
+      async runFirstTick() {
+        if (this.completed) return;
+        logger.debug(`[TaskLiveUpdates] Running first scheduled tick for task ${this.ctx.taskId}`);
+        await this.tick();
+        if (this.completed) return;
+        this.timer = setInterval(() => {
+          void this.tick();
+        }, this.ctx.config.intervalSeconds * 1e3);
+        if (typeof this.timer?.unref === "function") {
+          this.timer.unref();
+        }
+        this.metadataRefreshTimer = setInterval(() => {
+          void this.refreshProgressMetadata();
+        }, DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS * 1e3);
+        if (typeof this.metadataRefreshTimer?.unref === "function") {
+          this.metadataRefreshTimer.unref();
+        }
+      }
+      recordSinkRef(result) {
+        if (result?.ref) this.ctx.onPostedRef?.(result.ref);
+      }
+      getTraceState() {
+        const resolved = this.ctx.resolveTraceState?.();
+        return {
+          traceRef: resolved?.traceRef || this.ctx.traceRef,
+          traceId: resolved?.traceId || this.ctx.traceId
+        };
+      }
+      decorateText(text, _traceId) {
+        if (!this.ctx.includeTraceId) return text;
+        if (text.includes(`task_id: ${this.ctx.taskId}`)) return text;
+        return `${text}
+
+\`task_id: ${this.ctx.taskId}\``;
+      }
+      decorateProgressText(text, timing, traceId) {
+        const normalized = normalizeProgressSummary(text);
+        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 : "",
+          normalized,
+          formatProgressMetadata(timing)
+        ].filter(Boolean);
+        return this.decorateText(blocks.join("\n\n"), traceId);
+      }
+      async refreshProgressMetadata() {
+        if (this.completed || this.running || !this.lastUpdateText) return;
+        const traceState = this.getTraceState();
+        const message = this.decorateProgressText(
+          this.lastUpdateText,
+          {
+            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
+          },
+          traceState.traceId
+        );
+        if (!message || message === this.lastPostedMessage) return;
+        if (this.completed) return;
+        try {
+          logger.debug(
+            `[TaskLiveUpdates] Refreshing metadata-only live update for task ${this.ctx.taskId}`
+          );
+          const result = await this.ctx.sink.update(message);
+          this.recordSinkRef(result);
+          this.lastPostedMessage = message;
+        } catch (err) {
+          logger.warn(
+            `[TaskLiveUpdates] Metadata refresh failed for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      async maybePublishStallFallback(traceSnapshot, traceId) {
+        if (this.completed) return;
+        const now = /* @__PURE__ */ new Date();
+        if (this.lastStallFallbackAt && now.getTime() - this.lastStallFallbackAt.getTime() < DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS * 1e3) {
+          return;
+        }
+        if (this.lastUpdateAt && now.getTime() - this.lastUpdateAt.getTime() < DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS * 1e3) {
+          return;
+        }
+        this.lastSkillMetadata = await this.deps.extractSkillMetadata(
+          this.getTraceState().traceRef || traceId || "",
+          traceId
+        );
+        const fallback = buildStallFallbackSummary(traceSnapshot, this.lastUpdateText);
+        const baseText = this.lastUpdateText || fallback;
+        if (!baseText) return;
+        logger.info(
+          `[TaskLiveUpdates] Publishing stall notice for task ${this.ctx.taskId}: ${baseText.slice(0, 160)}`
+        );
+        this.lastUpdateKind = "stall";
+        if (this.completed) return;
+        const message = this.decorateProgressText(
+          baseText,
+          {
+            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
+          },
+          traceId
+        );
+        if (message === this.lastPostedMessage) {
+          this.lastStallFallbackAt = now;
+          return;
+        }
+        const result = await this.ctx.sink.update(message);
+        this.recordSinkRef(result);
+        if (!this.lastUpdateText) {
+          this.ctx.appendHistory?.(baseText, "progress");
+          this.lastUpdateText = baseText;
+          this.lastUpdateAt = now;
+        }
+        this.lastPostedMessage = message;
+        this.lastStallFallbackAt = now;
+      }
+    };
+  }
+});
+
+// src/agent-protocol/task-trace-resolution.ts
+async function resolveTaskTraceReference(metadata) {
+  const traceFile = metadata?.trace_file;
+  let traceId = metadata?.trace_id;
+  if (!traceId && traceFile) {
+    try {
+      const { readTraceIdFromFile: readTraceIdFromFile2 } = await Promise.resolve().then(() => (init_trace_serializer(), trace_serializer_exports));
+      traceId = await readTraceIdFromFile2(traceFile) || void 0;
+    } catch {
+      traceId = void 0;
+    }
+  }
+  return {
+    traceId,
+    traceFile,
+    primaryRef: traceId || traceFile || void 0
+  };
+}
+var init_task_trace_resolution = __esm({
+  "src/agent-protocol/task-trace-resolution.ts"() {
+    "use strict";
+  }
+});
+
 // src/agent-protocol/task-evaluator.ts
 var task_evaluator_exports = {};
 __export(task_evaluator_exports, {
@@ -25437,18 +26208,18 @@ async function evaluateAndStore(taskId, store, config) {
   const match = rows.find((r) => r.id === taskId || r.id.startsWith(taskId));
   if (match) {
     store.addArtifact(match.id, {
-      artifact_id: import_crypto5.default.randomUUID(),
+      artifact_id: import_crypto6.default.randomUUID(),
       name: "evaluation",
       parts: [{ text: JSON.stringify(result), media_type: "application/json" }]
     });
   }
   return result;
 }
-var import_crypto5, DEFAULT_EVALUATION_PROMPT;
+var import_crypto6, DEFAULT_EVALUATION_PROMPT;
 var init_task_evaluator = __esm({
   "src/agent-protocol/task-evaluator.ts"() {
     "use strict";
-    import_crypto5 = __toESM(require("crypto"));
+    import_crypto6 = __toESM(require("crypto"));
     init_logger();
     init_trace_serializer();
     DEFAULT_EVALUATION_PROMPT = `You are a task response quality evaluator for an AI agent system called Visor.
@@ -25540,13 +26311,13 @@ async function trackExecution(opts, executor) {
   const configName = configPath ? import_path12.default.basename(configPath, import_path12.default.extname(configPath)) : void 0;
   const workflowId = configName && opts.workflowId ? `${configName}#${opts.workflowId}` : opts.workflowId;
   const requestMessage = {
-    message_id: import_crypto6.default.randomUUID(),
+    message_id: import_crypto7.default.randomUUID(),
     role: "user",
     parts: [{ text: messageText }]
   };
   const traceFile = process.env.VISOR_FALLBACK_TRACE_FILE || void 0;
   const task = taskStore.createTask({
-    contextId: import_crypto6.default.randomUUID(),
+    contextId: import_crypto7.default.randomUUID(),
     requestMessage,
     workflowId,
     requestMetadata: {
@@ -25560,105 +26331,181 @@ async function trackExecution(opts, executor) {
     }
   });
   const instanceId = getInstanceId();
-  taskStore.updateTaskState(task.id, "working");
-  taskStore.claimTask(task.id, instanceId);
-  logger.info(
-    `[TaskTracking] Task ${task.id} started (source=${source}, workflow=${workflowId || "-"}, instance=${instanceId})`
-  );
-  const HEARTBEAT_INTERVAL = 6e4;
-  const heartbeatTimer = setInterval(() => {
-    try {
-      taskStore.heartbeat(task.id);
-    } catch {
+  return await logger.withTaskContext(task.id, async () => {
+    taskStore.updateTaskState(task.id, "working");
+    taskStore.claimTask(task.id, instanceId);
+    logger.info(
+      `[TaskTracking] Task ${task.id} started (source=${source}, workflow=${workflowId || "-"}, instance=${instanceId})`
+    );
+    const liveUpdateConfig = resolveTaskLiveUpdatesConfig(opts.liveUpdates?.config);
+    const initialTraceId = trace.getActiveSpan()?.spanContext().traceId || task.metadata?.trace_id;
+    if (initialTraceId && !task.metadata?.trace_id) {
+      try {
+        taskStore.updateMetadata(task.id, { trace_id: initialTraceId });
+      } catch {
+      }
     }
-  }, HEARTBEAT_INTERVAL);
-  try {
-    const result = await executor();
-    try {
-      const activeTraceId = trace.getActiveSpan()?.spanContext().traceId;
-      const persistedTraceId = (activeTraceId && activeTraceId !== "" ? activeTraceId : void 0) || await readTraceIdFromFallbackFile(traceFile);
-      if (persistedTraceId && !task.metadata?.trace_id) {
-        taskStore.updateMetadata(task.id, { trace_id: persistedTraceId });
+    const initialResolvedTrace = await resolveTaskTraceReference({
+      trace_id: initialTraceId || task.metadata?.trace_id,
+      trace_file: task.metadata?.trace_file
+    });
+    const liveUpdateManager = liveUpdateConfig && opts.liveUpdates?.sink ? new TaskLiveUpdateManager({
+      taskId: task.id,
+      requestText: messageText,
+      traceRef: initialResolvedTrace.primaryRef,
+      traceId: initialResolvedTrace.traceId,
+      includeTraceId: opts.liveUpdates?.includeTraceId === true,
+      sink: opts.liveUpdates.sink,
+      config: liveUpdateConfig,
+      resolveTraceState: () => {
+        let current;
+        try {
+          current = taskStore.getTask(task.id);
+        } catch {
+          return {
+            traceRef: initialResolvedTrace.primaryRef,
+            traceId: initialResolvedTrace.traceId
+          };
+        }
+        return {
+          traceRef: current?.metadata?.trace_id || current?.metadata?.trace_file || initialResolvedTrace.primaryRef,
+          traceId: current?.metadata?.trace_id
+        };
+      },
+      onPostedRef: (ref) => {
+        try {
+          taskStore.updateMetadata(task.id, ref);
+        } catch {
+        }
+      },
+      appendHistory: (text, stage) => {
+        try {
+          taskStore.appendHistory(task.id, {
+            message_id: import_crypto7.default.randomUUID(),
+            role: "agent",
+            parts: [{ text }],
+            metadata: { kind: "task_live_update", stage, source }
+          });
+        } catch {
+        }
       }
-    } catch {
+    }) : null;
+    if (liveUpdateConfig && !opts.liveUpdates?.sink) {
+      logger.debug(
+        `[TaskTracking] Live updates requested for task ${task.id} but no sink is available for source=${source}`
+      );
+    } else if (liveUpdateManager) {
+      logger.info(`[TaskTracking] Live updates enabled for task ${task.id} (source=${source})`);
     }
-    let responseText = "Execution completed";
+    const HEARTBEAT_INTERVAL = 6e4;
+    const heartbeatTimer = setInterval(() => {
+      try {
+        taskStore.heartbeat(task.id);
+      } catch {
+      }
+    }, HEARTBEAT_INTERVAL);
     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 (liveUpdateManager) {
+        await liveUpdateManager.start();
+      }
+      const result = await executor();
+      try {
+        const activeTraceId = trace.getActiveSpan()?.spanContext().traceId;
+        const persistedTraceId = (activeTraceId && activeTraceId !== "" ? activeTraceId : void 0) || await readTraceIdFromFallbackFile(traceFile);
+        if (persistedTraceId && !task.metadata?.trace_id) {
+          taskStore.updateMetadata(task.id, { trace_id: persistedTraceId });
+        }
+      } catch {
+      }
+      let responseText = "Execution completed";
+      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;
           }
-          if (responseText !== "Execution completed") break;
         }
+      } catch {
       }
-    } catch {
-    }
-    const completedMsg = {
-      message_id: import_crypto6.default.randomUUID(),
-      role: "agent",
-      parts: [{ text: responseText }]
-    };
-    try {
-      taskStore.updateTaskState(task.id, "completed", completedMsg);
-      logger.info(`[TaskTracking] Task ${task.id} completed`);
-    } catch (stateErr) {
-      logger.warn(
-        `[TaskTracking] Task ${task.id} completed but state transition failed: ${stateErr instanceof Error ? stateErr.message : stateErr}`
-      );
-    }
-    if (opts.autoEvaluate || process.env.VISOR_TASK_EVALUATE === "true") {
-      scheduleEvaluation(task.id, taskStore);
-    }
-    return { task, result };
-  } catch (err) {
-    const errorText = err instanceof Error ? err.message : String(err);
-    const failMessage = {
-      message_id: import_crypto6.default.randomUUID(),
-      role: "agent",
-      parts: [{ text: errorText }]
-    };
-    try {
-      taskStore.updateTaskState(task.id, "failed", failMessage);
-      logger.info(`[TaskTracking] Task ${task.id} failed: ${errorText}`);
-    } catch {
+      const completedMsg = {
+        message_id: import_crypto7.default.randomUUID(),
+        role: "agent",
+        parts: [{ text: responseText }]
+      };
+      try {
+        taskStore.updateTaskState(task.id, "completed", completedMsg);
+        logger.info(`[TaskTracking] Task ${task.id} completed`);
+      } catch (stateErr) {
+        logger.warn(
+          `[TaskTracking] Task ${task.id} completed but state transition failed: ${stateErr instanceof Error ? stateErr.message : stateErr}`
+        );
+      }
+      if (opts.autoEvaluate || process.env.VISOR_TASK_EVALUATE === "true") {
+        scheduleEvaluation(task.id, taskStore);
+      }
+      if (liveUpdateManager) {
+        await liveUpdateManager.complete(responseText);
+      }
+      return { task, result };
+    } catch (err) {
+      const errorText = err instanceof Error ? err.message : String(err);
+      const failMessage = {
+        message_id: import_crypto7.default.randomUUID(),
+        role: "agent",
+        parts: [{ text: errorText }]
+      };
+      try {
+        taskStore.updateTaskState(task.id, "failed", failMessage);
+        logger.info(`[TaskTracking] Task ${task.id} failed: ${errorText}`);
+      } catch {
+      }
+      if (liveUpdateManager) {
+        await liveUpdateManager.fail(`:warning: ${errorText}`);
+      }
+      throw err;
+    } finally {
+      clearInterval(heartbeatTimer);
+      liveUpdateManager?.stop();
     }
-    throw err;
-  } finally {
-    clearInterval(heartbeatTimer);
-  }
+  });
 }
 function scheduleEvaluation(taskId, taskStore) {
   setTimeout(async () => {
-    try {
-      const { evaluateAndStore: evaluateAndStore2 } = await Promise.resolve().then(() => (init_task_evaluator(), task_evaluator_exports));
-      await evaluateAndStore2(taskId, taskStore);
-      logger.info(`[TaskEvaluator] Auto-evaluation completed for task ${taskId}`);
-    } catch (err) {
-      logger.warn(
-        `[TaskEvaluator] Auto-evaluation failed for task ${taskId}: ${err instanceof Error ? err.message : err}`
-      );
-    }
+    await logger.withTaskContext(taskId, async () => {
+      try {
+        const { evaluateAndStore: evaluateAndStore2 } = await Promise.resolve().then(() => (init_task_evaluator(), task_evaluator_exports));
+        await evaluateAndStore2(taskId, taskStore);
+        logger.info(`[TaskEvaluator] Auto-evaluation completed for task ${taskId}`);
+      } catch (err) {
+        logger.warn(
+          `[TaskEvaluator] Auto-evaluation failed for task ${taskId}: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    });
   }, 5e3);
 }
-var import_crypto6, import_fs10, import_path12;
+var import_crypto7, import_fs10, import_path12;
 var init_track_execution = __esm({
   "src/agent-protocol/track-execution.ts"() {
     "use strict";
-    import_crypto6 = __toESM(require("crypto"));
+    import_crypto7 = __toESM(require("crypto"));
     import_fs10 = __toESM(require("fs"));
     import_path12 = __toESM(require("path"));
     init_logger();
     init_lazy_otel();
     init_instance_id();
+    init_task_live_updates();
+    init_task_trace_resolution();
   }
 });
 
@@ -27549,8 +28396,9 @@ async function handleTrace(taskId, taskStore) {
   if (!task) {
     return { success: false, error: `Task not found: ${taskId}` };
   }
-  const traceId = task.metadata?.trace_id;
-  const traceFile = task.metadata?.trace_file;
+  const resolvedTrace = await resolveTaskTraceReference(task.metadata);
+  const traceId = resolvedTrace.traceId;
+  const traceFile = resolvedTrace.traceFile;
   if (!traceId && !traceFile) {
     const trigger2 = task.metadata?.slack_trigger_text || "";
     return {
@@ -27566,19 +28414,15 @@ async function handleTrace(taskId, taskStore) {
       ].filter(Boolean).join("\n")
     };
   }
-  const { serializeTraceForPrompt: serializeTraceForPrompt2, readTraceIdFromFile: readTraceIdFromFile2 } = await Promise.resolve().then(() => (init_trace_serializer(), trace_serializer_exports));
-  let resolvedTraceId = traceId;
-  if (!resolvedTraceId && traceFile) {
-    resolvedTraceId = await readTraceIdFromFile2(traceFile);
-  }
+  const { serializeTraceForPrompt: serializeTraceForPrompt2 } = await Promise.resolve().then(() => (init_trace_serializer(), trace_serializer_exports));
   const taskResponse = task.status?.message?.parts?.[0]?.text;
   const traceTree = await serializeTraceForPrompt2(
-    traceFile || resolvedTraceId || "",
+    resolvedTrace.primaryRef || "",
     8e3,
     // generous limit so AI gets good context
     void 0,
     taskResponse,
-    resolvedTraceId || void 0
+    traceId || void 0
   );
   const trigger = task.metadata?.slack_trigger_text || "";
   const elapsed = timeSince(task.created_at);
@@ -27605,6 +28449,7 @@ var init_task_progress_tool = __esm({
   "src/agent-protocol/task-progress-tool.ts"() {
     "use strict";
     init_logger();
+    init_task_trace_resolution();
   }
 });
 
@@ -38801,11 +39646,11 @@ var require_util2 = __commonJS({
     var assert = require("assert");
     var { isUint8Array } = require("util/types");
     var supportedHashes = [];
-    var crypto10;
+    var crypto11;
     try {
-      crypto10 = require("crypto");
+      crypto11 = require("crypto");
       const possibleRelevantHashes = ["sha256", "sha384", "sha512"];
-      supportedHashes = crypto10.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
+      supportedHashes = crypto11.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
     } catch {
     }
     function responseURL(response) {
@@ -39082,7 +39927,7 @@ var require_util2 = __commonJS({
       }
     }
     function bytesMatch(bytes, metadataList) {
-      if (crypto10 === void 0) {
+      if (crypto11 === void 0) {
         return true;
       }
       const parsedMetadata = parseMetadata(metadataList);
@@ -39097,7 +39942,7 @@ var require_util2 = __commonJS({
       for (const item of metadata) {
         const algorithm = item.algo;
         const expectedValue = item.hash;
-        let actualValue = crypto10.createHash(algorithm).update(bytes).digest("base64");
+        let actualValue = crypto11.createHash(algorithm).update(bytes).digest("base64");
         if (actualValue[actualValue.length - 1] === "=") {
           if (actualValue[actualValue.length - 2] === "=") {
             actualValue = actualValue.slice(0, -2);
@@ -40444,8 +41289,8 @@ var require_body = __commonJS({
     var { parseMIMEType, serializeAMimeType } = require_dataURL();
     var random;
     try {
-      const crypto10 = require("crypto");
-      random = (max) => crypto10.randomInt(0, max);
+      const crypto11 = require("crypto");
+      random = (max) => crypto11.randomInt(0, max);
     } catch {
       random = (max) => Math.floor(Math.random(max));
     }
@@ -51501,9 +52346,9 @@ var require_connection = __commonJS({
     channels.open = diagnosticsChannel.channel("undici:websocket:open");
     channels.close = diagnosticsChannel.channel("undici:websocket:close");
     channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
-    var crypto10;
+    var crypto11;
     try {
-      crypto10 = require("crypto");
+      crypto11 = require("crypto");
     } catch {
     }
     function establishWebSocketConnection(url, protocols, ws, onEstablish, options) {
@@ -51522,7 +52367,7 @@ var require_connection = __commonJS({
         const headersList = new Headers(options.headers)[kHeadersList];
         request.headersList = headersList;
       }
-      const keyValue = crypto10.randomBytes(16).toString("base64");
+      const keyValue = crypto11.randomBytes(16).toString("base64");
       request.headersList.append("sec-websocket-key", keyValue);
       request.headersList.append("sec-websocket-version", "13");
       for (const protocol of protocols) {
@@ -51551,7 +52396,7 @@ var require_connection = __commonJS({
             return;
           }
           const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
-          const digest = crypto10.createHash("sha1").update(keyValue + uid).digest("base64");
+          const digest = crypto11.createHash("sha1").update(keyValue + uid).digest("base64");
           if (secWSAccept !== digest) {
             failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
             return;
@@ -51631,9 +52476,9 @@ var require_frame = __commonJS({
   "node_modules/undici/lib/websocket/frame.js"(exports2, module2) {
     "use strict";
     var { maxUnsigned16Bit } = require_constants5();
-    var crypto10;
+    var crypto11;
     try {
-      crypto10 = require("crypto");
+      crypto11 = require("crypto");
     } catch {
     }
     var WebsocketFrameSend = class {
@@ -51642,7 +52487,7 @@ var require_frame = __commonJS({
        */
       constructor(data) {
         this.frameData = data;
-        this.maskKey = crypto10.randomBytes(4);
+        this.maskKey = crypto11.randomBytes(4);
       }
       createFrame(opcode) {
         const bodyLength = this.frameData?.byteLength ?? 0;
@@ -54967,14 +55812,14 @@ var init_script_check_provider = __esm({
 });
 
 // src/utils/worktree-manager.ts
-var fs25, fsp, path26, crypto3, WorktreeManager, worktreeManager;
+var fs25, fsp, path26, crypto4, WorktreeManager, worktreeManager;
 var init_worktree_manager = __esm({
   "src/utils/worktree-manager.ts"() {
     "use strict";
     fs25 = __toESM(require("fs"));
     fsp = __toESM(require("fs/promises"));
     path26 = __toESM(require("path"));
-    crypto3 = __toESM(require("crypto"));
+    crypto4 = __toESM(require("crypto"));
     init_command_executor();
     init_logger();
     WorktreeManager = class _WorktreeManager {
@@ -55055,7 +55900,7 @@ var init_worktree_manager = __esm({
         const sanitizedRepo = repository.replace(/[^a-zA-Z0-9-]/g, "-");
         const sanitizedRef = ref.replace(/[^a-zA-Z0-9-]/g, "-");
         const hashInput = sessionId ? `${repository}:${ref}:${sessionId}` : `${repository}:${ref}`;
-        const hash = crypto3.createHash("md5").update(hashInput).digest("hex").substring(0, 8);
+        const hash = crypto4.createHash("md5").update(hashInput).digest("hex").substring(0, 8);
         return `${sanitizedRepo}-${sanitizedRef}-${hash}`;
       }
       /**
@@ -63230,11 +64075,11 @@ var validator_exports = {};
 __export(validator_exports, {
   LicenseValidator: () => LicenseValidator
 });
-var crypto4, fs28, path30, LicenseValidator;
+var crypto5, fs28, path30, LicenseValidator;
 var init_validator = __esm({
   "src/enterprise/license/validator.ts"() {
     "use strict";
-    crypto4 = __toESM(require("crypto"));
+    crypto5 = __toESM(require("crypto"));
     fs28 = __toESM(require("fs"));
     path30 = __toESM(require("path"));
     LicenseValidator = class _LicenseValidator {
@@ -63332,11 +64177,11 @@ var init_validator = __esm({
           if (header.alg !== "EdDSA") return null;
           const data = `${headerB64}.${payloadB64}`;
           const signature = Buffer.from(signatureB64, "base64url");
-          const publicKey = crypto4.createPublicKey(_LicenseValidator.PUBLIC_KEY);
+          const publicKey = crypto5.createPublicKey(_LicenseValidator.PUBLIC_KEY);
           if (publicKey.asymmetricKeyType !== "ed25519") {
             return null;
           }
-          const isValid = crypto4.verify(null, Buffer.from(data), publicKey, signature);
+          const isValid = crypto5.verify(null, Buffer.from(data), publicKey, signature);
           if (!isValid) return null;
           const payload = JSON.parse(Buffer.from(payloadB64, "base64url").toString());
           if (!payload.org || !Array.isArray(payload.features) || typeof payload.exp !== "number" || typeof payload.iat !== "number" || !payload.sub) {
@@ -63357,14 +64202,14 @@ var init_validator = __esm({
 });
 
 // src/enterprise/policy/opa-compiler.ts
-var fs29, path31, os2, crypto5, import_child_process8, OpaCompiler;
+var fs29, path31, os2, crypto6, import_child_process8, OpaCompiler;
 var init_opa_compiler = __esm({
   "src/enterprise/policy/opa-compiler.ts"() {
     "use strict";
     fs29 = __toESM(require("fs"));
     path31 = __toESM(require("path"));
     os2 = __toESM(require("os"));
-    crypto5 = __toESM(require("crypto"));
+    crypto6 = __toESM(require("crypto"));
     import_child_process8 = require("child_process");
     OpaCompiler = class _OpaCompiler {
       static CACHE_DIR = path31.join(os2.tmpdir(), "visor-opa-cache");
@@ -63424,7 +64269,7 @@ var init_opa_compiler = __esm({
             "OPA CLI (`opa`) not found on PATH. Install it from https://www.openpolicyagent.org/docs/latest/#running-opa\nOr pre-compile your .rego files: opa build -t wasm -e visor -o bundle.tar.gz " + regoFiles.join(" ")
           );
         }
-        const hash = crypto5.createHash("sha256");
+        const hash = crypto6.createHash("sha256");
         for (const f of regoFiles.sort()) {
           hash.update(fs29.readFileSync(f));
           hash.update(f);
@@ -66220,6 +67065,29 @@ var init_client = __esm({
               data: void 0
             };
           }
+        },
+        delete: async ({ channel, ts }) => {
+          try {
+            const resp = await this.api("chat.delete", { channel, ts });
+            if (!resp || resp.ok !== true) {
+              const err = resp && resp.error || "unknown_error";
+              console.warn(
+                `Slack chat.delete failed (non-fatal): error=${err} channel=${channel} ts=${ts}`
+              );
+              return { ok: false, ts, error: err, data: resp };
+            }
+            return { ok: true, ts: resp.ts || ts, error: void 0, data: resp };
+          } catch (e) {
+            console.warn(
+              `Slack chat.delete threw (non-fatal): channel=${channel} ts=${ts} error=${e instanceof Error ? e.message : String(e)}`
+            );
+            return {
+              ok: false,
+              ts,
+              error: e instanceof Error ? e.message : String(e),
+              data: void 0
+            };
+          }
         }
       };
       async getBotUserId() {
@@ -66441,6 +67309,8 @@ var init_slack_frontend = __esm({
     init_client();
     init_markdown();
     init_lazy_otel();
+    init_task_live_updates();
+    init_logger();
     SlackFrontend = class {
       name = "slack";
       subs = [];
@@ -66649,7 +67519,16 @@ var init_slack_frontend = __esm({
           return false;
         }
       }
+      isLiveTaskUpdatesMode(ctx) {
+        try {
+          if (!this.getInboundSlackPayload(ctx)) return false;
+          return isFrontendLiveUpdatesEnabled(ctx.config?.task_live_updates, "slack");
+        } catch {
+          return false;
+        }
+      }
       async maybePostError(ctx, title, message, checkId) {
+        if (this.isLiveTaskUpdatesMode(ctx)) return;
         if (this.errorNotified) return;
         return this.postErrorToSlack(ctx, title, message, checkId);
       }
@@ -66658,6 +67537,7 @@ var init_slack_frontend = __esm({
        * Used for fatal/shutdown errors that must always reach the user.
        */
       async forcePostError(ctx, title, message, checkId) {
+        if (this.isLiveTaskUpdatesMode(ctx)) return;
         return this.postErrorToSlack(ctx, title, message, checkId);
       }
       async postErrorToSlack(ctx, title, message, checkId) {
@@ -66682,11 +67562,11 @@ Check: ${checkId}`;
         if (message) text += `
 ${message}`;
         if (this.isTelemetryEnabled(ctx)) {
-          const traceInfo = this.getTraceInfo() || this.cachedTraceInfo;
-          if (traceInfo?.traceId) {
+          const suffix = this.getExecutionReferenceSuffix();
+          if (suffix) {
             text += `
 
-\`trace_id: ${traceInfo.traceId}\``;
+${suffix}`;
           }
         }
         const formattedText = formatSlackText(text);
@@ -66720,6 +67600,7 @@ ${message}`;
       }
       async maybePostExecutionFailure(ctx, checkId, result) {
         try {
+          if (this.isLiveTaskUpdatesMode(ctx)) return;
           if (this.errorNotified) return;
           const cfg = ctx.config || {};
           const checkCfg = cfg.checks?.[checkId];
@@ -66810,6 +67691,7 @@ ${message}`;
        */
       async maybePostDirectReply(ctx, checkId, result) {
         try {
+          if (this.isLiveTaskUpdatesMode(ctx)) return;
           const cfg = ctx.config || {};
           const checkCfg = cfg.checks?.[checkId];
           if (!checkCfg) return;
@@ -66973,9 +67855,8 @@ ${errorMessages}`;
           let decoratedText = processedText;
           const telemetryEnabled = telemetryCfg === true || telemetryCfg && typeof telemetryCfg === "object" && telemetryCfg.enabled === true;
           if (telemetryEnabled) {
-            const traceInfo = this.getTraceInfo() || this.cachedTraceInfo;
-            if (traceInfo?.traceId) {
-              const suffix = `\`trace_id: ${traceInfo.traceId}\``;
+            const suffix = this.getExecutionReferenceSuffix();
+            if (suffix) {
               decoratedText = `${decoratedText}
 
 ${suffix}`;
@@ -67023,6 +67904,17 @@ ${suffix}`;
           return null;
         }
       }
+      getExecutionReferenceSuffix() {
+        try {
+          const taskId = logger.getCurrentTaskId();
+          if (taskId) return `\`task_id: ${taskId}\``;
+          const traceInfo = this.getTraceInfo() || this.cachedTraceInfo;
+          if (traceInfo?.traceId) return `\`trace_id: ${traceInfo.traceId}\``;
+          return null;
+        } catch {
+          return null;
+        }
+      }
     };
   }
 });
@@ -67535,6 +68427,44 @@ var init_client2 = __esm({
           return { ok: false, error: errMsg };
         }
       }
+      /**
+       * Edit an existing text message.
+       * Returns ok=false if Telegram rejects the edit (e.g. message too old or unchanged).
+       */
+      async editMessageText(opts) {
+        try {
+          const params = {
+            link_preview_options: { is_disabled: true }
+          };
+          if (opts.parse_mode) params.parse_mode = opts.parse_mode;
+          const msg = await this.bot.api.editMessageText(
+            opts.chat_id,
+            opts.message_id,
+            opts.text,
+            params
+          );
+          const messageId = msg?.message_id || opts.message_id;
+          return { ok: true, message_id: messageId };
+        } catch (err) {
+          const errMsg = err?.description || err?.message || String(err);
+          console.warn(`Telegram editMessageText failed (non-fatal): ${errMsg}`);
+          return { ok: false, error: errMsg };
+        }
+      }
+      /**
+       * Delete a message.
+       */
+      async deleteMessage(opts) {
+        try {
+          await this.bot.api.deleteMessage(opts.chat_id, opts.message_id);
+          return true;
+        } catch (err) {
+          console.warn(
+            `Telegram deleteMessage failed (non-fatal): ${err?.description || err?.message || String(err)}`
+          );
+          return false;
+        }
+      }
       /**
        * Send a document/file.
        */
@@ -67595,6 +68525,7 @@ var init_telegram_frontend = __esm({
     "use strict";
     init_client2();
     init_markdown2();
+    init_task_live_updates();
     TelegramFrontend = class {
       name = "telegram";
       subs = [];
@@ -67777,6 +68708,7 @@ ${message}`;
           const isWorkflow = providerType === "workflow";
           if (!isAi && !isLogChat && !isWorkflow) return;
           if (checkCfg.criticality === "internal") return;
+          if (isFrontendLiveUpdatesEnabled(cfg.task_live_updates, "telegram")) return;
           if (isAi) {
             const schema = checkCfg.schema;
             if (typeof schema === "string") {
@@ -75797,11 +76729,11 @@ var require_dist2 = __commonJS({
 });
 
 // src/email/client.ts
-var import_crypto7, EmailClient;
+var import_crypto8, EmailClient;
 var init_client3 = __esm({
   "src/email/client.ts"() {
     "use strict";
-    import_crypto7 = require("crypto");
+    import_crypto8 = require("crypto");
     EmailClient = class {
       receiveBackend;
       sendBackend;
@@ -75906,7 +76838,7 @@ var init_client3 = __esm({
           const messages = [];
           for await (const msg of this.imapClient.fetch({ seen: false }, { source: true, uid: true })) {
             const parsed = await simpleParser(msg.source);
-            const messageId = parsed.messageId || `<${(0, import_crypto7.randomUUID)()}@visor>`;
+            const messageId = parsed.messageId || `<${(0, import_crypto8.randomUUID)()}@visor>`;
             const inReplyTo = typeof parsed.inReplyTo === "string" ? parsed.inReplyTo : void 0;
             const references = parsed.references ? Array.isArray(parsed.references) ? parsed.references : [parsed.references] : void 0;
             messages.push({
@@ -76047,7 +76979,7 @@ var init_client3 = __esm({
       // ─── Send ───
       /** Send an email via configured backend (SMTP or Resend) */
       async sendEmail(opts) {
-        const messageId = opts.messageId || `<${(0, import_crypto7.randomUUID)()}@visor>`;
+        const messageId = opts.messageId || `<${(0, import_crypto8.randomUUID)()}@visor>`;
         if (this.sendBackend === "resend") {
           return this.sendViaResend(opts, messageId);
         }
@@ -76130,7 +77062,7 @@ var init_client3 = __esm({
       }
       /** Generate a deterministic thread ID from a Message-ID chain */
       static deriveThreadId(rootMessageId) {
-        return (0, import_crypto7.createHash)("sha256").update(rootMessageId).digest("hex").slice(0, 16);
+        return (0, import_crypto8.createHash)("sha256").update(rootMessageId).digest("hex").slice(0, 16);
       }
     };
   }
@@ -76624,11 +77556,11 @@ var init_markdown4 = __esm({
 });
 
 // src/whatsapp/client.ts
-var import_crypto8, WhatsAppClient;
+var import_crypto9, WhatsAppClient;
 var init_client4 = __esm({
   "src/whatsapp/client.ts"() {
     "use strict";
-    import_crypto8 = require("crypto");
+    import_crypto9 = require("crypto");
     init_markdown4();
     WhatsAppClient = class {
       accessToken;
@@ -76734,7 +77666,7 @@ var init_client4 = __esm({
       verifyWebhookSignature(rawBody, signatureHeader) {
         if (!this.appSecret) return true;
         if (!signatureHeader) return false;
-        const expected = "sha256=" + (0, import_crypto8.createHmac)("sha256", this.appSecret).update(rawBody).digest("hex");
+        const expected = "sha256=" + (0, import_crypto9.createHmac)("sha256", this.appSecret).update(rawBody).digest("hex");
         return signatureHeader === expected;
       }
       /**
@@ -77032,6 +77964,50 @@ var init_client5 = __esm({
         }
         return { ok: true, activityId: lastActivityId };
       }
+      /**
+       * Update an existing bot message.
+       * For safety, only supports single-activity payloads. Oversized content returns msg_too_long.
+       */
+      async updateMessage(opts) {
+        const chunks = chunkText3(opts.text, 28e3);
+        if (chunks.length > 1) {
+          return { ok: false, error: "msg_too_long" };
+        }
+        try {
+          await this.adapter.continueConversationAsync(
+            this.appId,
+            opts.conversationReference,
+            async (turnContext) => {
+              const activity = import_botbuilder.MessageFactory.text(chunks[0] || "");
+              activity.id = opts.activityId;
+              await turnContext.updateActivity(activity);
+            }
+          );
+          return { ok: true, activityId: opts.activityId };
+        } catch (err) {
+          return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      }
+      /**
+       * Delete a previously sent bot message.
+       */
+      async deleteMessage(opts) {
+        try {
+          await this.adapter.continueConversationAsync(
+            this.appId,
+            opts.conversationReference,
+            async (turnContext) => {
+              await turnContext.deleteActivity(opts.activityId);
+            }
+          );
+          return true;
+        } catch {
+          return false;
+        }
+      }
     };
   }
 });
@@ -77047,6 +78023,7 @@ var init_teams_frontend = __esm({
     "use strict";
     init_client5();
     init_markdown5();
+    init_task_live_updates();
     TeamsFrontend = class {
       name = "teams";
       subs = [];
@@ -77145,6 +78122,7 @@ ${message}`;
           const isWorkflow = providerType === "workflow";
           if (!isAi && !isLogChat && !isWorkflow) return;
           if (checkCfg.criticality === "internal") return;
+          if (isFrontendLiveUpdatesEnabled(cfg.task_live_updates, "teams")) return;
           if (isAi) {
             const schema = checkCfg.schema;
             if (typeof schema === "string") {
@@ -77238,13 +78216,13 @@ function taskRowToAgentTask(row) {
     workflow_id: row.workflow_id ?? void 0
   };
 }
-var import_path16, import_fs13, import_crypto9, SqliteTaskStore;
+var import_path16, import_fs13, import_crypto10, SqliteTaskStore;
 var init_task_store = __esm({
   "src/agent-protocol/task-store.ts"() {
     "use strict";
     import_path16 = __toESM(require("path"));
     import_fs13 = __toESM(require("fs"));
-    import_crypto9 = __toESM(require("crypto"));
+    import_crypto10 = __toESM(require("crypto"));
     init_logger();
     init_types();
     init_state_transitions();
@@ -77325,7 +78303,7 @@ var init_task_store = __esm({
       // -------------------------------------------------------------------------
       createTask(params) {
         const db = this.getDb();
-        const id = import_crypto9.default.randomUUID();
+        const id = import_crypto10.default.randomUUID();
         const now = nowISO();
         const contextId = this.resolveContextId(params.requestMessage, params.contextId);
         const expiresAt = params.expiresAt ?? null;
@@ -77577,7 +78555,7 @@ var init_task_store = __esm({
         const now = nowISO();
         const msg = reason || "Process terminated while task was running";
         const statusMessage = JSON.stringify({
-          message_id: import_crypto9.default.randomUUID(),
+          message_id: import_crypto10.default.randomUUID(),
           role: "agent",
           parts: [{ text: msg }]
         });
@@ -77602,7 +78580,7 @@ var init_task_store = __esm({
         const cutoff = new Date(Date.now() - olderThanMs).toISOString();
         const msg = reason || "Task exceeded maximum working duration";
         const statusMessage = JSON.stringify({
-          message_id: import_crypto9.default.randomUUID(),
+          message_id: import_crypto10.default.randomUUID(),
           role: "agent",
           parts: [{ text: msg }]
         });
@@ -77771,11 +78749,11 @@ var init_task_stream_manager = __esm({
 });
 
 // src/agent-protocol/push-notification-manager.ts
-var import_crypto10, PushNotificationManager;
+var import_crypto11, PushNotificationManager;
 var init_push_notification_manager = __esm({
   "src/agent-protocol/push-notification-manager.ts"() {
     "use strict";
-    import_crypto10 = __toESM(require("crypto"));
+    import_crypto11 = __toESM(require("crypto"));
     init_logger();
     PushNotificationManager = class {
       db = null;
@@ -77820,7 +78798,7 @@ var init_push_notification_manager = __esm({
       // -------------------------------------------------------------------------
       create(config) {
         const db = this.getDb();
-        const id = config.id ?? import_crypto10.default.randomUUID();
+        const id = config.id ?? import_crypto11.default.randomUUID();
         const now = (/* @__PURE__ */ new Date()).toISOString();
         db.prepare(
           `INSERT INTO agent_push_configs (id, task_id, url, token, auth_scheme, auth_credentials, created_at)
@@ -77918,11 +78896,11 @@ var init_push_notification_manager = __esm({
 });
 
 // src/agent-protocol/task-queue.ts
-var import_crypto11, DEFAULT_CONFIG, TaskQueue;
+var import_crypto12, DEFAULT_CONFIG, TaskQueue;
 var init_task_queue = __esm({
   "src/agent-protocol/task-queue.ts"() {
     "use strict";
-    import_crypto11 = __toESM(require("crypto"));
+    import_crypto12 = __toESM(require("crypto"));
     init_logger();
     init_trace_helpers();
     DEFAULT_CONFIG = {
@@ -77935,7 +78913,7 @@ var init_task_queue = __esm({
         this.taskStore = taskStore;
         this.executor = executor;
         this.config = { ...DEFAULT_CONFIG, ...config };
-        this.workerId = workerId ?? import_crypto11.default.randomUUID();
+        this.workerId = workerId ?? import_crypto12.default.randomUUID();
       }
       running = false;
       timer = null;
@@ -78009,7 +78987,7 @@ var init_task_queue = __esm({
           }
           if (result.success) {
             const completedMsg = {
-              message_id: import_crypto11.default.randomUUID(),
+              message_id: import_crypto12.default.randomUUID(),
               role: "agent",
               parts: [
                 {
@@ -78021,7 +78999,7 @@ var init_task_queue = __esm({
             this.taskStore.updateTaskState(task.id, "completed", completedMsg);
           } else {
             this.taskStore.updateTaskState(task.id, "failed", {
-              message_id: import_crypto11.default.randomUUID(),
+              message_id: import_crypto12.default.randomUUID(),
               role: "agent",
               parts: [{ text: result.error ?? "Task execution failed" }]
             });
@@ -78032,7 +79010,7 @@ var init_task_queue = __esm({
           );
           try {
             this.taskStore.updateTaskState(task.id, "failed", {
-              message_id: import_crypto11.default.randomUUID(),
+              message_id: import_crypto12.default.randomUUID(),
               role: "agent",
               parts: [{ text: err instanceof Error ? err.message : "Unknown error" }]
             });
@@ -78086,7 +79064,7 @@ function timingSafeEqual(a, b) {
   if (!a || !b) return false;
   if (a.length !== b.length) return false;
   try {
-    return import_crypto12.default.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+    return import_crypto13.default.timingSafeEqual(Buffer.from(a), Buffer.from(b));
   } catch {
     return false;
   }
@@ -78160,7 +79138,7 @@ function resultToArtifacts(checkResults) {
     }
     if (parts.length > 0) {
       artifacts.push({
-        artifact_id: import_crypto12.default.randomUUID(),
+        artifact_id: import_crypto13.default.randomUUID(),
         name: checkId,
         description: `Output from check: ${checkId}`,
         parts
@@ -78169,14 +79147,14 @@ function resultToArtifacts(checkResults) {
   }
   return artifacts;
 }
-var import_http2, import_https, import_fs14, import_crypto12, A2AFrontend;
+var import_http2, import_https, import_fs14, import_crypto13, A2AFrontend;
 var init_a2a_frontend = __esm({
   "src/agent-protocol/a2a-frontend.ts"() {
     "use strict";
     import_http2 = __toESM(require("http"));
     import_https = __toESM(require("https"));
     import_fs14 = __toESM(require("fs"));
-    import_crypto12 = __toESM(require("crypto"));
+    import_crypto13 = __toESM(require("crypto"));
     init_logger();
     init_task_store();
     init_types();
@@ -78270,7 +79248,7 @@ var init_a2a_frontend = __esm({
           if (!taskId) return;
           try {
             const statusMessage = {
-              message_id: import_crypto12.default.randomUUID(),
+              message_id: import_crypto13.default.randomUUID(),
               role: "agent",
               parts: [{ text: envelope.payload?.prompt ?? "Agent requires input" }]
             };
@@ -78476,7 +79454,7 @@ var init_a2a_frontend = __esm({
           const response = await this.handleFollowUpMessage(existingTaskId, body);
           return sendJson(res, 200, response);
         }
-        const contextId = body.message.context_id ?? import_crypto12.default.randomUUID();
+        const contextId = body.message.context_id ?? import_crypto13.default.randomUUID();
         const workflowId = resolveWorkflow(body, this.config);
         const blocking = body.configuration?.blocking ?? false;
         await withActiveSpan(
@@ -78589,7 +79567,7 @@ var init_a2a_frontend = __esm({
         if (!body.message?.parts?.length) {
           throw new InvalidRequestError("Message must contain at least one part");
         }
-        const contextId = body.message.context_id ?? import_crypto12.default.randomUUID();
+        const contextId = body.message.context_id ?? import_crypto13.default.randomUUID();
         const workflowId = resolveWorkflow(body, this.config);
         const task = this.taskStore.createTask({
           contextId,
@@ -78723,7 +79701,7 @@ var init_a2a_frontend = __esm({
             await this.executeTaskViaEngine(task, message);
           } else {
             const agentResponse = {
-              message_id: import_crypto12.default.randomUUID(),
+              message_id: import_crypto13.default.randomUUID(),
               role: "agent",
               parts: [{ text: `Task ${task.id} received and processed.`, media_type: "text/markdown" }]
             };
@@ -78735,7 +79713,7 @@ var init_a2a_frontend = __esm({
           logger.error(`[A2A] Task ${task.id} execution failed: ${errorMsg}`);
           try {
             const failMessage = {
-              message_id: import_crypto12.default.randomUUID(),
+              message_id: import_crypto13.default.randomUUID(),
               role: "agent",
               parts: [{ text: errorMsg }]
             };
@@ -78778,7 +79756,7 @@ ${issueText}`, media_type: "text/markdown" });
           }
           if (summaryParts.length > 0) {
             artifacts.push({
-              artifact_id: import_crypto12.default.randomUUID(),
+              artifact_id: import_crypto13.default.randomUUID(),
               name: "review-summary",
               description: "Review summary with issues found",
               parts: summaryParts
@@ -78798,7 +79776,7 @@ ${issueText}`, media_type: "text/markdown" });
               }
               if (parts.length > 0) {
                 artifacts.push({
-                  artifact_id: import_crypto12.default.randomUUID(),
+                  artifact_id: import_crypto13.default.randomUUID(),
                   name: cr.checkName ?? groupName,
                   description: `Output from check: ${cr.checkName ?? groupName}`,
                   parts
@@ -78809,7 +79787,7 @@ ${issueText}`, media_type: "text/markdown" });
         }
         if (artifacts.length === 0) {
           artifacts.push({
-            artifact_id: import_crypto12.default.randomUUID(),
+            artifact_id: import_crypto13.default.randomUUID(),
             name: "result",
             description: "Execution result",
             parts: [
@@ -78831,7 +79809,7 @@ ${issueText}`, media_type: "text/markdown" });
           );
         }
         const agentResponse = {
-          message_id: import_crypto12.default.randomUUID(),
+          message_id: import_crypto13.default.randomUUID(),
           role: "agent",
           parts: [
             {
@@ -78884,7 +79862,7 @@ ${issueText}`, media_type: "text/markdown" });
         }
         if (parts.length === 0) return null;
         return {
-          artifact_id: import_crypto12.default.randomUUID(),
+          artifact_id: import_crypto13.default.randomUUID(),
           name: p.checkId ?? "check-result",
           parts
         };