@probelabs/visor 0.1.186 → 0.1.187

package/dist/sdk/{chunk-IY5PQ5EN.mjs → chunk-BVEATT5V.mjs}

@@ -18,7 +18,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() {
@@ -179,6 +180,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) {
@@ -254,9 +309,29 @@ async function fetchFromLocalFiles(traceRef, cfg) {
   const traceFile = isTraceFilePath(traceRef) ? traceRef : await findTraceFile(traceRef, cfg.traceDir);
   if (!traceFile) return null;
   try {
-    const { parseNDJSONTrace } = await import("./trace-reader-OVE4DL2D.mjs");
-    const trace = await parseNDJSONTrace(traceFile);
-    return parseLocalNDJSONSpans(trace.spans);
+    const targetTraceId = cfg.targetTraceId || (!isTraceFilePath(traceRef) ? traceRef : await readTraceIdFromFile(traceFile) || void 0);
+    const rawSpans = [];
+    const rl = readline.createInterface({
+      input: fs.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;
@@ -286,10 +361,22 @@ async function findTraceFile(traceId, traceDir) {
   for (const file of files) {
     const filePath = path.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: fs.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 {
     }
   }
@@ -318,25 +405,6 @@ async function readTraceIdFromFile(traceFile) {
   }
   return null;
 }
-async function readFirstLine(filePath) {
-  return new Promise((resolve, reject) => {
-    const stream = fs.createReadStream(filePath, { encoding: "utf-8" });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    let resolved = false;
-    rl.on("line", (line) => {
-      if (!resolved) {
-        resolved = true;
-        rl.close();
-        stream.destroy();
-        resolve(line.trim() || null);
-      }
-    });
-    rl.on("close", () => {
-      if (!resolved) resolve(null);
-    });
-    rl.on("error", reject);
-  });
-}
 function isNoiseSpan(span) {
   return NOISE_SPAN_NAMES.has(span.name);
 }
@@ -494,6 +562,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;
@@ -520,28 +1036,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)";
   }
@@ -555,6 +1050,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;
@@ -682,6 +1272,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;
@@ -695,10 +1298,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}`
     );
@@ -892,6 +1497,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 ? ":" : ""}`);
@@ -1171,9 +1856,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") {
@@ -1358,6 +2045,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) {
@@ -1693,7 +2446,7 @@ function truncate(str, max) {
   if (head < 10) return str.slice(0, max - 3) + "...";
   return str.slice(0, head) + " ...[truncated]... " + str.slice(-tail);
 }
-var NOISE_SPAN_NAMES, WRAPPER_SPAN_NAMES;
+var 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"() {
     init_logger();
@@ -1708,17 +2461,35 @@ 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"]);
   }
 });
 
 export {
   fetchTraceSpans,
+  resolveTraceSpans,
   findTraceFile,
   readTraceIdFromFile,
   serializeTraceForPrompt,
+  buildTraceHeaderLines,
+  buildTraceReport,
+  extractProbeTaskSummary,
   renderSpanTree,
   renderTraceTree,
   renderSpanYaml,
   init_trace_serializer
 };
-//# sourceMappingURL=chunk-IY5PQ5EN.mjs.map
+//# sourceMappingURL=chunk-BVEATT5V.mjs.map