elasticdash-test 0.1.18 → 0.1.19-alpha-2

package/dist/index.cjs

@@ -853,6 +853,57 @@ var init_matchers = __esm({
   }
 });
 
+// src/capture/replay.ts
+var ReplayController;
+var init_replay = __esm({
+  "src/capture/replay.ts"() {
+    "use strict";
+    ReplayController = class {
+      constructor(replayMode, checkpoint, history) {
+        this.replayMode = replayMode;
+        this.checkpoint = checkpoint;
+        this.history = history;
+        this.historyMap = new Map(history.map((e) => [e.id, e]));
+        this.sideEffectMap = new Map(
+          history.filter((e) => e.type === "side_effect").map((e) => [e.id, e])
+        );
+      }
+      historyMap;
+      /** Side effects keyed by their assigned sideEffectId, independent of main event IDs */
+      sideEffectMap;
+      shouldReplay(eventId) {
+        return this.replayMode && eventId <= this.checkpoint;
+      }
+      getRecordedEvent(eventId) {
+        return this.historyMap.get(eventId);
+      }
+      getRecordedResult(eventId) {
+        return this.historyMap.get(eventId)?.output;
+      }
+      /** Returns true if the side effect with this sideEffectId has a recorded value to replay */
+      shouldReplaySideEffect(n) {
+        return this.replayMode && this.sideEffectMap.has(n);
+      }
+      getSideEffectResult(n) {
+        return this.sideEffectMap.get(n)?.output;
+      }
+      getRecordedSideEffectEvent(n) {
+        return this.sideEffectMap.get(n);
+      }
+      shouldReplaySideEffectOfType(n, expectedName) {
+        if (!this.replayMode) return false;
+        const event = this.sideEffectMap.get(n);
+        return !!event && event.type === "side_effect" && event.name === expectedName;
+      }
+      getSideEffectResultOfType(n, expectedName) {
+        const event = this.sideEffectMap.get(n);
+        if (!event || event.type !== "side_effect" || event.name !== expectedName) return void 0;
+        return event.output;
+      }
+    };
+  }
+});
+
 // src/internals/mock-resolver.ts
 function normaliseMockResult(value) {
   if (typeof value === "string") {
@@ -1196,30 +1247,30 @@ function parseBody(body) {
   }
   return "[binary]";
 }
-function normalizeHeaders(headers) {
-  if (!headers) return void 0;
-  if (headers instanceof Headers) {
+function normalizeHeaders(headers2) {
+  if (!headers2) return void 0;
+  if (headers2 instanceof Headers) {
     const obj = {};
-    headers.forEach((v, k) => {
+    headers2.forEach((v, k) => {
       obj[k] = v;
     });
     return obj;
   }
-  if (Array.isArray(headers)) return Object.fromEntries(headers);
-  return headers;
+  if (Array.isArray(headers2)) return Object.fromEntries(headers2);
+  return headers2;
 }
-function pickReplayResponseHeaders(headers) {
-  if (!headers) return { "Content-Type": "application/json" };
+function pickReplayResponseHeaders(headers2) {
+  if (!headers2) return { "Content-Type": "application/json" };
   const out = {};
-  for (const [key, value] of Object.entries(headers)) {
+  for (const [key, value] of Object.entries(headers2)) {
     if (typeof value === "string") out[key] = value;
   }
   if (!out["Content-Type"]) out["Content-Type"] = "application/json";
   return out;
 }
-function isStreamingContentType(headers) {
-  const ct = headers.get("content-type") ?? "";
-  return ct.includes("text/event-stream") || ct.includes("application/x-ndjson") || ct.includes("application/stream+json") || ct.includes("application/jsonl") || headers.get("x-vercel-ai-data-stream") === "v1";
+function isStreamingContentType(headers2) {
+  const ct = headers2.get("content-type") ?? "";
+  return ct.includes("text/event-stream") || ct.includes("application/x-ndjson") || ct.includes("application/stream+json") || ct.includes("application/jsonl") || headers2.get("x-vercel-ai-data-stream") === "v1";
 }
 function parseVercelAIDataStream(raw) {
   let accumulatedText = "";
@@ -1308,20 +1359,20 @@ function synthesizeFrozenResponse(frozen) {
   const responseMeta = frozenInput?.__elasticdashResponse ?? {};
   const status = typeof responseMeta.status === "number" ? responseMeta.status : 200;
   const statusText = typeof responseMeta.statusText === "string" ? responseMeta.statusText : "";
-  const headers = pickReplayResponseHeaders(
+  const headers2 = pickReplayResponseHeaders(
     responseMeta.headers && typeof responseMeta.headers === "object" ? responseMeta.headers : void 0
   );
   if (frozen.streamed === true) {
     const raw = typeof frozen.streamRaw === "string" ? frozen.streamRaw : "";
-    return new Response(reconstructStream(raw), { status, statusText, headers });
+    return new Response(reconstructStream(raw), { status, statusText, headers: headers2 });
   }
   const body = frozen.output != null ? JSON.stringify(frozen.output) : null;
-  return new Response(body, { status, statusText, headers });
+  return new Response(body, { status, statusText, headers: headers2 });
 }
 async function executeLiveAndRecord(originalFetchFn, input, init, id, url, method, rawHeaders, rawBody) {
   const query = parseQuery(url);
   const body = parseBody(rawBody);
-  const headers = normalizeHeaders(rawHeaders);
+  const headers2 = normalizeHeaders(rawHeaders);
   const start = rawDateNow();
   const res = await originalFetchFn(input, init);
   const responseHeadersObj = {};
@@ -1334,7 +1385,7 @@ async function executeLiveAndRecord(originalFetchFn, input, init, id, url, metho
     method,
     ...query ? { query } : {},
     ...body !== void 0 ? { body } : {},
-    ...headers && Object.keys(headers).length > 0 ? { headers } : {},
+    ...headers2 && Object.keys(headers2).length > 0 ? { headers: headers2 } : {},
     __elasticdashResponse: elasticdashResponse
   };
   if (isStreamingContentType(res.headers) && res.body) {
@@ -2365,11 +2416,12 @@ function* jsonStreamEvents(sessionId, events) {
   }
   yield "]}";
 }
-var import_node_stream2, TelemetryBatcher;
+var import_node_stream2, import_node_crypto3, TelemetryBatcher;
 var init_telemetry_batcher = __esm({
   "src/telemetry-batcher.ts"() {
     "use strict";
     import_node_stream2 = require("node:stream");
+    import_node_crypto3 = require("node:crypto");
     init_http();
     init_debug();
     init_redact();
@@ -2420,13 +2472,16 @@ var init_telemetry_batcher = __esm({
         }
         const maxRetries = 3;
         const url = `${this.serverUrl}/api/observability/events`;
-        const headers = { "Content-Type": "application/json" };
-        if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+        const headers2 = {
+          "Content-Type": "application/json",
+          "X-Correlation-ID": (0, import_node_crypto3.randomUUID)()
+        };
+        if (this.apiKey) headers2["Authorization"] = `Bearer ${this.apiKey}`;
         try {
           const body = import_node_stream2.Readable.from(jsonStreamEvents(this.sessionId, batch));
           const res = await getOriginalFetch()(url, {
             method: "POST",
-            headers,
+            headers: headers2,
             body,
             duplex: "half"
           });
@@ -2477,6 +2532,15 @@ var init_telemetry_batcher = __esm({
 });
 
 // src/execution/tool-runner.ts
+var tool_runner_exports = {};
+__export(tool_runner_exports, {
+  buildToolArgs: () => buildToolArgs,
+  isDenoProject: () => isDenoProject,
+  resolveRuntimeModule: () => resolveRuntimeModule,
+  runToolInSubprocess: () => runToolInSubprocess,
+  scanTools: () => scanTools,
+  scanWorkflows: () => scanWorkflows
+});
 function resolveWorkerScript(relativePath) {
   try {
     return new URL(relativePath, import_meta.url).pathname;
@@ -3064,8 +3128,8 @@ async function executeTrigger(serverUrl, apiKey, trigger) {
     return;
   }
   const baseUrl = serverUrl.replace(/\/$/, "");
-  const headers = { "Content-Type": "application/json" };
-  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const headers2 = { "Content-Type": "application/json" };
+  if (apiKey) headers2["Authorization"] = `Bearer ${apiKey}`;
   for (let stepIndex = 0; stepIndex < totalSteps; stepIndex++) {
     const step = trigger.steps[stepIndex];
     const availability = step.eventType === "ai" ? checkAIAvailability(step.provider, step.model ?? step.eventName) : checkToolAvailability(step.eventName, cwd, tools);
@@ -3124,7 +3188,7 @@ ${result.error}`);
     try {
       const res = await getOriginalFetch()(url, {
         method: "POST",
-        headers,
+        headers: headers2,
         body: JSON.stringify({
           triggerId: trigger.triggerId,
           eventType: stepResult.eventType,
@@ -3262,7 +3326,7 @@ function initObservability(options) {
     throw new Error("[elasticdash] initObservability: serverUrl is required (set ELASTICDASH_API_URL or pass serverUrl option)");
   }
   const apiKey = options?.apiKey ?? process.env.ELASTICDASH_API_KEY;
-  const sessionId = options?.sessionId ?? process.env.ELASTICDASH_SESSION_ID ?? (0, import_node_crypto3.randomUUID)();
+  const sessionId = options?.sessionId ?? process.env.ELASTICDASH_SESSION_ID ?? (0, import_node_crypto4.randomUUID)();
   const sampleRate = options?.sampleRate ?? 1;
   const redactKeys = options?.redactKeys ?? [];
   const heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 3e4;
@@ -3281,7 +3345,7 @@ function initObservability(options) {
     }
   });
   let counter = 0;
-  const traceId = `${defaultWorkflowName}::${Date.now()}::${(0, import_node_crypto3.randomUUID)().slice(0, 8)}`;
+  const traceId = `${defaultWorkflowName}::${Date.now()}::${(0, import_node_crypto4.randomUUID)().slice(0, 8)}`;
   const ctx = {
     sessionId,
     serverUrl,
@@ -3339,12 +3403,12 @@ async function pushCatalog(serverUrl, apiKey, workflows = []) {
   const body = {};
   if (workflows.length > 0) body.workflows = workflows.map((w) => ({ name: w.name }));
   if (tools.length > 0) body.tools = tools.map((t) => ({ name: t.name }));
-  const headers = { "Content-Type": "application/json" };
-  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const headers2 = { "Content-Type": "application/json" };
+  if (apiKey) headers2["Authorization"] = `Bearer ${apiKey}`;
   try {
     const res = await getOriginalFetch()(`${serverUrl.replace(/\/$/, "")}/api/observability/catalog`, {
       method: "POST",
-      headers,
+      headers: headers2,
       body: JSON.stringify(body)
     });
     debugLog(`[elasticdash] Catalog pushed: ${workflows.length} workflows, ${tools.length} tools (status ${res.status})`);
@@ -3379,7 +3443,7 @@ function startTrace(workflowName) {
   if (!ctx) throw new Error("[elasticdash] startTrace: observability not initialised");
   const resolvedName = workflowName || ctx.defaultWorkflowName;
   const timestamp = Date.now();
-  const shortId = (0, import_node_crypto3.randomUUID)().slice(0, 8);
+  const shortId = (0, import_node_crypto4.randomUUID)().slice(0, 8);
   ctx.traceId = `${resolvedName}::${timestamp}::${shortId}`;
   pushTelemetryEvent({
     id: ctx.nextId(),
@@ -3397,7 +3461,7 @@ function endTrace() {
   const ctx = getObservabilityContext();
   if (!ctx) return;
   const timestamp = Date.now();
-  const shortId = (0, import_node_crypto3.randomUUID)().slice(0, 8);
+  const shortId = (0, import_node_crypto4.randomUUID)().slice(0, 8);
   ctx.traceId = `${ctx.defaultWorkflowName}::${timestamp}::${shortId}`;
 }
 function wrapWorkflow(name, fn) {
@@ -3431,11 +3495,11 @@ function wrapWorkflow(name, fn) {
     return fn(...args);
   };
 }
-var import_node_crypto3, heartbeatTimer, shutdownRegistered;
+var import_node_crypto4, heartbeatTimer, shutdownRegistered;
 var init_observability = __esm({
   "src/observability.ts"() {
     "use strict";
-    import_node_crypto3 = require("node:crypto");
+    import_node_crypto4 = require("node:crypto");
     init_telemetry_batcher();
     init_telemetry_push();
     init_ai_interceptor();
@@ -3769,7 +3833,7 @@ async function tryAutoInitHttpContext() {
         if (runId) {
           await initHttpRunContext(runId, serverUrl);
         } else {
-          setHttpRunContext((0, import_node_crypto4.randomUUID)(), serverUrl);
+          setHttpRunContext((0, import_node_crypto5.randomUUID)(), serverUrl);
         }
       } catch {
       }
@@ -3777,12 +3841,12 @@ async function tryAutoInitHttpContext() {
   }
   await g3[AUTO_INIT_KEY];
 }
-var import_node_async_hooks3, import_node_crypto4, g3, HTTP_RUN_ALS_KEY, GLOBAL_CTX_KEY, OBS_ALS_KEY, GLOBAL_OBS_KEY, httpRunAls, obsAls, INTERCEPTORS_KEY, AUTO_INIT_KEY;
+var import_node_async_hooks3, import_node_crypto5, g3, HTTP_RUN_ALS_KEY, GLOBAL_CTX_KEY, OBS_ALS_KEY, GLOBAL_OBS_KEY, httpRunAls, obsAls, INTERCEPTORS_KEY, AUTO_INIT_KEY;
 var init_telemetry_push = __esm({
   "src/interceptors/telemetry-push.ts"() {
     "use strict";
     import_node_async_hooks3 = require("node:async_hooks");
-    import_node_crypto4 = require("node:crypto");
+    import_node_crypto5 = require("node:crypto");
     init_mock_resolver();
     init_debug();
     g3 = globalThis;
@@ -3852,6 +3916,50 @@ var init_tracing = __esm({
   }
 });
 
+// src/workflow-runner.ts
+var workflow_runner_exports = {};
+__export(workflow_runner_exports, {
+  runWorkflow: () => runWorkflow
+});
+async function runWorkflow(workflowFn, options = {}) {
+  const {
+    replayMode = false,
+    checkpoint = 0,
+    history = [],
+    interceptHttp = true,
+    interceptSideEffects = true
+  } = options;
+  const recorder = new TraceRecorder();
+  const replay = new ReplayController(replayMode, checkpoint, history);
+  setCaptureContext({ recorder, replay });
+  if (interceptHttp) interceptFetch();
+  if (interceptSideEffects) {
+    interceptRandom();
+    interceptDateNow();
+  }
+  try {
+    const result = await workflowFn();
+    await recorder.flush();
+    return { result, trace: recorder.toTrace() };
+  } finally {
+    if (interceptHttp) restoreFetch();
+    if (interceptSideEffects) {
+      restoreRandom();
+      restoreDateNow();
+    }
+    setCaptureContext(void 0);
+  }
+}
+var init_workflow_runner = __esm({
+  "src/workflow-runner.ts"() {
+    "use strict";
+    init_recorder();
+    init_replay();
+    init_http();
+    init_side_effects();
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -3870,14 +3978,17 @@ __export(index_exports, {
   clearGlobalHttpContext: () => clearGlobalHttpContext,
   clearRegistry: () => clearRegistry,
   connectToBackend: () => connectToBackend,
+  createBatch: () => createBatch,
   createTraceHandle: () => createTraceHandle,
   deserializeAgentState: () => deserializeAgentState,
+  detectGitInfo: () => detectGitInfo,
   disconnectFromBackend: () => disconnectFromBackend,
   endTrace: () => endTrace,
   executePortalTask: () => executePortalTask,
   expect: () => import_expect.expect,
   extractTaskOutputs: () => extractTaskOutputs,
   fetchCapturedTrace: () => fetchCapturedTrace,
+  fetchTestGroups: () => fetchTestGroups,
   getCaptureContext: () => getCaptureContext,
   getCurrentTrace: () => getCurrentTrace,
   getHttpFrozenEvent: () => getHttpFrozenEvent,
@@ -3906,6 +4017,7 @@ __export(index_exports, {
   restoreDateNow: () => restoreDateNow,
   restoreFetch: () => restoreFetch,
   restoreRandom: () => restoreRandom,
+  runCI: () => runCI,
   runFiles: () => runFiles,
   runInHttpContext: () => runInHttpContext,
   runWithInitializedHttpContext: () => runWithInitializedHttpContext,
@@ -3921,6 +4033,7 @@ __export(index_exports, {
   startPortalServer: () => startPortalServer,
   startTrace: () => startTrace,
   startTraceSession: () => startTraceSession,
+  submitTestRun: () => submitTestRun,
   tryAutoInitHttpContext: () => tryAutoInitHttpContext,
   uninstallAIInterceptor: () => uninstallAIInterceptor,
   uninstallDBAutoInterceptor: () => uninstallDBAutoInterceptor,
@@ -4106,9 +4219,9 @@ function extractCompletion(provider, responseBody) {
   }
   return "";
 }
-function cloneHeaders(headers) {
+function cloneHeaders(headers2) {
   const result = {};
-  for (const [key, value] of Object.entries(headers)) {
+  for (const [key, value] of Object.entries(headers2)) {
     if (Array.isArray(value)) {
       result[key] = value.join(", ");
     } else if (typeof value === "string") {
@@ -4184,12 +4297,12 @@ async function startLLMProxy(options = {}) {
       const provider = detectProvider(parsed.pathname);
       const traceId = req.headers[HEADER_TRACE_ID]?.toString();
       const isStreaming = requestBody && typeof requestBody === "object" ? requestBody.stream === true : false;
-      const headers = cloneHeaders(req.headers);
+      const headers2 = cloneHeaders(req.headers);
       const upstreamBase = provider ? normalizeUpstream(provider, upstreamOverride[provider]) : void 0;
       if (!provider || !upstreamBase) {
         const passthrough = await fetch(parsed.toString(), {
           method: req.method,
-          headers,
+          headers: headers2,
           body: bodyBuf.length > 0 ? bodyBuf : void 0
         });
         sendUpstreamResponse(passthrough, res);
@@ -4198,7 +4311,7 @@ async function startLLMProxy(options = {}) {
       const targetUrl = `${upstreamBase}${parsed.pathname}${parsed.search}`;
       const upstreamRes = await fetch(targetUrl, {
         method: req.method,
-        headers,
+        headers: headers2,
         body: bodyBuf.length > 0 ? bodyBuf : void 0
       });
       if (traceId) {
@@ -4430,51 +4543,7 @@ init_matchers();
 init_matchers();
 init_context();
 init_recorder();
-
-// src/capture/replay.ts
-var ReplayController = class {
-  constructor(replayMode, checkpoint, history) {
-    this.replayMode = replayMode;
-    this.checkpoint = checkpoint;
-    this.history = history;
-    this.historyMap = new Map(history.map((e) => [e.id, e]));
-    this.sideEffectMap = new Map(
-      history.filter((e) => e.type === "side_effect").map((e) => [e.id, e])
-    );
-  }
-  historyMap;
-  /** Side effects keyed by their assigned sideEffectId, independent of main event IDs */
-  sideEffectMap;
-  shouldReplay(eventId) {
-    return this.replayMode && eventId <= this.checkpoint;
-  }
-  getRecordedEvent(eventId) {
-    return this.historyMap.get(eventId);
-  }
-  getRecordedResult(eventId) {
-    return this.historyMap.get(eventId)?.output;
-  }
-  /** Returns true if the side effect with this sideEffectId has a recorded value to replay */
-  shouldReplaySideEffect(n) {
-    return this.replayMode && this.sideEffectMap.has(n);
-  }
-  getSideEffectResult(n) {
-    return this.sideEffectMap.get(n)?.output;
-  }
-  getRecordedSideEffectEvent(n) {
-    return this.sideEffectMap.get(n);
-  }
-  shouldReplaySideEffectOfType(n, expectedName) {
-    if (!this.replayMode) return false;
-    const event = this.sideEffectMap.get(n);
-    return !!event && event.type === "side_effect" && event.name === expectedName;
-  }
-  getSideEffectResultOfType(n, expectedName) {
-    const event = this.sideEffectMap.get(n);
-    if (!event || event.type !== "side_effect" || event.name !== expectedName) return void 0;
-    return event.output;
-  }
-};
+init_replay();
 
 // src/interceptors/tool.ts
 init_recorder();
@@ -5243,39 +5312,8 @@ var isWorker = () => {
   return isWorkerContext();
 };
 
-// src/workflow-runner.ts
-init_recorder();
-init_http();
-init_side_effects();
-async function runWorkflow(workflowFn, options = {}) {
-  const {
-    replayMode = false,
-    checkpoint = 0,
-    history = [],
-    interceptHttp = true,
-    interceptSideEffects = true
-  } = options;
-  const recorder = new TraceRecorder();
-  const replay = new ReplayController(replayMode, checkpoint, history);
-  setCaptureContext({ recorder, replay });
-  if (interceptHttp) interceptFetch();
-  if (interceptSideEffects) {
-    interceptRandom();
-    interceptDateNow();
-  }
-  try {
-    const result = await workflowFn();
-    await recorder.flush();
-    return { result, trace: recorder.toTrace() };
-  } finally {
-    if (interceptHttp) restoreFetch();
-    if (interceptSideEffects) {
-      restoreRandom();
-      restoreDateNow();
-    }
-    setCaptureContext(void 0);
-  }
-}
+// src/index.ts
+init_workflow_runner();
 
 // src/core/agent-state.ts
 function serializeAgentState(plan, trace) {
@@ -5451,13 +5489,13 @@ async function startPortalServer(options) {
   }
   async function deliverResult(result) {
     const url2 = `${backendUrl}/api/portal/results/${result.taskId}`;
-    const headers = { "Content-Type": "application/json" };
-    if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+    const headers2 = { "Content-Type": "application/json" };
+    if (apiKey) headers2["Authorization"] = `Bearer ${apiKey}`;
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
         const res = await fetch(url2, {
           method: "POST",
-          headers,
+          headers: headers2,
           body: JSON.stringify(result)
         });
         if (res.ok || res.status < 500) {
@@ -5481,13 +5519,27 @@ async function startPortalServer(options) {
     }
     if (isAllowedOrigin(req, allowedHosts)) {
       if (apiKey) {
+        console.warn(JSON.stringify({
+          event: "auth.failure",
+          reason: "invalid_api_key",
+          ip: req.ip || req.headers["x-forwarded-for"] || "unknown",
+          userAgent: req.headers["user-agent"] || "unknown",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
         res.status(401).json({ ok: false, error: "unauthorized \u2014 valid API key required" });
         return;
       }
       return next();
     }
     const origin = req.headers.origin ?? req.headers.referer ?? req.ip ?? "unknown";
-    console.warn(`[elasticdash portal] Blocked request from disallowed origin: ${origin}`);
+    console.warn(JSON.stringify({
+      event: "auth.failure",
+      reason: "origin_not_allowed",
+      origin,
+      ip: req.ip || req.headers["x-forwarded-for"] || "unknown",
+      userAgent: req.headers["user-agent"] || "unknown",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
     res.status(403).json({ ok: false, error: "forbidden \u2014 origin not in allowlist" });
   }
   const app = (0, import_express.default)();
@@ -5573,6 +5625,777 @@ async function startPortalServer(options) {
 
 // src/index.ts
 init_portal_executor();
+
+// src/ci/runner.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
+
+// src/ci/api-client.ts
+var import_node_crypto6 = require("node:crypto");
+init_http();
+function headers(apiKey) {
+  return {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`,
+    "X-Correlation-ID": (0, import_node_crypto6.randomUUID)()
+  };
+}
+async function apiRequest(url, apiKey, options = {}) {
+  const res = await getOriginalFetch()(url, {
+    ...options,
+    headers: { ...headers(apiKey), ...options.headers ?? {} }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`API ${res.status}: ${text || res.statusText}`);
+  }
+  const json = await res.json();
+  return json.result ?? json.data ?? json;
+}
+async function fetchTestGroups(serverUrl, apiKey, filters) {
+  const base = serverUrl.replace(/\/$/, "");
+  const params = new URLSearchParams();
+  if (filters?.workflowName) params.set("workflowName", filters.workflowName);
+  if (filters?.tags?.length) params.set("tags", filters.tags.join(","));
+  if (filters?.status) params.set("status", filters.status);
+  const qs = params.toString();
+  const url = `${base}/api/testgroups/by-project${qs ? `?${qs}` : ""}`;
+  return apiRequest(url, apiKey);
+}
+async function submitTestRun(serverUrl, apiKey, testGroupId, payload) {
+  const base = serverUrl.replace(/\/$/, "");
+  const url = `${base}/api/testgroups/${testGroupId}/runs`;
+  return apiRequest(url, apiKey, {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+}
+async function createBatch(serverUrl, apiKey, payload) {
+  const base = serverUrl.replace(/\/$/, "");
+  const url = `${base}/api/testgroups/batches`;
+  return apiRequest(url, apiKey, {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+}
+
+// src/ci/executor.ts
+init_portal_executor();
+init_tool_runner();
+init_matchers();
+async function executeTest(test, cwd) {
+  const tools = scanTools(cwd);
+  const runCount = test.run_count || 1;
+  const timeoutMs = test.timeout_ms || 3e4;
+  const startTime = Date.now();
+  const singleRuns = [];
+  for (let i = 0; i < runCount; i++) {
+    const runStart = Date.now();
+    let result;
+    try {
+      const runPromise = executeSingleRun(test, cwd, tools, i);
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${timeoutMs}ms`)), timeoutMs)
+      );
+      result = await Promise.race([runPromise, timeoutPromise]);
+    } catch (err) {
+      result = {
+        runIndex: i + 1,
+        passed: false,
+        durationMs: Date.now() - runStart,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        output: null,
+        trace: null,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    singleRuns.push(result);
+  }
+  const expectationResults = await evaluateExpectations(test.expectations, singleRuns);
+  const passed = determinePassFail(test.pass_threshold, singleRuns, expectationResults);
+  return {
+    passed,
+    singleRuns,
+    expectationResults,
+    durationMs: Date.now() - startTime
+  };
+}
+async function executeSingleRun(test, cwd, tools, runIndex) {
+  const start = Date.now();
+  if (test.test_type === "single-step") {
+    return executeSingleStep(test, cwd, tools, runIndex, start);
+  }
+  return executeFullFlow(test, cwd, tools, runIndex, start);
+}
+async function executeSingleStep(test, cwd, tools, runIndex, start) {
+  const stepType = test.target_step_type;
+  const stepName = test.target_step_name;
+  if (!stepType || !stepName) {
+    return {
+      runIndex: runIndex + 1,
+      passed: false,
+      durationMs: Date.now() - start,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      output: null,
+      trace: null,
+      error: "Single-step test requires target_step_type and target_step_name."
+    };
+  }
+  const availability = stepType === "ai" ? checkAIAvailability(void 0, stepName) : checkToolAvailability(stepName, cwd, tools);
+  if (!availability.available) {
+    return {
+      runIndex: runIndex + 1,
+      passed: false,
+      durationMs: Date.now() - start,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      output: null,
+      trace: null,
+      error: `Step unavailable: ${availability.reason}`
+    };
+  }
+  const result = await executePortalTask(
+    {
+      taskId: `ci-${test.id}-run-${runIndex}`,
+      type: stepType === "ai" ? "ai" : "tool",
+      name: stepName,
+      input: test.mock_input,
+      frozenEvents: test.frozen_events
+    },
+    cwd,
+    tools
+  );
+  return {
+    runIndex: runIndex + 1,
+    passed: result.ok,
+    durationMs: result.durationMs,
+    inputTokens: result.usage?.inputTokens ?? 0,
+    outputTokens: result.usage?.outputTokens ?? 0,
+    totalTokens: result.usage?.totalTokens ?? 0,
+    output: result.output,
+    trace: null,
+    error: result.error
+  };
+}
+async function executeFullFlow(test, cwd, tools, runIndex, start) {
+  try {
+    const { runWorkflow: runWorkflow2 } = await Promise.resolve().then(() => (init_workflow_runner(), workflow_runner_exports));
+    const { resolveRuntimeModule: resolveRuntimeModule2 } = await Promise.resolve().then(() => (init_tool_runner(), tool_runner_exports));
+    const { pathToFileURL: pathToFileURL3 } = await import("node:url");
+    const workflowModulePath = resolveRuntimeModule2(cwd, "ed_workflows");
+    if (!workflowModulePath) {
+      return {
+        runIndex: runIndex + 1,
+        passed: false,
+        durationMs: Date.now() - start,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        output: null,
+        trace: null,
+        error: "Cannot find ed_workflows.ts/js in workspace root."
+      };
+    }
+    const workflowModule = await import(pathToFileURL3(workflowModulePath).href);
+    const workflowFns = Object.entries(workflowModule).filter(
+      ([, val]) => typeof val === "function"
+    );
+    if (workflowFns.length === 0) {
+      return {
+        runIndex: runIndex + 1,
+        passed: false,
+        durationMs: Date.now() - start,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        output: null,
+        trace: null,
+        error: "No workflow functions found in ed_workflows."
+      };
+    }
+    const targetFn = test.target_step_name ? workflowFns.find(([name]) => name === test.target_step_name)?.[1] : workflowFns[0][1];
+    const fn = targetFn ?? workflowFns[0][1];
+    const frozenEvents = Array.isArray(test.frozen_events) ? test.frozen_events : [];
+    const { result, trace } = await runWorkflow2(
+      () => {
+        const input = test.workflow_input;
+        return fn(input);
+      },
+      {
+        replayMode: frozenEvents.length > 0,
+        history: frozenEvents,
+        interceptHttp: true,
+        interceptSideEffects: true
+      }
+    );
+    let inputTokens = 0, outputTokens = 0, totalTokens = 0;
+    if (trace?.events) {
+      for (const evt of trace.events) {
+        if (evt.type === "ai" && evt.usage) {
+          inputTokens += evt.usage.inputTokens ?? evt.usage.input ?? 0;
+          outputTokens += evt.usage.outputTokens ?? evt.usage.output ?? 0;
+          totalTokens += evt.usage.totalTokens ?? evt.usage.total ?? 0;
+        }
+      }
+    }
+    return {
+      runIndex: runIndex + 1,
+      passed: true,
+      durationMs: Date.now() - start,
+      inputTokens,
+      outputTokens,
+      totalTokens,
+      output: result,
+      trace: trace ?? null
+    };
+  } catch (err) {
+    return {
+      runIndex: runIndex + 1,
+      passed: false,
+      durationMs: Date.now() - start,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      output: null,
+      trace: null,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function evaluateExpectations(expectations, singleRuns) {
+  const results = [];
+  for (const exp of expectations) {
+    const result = await evaluateExpectation(exp, singleRuns);
+    results.push(result);
+  }
+  return results;
+}
+async function evaluateExpectation(exp, singleRuns) {
+  switch (exp.type) {
+    case "token-budget":
+      return evaluateTokenBudget(exp, singleRuns);
+    case "latency-budget":
+      return evaluateLatencyBudget(exp, singleRuns);
+    case "output-contains":
+      return evaluateOutputContains(exp, singleRuns);
+    case "output-schema":
+      return evaluateOutputSchema(exp, singleRuns);
+    case "tool-called":
+      return evaluateToolCalled(exp, singleRuns);
+    case "determinism":
+      return evaluateDeterminism(exp, singleRuns);
+    case "llm-judge":
+      return evaluateLLMJudge(exp, singleRuns);
+    default:
+      return {
+        expectationId: exp.id,
+        type: exp.type,
+        passed: false,
+        detail: `Unknown expectation type: ${exp.type}`
+      };
+  }
+}
+function evaluateTokenBudget(exp, runs) {
+  const perRun = {};
+  let allPassed = true;
+  for (const run of runs) {
+    let passed = true;
+    const details = [];
+    if (exp.max_tokens_per_run != null && run.totalTokens > exp.max_tokens_per_run) {
+      passed = false;
+      details.push(`total ${run.totalTokens} > max ${exp.max_tokens_per_run}`);
+    }
+    perRun[run.runIndex] = { passed, detail: details.join("; ") || void 0 };
+    if (!passed) allPassed = false;
+  }
+  if (exp.max_total_tokens != null) {
+    const total = runs.reduce((sum, r) => sum + r.totalTokens, 0);
+    if (total > exp.max_total_tokens) {
+      allPassed = false;
+    }
+  }
+  return {
+    expectationId: exp.id,
+    type: "token-budget",
+    passed: allPassed,
+    detail: allPassed ? void 0 : "Token budget exceeded.",
+    perRun
+  };
+}
+function evaluateLatencyBudget(exp, runs) {
+  const perRun = {};
+  let allPassed = true;
+  for (const run of runs) {
+    let passed = true;
+    if (exp.max_duration_ms != null && run.durationMs > exp.max_duration_ms) {
+      passed = false;
+    }
+    perRun[run.runIndex] = { passed, detail: passed ? void 0 : `${run.durationMs}ms > ${exp.max_duration_ms}ms` };
+    if (!passed) allPassed = false;
+  }
+  if (exp.max_total_duration_ms != null) {
+    const total = runs.reduce((sum, r) => sum + r.durationMs, 0);
+    if (total > exp.max_total_duration_ms) {
+      allPassed = false;
+    }
+  }
+  return {
+    expectationId: exp.id,
+    type: "latency-budget",
+    passed: allPassed,
+    detail: allPassed ? void 0 : "Latency budget exceeded.",
+    perRun
+  };
+}
+function evaluateOutputContains(exp, runs) {
+  const perRun = {};
+  let allPassed = true;
+  for (const run of runs) {
+    const outputStr = typeof run.output === "string" ? run.output : JSON.stringify(run.output ?? "");
+    const haystack = exp.case_insensitive ? outputStr.toLowerCase() : outputStr;
+    let passed = true;
+    if (exp.contains_text) {
+      const needle = exp.case_insensitive ? exp.contains_text.toLowerCase() : exp.contains_text;
+      if (!haystack.includes(needle)) passed = false;
+    }
+    if (exp.not_contains_text) {
+      const needle = exp.case_insensitive ? exp.not_contains_text.toLowerCase() : exp.not_contains_text;
+      if (haystack.includes(needle)) passed = false;
+    }
+    perRun[run.runIndex] = { passed, detail: passed ? void 0 : "Output text check failed." };
+    if (!passed) allPassed = false;
+  }
+  return {
+    expectationId: exp.id,
+    type: "output-contains",
+    passed: allPassed,
+    detail: allPassed ? void 0 : "Output contains check failed.",
+    perRun
+  };
+}
+function evaluateOutputSchema(exp, runs) {
+  const perRun = {};
+  let allPassed = true;
+  const schema = exp.json_schema;
+  for (const run of runs) {
+    if (!schema) {
+      perRun[run.runIndex] = { passed: true };
+      continue;
+    }
+    let output = run.output;
+    if (typeof output === "string") {
+      try {
+        output = JSON.parse(output);
+      } catch {
+        perRun[run.runIndex] = { passed: false, detail: "Output is not valid JSON." };
+        allPassed = false;
+        continue;
+      }
+    }
+    const schemaType = schema.type;
+    let passed = true;
+    if (schemaType === "object" && (typeof output !== "object" || output === null || Array.isArray(output))) {
+      passed = false;
+    } else if (schemaType === "array" && !Array.isArray(output)) {
+      passed = false;
+    } else if (schemaType === "string" && typeof output !== "string") {
+      passed = false;
+    }
+    if (passed && schemaType === "object" && Array.isArray(schema.required)) {
+      for (const key of schema.required) {
+        if (!(key in output)) {
+          passed = false;
+          break;
+        }
+      }
+    }
+    perRun[run.runIndex] = { passed, detail: passed ? void 0 : "Output does not match schema." };
+    if (!passed) allPassed = false;
+  }
+  return {
+    expectationId: exp.id,
+    type: "output-schema",
+    passed: allPassed,
+    detail: allPassed ? void 0 : "Output schema check failed.",
+    perRun
+  };
+}
+function evaluateToolCalled(exp, runs) {
+  const perRun = {};
+  let allPassed = true;
+  for (const run of runs) {
+    const trace = run.trace;
+    const toolNames = trace?.events?.filter((e) => e.type === "tool").map((e) => e.name) ?? [];
+    let passed = true;
+    if (exp.required_tools?.length) {
+      for (const required of exp.required_tools) {
+        if (!toolNames.includes(required)) {
+          passed = false;
+          break;
+        }
+      }
+    }
+    if (exp.forbidden_tools?.length) {
+      for (const forbidden of exp.forbidden_tools) {
+        if (toolNames.includes(forbidden)) {
+          passed = false;
+          break;
+        }
+      }
+    }
+    perRun[run.runIndex] = { passed, detail: passed ? void 0 : `Tools called: [${toolNames.join(", ")}]` };
+    if (!passed) allPassed = false;
+  }
+  return {
+    expectationId: exp.id,
+    type: "tool-called",
+    passed: allPassed,
+    detail: allPassed ? void 0 : "Tool call check failed.",
+    perRun
+  };
+}
+function evaluateDeterminism(exp, runs) {
+  if (runs.length < 2) {
+    return {
+      expectationId: exp.id,
+      type: "determinism",
+      passed: true,
+      detail: "Only one run \u2014 determinism check skipped."
+    };
+  }
+  const outputs = runs.map(
+    (r) => typeof r.output === "string" ? r.output : JSON.stringify(r.output ?? "")
+  );
+  const reference = outputs[0];
+  let allSame = true;
+  const perRun = {};
+  for (let i = 0; i < runs.length; i++) {
+    const same = outputs[i] === reference;
+    perRun[runs[i].runIndex] = { passed: same, detail: same ? void 0 : "Output differs from run 1." };
+    if (!same) allSame = false;
+  }
+  if (!allSame && exp.similarity_threshold != null) {
+    const threshold = exp.similarity_threshold;
+    let allAboveThreshold = true;
+    for (let i = 1; i < outputs.length; i++) {
+      const similarity = computeStringSimilarity(reference, outputs[i]);
+      if (similarity < threshold) {
+        allAboveThreshold = false;
+        perRun[runs[i].runIndex] = {
+          passed: false,
+          detail: `Similarity ${(similarity * 100).toFixed(1)}% < ${(threshold * 100).toFixed(1)}%`
+        };
+      } else {
+        perRun[runs[i].runIndex] = { passed: true };
+      }
+    }
+    return {
+      expectationId: exp.id,
+      type: "determinism",
+      passed: allAboveThreshold,
+      detail: allAboveThreshold ? void 0 : "Outputs are not sufficiently similar.",
+      perRun
+    };
+  }
+  return {
+    expectationId: exp.id,
+    type: "determinism",
+    passed: allSame,
+    detail: allSame ? void 0 : "Outputs are not identical across runs.",
+    perRun
+  };
+}
+function computeStringSimilarity(a, b) {
+  if (a === b) return 1;
+  if (!a.length || !b.length) return 0;
+  const longer = a.length >= b.length ? a : b;
+  const shorter = a.length < b.length ? a : b;
+  let matches = 0;
+  for (let i = 0; i < shorter.length; i++) {
+    if (shorter[i] === longer[i]) matches++;
+  }
+  return matches / longer.length;
+}
+async function evaluateLLMJudge(exp, runs) {
+  if (!exp.judge_prompt) {
+    return {
+      expectationId: exp.id,
+      type: "llm-judge",
+      passed: false,
+      detail: "LLM judge expectation requires judge_prompt."
+    };
+  }
+  const perRun = {};
+  let allPassed = true;
+  const threshold = exp.judge_score_threshold ?? 7;
+  for (const run of runs) {
+    const outputStr = typeof run.output === "string" ? run.output : JSON.stringify(run.output ?? "");
+    const evalPrompt = `${exp.judge_prompt}
+
+Output to evaluate:
+${outputStr}
+
+Score this output on a scale of 0-10. Respond with only the number.`;
+    try {
+      const provider = exp.judge_provider || "openai";
+      const result = await callProviderLLM(
+        evalPrompt,
+        { provider, model: exp.judge_model ?? void 0 },
+        "You are an expert test judge. Return only a number between 0 and 10.",
+        16,
+        0
+      );
+      const score = parseFloat(result.content.match(/-?\d+(?:\.\d+)?/)?.[0] ?? "");
+      if (isNaN(score)) {
+        perRun[run.runIndex] = { passed: false, detail: `Could not parse score from: "${result.content}"` };
+        allPassed = false;
+      } else {
+        const passed = score >= threshold;
+        perRun[run.runIndex] = { passed, detail: `Score: ${score}/${threshold}` };
+        if (!passed) allPassed = false;
+      }
+    } catch (err) {
+      perRun[run.runIndex] = {
+        passed: false,
+        detail: `LLM judge error: ${err instanceof Error ? err.message : String(err)}`
+      };
+      allPassed = false;
+    }
+  }
+  return {
+    expectationId: exp.id,
+    type: "llm-judge",
+    passed: allPassed,
+    detail: allPassed ? void 0 : "LLM judge check failed.",
+    perRun
+  };
+}
+function determinePassFail(passThreshold, singleRuns, expectationResults) {
+  const runsPassed = singleRuns.filter((r) => r.passed).length;
+  const totalRuns = singleRuns.length;
+  let runsPass;
+  switch (passThreshold) {
+    case "all":
+      runsPass = runsPassed === totalRuns;
+      break;
+    case "majority":
+      runsPass = runsPassed > totalRuns / 2;
+      break;
+    case "any":
+      runsPass = runsPassed > 0;
+      break;
+    default:
+      runsPass = runsPassed === totalRuns;
+  }
+  const expectationsPass = expectationResults.every((e) => e.passed);
+  return runsPass && expectationsPass;
+}
+
+// src/ci/git-info.ts
+function detectGitInfo() {
+  const env = process.env;
+  if (env.GITHUB_ACTIONS === "true") {
+    const prNumber = env.GITHUB_EVENT_NAME === "pull_request" ? parseInt(env.GITHUB_REF?.match(/refs\/pull\/(\d+)/)?.[1] ?? "", 10) || void 0 : void 0;
+    const repo = env.GITHUB_REPOSITORY;
+    const prUrl = prNumber && repo ? `https://github.com/${repo}/pull/${prNumber}` : void 0;
+    return {
+      branch: env.GITHUB_HEAD_REF || env.GITHUB_REF_NAME,
+      commit: env.GITHUB_SHA,
+      commitMessage: env.GITHUB_COMMIT_MESSAGE,
+      prNumber,
+      prUrl
+    };
+  }
+  if (env.GITLAB_CI === "true") {
+    const prNumber = env.CI_MERGE_REQUEST_IID ? parseInt(env.CI_MERGE_REQUEST_IID, 10) || void 0 : void 0;
+    return {
+      branch: env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME || env.CI_COMMIT_BRANCH,
+      commit: env.CI_COMMIT_SHA,
+      commitMessage: env.CI_COMMIT_MESSAGE,
+      prNumber,
+      prUrl: env.CI_MERGE_REQUEST_PROJECT_URL && prNumber ? `${env.CI_MERGE_REQUEST_PROJECT_URL}/-/merge_requests/${prNumber}` : void 0
+    };
+  }
+  return {
+    branch: env.CIRCLE_BRANCH || env.TRAVIS_BRANCH || env.BITBUCKET_BRANCH || env.CI_BRANCH,
+    commit: env.CIRCLE_SHA1 || env.TRAVIS_COMMIT || env.BITBUCKET_COMMIT || env.CI_COMMIT_SHA,
+    commitMessage: env.CI_COMMIT_MESSAGE,
+    prNumber: env.CIRCLE_PULL_REQUEST ? parseInt(env.CIRCLE_PULL_REQUEST.split("/").pop() ?? "", 10) || void 0 : env.TRAVIS_PULL_REQUEST && env.TRAVIS_PULL_REQUEST !== "false" ? parseInt(env.TRAVIS_PULL_REQUEST, 10) || void 0 : void 0
+  };
+}
+
+// src/ci/runner.ts
+async function runCI(config) {
+  const { serverUrl, apiKey } = config;
+  const cwd = process.cwd();
+  const detected = detectGitInfo();
+  const gitBranch = config.gitBranch || detected.branch;
+  const gitCommit = config.gitCommit || detected.commit;
+  const gitCommitMessage = config.gitCommitMessage || detected.commitMessage;
+  const gitPrNumber = config.gitPrNumber || detected.prNumber;
+  const gitPrUrl = config.gitPrUrl || detected.prUrl;
+  const triggeredBy = config.triggeredBy || "ci";
+  const overallStart = Date.now();
+  console.log(import_chalk2.default.cyan("\n[elasticdash ci] Fetching test groups..."));
+  const testGroups = await fetchTestGroups(serverUrl, apiKey, {
+    workflowName: config.workflowName,
+    tags: config.tags
+  });
+  if (testGroups.length === 0) {
+    console.log(import_chalk2.default.yellow("[elasticdash ci] No active test groups found."));
+    return {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      durationMs: Date.now() - overallStart,
+      batchId: null,
+      results: []
+    };
+  }
+  const totalTests = testGroups.reduce((sum, g5) => sum + g5.tests.length, 0);
+  console.log(import_chalk2.default.cyan(`[elasticdash ci] Found ${testGroups.length} test group(s), ${totalTests} test(s) total.
+`));
+  const allResults = [];
+  const runIds = [];
+  for (const group of testGroups) {
+    console.log(import_chalk2.default.white.bold(`  ${group.name}`) + import_chalk2.default.gray(` (${group.tests.length} tests)`));
+    for (const test of group.tests) {
+      const testLabel = test.name || `${test.test_type}:${test.target_step_name || "unnamed"}`;
+      process.stdout.write(import_chalk2.default.gray(`    ${testLabel} ... `));
+      const testStart = Date.now();
+      let testResult;
+      try {
+        const execution = await executeTest(test, cwd);
+        const payload = {
+          testGroupTestId: test.id,
+          triggeredBy,
+          passed: execution.passed,
+          summary: execution.passed ? "Passed" : "Failed",
+          gitBranch,
+          gitCommit,
+          gitCommitMessage,
+          gitPrNumber,
+          gitPrUrl,
+          singleRuns: execution.singleRuns,
+          expectationResults: execution.expectationResults,
+          startedAt: new Date(testStart).toISOString(),
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        let runId = null;
+        try {
+          const submitted = await submitTestRun(serverUrl, apiKey, group.id, payload);
+          runId = submitted.id;
+          runIds.push(runId);
+        } catch (submitErr) {
+          console.error(import_chalk2.default.yellow(`
+    [warn] Failed to submit result: ${submitErr instanceof Error ? submitErr.message : String(submitErr)}`));
+        }
+        testResult = {
+          testGroupId: group.id,
+          testGroupName: group.name,
+          testId: test.id,
+          testName: test.name,
+          testType: test.test_type,
+          passed: execution.passed,
+          runId,
+          singleRuns: execution.singleRuns,
+          expectationResults: execution.expectationResults,
+          durationMs: execution.durationMs
+        };
+      } catch (err) {
+        testResult = {
+          testGroupId: group.id,
+          testGroupName: group.name,
+          testId: test.id,
+          testName: test.name,
+          testType: test.test_type,
+          passed: false,
+          runId: null,
+          singleRuns: [],
+          expectationResults: [],
+          error: err instanceof Error ? err.message : String(err),
+          durationMs: Date.now() - testStart
+        };
+      }
+      allResults.push(testResult);
+      const durationStr = import_chalk2.default.gray(`(${testResult.durationMs}ms)`);
+      if (testResult.passed) {
+        console.log(import_chalk2.default.green("PASS") + ` ${durationStr}`);
+      } else {
+        console.log(import_chalk2.default.red("FAIL") + ` ${durationStr}`);
+        if (testResult.error) {
+          console.log(import_chalk2.default.red(`      ${testResult.error}`));
+        }
+        for (const exp of testResult.expectationResults) {
+          if (!exp.passed) {
+            console.log(import_chalk2.default.red(`      [${exp.type}] ${exp.detail || "failed"}`));
+          }
+        }
+      }
+    }
+    console.log();
+  }
+  let batchId = null;
+  if (runIds.length > 0) {
+    try {
+      const passedCount = allResults.filter((r) => r.passed).length;
+      const allPassed = passedCount === allResults.length;
+      const batch = await createBatch(serverUrl, apiKey, {
+        testGroupRunIds: runIds,
+        status: allPassed ? "success" : "failed",
+        passed: allPassed,
+        summary: `CI: ${passedCount}/${allResults.length} passed`,
+        gitBranch,
+        gitCommit,
+        startedAt: new Date(overallStart).toISOString(),
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      batchId = batch.id;
+    } catch {
+    }
+  }
+  const passed = allResults.filter((r) => r.passed).length;
+  const failed = allResults.filter((r) => !r.passed).length;
+  const durationMs = Date.now() - overallStart;
+  console.log(import_chalk2.default.white.bold("\u2500".repeat(50)));
+  console.log(import_chalk2.default.white.bold("Summary"));
+  console.log(import_chalk2.default.white.bold("\u2500".repeat(50)));
+  console.log(`  Total:    ${allResults.length}`);
+  console.log(`  ${import_chalk2.default.green(`Passed:   ${passed}`)}`);
+  if (failed > 0) {
+    console.log(`  ${import_chalk2.default.red(`Failed:   ${failed}`)}`);
+  }
+  console.log(`  Duration: ${(durationMs / 1e3).toFixed(1)}s`);
+  if (batchId) {
+    console.log(`  Batch ID: ${batchId}`);
+  }
+  console.log(import_chalk2.default.white.bold("\u2500".repeat(50)));
+  if (failed > 0) {
+    console.log(import_chalk2.default.red(`
+[elasticdash ci] ${failed} test(s) failed.
+`));
+  } else {
+    console.log(import_chalk2.default.green(`
+[elasticdash ci] All tests passed.
+`));
+  }
+  return {
+    total: allResults.length,
+    passed,
+    failed,
+    skipped: 0,
+    durationMs,
+    batchId,
+    results: allResults
+  };
+}
+
+// src/index.ts
 init_telemetry_push();
 tryAutoInitHttpContext().catch(() => {
 });
@@ -5593,14 +6416,17 @@ tryAutoInitHttpContext().catch(() => {
   clearGlobalHttpContext,
   clearRegistry,
   connectToBackend,
+  createBatch,
   createTraceHandle,
   deserializeAgentState,
+  detectGitInfo,
   disconnectFromBackend,
   endTrace,
   executePortalTask,
   expect,
   extractTaskOutputs,
   fetchCapturedTrace,
+  fetchTestGroups,
   getCaptureContext,
   getCurrentTrace,
   getHttpFrozenEvent,
@@ -5629,6 +6455,7 @@ tryAutoInitHttpContext().catch(() => {
   restoreDateNow,
   restoreFetch,
   restoreRandom,
+  runCI,
   runFiles,
   runInHttpContext,
   runWithInitializedHttpContext,
@@ -5644,6 +6471,7 @@ tryAutoInitHttpContext().catch(() => {
   startPortalServer,
   startTrace,
   startTraceSession,
+  submitTestRun,
   tryAutoInitHttpContext,
   uninstallAIInterceptor,
   uninstallDBAutoInterceptor,