@probelabs/visor 0.1.181 → 0.1.182

package/dist/sdk/task-evaluator-HLNXKKVV.mjs

@@ -0,0 +1,1278 @@
+import {
+  init_logger,
+  logger
+} from "./chunk-FT3I25QV.mjs";
+import "./chunk-UCMJJ3IM.mjs";
+import {
+  __esm,
+  __require
+} from "./chunk-J7LXIPZS.mjs";
+
+// src/agent-protocol/trace-serializer.ts
+import * as fs from "fs";
+import * as readline from "readline";
+import * as path from "path";
+function resolveBackendConfig(overrides) {
+  const explicit = process.env.VISOR_TRACE_BACKEND;
+  return {
+    type: overrides?.type || explicit || "auto",
+    grafanaUrl: overrides?.grafanaUrl || process.env.GRAFANA_URL,
+    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
+  };
+}
+function parseOTLPResponse(data) {
+  const spans = [];
+  if (data.batches) {
+    for (const batch of data.batches) {
+      for (const ss of batch.scopeSpans || []) {
+        for (const s of ss.spans || []) {
+          spans.push(normalizeOTLPSpan(s));
+        }
+      }
+    }
+    return spans;
+  }
+  if (data.data && Array.isArray(data.data)) {
+    for (const trace of data.data) {
+      for (const s of trace.spans || []) {
+        spans.push(normalizeJaegerSpan(s, trace.traceID));
+      }
+    }
+    return spans;
+  }
+  return spans;
+}
+function normalizeOTLPSpan(s) {
+  const startNs = parseInt(s.startTimeUnixNano || "0", 10);
+  const endNs = parseInt(s.endTimeUnixNano || "0", 10);
+  const traceId = decodeOTLPId(s.traceId);
+  const spanId = decodeOTLPId(s.spanId);
+  const parentSpanId = s.parentSpanId ? decodeOTLPId(s.parentSpanId) : void 0;
+  const attributes = {};
+  for (const attr of s.attributes || []) {
+    const val = attr.value;
+    if (val.stringValue !== void 0) attributes[attr.key] = val.stringValue;
+    else if (val.intValue !== void 0) attributes[attr.key] = parseInt(val.intValue, 10);
+    else if (val.boolValue !== void 0) attributes[attr.key] = val.boolValue;
+    else if (val.doubleValue !== void 0) attributes[attr.key] = val.doubleValue;
+  }
+  const events = [];
+  for (const evt of s.events || []) {
+    const evtAttrs = {};
+    for (const a of evt.attributes || []) {
+      const v = a.value;
+      if (v.stringValue !== void 0) evtAttrs[a.key] = v.stringValue;
+      else if (v.intValue !== void 0) evtAttrs[a.key] = parseInt(v.intValue, 10);
+    }
+    events.push({ name: evt.name, attributes: evtAttrs });
+  }
+  return {
+    traceId,
+    spanId,
+    parentSpanId,
+    name: s.name || "unknown",
+    startTimeMs: startNs / 1e6,
+    endTimeMs: endNs / 1e6,
+    durationMs: (endNs - startNs) / 1e6,
+    attributes,
+    events,
+    status: s.status?.code === 2 ? "error" : "ok"
+  };
+}
+function normalizeJaegerSpan(s, traceId) {
+  const attributes = {};
+  for (const tag of s.tags || []) {
+    attributes[tag.key] = tag.value;
+  }
+  const events = [];
+  for (const log of s.logs || []) {
+    const evtAttrs = {};
+    for (const f of log.fields || []) evtAttrs[f.key] = f.value;
+    events.push({ name: evtAttrs["event"] || "log", attributes: evtAttrs });
+  }
+  const startUs = s.startTime || 0;
+  const durationUs = s.duration || 0;
+  return {
+    traceId,
+    spanId: s.spanID,
+    parentSpanId: s.references?.find((r) => r.refType === "CHILD_OF")?.spanID,
+    name: s.operationName || "unknown",
+    startTimeMs: startUs / 1e3,
+    endTimeMs: (startUs + durationUs) / 1e3,
+    durationMs: durationUs / 1e3,
+    attributes,
+    events,
+    status: attributes["otel.status_code"] === "ERROR" || attributes["error"] === true ? "error" : "ok"
+  };
+}
+function decodeOTLPId(id) {
+  if (!id) return "";
+  if (/^[0-9a-f]+$/i.test(id)) return id.toLowerCase();
+  try {
+    return Buffer.from(id, "base64").toString("hex");
+  } catch {
+    return id;
+  }
+}
+function parseLocalNDJSONSpans(spans) {
+  return spans.map((s) => {
+    const startMs = timeValueToMs(s.startTime || [0, 0]);
+    const endMs = timeValueToMs(s.endTime || s.startTime || [0, 0]);
+    const events = (s.events || []).map((e) => ({
+      name: e.name,
+      attributes: e.attributes || {}
+    }));
+    return {
+      traceId: s.traceId || "",
+      spanId: s.spanId || "",
+      parentSpanId: s.parentSpanId || void 0,
+      name: s.name || "unknown",
+      startTimeMs: startMs,
+      endTimeMs: endMs,
+      durationMs: endMs - startMs,
+      attributes: s.attributes || {},
+      events,
+      status: s.status?.code === 2 ? "error" : "ok"
+    };
+  });
+}
+function timeValueToMs(tv) {
+  return tv[0] * 1e3 + tv[1] / 1e6;
+}
+async function fetchTraceSpans(traceId, config) {
+  const cfg = resolveBackendConfig(config);
+  const tryGrafana = cfg.type === "grafana" || cfg.type === "auto";
+  const tryJaeger = cfg.type === "jaeger" || cfg.type === "auto";
+  const tryFile = cfg.type === "file" || cfg.type === "auto";
+  if (tryGrafana) {
+    const spans = await fetchFromGrafanaTempo(traceId, cfg);
+    if (spans && spans.length > 0) return spans;
+  }
+  if (tryJaeger) {
+    const spans = await fetchFromJaeger(traceId, cfg);
+    if (spans && spans.length > 0) return spans;
+  }
+  if (tryFile) {
+    const spans = await fetchFromLocalFiles(traceId, cfg);
+    if (spans && spans.length > 0) return spans;
+  }
+  return [];
+}
+async function fetchFromGrafanaTempo(traceId, cfg) {
+  let grafanaUrl = cfg.grafanaUrl;
+  if (!grafanaUrl) {
+    const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    if (otlpEndpoint) {
+      const url = new URL(otlpEndpoint);
+      const host = url.hostname;
+      for (const port of ["3000", "8001", "80"]) {
+        try {
+          const testUrl = `http://${host}:${port}/api/health`;
+          const resp = await httpGet(testUrl, cfg.authToken, 2e3);
+          if (resp && resp.includes('"database"')) {
+            grafanaUrl = `http://${host}:${port}`;
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  if (!grafanaUrl) return null;
+  try {
+    let dsId = cfg.grafanaDatasourceId;
+    if (!dsId) {
+      const dsResp = await httpGet(`${grafanaUrl}/api/datasources`, cfg.authToken);
+      if (dsResp) {
+        const datasources = JSON.parse(dsResp);
+        const tempo = datasources.find((d) => d.type === "tempo");
+        if (tempo) dsId = tempo.id;
+      }
+    }
+    if (!dsId) return null;
+    const traceUrl = `${grafanaUrl}/api/datasources/proxy/${dsId}/api/traces/${traceId}`;
+    const resp = await httpGet(traceUrl, cfg.authToken);
+    if (!resp) return null;
+    const data = JSON.parse(resp);
+    return parseOTLPResponse(data);
+  } catch (err) {
+    logger.debug(`[TraceSerializer] Grafana Tempo fetch failed: ${err}`);
+    return null;
+  }
+}
+async function fetchFromJaeger(traceId, cfg) {
+  let jaegerUrl = cfg.jaegerUrl;
+  if (!jaegerUrl) {
+    const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    const host = otlpEndpoint ? new URL(otlpEndpoint).hostname : "localhost";
+    for (const port of ["16686"]) {
+      try {
+        const testUrl = `http://${host}:${port}/api/services`;
+        const resp = await httpGet(testUrl, void 0, 2e3);
+        if (resp && resp.includes('"data"')) {
+          jaegerUrl = `http://${host}:${port}`;
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!jaegerUrl) return null;
+  try {
+    const traceUrl = `${jaegerUrl}/api/traces/${traceId}`;
+    const resp = await httpGet(traceUrl, cfg.authToken);
+    if (!resp) return null;
+    const data = JSON.parse(resp);
+    return parseOTLPResponse(data);
+  } catch (err) {
+    logger.debug(`[TraceSerializer] Jaeger fetch failed: ${err}`);
+    return null;
+  }
+}
+async function fetchFromLocalFiles(traceId, cfg) {
+  const traceFile = await findTraceFile(traceId, cfg.traceDir);
+  if (!traceFile) return null;
+  try {
+    const { parseNDJSONTrace } = await import("./trace-reader-ZY77OFNM.mjs");
+    const trace = await parseNDJSONTrace(traceFile);
+    return parseLocalNDJSONSpans(trace.spans);
+  } catch (err) {
+    logger.debug(`[TraceSerializer] Local file parse failed: ${err}`);
+    return null;
+  }
+}
+async function httpGet(url, authToken, timeoutMs) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs || 1e4);
+    const headers = {};
+    if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+    const resp = await fetch(url, {
+      signal: controller.signal,
+      headers
+    });
+    clearTimeout(timeout);
+    if (!resp.ok) return null;
+    return await resp.text();
+  } catch {
+    return null;
+  }
+}
+async function findTraceFile(traceId, traceDir) {
+  const dir = traceDir || process.env.VISOR_TRACE_DIR || "output/traces";
+  if (!fs.existsSync(dir)) return null;
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".ndjson"));
+  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;
+    } catch {
+    }
+  }
+  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);
+}
+function isWrapperSpan(span) {
+  return WRAPPER_SPAN_NAMES.has(span.name);
+}
+function buildSpanTree(spans) {
+  const filtered = spans.filter((s) => !isNoiseSpan(s));
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const span of filtered) {
+    nodeMap.set(span.spanId, { span, children: [] });
+  }
+  let root;
+  for (const span of filtered) {
+    const node = nodeMap.get(span.spanId);
+    if (!span.parentSpanId) {
+      root = node;
+    } else {
+      let parentId = span.parentSpanId;
+      while (parentId && !nodeMap.has(parentId)) {
+        const parentSpan = spans.find((s) => s.spanId === parentId);
+        parentId = parentSpan?.parentSpanId;
+      }
+      if (parentId) {
+        const parent = nodeMap.get(parentId);
+        if (parent) parent.children.push(node);
+      } else if (!root) {
+        root = node;
+      }
+    }
+  }
+  if (!root) {
+    const sorted = [...nodeMap.values()].sort((a, b) => b.span.durationMs - a.span.durationMs);
+    root = sorted[0] || { span: filtered[0], children: [] };
+  }
+  const sortChildren = (node) => {
+    node.children.sort((a, b) => a.span.startTimeMs - b.span.startTimeMs);
+    node.children.forEach(sortChildren);
+  };
+  sortChildren(root);
+  const unwrap = (node) => {
+    node.children = node.children.map(unwrap);
+    const newChildren = [];
+    for (const child of node.children) {
+      if (isWrapperSpan(child.span)) {
+        newChildren.push(...child.children);
+      } else {
+        newChildren.push(child);
+      }
+    }
+    node.children = newChildren;
+    return node;
+  };
+  unwrap(root);
+  const removeDelegateEchos = (node) => {
+    const hasDelegateChild = node.children.some((c) => c.span.name === "search.delegate");
+    if (hasDelegateChild) {
+      node.children = node.children.filter((c) => {
+        if (c.span.name !== "probe.event.tool.result") return true;
+        const toolName = c.span.attributes["tool.name"];
+        return toolName !== "search";
+      });
+    }
+    node.children.forEach(removeDelegateEchos);
+  };
+  removeDelegateEchos(root);
+  return root;
+}
+function dedupeKey(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 100).toLowerCase();
+}
+function dedupeOrRegister(ctx, kind, text, spanName) {
+  if (!text || text.length < 20) return null;
+  const key = dedupeKey(text);
+  if (!key) return null;
+  const map = ctx[kind];
+  const existing = map.get(key);
+  if (existing && existing !== spanName) {
+    return existing;
+  }
+  const otherMap = kind === "outputs" ? ctx.intents : ctx.outputs;
+  const crossRef = otherMap.get(key);
+  if (crossRef && crossRef !== spanName) {
+    map.set(key, spanName);
+    return crossRef;
+  }
+  map.set(key, spanName);
+  return null;
+}
+async function serializeTraceForPrompt(traceIdOrPath, maxChars, backendConfig, taskResponse) {
+  let spans;
+  if (traceIdOrPath.includes("/") || traceIdOrPath.endsWith(".ndjson")) {
+    const { parseNDJSONTrace } = await import("./trace-reader-ZY77OFNM.mjs");
+    const trace = await parseNDJSONTrace(traceIdOrPath);
+    spans = parseLocalNDJSONSpans(trace.spans);
+  } else {
+    spans = await fetchTraceSpans(traceIdOrPath, backendConfig);
+  }
+  if (spans.length === 0) {
+    return "(no trace data available)";
+  }
+  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 renderSpanYaml(tree, allSpans, opts) {
+  const fullOutput = opts?.fullOutput ?? false;
+  const maxLen = fullOutput ? 1e5 : 120;
+  const dedup = { outputs: /* @__PURE__ */ new Map(), intents: /* @__PURE__ */ new Map() };
+  const lines = [];
+  renderYamlNode(tree, 0, lines, dedup, opts?.fallbackIntent, fullOutput, maxLen);
+  if (opts?.taskResponse) {
+    while (lines.length > 0 && /^\s*output:\s*=\s*\S+/.test(lines[lines.length - 1])) {
+      lines.pop();
+    }
+    const ml = fullOutput ? 1e5 : 500;
+    const text = opts.taskResponse.replace(/\*\*/g, "").replace(/`/g, "").trim();
+    if (fullOutput) {
+      lines.push("  response: |");
+      for (const line of text.split("\n")) {
+        lines.push(`    ${line}`);
+      }
+    } else {
+      const truncated = truncate(text.replace(/\n/g, " "), ml);
+      lines.push(`  response: ${truncated}`);
+      if (text.length > ml) {
+        lines.push("  # use --full for complete response");
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderYamlNode(node, indent, lines, dedup, fallbackIntent, fullOutput, maxLen, parentSpan) {
+  const pad = "  ".repeat(indent);
+  const attrs = node.span.attributes;
+  const duration = formatDurationMs(node.span.durationMs);
+  const name = node.span.name;
+  const ml = maxLen ?? 120;
+  const parentCheckId = parentSpan?.attributes["visor.check.id"];
+  const parentCheckName = parentCheckId ? String(parentCheckId).replace(/^visor\.check\./, "") : void 0;
+  const displayName = name === "ai.request" && parentCheckName ? parentCheckName : String(attrs["visor.check.id"] || name).replace(/^visor\.check\./, "");
+  const toolName = attrs["tool.name"] || attrs["visor.tool.name"];
+  if (toolName) {
+    const toolInput = extractToolInput(String(toolName), attrs);
+    const toolResultLen = attrs["tool.result.length"] || attrs["tool.result.count"];
+    const tn = String(toolName);
+    const isSearchTool = tn === "search" || tn === "searchCode" || tn === "search_code";
+    const numLen = toolResultLen ? Number(toolResultLen) : -1;
+    const noResults = isSearchTool && numLen >= 0 && numLen < 500;
+    const resultSize = noResults ? " \u2192 no results" : toolResultLen ? ` \u2192 ${formatSize(numLen)}` : "";
+    const successMark = attrs["tool.success"] === false ? " \u2717" : "";
+    lines.push(`${pad}- ${tn}(${toolInput})${resultSize}${successMark}`);
+    return;
+  }
+  if (name === "search.delegate") {
+    const query = attrs["search.query"] || "";
+    lines.push(`${pad}search.delegate("${truncate(String(query), 80)}") \u2014 ${duration}:`);
+    for (const child of node.children) {
+      renderYamlNode(
+        child,
+        indent + 1,
+        lines,
+        dedup,
+        fallbackIntent,
+        fullOutput,
+        maxLen,
+        node.span
+      );
+    }
+    return;
+  }
+  if (name === "ai.request") {
+    const model = attrs["ai.model"] || attrs["gen_ai.request.model"] || "?";
+    const tokensIn = attrs["ai.input_length"] || attrs["gen_ai.usage.input_tokens"] || "";
+    const tokensOut = attrs["gen_ai.usage.output_tokens"] || "";
+    const tokenParts = [];
+    if (tokensIn) tokenParts.push(`${tokensIn} in`);
+    if (tokensOut) tokenParts.push(`${tokensOut} out`);
+    const tokenStr = tokenParts.length > 0 ? ` \u2014 ${tokenParts.join(", ")}` : "";
+    const hasChildren2 = node.children.length > 0;
+    lines.push(`${pad}ai: ${model} \u2014 ${duration}${tokenStr}${hasChildren2 ? ":" : ""}`);
+    const aiInput = String(attrs["ai.input"] || "");
+    let intent = extractAIIntent(aiInput, ml);
+    if (!intent && parentSpan) {
+      const promptPreview = String(
+        parentSpan.attributes["visor.provider.request.prompt.preview"] || ""
+      );
+      if (promptPreview) intent = extractAIIntent(promptPreview, ml);
+      if (!intent) {
+        const inputOutputs = String(parentSpan.attributes["visor.check.input.outputs"] || "");
+        if (inputOutputs) {
+          try {
+            const o = JSON.parse(inputOutputs);
+            const t = o["route-intent"]?.topic;
+            if (t) intent = truncate(String(t), ml);
+          } catch {
+          }
+        }
+      }
+    }
+    if (!intent && fallbackIntent && parentSpan?.name !== "search.delegate") {
+      intent = fallbackIntent;
+    }
+    if (intent) {
+      const intentRef = dedupeOrRegister(dedup, "intents", intent, displayName);
+      if (intentRef) {
+        lines.push(`${pad}  intent: = ${intentRef}`);
+      } else {
+        lines.push(`${pad}  intent: ${intent}`);
+      }
+    }
+    for (const child of node.children) {
+      renderYamlNode(
+        child,
+        indent + 1,
+        lines,
+        dedup,
+        fallbackIntent,
+        fullOutput,
+        maxLen,
+        node.span
+      );
+    }
+    if (parentSpan) {
+      const checkOutput = String(parentSpan.attributes["visor.check.output"] || "");
+      if (checkOutput) {
+        renderYamlOutput(
+          checkOutput,
+          `${pad}  `,
+          "output",
+          displayName,
+          dedup,
+          lines,
+          fullOutput,
+          ml
+        );
+      }
+    }
+    return;
+  }
+  if (name === "visor.run") {
+    const source = attrs["visor.run.source"] || "";
+    const visorVersion = attrs["visor.version"] || "";
+    const probeVersion = attrs["probe.version"] || "";
+    const slackUser = attrs["slack.user_id"] || "";
+    lines.push(`${pad}visor.run:`);
+    lines.push(`${pad}  trace_id: ${node.span.traceId}`);
+    if (visorVersion) lines.push(`${pad}  visor: ${visorVersion}`);
+    if (probeVersion) lines.push(`${pad}  probe: ${probeVersion}`);
+    if (source) lines.push(`${pad}  source: ${source}`);
+    if (slackUser) lines.push(`${pad}  slack_user: ${slackUser}`);
+    lines.push(`${pad}  duration: ${duration}`);
+    for (const child of node.children) {
+      renderYamlNode(
+        child,
+        indent + 1,
+        lines,
+        dedup,
+        fallbackIntent,
+        fullOutput,
+        maxLen,
+        node.span
+      );
+    }
+    return;
+  }
+  const checkId = attrs["visor.check.id"];
+  const checkType = attrs["visor.check.type"];
+  if (checkId || name.startsWith("visor.check.")) {
+    const cleanName = String(checkId || name).replace(/^visor\.check\./, "");
+    const errMark2 = node.span.status === "error" ? " \u2717" : "";
+    lines.push(`${pad}${cleanName}:${errMark2}`);
+    if (checkType) lines.push(`${pad}  type: ${checkType}`);
+    lines.push(`${pad}  duration: ${duration}`);
+    const inputContext = String(attrs["visor.check.input.context"] || "");
+    const inputOutputs = String(attrs["visor.check.input.outputs"] || "");
+    const question = extractQuestionFromContext(inputContext, inputOutputs);
+    if (question || inputOutputs && inputOutputs !== "{}") {
+      renderYamlInput(inputOutputs, `${pad}  `, lines, fullOutput, ml, question);
+    }
+    for (const child of node.children) {
+      renderYamlNode(
+        child,
+        indent + 1,
+        lines,
+        dedup,
+        fallbackIntent,
+        fullOutput,
+        maxLen,
+        node.span
+      );
+    }
+    const hasDirectAiChild = node.children.some((c) => c.span.name === "ai.request");
+    if (!hasDirectAiChild) {
+      const output = String(attrs["visor.check.output"] || "");
+      if (output) {
+        renderYamlOutput(output, `${pad}  `, "output", cleanName, dedup, lines, fullOutput, ml);
+      }
+    }
+    return;
+  }
+  const errMark = node.span.status === "error" ? " \u2717" : "";
+  const hasChildren = node.children.length > 0;
+  lines.push(`${pad}${name} \u2014 ${duration}${errMark}${hasChildren ? ":" : ""}`);
+  for (const child of node.children) {
+    renderYamlNode(child, indent + 1, lines, dedup, fallbackIntent, fullOutput, maxLen, node.span);
+  }
+}
+function renderYamlOutput(rawOutput, pad, label, spanName, dedup, lines, fullOutput, maxLen) {
+  const ml = maxLen ?? 120;
+  let obj;
+  try {
+    obj = JSON.parse(rawOutput);
+  } catch {
+    obj = parseTruncatedJson(rawOutput);
+    if (!obj || 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) {
+      obj = obj[keys[0]];
+    }
+    const objKeys = Object.keys(obj);
+    if (objKeys.length === 1 && objKeys[0] === "text" && typeof obj.text === "string") {
+      const text = obj.text.replace(/\*\*/g, "").replace(/`/g, "").trim();
+      const flat = text.replace(/\n/g, " ");
+      const preview2 = fullOutput ? flat : truncate(flat, ml);
+      const ref2 = dedupeOrRegister(dedup, "outputs", truncate(flat, 100), spanName);
+      if (ref2) {
+        lines.push(`${pad}${label}: = ${ref2}`);
+      } else {
+        lines.push(`${pad}${label}: ${preview2}`);
+      }
+      return;
+    }
+  }
+  const preview = formatJsonPreview(obj, 200);
+  if (!preview) return;
+  const ref = dedupeOrRegister(dedup, "outputs", preview, spanName);
+  if (ref) {
+    lines.push(`${pad}${label}: = ${ref}`);
+    return;
+  }
+  renderYamlValue(obj, pad, label, lines, fullOutput, ml);
+}
+function renderYamlValue(val, pad, key, lines, fullOutput, maxLen, depth) {
+  const ml = maxLen ?? 120;
+  const d = depth ?? 0;
+  if (val === null || val === void 0) return;
+  if (typeof val === "boolean" || typeof val === "number") {
+    lines.push(`${pad}${key}: ${val}`);
+    return;
+  }
+  if (typeof val === "string") {
+    if (val.startsWith("{") || val.startsWith("[")) return;
+    const clean = val.replace(/\*\*/g, "").replace(/`/g, "").trim();
+    if (fullOutput && clean.length > 100 && clean.includes("\n")) {
+      lines.push(`${pad}${key}: |`);
+      for (const line of clean.split("\n").slice(0, fullOutput ? 500 : 5)) {
+        lines.push(`${pad}  ${line}`);
+      }
+    } else {
+      const flat = clean.replace(/\n/g, " ");
+      const truncVal = fullOutput ? flat : truncate(flat, ml);
+      lines.push(`${pad}${key}: ${truncVal}`);
+    }
+    return;
+  }
+  if (Array.isArray(val)) {
+    if (val.length === 0) {
+      lines.push(`${pad}${key}: []`);
+      return;
+    }
+    const maxItems = fullOutput ? 20 : 3;
+    lines.push(`${pad}${key}:`);
+    for (let i = 0; i < Math.min(val.length, maxItems); i++) {
+      const item = val[i];
+      if (typeof item === "object" && item !== null) {
+        const entries = Object.entries(item).filter(
+          ([k]) => k !== "raw" && k !== "skills" && k !== "tags"
+        );
+        if (entries.length > 0) {
+          const [firstKey, firstVal] = entries[0];
+          if (firstVal === null || firstVal === void 0 || typeof firstVal !== "object") {
+            const sv = typeof firstVal === "string" ? fullOutput ? firstVal.split("\n")[0] : truncate(firstVal.split("\n")[0], ml) : String(firstVal ?? "");
+            lines.push(`${pad}  - ${firstKey}: ${sv}`);
+          } else {
+            lines.push(`${pad}  - ${firstKey}:`);
+            for (const [ck, cv] of Object.entries(firstVal)) {
+              if (ck === "raw" || ck === "skills" || ck === "tags") continue;
+              renderYamlValue(cv, `${pad}      `, ck, lines, fullOutput, ml, d + 2);
+            }
+          }
+          for (let j = 1; j < entries.length; j++) {
+            const [k, v] = entries[j];
+            renderYamlValue(v, `${pad}    `, k, lines, fullOutput, ml, d + 1);
+          }
+        }
+      } else {
+        lines.push(`${pad}  - ${truncate(String(item), ml)}`);
+      }
+    }
+    if (val.length > maxItems) {
+      lines.push(`${pad}  # ... ${val.length - maxItems} more`);
+    }
+    return;
+  }
+  if (typeof val === "object") {
+    if (d > 3) {
+      const keys = Object.keys(val);
+      lines.push(`${pad}${key}: {${keys.slice(0, 4).join(", ")}${keys.length > 4 ? ", ..." : ""}}`);
+      return;
+    }
+    lines.push(`${pad}${key}:`);
+    for (const [k, v] of Object.entries(val)) {
+      if (k === "raw" || k === "skills" || k === "tags") continue;
+      renderYamlValue(v, `${pad}  `, k, lines, fullOutput, ml, d + 1);
+    }
+  }
+}
+function extractQuestionFromContext(contextStr, inputOutputsStr) {
+  if (!contextStr) return void 0;
+  try {
+    const ctx = JSON.parse(contextStr);
+    const outputs = ctx.outputs || {};
+    const routeIntent = outputs["route-intent"];
+    if (routeIntent) {
+      const topic = routeIntent.topic || routeIntent.intent || routeIntent.question;
+      if (topic && typeof topic === "string") return topic;
+      if (typeof routeIntent === "string") return routeIntent;
+    }
+    const args = ctx.args || {};
+    if (args.topic && typeof args.topic === "string") return args.topic;
+    if (args.question && typeof args.question === "string") return args.question;
+    if (args.intent && typeof args.intent === "string") return args.intent;
+    for (const key of Object.keys(outputs)) {
+      const val = outputs[key];
+      if (typeof val === "object" && val !== null) {
+        if (val.topic && typeof val.topic === "string") {
+          try {
+            const depOutputs = JSON.parse(inputOutputsStr);
+            if (depOutputs[key]) continue;
+          } catch {
+          }
+          return val.topic;
+        }
+      }
+    }
+  } catch {
+    const topicMatch = contextStr.match(/"topic"\s*:\s*"([^"]+)"/);
+    if (topicMatch) return topicMatch[1];
+  }
+  return void 0;
+}
+function renderYamlInput(inputOutputsStr, pad, lines, fullOutput, maxLen, question) {
+  const ml = maxLen ?? 120;
+  if (question) {
+    lines.push(`${pad}input: ${truncate(question, fullOutput ? 1e5 : ml)}`);
+  }
+  try {
+    const inputs = JSON.parse(inputOutputsStr);
+    if (typeof inputs !== "object" || inputs === null) return;
+    const keys = Object.keys(inputs);
+    if (keys.length === 0) return;
+    if (!question) lines.push(`${pad}input:`);
+    for (const key of keys) {
+      const val = inputs[key];
+      if (typeof val === "object" && val !== null) {
+        renderYamlValue(val, `${pad}  `, key, lines, fullOutput, ml, 0);
+      } else {
+        lines.push(`${pad}  ${key}: ${truncate(String(val), ml)}`);
+      }
+    }
+  } catch {
+  }
+}
+function extractToolInput(toolName, attrs) {
+  const result = String(attrs["tool.result"] || "");
+  const explicitInput = String(attrs["tool.input"] || "");
+  if (explicitInput) return truncate(explicitInput, 80);
+  switch (toolName) {
+    case "search": {
+      const patMatch = result.match(/Pattern: (.+)/);
+      const pathMatch = result.match(/Path: \S+\/([^\s/]+)\s/);
+      const pattern = patMatch ? patMatch[1].trim() : "";
+      const inPath = pathMatch ? pathMatch[1] : "";
+      if (pattern && inPath) return `"${truncate(pattern, 50)}" in ${inPath}`;
+      if (pattern) return `"${truncate(pattern, 60)}"`;
+      return "";
+    }
+    case "extract": {
+      const fileMatch = result.match(/Files to extract:\n\s*(\S+)/);
+      if (fileMatch) {
+        const filePath = fileMatch[1];
+        const parts = filePath.split("/");
+        return parts.length > 2 ? parts.slice(-2).join("/") : parts[parts.length - 1];
+      }
+      return "";
+    }
+    case "listFiles": {
+      const pathMatch = result.match(/^(\S+):/);
+      if (pathMatch) {
+        const parts = pathMatch[1].split("/");
+        return parts[parts.length - 1] || "";
+      }
+      return "";
+    }
+    default:
+      return truncate(explicitInput, 60);
+  }
+}
+function extractAIIntent(input, maxLen = 150) {
+  if (!input || input.length < 20) return "";
+  const qMatch = input.match(/<question>([\s\S]*?)<\/question>/);
+  if (qMatch) return truncate(qMatch[1].trim(), maxLen);
+  const crMatch = input.match(/## Current Request\s*\n(?:User: )?(.+)/);
+  if (crMatch) return truncate(crMatch[1].trim(), maxLen);
+  const userMatch = input.match(/(?:^|\n)User: (.+)/);
+  if (userMatch) return truncate(userMatch[1].trim(), maxLen);
+  const pmMatch = input.match(/Primary message[^:]*:\s*\n(.+)/);
+  if (pmMatch) return truncate(pmMatch[1].trim(), maxLen);
+  return "";
+}
+function formatJsonPreview(obj, maxLen) {
+  if (obj === null || obj === void 0) return "";
+  if (typeof obj !== "object") return truncate(String(obj), maxLen);
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    const first = typeof obj[0] === "object" && obj[0] !== null ? obj[0].project_id || obj[0].id || obj[0].name || Object.keys(obj[0])[0] || "..." : String(obj[0]);
+    return `[${obj.length}] ${truncate(String(first), 30)}${obj.length > 1 ? ", ..." : ""}`;
+  }
+  const parts = [];
+  let len = 2;
+  for (const [key, val] of Object.entries(obj)) {
+    if (key === "raw" || key === "skills" || key === "tags") continue;
+    let valStr;
+    if (val === null || val === void 0) continue;
+    if (typeof val === "boolean") valStr = String(val);
+    else if (typeof val === "number") valStr = String(val);
+    else if (typeof val === "string") {
+      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 valStr = "...";
+    const part = `${key}: ${valStr}`;
+    if (len + part.length + 2 > maxLen) {
+      parts.push("...");
+      break;
+    }
+    parts.push(part);
+    len += part.length + 2;
+  }
+  return `{${parts.join(", ")}}`;
+}
+function parseTruncatedJson(input) {
+  let pos = 0;
+  const len = input.length;
+  function skipWhitespace() {
+    while (pos < len && " 	\n\r".includes(input[pos])) pos++;
+  }
+  function parseString() {
+    if (input[pos] !== '"') return "";
+    pos++;
+    let result = "";
+    while (pos < len) {
+      const ch = input[pos];
+      if (ch === "\\" && pos + 1 < len) {
+        const next = input[pos + 1];
+        if (next === "n") {
+          result += "\n";
+          pos += 2;
+          continue;
+        }
+        if (next === "t") {
+          result += "	";
+          pos += 2;
+          continue;
+        }
+        if (next === '"') {
+          result += '"';
+          pos += 2;
+          continue;
+        }
+        if (next === "\\") {
+          result += "\\";
+          pos += 2;
+          continue;
+        }
+        result += next;
+        pos += 2;
+        continue;
+      }
+      if (ch === '"') {
+        pos++;
+        return result;
+      }
+      result += ch;
+      pos++;
+    }
+    return result;
+  }
+  function parseNumber() {
+    const start = pos;
+    if (input[pos] === "-") pos++;
+    while (pos < len && input[pos] >= "0" && input[pos] <= "9") pos++;
+    if (pos < len && input[pos] === ".") {
+      pos++;
+      while (pos < len && input[pos] >= "0" && input[pos] <= "9") pos++;
+    }
+    return Number(input.slice(start, pos));
+  }
+  function parseValue() {
+    skipWhitespace();
+    if (pos >= len) return void 0;
+    const ch = input[pos];
+    if (ch === '"') return parseString();
+    if (ch === "{") return parseObject();
+    if (ch === "[") return parseArray();
+    if (ch === "t" && input.slice(pos, pos + 4) === "true") {
+      pos += 4;
+      return true;
+    }
+    if (ch === "f" && input.slice(pos, pos + 5) === "false") {
+      pos += 5;
+      return false;
+    }
+    if (ch === "n" && input.slice(pos, pos + 4) === "null") {
+      pos += 4;
+      return null;
+    }
+    if (ch === "-" || ch >= "0" && ch <= "9") return parseNumber();
+    return void 0;
+  }
+  function parseObject() {
+    const obj = {};
+    pos++;
+    skipWhitespace();
+    while (pos < len && input[pos] !== "}") {
+      skipWhitespace();
+      if (pos >= len || input[pos] !== '"') break;
+      const key = parseString();
+      skipWhitespace();
+      if (pos >= len || input[pos] !== ":") {
+        obj[key] = void 0;
+        break;
+      }
+      pos++;
+      const val = parseValue();
+      if (val !== void 0) obj[key] = val;
+      skipWhitespace();
+      if (pos < len && input[pos] === ",") pos++;
+    }
+    if (pos < len && input[pos] === "}") pos++;
+    return obj;
+  }
+  function parseArray() {
+    const arr = [];
+    pos++;
+    skipWhitespace();
+    while (pos < len && input[pos] !== "]") {
+      const val = parseValue();
+      if (val !== void 0) arr.push(val);
+      else break;
+      skipWhitespace();
+      if (pos < len && input[pos] === ",") pos++;
+      skipWhitespace();
+    }
+    if (pos < len && input[pos] === "]") pos++;
+    return arr;
+  }
+  return parseValue();
+}
+function extractRouteIntentTopic(spans) {
+  const riSpan = spans.find((s) => s.attributes["visor.check.id"] === "route-intent");
+  if (riSpan) {
+    const output = String(riSpan.attributes["visor.check.output"] || "");
+    if (output) {
+      try {
+        const obj = JSON.parse(output);
+        if (obj.topic) return truncate(String(obj.topic), 150);
+      } catch {
+      }
+    }
+  }
+  const classifySpan = spans.find((s) => s.attributes["visor.check.id"] === "classify");
+  if (classifySpan) {
+    const output = String(classifySpan.attributes["visor.check.output"] || "");
+    if (output) {
+      try {
+        const obj = JSON.parse(output);
+        if (obj.topic) return truncate(String(obj.topic), 150);
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function formatSize(chars) {
+  if (chars < 1e3) return `${chars} chars`;
+  return `${(chars / 1e3).toFixed(1)}k chars`;
+}
+function formatDurationMs(ms) {
+  if (ms < 0) return "0ms";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const mins = Math.floor(ms / 6e4);
+  const secs = Math.round(ms % 6e4 / 1e3);
+  return `${mins}m ${secs}s`;
+}
+function truncate(str, max) {
+  if (typeof str !== "string") return "";
+  if (str.length <= max) return str;
+  const tail = Math.min(100, Math.floor(max / 3));
+  const head = max - tail - 19;
+  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 init_trace_serializer = __esm({
+  "src/agent-protocol/trace-serializer.ts"() {
+    "use strict";
+    init_logger();
+    NOISE_SPAN_NAMES = /* @__PURE__ */ new Set([
+      "engine.state.init",
+      "engine.state.waveplanning",
+      "engine.state.planready",
+      "visor.sandbox.stopAll"
+    ]);
+    WRAPPER_SPAN_NAMES = /* @__PURE__ */ new Set([
+      "engine.state.leveldispatch",
+      "visor.ai_check",
+      "probe.delegation"
+    ]);
+  }
+});
+
+// src/agent-protocol/task-evaluator.ts
+import crypto from "crypto";
+function buildEvaluationSchema(includeExecution) {
+  const schema = {
+    type: "object",
+    required: ["response_quality", "overall_rating", "summary"],
+    properties: {
+      response_quality: {
+        type: "object",
+        required: ["rating", "category", "relevance", "completeness", "actionable", "reasoning"],
+        properties: {
+          rating: { type: "integer", minimum: 1, maximum: 5 },
+          category: {
+            type: "string",
+            enum: ["excellent", "good", "adequate", "poor", "off-topic", "error"]
+          },
+          relevance: { type: "boolean" },
+          completeness: { type: "boolean" },
+          actionable: { type: "boolean" },
+          reasoning: { type: "string" }
+        }
+      },
+      overall_rating: { type: "integer", minimum: 1, maximum: 5 },
+      summary: { type: "string" }
+    }
+  };
+  if (includeExecution) {
+    schema.required.push("execution_quality");
+    schema.properties.execution_quality = {
+      type: "object",
+      required: ["rating", "category", "reasoning"],
+      properties: {
+        rating: { type: "integer", minimum: 1, maximum: 5 },
+        category: { type: "string", enum: ["efficient", "adequate", "wasteful", "error"] },
+        unnecessary_tool_calls: { type: "integer" },
+        reasoning: { type: "string" }
+      }
+    };
+  }
+  return schema;
+}
+async function evaluateTask(taskId, store, config) {
+  const { rows } = store.listTasksRaw({ limit: 500 });
+  const match = rows.find((r) => r.id === taskId || r.id.startsWith(taskId));
+  if (!match) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  const fullTask = store.getTask(match.id);
+  if (!fullTask) {
+    throw new Error(`Task data not found: ${match.id}`);
+  }
+  const requestText = match.request_message || "No request text available";
+  let responseText = "No response available";
+  if (fullTask.status?.message) {
+    const parts = fullTask.status.message.parts ?? [];
+    const textPart = parts.find((p) => typeof p.text === "string");
+    if (textPart) {
+      responseText = textPart.text;
+    }
+  }
+  if (fullTask.status.state === "failed" && responseText === "No response available") {
+    return {
+      response_quality: {
+        rating: 1,
+        category: "error",
+        relevance: false,
+        completeness: false,
+        actionable: false,
+        reasoning: "Task failed without producing a response."
+      },
+      overall_rating: 1,
+      summary: "Task failed without producing a response."
+    };
+  }
+  let traceTree;
+  const traceId = match.metadata?.trace_id;
+  const traceFile = match.metadata?.trace_file;
+  if (traceFile || traceId) {
+    try {
+      const traceRef = traceFile || traceId;
+      traceTree = await serializeTraceForPrompt(
+        traceRef,
+        1e6,
+        { traceDir: config?.traceDir },
+        responseText !== "No response available" ? responseText : void 0
+      );
+      if (traceTree === "(no trace data available)") {
+        traceTree = void 0;
+      }
+    } catch (err) {
+      logger.debug(
+        `[TaskEvaluator] Failed to load trace: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  const systemPrompt = config?.prompt || process.env.VISOR_EVAL_PROMPT || DEFAULT_EVALUATION_PROMPT;
+  const hasTrace = !!traceTree;
+  let userPrompt;
+  if (traceTree) {
+    userPrompt = `<user_request>
+${requestText}
+</user_request>
+
+<execution_trace>
+${traceTree}
+</execution_trace>`;
+  } else {
+    userPrompt = `<user_request>
+${requestText}
+</user_request>
+
+<agent_response>
+${responseText}
+</agent_response>`;
+  }
+  const { ProbeAgent } = __require("@probelabs/probe");
+  const model = config?.model || process.env.VISOR_EVAL_MODEL || process.env.VISOR_JUDGE_MODEL || void 0;
+  const provider = config?.provider || process.env.VISOR_EVAL_PROVIDER || void 0;
+  const agentOptions = {
+    sessionId: `visor-task-eval-${Date.now()}`,
+    systemPrompt,
+    maxIterations: 1,
+    disableTools: true
+  };
+  if (model) agentOptions.model = model;
+  if (provider) agentOptions.provider = provider;
+  if (config?.apiKey) {
+    const envKey = provider === "openai" ? "OPENAI_API_KEY" : provider === "anthropic" ? "ANTHROPIC_API_KEY" : "GOOGLE_API_KEY";
+    process.env[envKey] = config.apiKey;
+  }
+  const agent = new ProbeAgent(agentOptions);
+  if (typeof agent.initialize === "function") {
+    await agent.initialize();
+  }
+  const jsonSchema = buildEvaluationSchema(hasTrace);
+  const schemaStr = JSON.stringify(jsonSchema);
+  const response = await agent.answer(userPrompt, void 0, { schema: schemaStr });
+  let result;
+  try {
+    const cleaned = response.replace(/^```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    result = JSON.parse(cleaned);
+  } catch {
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      result = JSON.parse(jsonMatch[0]);
+    } else {
+      throw new Error(`Failed to parse evaluation response as JSON: ${response.slice(0, 200)}`);
+    }
+  }
+  return result;
+}
+async function evaluateAndStore(taskId, store, config) {
+  const result = await evaluateTask(taskId, store, config);
+  const { rows } = store.listTasksRaw({ limit: 500 });
+  const match = rows.find((r) => r.id === taskId || r.id.startsWith(taskId));
+  if (match) {
+    store.addArtifact(match.id, {
+      artifact_id: crypto.randomUUID(),
+      name: "evaluation",
+      parts: [{ text: JSON.stringify(result), media_type: "application/json" }]
+    });
+  }
+  return result;
+}
+var DEFAULT_EVALUATION_PROMPT;
+var init_task_evaluator = __esm({
+  "src/agent-protocol/task-evaluator.ts"() {
+    init_logger();
+    init_trace_serializer();
+    DEFAULT_EVALUATION_PROMPT = `You are a task response quality evaluator for an AI agent system called Visor.
+
+You will receive the user's original request and an execution trace inside <execution_trace> tags. The trace is a YAML-formatted view of the entire agent execution, including the final response. When no trace is available, the agent response is provided directly.
+
+## How to Read the Execution Trace
+
+The trace is a tree of spans representing the agent's execution pipeline:
+
+**Top-level: \`visor.run\`** \u2014 The root span with metadata:
+- \`trace_id\`: Unique execution identifier
+- \`visor\` / \`probe\`: Software versions
+- \`source\`: Where the request came from (e.g., "slack", "cli")
+- \`duration\`: Total wall-clock time
+
+**Checks** \u2014 Named processing steps (e.g., \`route-intent\`, \`explore-code\`, \`generate-response\`):
+- \`type\`: "ai" (LLM-powered), "script" (deterministic), or "workflow" (sub-pipeline)
+- \`duration\`: How long this step took
+- \`input\`: What was passed to this check \u2014 may include an \`intent\` (the user's question as understood by the router) and dependency outputs
+- \`output\`: The check's result \u2014 may be structured JSON or plain text
+
+**AI blocks** (\`ai: model-name\`) \u2014 Individual LLM calls within checks:
+- Shows model used, duration, and token counts (input/output)
+- \`intent\`: The question or instruction sent to the LLM
+
+**Tool calls** \u2014 Listed as \`- toolName(input) \u2192 size\`:
+- \`search("query" in repo)\`: Code search. "\u2192 no results" means nothing was found; otherwise shows result size
+- \`extract(file/path)\`: File content extraction with result size
+- \`listFiles(dir)\`: Directory listing
+- \`bash()\`: Shell command execution
+
+**Delegations** (\`search.delegate("query")\`) \u2014 Sub-agent searches:
+- Contains their own AI blocks and tool calls
+- Used for complex multi-step code exploration
+
+**The \`response\` field** at the end of the trace is the final answer sent back to the user. This is the primary output to evaluate.
+
+**Symbols:**
+- \`\u2717\` marks failed/error spans
+- \`= check-name\` means output is identical to that check's output (deduplication)
+
+## Evaluation Criteria
+
+**Response Quality** (1-5):
+- **Relevance**: Does the response directly address what the user asked? A response about the wrong topic or that misunderstands the question scores low.
+- **Completeness**: Does it fully answer the question? Partial answers, missing key details, or surface-level responses score lower.
+- **Actionable**: Can the user act on this information? Vague or generic advice scores lower than specific, concrete answers with code references.
+- Rating: 5=excellent (thorough, specific, directly useful), 4=good (answers well but minor gaps), 3=adequate (addresses question but lacks depth), 2=poor (partially relevant or very incomplete), 1=off-topic or error
+
+**Execution Quality** (1-5, only when trace is provided):
+- **Efficiency**: Were tool calls necessary and well-targeted? Good search queries that find results on the first try score high.
+- **Redundancy**: Were there duplicate searches, unnecessary re-searches with slightly different queries, or tools called for information already available?
+- **Delegation quality**: Were search delegations productive? Did they explore relevant code paths?
+- **Token usage**: Was input context kept reasonable, or did the agent load excessive amounts of code?
+- Rating: 5=efficient (minimal, targeted tool use), 4=adequate (minor redundancy), 3=some waste (noticeable unnecessary calls), 2=wasteful (many redundant searches or delegations), 1=error/broken execution
+
+**Overall Rating** (1-5): Weighted combination \u2014 response quality matters most, execution quality is secondary. A perfect response from a wasteful execution still scores 3-4 overall.
+
+You MUST respond with valid JSON matching the provided schema. Be specific in your reasoning \u2014 reference actual check names, tool calls, or response content.`;
+  }
+});
+init_task_evaluator();
+export {
+  DEFAULT_EVALUATION_PROMPT,
+  evaluateAndStore,
+  evaluateTask
+};
+//# sourceMappingURL=task-evaluator-HLNXKKVV.mjs.map