poe-code 3.0.204 → 3.0.206

package/dist/providers/poe-agent.js

@@ -3793,19 +3793,6 @@ var init_merge_callbacks = __esm({
   }
 });
 
-// packages/poe-code-config/src/integrations-loader.ts
-async function loadIntegrations(config) {
-  if (!config.integrations?.braintrust?.enabled) return null;
-  const packageName = "@poe-code/braintrust";
-  const mod = await import(packageName);
-  return mod.bootstrap(config);
-}
-var init_integrations_loader = __esm({
-  "packages/poe-code-config/src/integrations-loader.ts"() {
-    "use strict";
-  }
-});
-
 // packages/poe-code-config/src/models.ts
 var init_models = __esm({
   "packages/poe-code-config/src/models.ts"() {
@@ -4351,7 +4338,6 @@ var init_src5 = __esm({
     init_config();
     init_merge2();
     init_merge_callbacks();
-    init_integrations_loader();
     init_models();
     init_memory();
     init_resolve2();
@@ -22826,6 +22812,25 @@ var init_adapters = __esm({
   }
 });
 
+// packages/agent-spawn/src/acp/meta.ts
+function stampReceiveTime(event, ts) {
+  if (event === null || typeof event !== "object") {
+    return event;
+  }
+  const target = event;
+  const existing = target._meta;
+  if (existing && typeof existing.ts === "number") {
+    return event;
+  }
+  target._meta = existing ? { ...existing, ts } : { ts };
+  return event;
+}
+var init_meta = __esm({
+  "packages/agent-spawn/src/acp/meta.ts"() {
+    "use strict";
+  }
+});
+
 // packages/agent-spawn/src/acp/spawn.ts
 function createAbortError4() {
   const error2 = new Error("Agent spawn aborted");
@@ -22999,7 +23004,7 @@ function spawnStreaming(options) {
   const events = (async function* () {
     for await (const output of adapter(queue.lines())) {
       if (!isAcpEvent(output)) continue;
-      yield output;
+      yield stampReceiveTime(output, Date.now());
     }
   })();
   const done = (async () => {
@@ -23034,6 +23039,7 @@ var init_spawn2 = __esm({
     init_register_factories();
     init_src9();
     init_adapters();
+    init_meta();
     init_resolve_config();
     init_mcp_args();
     init_model_utils();
@@ -23049,6 +23055,7 @@ var init_spawn_acp = __esm({
     init_src8();
     init_src();
     init_configs();
+    init_meta();
     init_session_update_converter();
   }
 });
@@ -26699,6 +26706,889 @@ async function executePoeAgent(agentSpec, input, createAgent = agent) {
 init_src12();
 init_src5();
 
+// packages/braintrust/src/client.ts
+function createClient(opts) {
+  let sdkPromise;
+  let rootLoggerPromise;
+  const experiments = /* @__PURE__ */ new Map();
+  let lastError = null;
+  let errorCount = 0;
+  const recordError = (err, ctx) => {
+    try {
+      errorCount += 1;
+      lastError = `${ctx}: ${formatError(err)}`;
+    } catch {
+      errorCount += 1;
+      lastError = `${ctx}: unknown error`;
+    }
+  };
+  const loadSdk = async () => {
+    sdkPromise ??= import("braintrust").catch((err) => {
+      recordError(err, "load sdk");
+      return void 0;
+    });
+    return sdkPromise;
+  };
+  const sdkOptions = () => ({
+    projectName: opts.project,
+    apiKey: opts.apiKey,
+    apiUrl: opts.apiUrl
+  });
+  const client = {
+    getSdk: loadSdk,
+    async getRootLogger() {
+      rootLoggerPromise ??= (async () => {
+        try {
+          const sdk = await loadSdk();
+          return sdk?.initLogger(sdkOptions());
+        } catch (err) {
+          recordError(err, "init logger");
+          return void 0;
+        }
+      })();
+      return rootLoggerPromise;
+    },
+    async getExperiment(name) {
+      if (!experiments.has(name)) {
+        experiments.set(name, (async () => {
+          try {
+            const sdk = await loadSdk();
+            return sdk?.initExperiment({
+              ...sdkOptions(),
+              experimentName: name
+            });
+          } catch (err) {
+            recordError(err, `init experiment ${name}`);
+            return void 0;
+          }
+        })());
+      }
+      return experiments.get(name);
+    },
+    async flush(timeoutMs) {
+      const flushAll = (async () => {
+        const sdk = await sdkPromise;
+        if (sdk === void 0) {
+          return;
+        }
+        const targets = [
+          await rootLoggerPromise,
+          ...await Promise.all(experiments.values())
+        ].filter((target) => target !== void 0);
+        const flushTargets = Promise.all(
+          targets.map((target) => sdk.flush(target))
+        ).then(() => void 0);
+        await flushTargets;
+      })().catch((err) => {
+        recordError(err, "flush");
+      });
+      try {
+        await Promise.race([
+          flushAll,
+          new Promise((resolve2) => {
+            setTimeout(resolve2, timeoutMs);
+          })
+        ]);
+      } catch (err) {
+        recordError(err, "flush");
+      }
+    },
+    recordError,
+    status() {
+      return {
+        lastError,
+        errorCount,
+        project: opts.project
+      };
+    }
+  };
+  return client;
+}
+function formatError(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
+// packages/braintrust/src/redact.ts
+var MAX_STRING_BYTES = 65536;
+var MAX_JSON_BYTES = 262144;
+var BINARY_SCAN_BYTES = 1024;
+function redact(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized !== void 0) {
+    const originalBytes = Buffer.byteLength(serialized, "utf8");
+    if (originalBytes > MAX_JSON_BYTES) {
+      return `[truncated:${originalBytes}]`;
+    }
+  }
+  return redactLeaf(value);
+}
+function redactLeaf(value) {
+  if (typeof value === "string") {
+    const bytes = Buffer.byteLength(value, "utf8");
+    return bytes > MAX_STRING_BYTES ? `[truncated:${bytes}]` : value;
+  }
+  if (value instanceof Uint8Array) {
+    const scanLength = Math.min(value.byteLength, BINARY_SCAN_BYTES);
+    for (let index = 0; index < scanLength; index += 1) {
+      if (value[index] === 0) {
+        return `[binary:${value.byteLength}]`;
+      }
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactLeaf(item));
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key2, item]) => [key2, redactLeaf(item)])
+    );
+  }
+  return value;
+}
+
+// packages/braintrust/src/row-builder.ts
+function makePipelineRowState(client) {
+  const rows = /* @__PURE__ */ new Map();
+  return {
+    start(progress) {
+      try {
+        const key2 = pipelineKey(progress);
+        const row = {
+          progress,
+          span: openCurrentChildSpan(client, {
+            name: `step:${readPipelineStep(progress)}:${readPipelineIndex(progress)}`,
+            type: "task"
+          }, "pipeline step start")
+        };
+        rows.set(key2, row);
+      } catch (err) {
+        client.recordError(err, "pipeline step start");
+      }
+    },
+    complete(progress) {
+      try {
+        const key2 = pipelineKey(progress);
+        const row = rows.get(key2);
+        rows.delete(key2);
+        void (async () => {
+          try {
+            const span = row?.span === void 0 ? await openCurrentChildSpan(client, {
+              name: `step:${readPipelineStep(progress)}:${readPipelineIndex(progress)}`,
+              type: "task"
+            }, "pipeline step complete") : await row.span;
+            if (span === void 0) {
+              return;
+            }
+            try {
+              span.log(buildPipelineCompletionLog(row?.progress ?? progress, progress));
+            } finally {
+              span.end();
+            }
+          } catch (err) {
+            client.recordError(err, "pipeline step complete");
+          }
+        })();
+      } catch (err) {
+        client.recordError(err, "pipeline step complete");
+      }
+    }
+  };
+}
+async function logSuperintendentRole(client, role, result) {
+  try {
+    const span = await openCurrentChildSpan(client, {
+      name: `role:${role}`,
+      type: "task"
+    }, `superintendent ${role}`);
+    if (span === void 0) {
+      return;
+    }
+    try {
+      span.log(buildSuperintendentLog(role, result));
+    } finally {
+      span.end();
+    }
+  } catch (err) {
+    client.recordError(err, `superintendent ${role}`);
+  }
+}
+function makeExperimentIterationState(client, experimentName) {
+  const rows = /* @__PURE__ */ new Map();
+  let latestBaseline;
+  return {
+    async start(index, agent2) {
+      try {
+        const experiment = asSpanParent(await client.getExperiment(experimentName));
+        rows.set(index, {
+          span: experiment.startSpan({
+            name: `iteration:${index}`,
+            type: "task"
+          }),
+          agent: agent2,
+          iteration: index,
+          baseline: latestBaseline,
+          metrics: {}
+        });
+      } catch (err) {
+        client.recordError(err, `experiment ${experimentName} iteration start`);
+      }
+    },
+    baseline(b) {
+      try {
+        latestBaseline = { ...b };
+        for (const row of rows.values()) {
+          row.baseline = latestBaseline;
+        }
+      } catch (err) {
+        client.recordError(err, `experiment ${experimentName} baseline`);
+      }
+    },
+    metric(name, value) {
+      try {
+        const row = readLatestRow(rows);
+        if (row !== void 0 && Number.isFinite(value)) {
+          row.metrics[name] = value;
+        }
+      } catch (err) {
+        client.recordError(err, `experiment ${experimentName} metric`);
+      }
+    },
+    commit(hash) {
+      try {
+        const row = readLatestRow(rows);
+        if (row !== void 0) {
+          row.commit = hash;
+        }
+      } catch (err) {
+        client.recordError(err, `experiment ${experimentName} commit`);
+      }
+    },
+    reset(hash) {
+      try {
+        const row = readLatestRow(rows);
+        if (row !== void 0) {
+          row.reset = hash;
+        }
+      } catch (err) {
+        client.recordError(err, `experiment ${experimentName} reset`);
+      }
+    },
+    async complete(index, entry) {
+      const row = rows.get(index);
+      rows.delete(index);
+      try {
+        if (row?.span === void 0) {
+          return;
+        }
+        try {
+          row.span.log(buildExperimentLog(row, entry));
+        } finally {
+          row.span.end();
+        }
+      } catch (err) {
+        client.recordError(err, `experiment ${experimentName} iteration complete`);
+      }
+    }
+  };
+}
+async function openCurrentChildSpan(client, args, ctx) {
+  try {
+    const { currentSpan } = await import("braintrust");
+    return asSpanParent(currentSpan()).startSpan(args);
+  } catch (err) {
+    client.recordError(err, ctx);
+    return void 0;
+  }
+}
+function buildPipelineCompletionLog(started, completed) {
+  const startRecord = asRecord2(started) ?? {};
+  const completeRecord = asRecord2(completed) ?? {};
+  return {
+    input: redact({
+      step_name: readPipelineStep(started),
+      step_prompt: readFirstString(startRecord, ["step_prompt", "stepPrompt", "prompt"]),
+      plan_section: readFirstString(startRecord, ["plan_section", "planSection", "section"])
+    }),
+    output: redact({
+      result_summary: readFirstString(completeRecord, [
+        "result_summary",
+        "resultSummary",
+        "summary"
+      ]),
+      files_changed: readFirstValue(completeRecord, ["files_changed", "filesChanged"]),
+      success: completed.success
+    }),
+    scores: {
+      passed: completed.success ? 1 : 0
+    },
+    metrics: buildPipelineMetrics(completed)
+  };
+}
+function buildSuperintendentLog(role, result) {
+  const record = asRecord2(result);
+  const event = {
+    input: redact(record?.input),
+    output: redact(record?.output ?? result)
+  };
+  if (role === "inspector") {
+    const satisfied = readSatisfiedScore(record);
+    if (satisfied !== void 0) {
+      event.scores = { satisfied };
+    }
+  }
+  return event;
+}
+function buildExperimentLog(row, entry) {
+  const entryRecord = asRecord2(entry) ?? {};
+  const scores = buildExperimentScores(row.baseline, entry.scores);
+  const metrics = { ...row.metrics };
+  if (Number.isFinite(entry.durationMs)) {
+    metrics.durationMs = entry.durationMs;
+  }
+  return {
+    input: redact({
+      brief: readFirstString(entryRecord, ["brief"]),
+      baseline: row.baseline,
+      agent: row.agent,
+      iteration: row.iteration
+    }),
+    output: redact({
+      diff_summary: entry.agentOutput,
+      kept: entry.status === "keep"
+    }),
+    ...Object.keys(scores).length === 0 ? {} : { scores },
+    ...Object.keys(metrics).length === 0 ? {} : { metrics },
+    metadata: {
+      ...row.commit !== void 0 ? { commit: row.commit } : {},
+      ...row.reset !== void 0 ? { reset: row.reset } : {}
+    }
+  };
+}
+function buildPipelineMetrics(progress) {
+  const metrics = {};
+  const usage = progress.usage;
+  if (usage !== void 0) {
+    addMetric(metrics, "prompt_tokens", usage.inputTokens);
+    addMetric(metrics, "completion_tokens", usage.outputTokens);
+    addMetric(metrics, "tokens", usage.inputTokens + usage.outputTokens);
+    addMetric(metrics, "prompt_cached_tokens", usage.cachedTokens);
+  }
+  addMetric(metrics, "durationMs", progress.durationMs);
+  return metrics;
+}
+function buildExperimentScores(baseline, scores) {
+  const result = { ...scores ?? {} };
+  const delta = sumDelta(baseline, scores);
+  if (delta !== void 0) {
+    result.delta = delta;
+  }
+  return result;
+}
+function sumDelta(baseline, scores) {
+  if (baseline === void 0 || scores === void 0) {
+    return void 0;
+  }
+  let delta = 0;
+  let count = 0;
+  for (const [name, value] of Object.entries(scores)) {
+    const base = baseline[name];
+    if (Number.isFinite(value) && Number.isFinite(base)) {
+      delta += value - base;
+      count += 1;
+    }
+  }
+  return count === 0 ? void 0 : delta;
+}
+function readSatisfiedScore(record) {
+  const verdict = record?.verdict ?? record?.satisfied;
+  if (typeof verdict === "boolean") {
+    return verdict ? 1 : 0;
+  }
+  if (typeof verdict === "number" && Number.isFinite(verdict)) {
+    return verdict > 0 ? 1 : 0;
+  }
+  if (typeof verdict !== "string") {
+    return void 0;
+  }
+  const normalized = verdict.trim().toLowerCase();
+  if (["satisfied", "satisfy", "pass", "passed", "approve", "approved", "true", "yes"].includes(normalized)) {
+    return 1;
+  }
+  if (["unsatisfied", "fail", "failed", "reject", "rejected", "false", "no"].includes(normalized)) {
+    return 0;
+  }
+  return void 0;
+}
+function pipelineKey(progress) {
+  return [
+    progress.taskId,
+    progress.stepName ?? "",
+    progress.phase ?? "",
+    String(progress.taskIndex),
+    String(progress.stepIndex ?? "")
+  ].join(":");
+}
+function readPipelineStep(progress) {
+  return progress.stepName ?? progress.phase ?? progress.taskTitle;
+}
+function readPipelineIndex(progress) {
+  return progress.stepIndex ?? progress.taskIndex;
+}
+function readLatestRow(rows) {
+  let latest;
+  for (const row of rows.values()) {
+    if (latest === void 0 || row.iteration > latest.iteration) {
+      latest = row;
+    }
+  }
+  return latest;
+}
+function asSpanParent(value) {
+  const span = value;
+  if (span === void 0 || typeof span.startSpan !== "function") {
+    throw new Error("Braintrust span parent unavailable");
+  }
+  return span;
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function readFirstString(record, keys) {
+  const value = readFirstValue(record, keys);
+  return typeof value === "string" ? value : void 0;
+}
+function readFirstValue(record, keys) {
+  for (const key2 of keys) {
+    if (Object.hasOwn(record, key2)) {
+      return record[key2];
+    }
+  }
+  return void 0;
+}
+function addMetric(metrics, key2, value) {
+  if (value !== void 0 && Number.isFinite(value)) {
+    metrics[key2] = value;
+  }
+}
+
+// packages/braintrust/src/adapters/experiment.ts
+function createExperimentCallbacks(client, experimentName) {
+  const state = makeExperimentIterationState(client, experimentName);
+  return {
+    onExperimentStart(index, agent2) {
+      void state.start(index, agent2);
+    },
+    onBaselineCollected(baseline) {
+      state.baseline(baseline);
+    },
+    onMetricResult(metric, result) {
+      if (result.score !== null) {
+        state.metric(metric.name, result.score);
+      }
+    },
+    onCommit(commitHash) {
+      state.commit(commitHash);
+    },
+    onReset(targetHash) {
+      state.reset(targetHash);
+    },
+    onExperimentComplete(index, entry) {
+      void state.complete(index, entry);
+    }
+  };
+}
+
+// packages/braintrust/src/adapters/pipeline.ts
+function createPipelineCallbacks(client) {
+  const state = makePipelineRowState(client);
+  return {
+    onPlanResolved(summary) {
+      void summary;
+    },
+    onTaskStart(progress) {
+      state.start(progress);
+    },
+    onTaskComplete(progress) {
+      state.complete(progress);
+    },
+    onLockStatusChange(status) {
+      void status;
+    }
+  };
+}
+
+// packages/braintrust/src/span-builder.ts
+async function logSpawnSession(client, ctx) {
+  try {
+    const { currentSpan } = await import("braintrust");
+    const agentSpan = asSpanParent2(currentSpan()).startSpan({
+      name: `agent:${ctx.agent}:${ctx.model ?? "?"}`,
+      type: "task"
+    });
+    try {
+      logToolSpans(agentSpan, ctx.events);
+      agentSpan.log({
+        input: redact({
+          prompt: ctx.prompt,
+          mode: ctx.mode,
+          cwd: ctx.cwd
+        }),
+        output: redact(accumulateAgentOutput(ctx.events)),
+        metadata: {
+          sessionId: ctx.sessionId,
+          threadId: ctx.threadId,
+          ...ctx.metadata
+        },
+        metrics: buildMetrics(ctx)
+      });
+    } finally {
+      agentSpan.end();
+    }
+  } catch (err) {
+    client.recordError(err, "log spawn session");
+  }
+}
+function logToolSpans(agentSpan, events) {
+  for (const [index, event] of events.entries()) {
+    const toolCall = asToolCall(event);
+    if (toolCall === void 0) {
+      continue;
+    }
+    const toolSpan = agentSpan.startSpan({
+      name: `tool_call:${readString6(toolCall.kind) ?? "unknown"}`,
+      type: "tool"
+    });
+    try {
+      const metadata = collectToolMeta(events, index, readString6(toolCall.toolCallId));
+      toolSpan.log({
+        input: redact(readToolInput(toolCall)),
+        output: redact(assembleToolOutput(events, index, readString6(toolCall.toolCallId))),
+        ...metadata ? { metadata } : {}
+      });
+    } finally {
+      toolSpan.end();
+    }
+  }
+}
+function collectToolMeta(events, toolCallIndex, toolCallId) {
+  const merged = {};
+  const startMeta = asRecord3(asRecord3(events[toolCallIndex])?._meta);
+  if (startMeta) {
+    for (const [key2, value] of Object.entries(startMeta)) {
+      merged[key2 === "ts" ? "startTs" : key2] = value;
+    }
+  }
+  for (const event of events.slice(toolCallIndex + 1)) {
+    const update = asToolCallUpdate(event);
+    if (update === void 0) continue;
+    if (toolCallId !== void 0 && update.toolCallId !== toolCallId) continue;
+    const updateMeta = asRecord3(update._meta);
+    if (!updateMeta) continue;
+    for (const [key2, value] of Object.entries(updateMeta)) {
+      merged[key2 === "ts" ? "endTs" : key2] = value;
+    }
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function accumulateAgentOutput(events) {
+  let output = "";
+  for (const event of events) {
+    const record = asRecord3(event);
+    if (record === void 0) {
+      continue;
+    }
+    if (record.event === "agent_message") {
+      output += readString6(record.text) ?? "";
+      continue;
+    }
+    if (record.sessionUpdate === "agent_message_chunk") {
+      output += readContentText(record.content);
+    }
+  }
+  return output;
+}
+function assembleToolOutput(events, toolCallIndex, toolCallId) {
+  const outputs = [];
+  let text4 = "";
+  for (const event of events.slice(toolCallIndex + 1)) {
+    const update = asToolCallUpdate(event);
+    if (update === void 0) {
+      continue;
+    }
+    if (toolCallId !== void 0 && update.toolCallId !== toolCallId) {
+      continue;
+    }
+    if (Object.hasOwn(update, "rawOutput")) {
+      outputs.push(update.rawOutput);
+    }
+    const contentText = readContentText(update.content);
+    if (contentText.length > 0) {
+      text4 += contentText;
+    }
+  }
+  if (outputs.length === 0) {
+    return text4;
+  }
+  if (text4.length > 0) {
+    outputs.push(text4);
+  }
+  return outputs.length === 1 ? outputs[0] : outputs;
+}
+function buildMetrics(ctx) {
+  const usage = ctx.usage;
+  const metrics = {};
+  const promptTokens = readNumber(usage.prompt_tokens) ?? readNumber(usage.inputTokens);
+  const completionTokens = readNumber(usage.completion_tokens) ?? readNumber(usage.outputTokens);
+  addMetric2(metrics, "prompt_tokens", promptTokens);
+  addMetric2(metrics, "completion_tokens", completionTokens);
+  addMetric2(
+    metrics,
+    "tokens",
+    readNumber(usage.tokens) ?? sumIfPresent(promptTokens, completionTokens)
+  );
+  addMetric2(
+    metrics,
+    "prompt_cached_tokens",
+    readNumber(usage.prompt_cached_tokens) ?? readNumber(usage.cachedTokens)
+  );
+  addMetric2(
+    metrics,
+    "prompt_cache_creation_tokens",
+    readNumber(usage.prompt_cache_creation_tokens)
+  );
+  addMetric2(metrics, "durationMs", readNumber(usage.durationMs));
+  return metrics;
+}
+function asSpanParent2(value) {
+  const span = value;
+  if (span === void 0 || typeof span.startSpan !== "function") {
+    throw new Error("Braintrust current span unavailable");
+  }
+  return span;
+}
+function asToolCall(event) {
+  const record = asRecord3(event);
+  return record?.sessionUpdate === "tool_call" ? record : void 0;
+}
+function asToolCallUpdate(event) {
+  const record = asRecord3(event);
+  return record?.sessionUpdate === "tool_call_update" ? record : void 0;
+}
+function readToolInput(toolCall) {
+  if (Object.hasOwn(toolCall, "input")) {
+    return toolCall.input;
+  }
+  return toolCall.rawInput;
+}
+function readContentText(value) {
+  if (Array.isArray(value)) {
+    return value.map(readContentText).join("");
+  }
+  const record = asRecord3(value);
+  if (record === void 0 || record.type !== "text") {
+    return "";
+  }
+  return readString6(record.text) ?? "";
+}
+function asRecord3(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function readString6(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function addMetric2(metrics, key2, value) {
+  if (value !== void 0) {
+    metrics[key2] = value;
+  }
+}
+function sumIfPresent(left, right) {
+  return left !== void 0 && right !== void 0 ? left + right : void 0;
+}
+
+// packages/braintrust/src/adapters/spawn.ts
+function createSpawnMiddleware(client) {
+  return async (ctx, next) => {
+    try {
+      await next();
+    } catch (err) {
+      const metadataCtx = ctx;
+      metadataCtx.metadata = {
+        ...metadataCtx.metadata,
+        aborted: true
+      };
+      throw err;
+    } finally {
+      await logSpawnSession(client, ctx);
+    }
+  };
+}
+
+// packages/braintrust/src/adapters/superintendent.ts
+function createSuperintendentCallbacks(client) {
+  return {
+    onBuilderComplete(result) {
+      void logSuperintendentRole(client, "builder", result);
+    },
+    onBuilderFailed(error2) {
+      void logFailedRole(client, "builder", error2);
+    },
+    onInspectorComplete(result) {
+      void logSuperintendentRole(client, "inspector", result);
+    },
+    onInspectorFailed(name, error2) {
+      void logFailedRole(client, "inspector", error2, name);
+    },
+    onSuperintendentComplete(result) {
+      void logSuperintendentRole(client, "superintendent", result);
+    },
+    onOwnerComplete(result) {
+      void logSuperintendentRole(client, "owner", result);
+    }
+  };
+}
+async function logFailedRole(client, role, error2, name) {
+  try {
+    const { currentSpan } = await import("braintrust");
+    const span = asSpanParent3(currentSpan()).startSpan({
+      name: name === void 0 ? `role:${role}:failed` : `role:${role}:${name}:failed`,
+      type: "task"
+    });
+    try {
+      span.log({
+        metadata: {
+          role,
+          ...name === void 0 ? {} : { name },
+          error: error2.message
+        },
+        scores: {
+          passed: 0
+        }
+      });
+    } finally {
+      span.end();
+    }
+  } catch (err) {
+    client.recordError(err, `superintendent ${role} failed`);
+  }
+}
+function asSpanParent3(value) {
+  const span = value;
+  if (span === void 0 || typeof span.startSpan !== "function") {
+    throw new Error("Braintrust current span unavailable");
+  }
+  return span;
+}
+
+// packages/braintrust/src/trace-run.ts
+function makeTraceRun(client) {
+  return async (surface, name, fn) => {
+    const spanName = `${surface}:${name}`;
+    let callbackCompleted = false;
+    let callbackFailed = false;
+    let callbackError;
+    let callbackValue;
+    try {
+      const rootLogger = await client.getRootLogger();
+      if (rootLogger === void 0) {
+        throw new Error("Braintrust logger unavailable");
+      }
+      const sdk = await client.getSdk();
+      const traced = resolveTraced(sdk);
+      const tracedValue = await traced(
+        async () => {
+          try {
+            callbackValue = await fn();
+          } catch (err) {
+            callbackFailed = true;
+            callbackError = err;
+            throw err;
+          }
+          callbackCompleted = true;
+          return callbackValue;
+        },
+        {
+          name: spanName,
+          type: "task",
+          event: {
+            tags: [`surface:${surface}`]
+          }
+        }
+      );
+      return tracedValue;
+    } catch (err) {
+      if (callbackFailed) {
+        throw callbackError;
+      }
+      client.recordError(err, `trace ${spanName}`);
+      if (callbackCompleted) {
+        return callbackValue;
+      }
+      return fn();
+    }
+  };
+}
+function resolveTraced(sdk) {
+  if (sdk === void 0) {
+    throw new Error("Braintrust SDK unavailable");
+  }
+  if (typeof sdk.traced !== "function") {
+    throw new Error("Braintrust SDK traced unavailable");
+  }
+  return sdk.traced;
+}
+
+// packages/braintrust/src/load-integrations.ts
+async function loadIntegrations(config) {
+  if (config.integrations?.braintrust?.enabled !== true) {
+    return null;
+  }
+  return bootstrap(config.integrations.braintrust);
+}
+
+// packages/braintrust/src/index.ts
+function bootstrap(options) {
+  if (options?.enabled !== true) {
+    return null;
+  }
+  validateBraintrustConfig(options);
+  const client = createClient(options);
+  return {
+    spawnMiddleware: createSpawnMiddleware(client),
+    pipelineCallbacks: createPipelineCallbacks(client),
+    experimentCallbacks: createExperimentCallbacks(client, options.project),
+    superintendentCallbacks: createSuperintendentCallbacks(client),
+    status: () => client.status(),
+    traceRun: makeTraceRun(client),
+    shutdown() {
+      return client.flush(5e3);
+    }
+  };
+}
+function validateBraintrustConfig(options) {
+  requiredString(options.apiKey, "apiKey");
+  requiredString(options.project, "project");
+}
+function requiredString(value, field) {
+  if (typeof value === "string" && value.trim() !== "") {
+    return;
+  }
+  throw new Error(`Braintrust integration is enabled but ${field} is missing`);
+}
+
 // packages/superintendent/src/config-scope.ts
 init_src5();
 var superintendentConfigScope = defineScope("superintendent", {