@opensearch-project/agent-health 0.5.2 → 0.6.0

package/cli/dist/index.js

@@ -17,9 +17,11 @@ var __export = (target, all) => {
 
 // lib/envCompat.ts
 function readEnv(newName, oldName) {
-  const newVal = process.env[newName];
+  const env = typeof process !== "undefined" ? process.env : void 0;
+  if (!env) return void 0;
+  const newVal = env[newName];
   if (newVal !== void 0) return newVal;
-  const oldVal = process.env[oldName];
+  const oldVal = env[oldName];
   if (oldVal !== void 0) {
     warnDeprecated(oldName, newName);
     return oldVal;
@@ -29,7 +31,8 @@ function readEnv(newName, oldName) {
 function warnDeprecated(oldName, newName) {
   if (warned.has(oldName)) return;
   warned.add(oldName);
-  if (process.env.AH_QUIET_DEPRECATIONS === "1" || process.env.AGENT_HEALTH_QUIET_DEPRECATIONS === "1") {
+  const env = typeof process !== "undefined" ? process.env : void 0;
+  if (env?.AH_QUIET_DEPRECATIONS === "1" || env?.AGENT_HEALTH_QUIET_DEPRECATIONS === "1") {
     return;
   }
   console.warn(
@@ -472,6 +475,11 @@ function toAgentConfig(userAgent) {
     enabled: userAgent.enabled ?? true,
     headers: userAgent.headers ?? {},
     useTraces: userAgent.useTraces ?? false,
+    // Trace-correlation fields — dropping these silently broke per-agent
+    // service-window correlation (fell back to protocol defaults, colliding
+    // with other emitters) and per-agent poll budgets (fell back to 60×10s).
+    traceServiceName: userAgent.traceServiceName,
+    tracePolling: userAgent.tracePolling,
     connectorType: userAgent.connectorType,
     connectorConfig: userAgent.connectorConfig,
     hooks: userAgent.hooks
@@ -2349,6 +2357,14 @@ Question: ${prompt}`;
           ...process.env,
           ...this.buildAuthEnv(auth),
           ...this.config.env,
+          // W3C trace context (Strategy A): TRACEPARENT/TRACESTATE from the active
+          // eval `test_case` span. Agents whose OTel SDK honors TRACEPARENT (pi —
+          // verified) emit their spans under the eval span's traceId, giving the
+          // trace poller an exact, window-free correlator. Despite the
+          // `traceContext.propagateEnv` contract, this helper was never actually
+          // wired into the spawn env before — subprocess agents silently ran
+          // without trace context.
+          ...this.buildTraceparentEnv(),
           AGENT_EVAL_RUN_ID: runId
         };
         return new Promise((resolve10, reject) => {
@@ -2851,8 +2867,9 @@ var init_ClaudeCodeConnector = __esm({
         this.debug("Test case:", request.testCase.name);
         this.debug("Config:", this["config"]);
         this.resetState();
+        this.pristineArgs ??= this.config.args ? [...this.config.args] : [];
         const originalEnv = this.config.env ? structuredClone(this.config.env) : {};
-        const originalArgs = this.config.args ? [...this.config.args] : [];
+        const originalArgs = [...this.pristineArgs];
         const originalInputMode = this.config.inputMode;
         const originalTimeout = this.config.timeout;
         const originalWorkingDir = this.config.workingDir;
@@ -2878,8 +2895,8 @@ var init_ClaudeCodeConnector = __esm({
         }
         if (ccConfig) {
           const configArgs = this.buildConfigArgs(ccConfig);
+          this.config.args = [...this.pristineArgs, ...configArgs];
           if (configArgs.length > 0) {
-            this.config.args = [...this.config.args || [], ...configArgs];
             this.debug("Config args added:", configArgs);
           }
         }
@@ -4319,39 +4336,51 @@ var init_consolidate = __esm({
 // services/traces/messageExtraction.ts
 function extractMessagesFromSpans(spans, serviceName) {
   if (!spans || spans.length === 0) return [];
-  const isClaudeCode = serviceName === "claude-code" || spans.some((s) => s.attributes?.["service.name"] === "claude-code");
+  const isClaudeCode = serviceName?.startsWith("claude-code") || spans.some((s) => String(s.attributes?.["service.name"] ?? "").startsWith("claude-code")) || spans.some((s) => s.name?.startsWith("claude_code."));
   const sorted = [...spans].filter((s) => s.startTime && !isNaN(new Date(s.startTime).getTime())).sort(
     (a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime()
   );
   const messages = [];
+  const resultEmittedForToolUseId = /* @__PURE__ */ new Set();
   for (const span of sorted) {
     if (isClaudeCode) {
-      extractClaudeCodeMessages(span, messages);
+      extractClaudeCodeMessages(span, messages, resultEmittedForToolUseId);
     } else {
       extractGenericMessages(span, messages);
     }
   }
   return messages;
 }
-function extractClaudeCodeMessages(span, messages) {
+function extractClaudeCodeMessages(span, messages, resultEmittedForToolUseId) {
   const events = span.events || [];
   const attrs = span.attributes || {};
   const spanName = span.name?.toLowerCase() || "";
+  if (spanName.includes("interaction") && attrs["user_prompt"] && attrs["user_prompt"] !== "<REDACTED>") {
+    messages.push({
+      id: `${span.spanId}-user-prompt`,
+      timestamp: span.startTime,
+      role: "user",
+      content: String(attrs["user_prompt"]),
+      metadata: { spanId: span.spanId, spanName: span.name }
+    });
+  }
   for (const event of events) {
     if (event.name === "user_prompt") {
       const content = event.attributes?.["user.prompt"] || event.attributes?.["prompt"] || event.attributes?.["content"] || "";
-      messages.push({
-        id: `${span.spanId}-user-prompt`,
-        timestamp: event.time || span.startTime,
-        role: "user",
-        content: content || "[User prompt \u2014 content not captured. Set OTEL_LOG_USER_PROMPTS=1]",
-        metadata: { spanId: span.spanId, spanName: span.name }
-      });
+      if (content && !messages.some((m2) => m2.id === `${span.spanId}-user-prompt`)) {
+        messages.push({
+          id: `${span.spanId}-user-prompt-ev`,
+          timestamp: event.time || span.startTime,
+          role: "user",
+          content: content || "[User prompt \u2014 content not captured. Set OTEL_LOG_USER_PROMPTS=1]",
+          metadata: { spanId: span.spanId, spanName: span.name }
+        });
+      }
     }
   }
-  if (spanName.includes("tool") && !spanName.includes("execution")) {
+  if (spanName.includes("tool") && !spanName.includes("execution") && !spanName.includes("blocked")) {
     const toolName = attrs["tool_name"] || attrs["gen_ai.tool.name"] || attrs["tool.name"] || span.name;
-    const toolInput = attrs["tool_input"] || attrs["gen_ai.tool.input"] || "";
+    const toolInput = attrs["tool_input"] || attrs["gen_ai.tool.input"] || attrs["full_command"] || "";
     const toolDecisionEvent = events.find((e) => e.name === "tool_decision");
     const input = toolDecisionEvent?.attributes?.["input"] || toolDecisionEvent?.attributes?.["tool.input"] || toolInput;
     if (toolName) {
@@ -4368,6 +4397,26 @@ function extractClaudeCodeMessages(span, messages) {
         }
       });
     }
+    const toolOutputEvent = events.find((e) => e.name === "tool.output");
+    if (toolOutputEvent) {
+      const output = toolOutputEvent.attributes?.["output"] || toolOutputEvent.attributes?.["result"] || "";
+      const toolUseId = attrs["tool_use_id"] || attrs["gen_ai.tool.call.id"];
+      const alreadyEmitted = toolUseId != null && resultEmittedForToolUseId.has(String(toolUseId));
+      if (output && !alreadyEmitted) {
+        if (toolUseId) resultEmittedForToolUseId.add(String(toolUseId));
+        messages.push({
+          id: `${span.spanId}-tool-output-ev`,
+          timestamp: toolOutputEvent.time || span.endTime,
+          role: "tool_result",
+          content: typeof output === "object" ? JSON.stringify(output, null, 2) : String(output),
+          metadata: {
+            spanId: span.spanId,
+            spanName: span.name,
+            toolName: String(toolName)
+          }
+        });
+      }
+    }
   }
   for (const event of events) {
     if (event.name === "tool_result") {
@@ -4386,8 +4435,11 @@ function extractClaudeCodeMessages(span, messages) {
     }
   }
   if (spanName.includes("tool.execution") || spanName.includes("tool_execution")) {
+    const execToolUseId = attrs["tool_use_id"] || attrs["gen_ai.tool.call.id"];
+    const alreadyEmitted = execToolUseId != null && resultEmittedForToolUseId.has(String(execToolUseId));
     const output = attrs["gen_ai.tool.output"] || attrs["tool.output"] || attrs["output"];
-    if (output && !events.some((e) => e.name === "tool_result")) {
+    if (output && !alreadyEmitted && !events.some((e) => e.name === "tool_result")) {
+      if (execToolUseId != null) resultEmittedForToolUseId.add(String(execToolUseId));
       messages.push({
         id: `${span.spanId}-tool-output`,
         timestamp: span.endTime,
@@ -4465,22 +4517,22 @@ function extractGenericMessages(span, messages) {
   }
   const toolName = attrs["gen_ai.tool.name"] || attrs["tool.name"];
   if (toolName) {
-    const toolInput = attrs["gen_ai.tool.input"] || attrs["input"];
-    if (toolInput) {
-      messages.push({
-        id: `${span.spanId}-tool-call`,
-        timestamp: span.startTime,
-        role: "tool_call",
-        content: typeof toolInput === "object" ? JSON.stringify(toolInput, null, 2) : String(toolInput),
-        metadata: {
-          spanId: span.spanId,
-          spanName: span.name,
-          toolName: String(toolName),
-          durationMs: span.duration || new Date(span.endTime).getTime() - new Date(span.startTime).getTime()
-        }
-      });
-    }
-    const toolOutput = attrs["gen_ai.tool.output"] || attrs["output"];
+    const toolMessageEvent = events.find((e) => e.name === "gen_ai.tool.message");
+    const toolChoiceEvent = events.find((e) => e.name === "gen_ai.choice");
+    const toolInput = attrs["gen_ai.tool.call.arguments"] || toolMessageEvent?.attributes?.["content"] || attrs["gen_ai.tool.input"] || attrs["input"];
+    messages.push({
+      id: `${span.spanId}-tool-call`,
+      timestamp: span.startTime,
+      role: "tool_call",
+      content: toolInput ? typeof toolInput === "object" ? JSON.stringify(toolInput, null, 2) : String(toolInput) : "",
+      metadata: {
+        spanId: span.spanId,
+        spanName: span.name,
+        toolName: String(toolName),
+        durationMs: span.duration || new Date(span.endTime).getTime() - new Date(span.startTime).getTime()
+      }
+    });
+    const toolOutput = attrs["gen_ai.tool.call.result"] || toolChoiceEvent?.attributes?.["message"] || toolChoiceEvent?.attributes?.["content"] || attrs["gen_ai.tool.output"] || attrs["output"];
     if (toolOutput) {
       messages.push({
         id: `${span.spanId}-tool-result`,
@@ -4564,6 +4616,7 @@ function claudeNativeTrajectory(spans) {
   const sorted = sortByStart(spans);
   const toolNames = toolNamesById(sorted);
   const steps = [];
+  const resultEmittedForToolUseId = /* @__PURE__ */ new Set();
   for (const s of sorted) {
     const a = s.attributes || {};
     const ts2 = new Date(s.startTime).getTime() || Date.now();
@@ -4587,7 +4640,7 @@ function claudeNativeTrajectory(spans) {
       });
     } else if (t === "tool") {
       const name = a["tool_name"] || a["gen_ai.tool.name"];
-      const input = a["tool_input"] || a["gen_ai.tool.input"];
+      const input = a["tool_input"] || a["gen_ai.tool.input"] || a["full_command"];
       let toolArgs;
       if (input) {
         try {
@@ -4602,19 +4655,41 @@ function claudeNativeTrajectory(spans) {
         toolName: name ? String(name) : void 0,
         toolArgs
       });
+      const toolOutputEvent = (s.events || []).find((e) => e.name === "tool.output");
+      const eventOutput = toolOutputEvent?.attributes?.["output"] || toolOutputEvent?.attributes?.["result"];
+      const toolUseId = a["tool_use_id"] || a["gen_ai.tool.call.id"];
+      const alreadyEmittedForThisId = toolUseId != null && resultEmittedForToolUseId.has(String(toolUseId));
+      if (eventOutput && !alreadyEmittedForThisId) {
+        if (toolUseId != null) resultEmittedForToolUseId.add(String(toolUseId));
+        const eventTs = toolOutputEvent?.time ? new Date(toolOutputEvent.time).getTime() : NaN;
+        steps.push({
+          ...base,
+          id: `${s.spanId}-output`,
+          timestamp: !isNaN(eventTs) ? eventTs : ts2,
+          type: "tool_result",
+          content: String(eventOutput),
+          toolName: name ? String(name) : void 0,
+          toolOutput: eventOutput,
+          status: s.status === "ERROR" ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */
+        });
+      }
     } else if (t === "tool.execution") {
       const success = a["success"];
       const id = a["tool_use_id"] || a["gen_ai.tool.call.id"];
       const name = id && toolNames.get(String(id)) || a["tool_name"];
       const output = a["gen_ai.tool.output"] || a["tool.output"];
-      steps.push({
-        ...base,
-        type: "tool_result",
-        content: output != null ? String(output) : success === false ? "tool failed" : "tool succeeded",
-        toolName: name ? String(name) : void 0,
-        toolOutput: output,
-        status: success === false ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */
-      });
+      if (id && resultEmittedForToolUseId.has(String(id))) {
+      } else {
+        if (id) resultEmittedForToolUseId.add(String(id));
+        steps.push({
+          ...base,
+          type: "tool_result",
+          content: output != null ? String(output) : success === false ? "tool failed" : "tool succeeded",
+          toolName: name ? String(name) : void 0,
+          toolOutput: output,
+          status: success === false ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */
+        });
+      }
     } else if (t === "tool.blocked_on_user") {
       const decision = String(a["decision"] ?? "");
       if (decision && decision !== "accept") {
@@ -5166,10 +5241,27 @@ var init_authoringSurface = __esm({
   }
 });
 
+// lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function detectSourceLanguage(fileName) {
+  const lower = fileName.toLowerCase();
+  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs")) {
+    return "javascript";
+  }
+  return "typescript";
+}
+var init_utils = __esm({
+  "lib/utils.ts"() {
+    init_constants();
+  }
+});
+
 // lib/testCases/loader.ts
 var loader_exports = {};
 __export(loader_exports, {
   computeTestCaseHash: () => computeTestCaseHash,
+  detectSourceLanguage: () => detectSourceLanguage,
   isCodeFile: () => isCodeFile,
   loadTestCasesFromModule: () => loadTestCasesFromModule
 });
@@ -5182,7 +5274,7 @@ function isCodeFile(filename) {
   const lower = filename.toLowerCase();
   return CODE_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function computeTestCaseHash(tc) {
+function computeTestCaseHash(tc, fileSource2) {
   const content = JSON.stringify({
     name: tc.name,
     prompt: tc.options.prompt,
@@ -5195,17 +5287,27 @@ function computeTestCaseHash(tc) {
     // see the test case stay on its old version and the new outcomes
     // would never reach storage.
     expectedOutcomes: tc.options.expectedOutcomes,
-    expectedTrajectory: tc.options.expectedTrajectory
+    expectedTrajectory: tc.options.expectedTrajectory,
+    // Fold in the WHOLE file's raw text (optional -- omitted by callers that
+    // don't have it, e.g. existing unit tests exercising this function in
+    // isolation). Without this, editing ONLY the evaluate() body, a helper
+    // function, an import, or even just a comment would leave every
+    // options-derived field above unchanged, `sourceHash` would stay put,
+    // `bulkUpsert` would classify the row as unchanged, and the persisted
+    // `sourceCode` -- the entire point of the eval-source viewer -- would
+    // silently go stale relative to the real file on disk.
+    fileSource: fileSource2
   });
   return createHash("sha256").update(content).digest("hex");
 }
 async function loadTestCasesFromModule(filePath) {
   const absPath = resolve4(filePath);
+  const fileSource = readFileSync2(absPath, "utf-8");
   clearRegistry(absPath);
   setActiveFile(absPath);
   let module;
   if (absPath.endsWith(".js")) {
-    const code = readFileSync2(absPath, "utf-8");
+    const code = fileSource;
     const fileDir = dirname3(absPath);
     const Module = NodeModule;
     const m = new Module(absPath);
@@ -5262,7 +5364,7 @@ ${err.message}`);
   }
   const loaded = testCases.map((tc) => ({
     ...tc,
-    hash: computeTestCaseHash(tc)
+    hash: computeTestCaseHash(tc, fileSource)
   }));
   const benchmarks = /* @__PURE__ */ new Map();
   for (const tc of loaded) {
@@ -5273,13 +5375,14 @@ ${err.message}`);
     }
   }
   const hooks = getRegisteredHooks(absPath);
-  return { testCases: loaded, filePath: absPath, benchmarks, hooks };
+  return { testCases: loaded, filePath: absPath, benchmarks, hooks, fileSource };
 }
 var CODE_EXTENSIONS;
 var init_loader2 = __esm({
   "lib/testCases/loader.ts"() {
     init_define();
     init_authoringSurface();
+    init_utils();
     CODE_EXTENSIONS = [".ts", ".js", ".mjs"];
   }
 });
@@ -5471,14 +5574,14 @@ var init_codemod = __esm({
 });
 
 // cli/index.ts
-import { Command as Command18 } from "commander";
-import chalk19 from "chalk";
+import { Command as Command20 } from "commander";
+import chalk21 from "chalk";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname7, join as join11, resolve as resolve9 } from "path";
-import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
+import { dirname as dirname8, join as join12, resolve as resolve9 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync12 } from "fs";
 import { config as loadDotenv } from "dotenv";
 import open from "open";
-import ora7 from "ora";
+import ora8 from "ora";
 
 // cli/utils/startServer.ts
 import { fileURLToPath } from "url";
@@ -5549,8 +5652,9 @@ import { dirname as dirname2, join as join4 } from "path";
 
 // cli/utils/serverOwnership.ts
 function decideServerOwnership(params) {
-  const { serverCwd, myCwd, allowForeign } = params;
+  const { serverCwd, myCwd, allowForeign, readOnly } = params;
   const foreign = typeof serverCwd === "string" && serverCwd.length > 0 && serverCwd !== myCwd;
+  if (foreign && readOnly) return { action: "reuse-foreign-readonly" };
   if (foreign && !allowForeign) return { action: "refuse" };
   if (foreign && allowForeign) return { action: "reuse-foreign" };
   return { action: "proceed" };
@@ -5768,7 +5872,7 @@ function stopServer(process2) {
   }
 }
 async function ensureServer(config) {
-  const { port, reuseExistingServer, startTimeout } = config;
+  const { port, reuseExistingServer, startTimeout, readOnly } = config;
   const baseUrl = `http://localhost:${port}`;
   const serverStatus = await checkServerStatus(port);
   const cliVersion = getCliVersion();
@@ -5778,7 +5882,8 @@ async function ensureServer(config) {
     const ownership = decideServerOwnership({
       serverCwd: serverStatus.cwd,
       myCwd,
-      allowForeign
+      allowForeign,
+      readOnly
     });
     if (ownership.action === "refuse") {
       throw new Error(
@@ -5790,6 +5895,12 @@ async function ensureServer(config) {
         })
       );
     }
+    if (ownership.action === "reuse-foreign-readonly") {
+      console.log(
+        `[ServerLifecycle] Reusing FOREIGN server on port ${port} in read-only mode (cwd ${serverStatus.cwd}, no writes will be issued).`
+      );
+      return { wasStarted: false, baseUrl };
+    }
     if (ownership.action === "reuse-foreign") {
       console.log(
         `[ServerLifecycle] Reusing FOREIGN server on port ${port} (cwd ${serverStatus.cwd}) \u2014 AH_REUSE_FOREIGN_SERVER override set.`
@@ -6081,6 +6192,40 @@ var ApiClient = class {
       { timeoutMs, onPoll: onProgress }
     );
   }
+  /**
+   * Get a code-import / SDK evaluation run by id.
+   * GET /api/storage/evaluation-runs/:id — returns the run directly (not nested
+   * under a benchmark). Returns null on 404.
+   */
+  async getEvaluationRun(runId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/storage/evaluation-runs/${encodeURIComponent(runId)}`
+    );
+    if (res.status === 404) return null;
+    if (!res.ok) {
+      throw new Error(`Failed to get evaluation run: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /**
+   * Poll an evaluation run until it reaches a terminal state
+   * (completed / failed / cancelled).
+   *
+   * This is the fallback for long runs where the SSE progress stream drops
+   * (idle-timeout at a proxy, ~4 min) while the server keeps executing and
+   * persisting results. The CLI must read the true final state from storage
+   * rather than trusting the point at which the stream happened to end.
+   *
+   * Default timeout is deliberately generous (60 min): subprocess agents
+   * (Kiro / Claude Code / custom ops agents) can run many minutes per case.
+   */
+  async pollEvaluationRunStatus(runId, onProgress, timeoutMs = 36e5) {
+    return this.pollUntilTerminal(
+      () => this.getEvaluationRun(runId),
+      (run) => !!run.status && ["completed", "failed", "cancelled"].includes(run.status),
+      { timeoutMs, onPoll: onProgress }
+    );
+  }
   /**
    * Get a single report (TestCaseRun) by ID.
    *
@@ -6323,7 +6468,7 @@ var ApiClient = class {
         console.warn(`[ApiClient] Falling back to polling for report ${reportId} \u2014 server is still processing in the background...`);
         onProgress?.({ type: "reconnecting", reportId });
         const polledResult = await this.pollReportStatus(reportId, void 0, (report) => {
-          onProgress?.({ type: "polling", reportId: report.id, status: report.status });
+          onProgress?.({ type: "polling", reportId: report.id, status: report.status ?? "unknown" });
         });
         if (polledResult) {
           return polledResult;
@@ -6341,7 +6486,7 @@ var ApiClient = class {
         console.warn("[ApiClient] SSE stream ended without completion event, polling for status...");
         onProgress?.({ type: "reconnecting", reportId });
         const polledResult = await this.pollReportStatus(reportId, void 0, (report) => {
-          onProgress?.({ type: "polling", reportId: report.id, status: report.status });
+          onProgress?.({ type: "polling", reportId: report.id, status: report.status ?? "unknown" });
         });
         if (polledResult) {
           return polledResult;
@@ -6349,6 +6494,16 @@ var ApiClient = class {
       }
       throw new Error("No result received from evaluation");
     }
+    if (result.metricsStatus === "pending" || result.metricsStatus === "calculating") {
+      onProgress?.({ type: "awaiting-judge", reportId: result.id });
+      const judged = await this.pollReportStatus(result.id, void 0, (report) => {
+        const awaiting = report.metricsStatus === "pending" || report.metricsStatus === "calculating";
+        onProgress?.({ type: "polling", reportId: report.id, status: awaiting ? "awaiting traces/judge" : report.status ?? "unknown" });
+      });
+      if (judged) {
+        return judged;
+      }
+    }
     return result;
   }
   /**
@@ -6362,7 +6517,10 @@ var ApiClient = class {
   async pollReportStatus(reportId, timeoutMs = 6e5, onPoll) {
     const report = await this.pollUntilTerminal(
       () => this.getReportById(reportId),
-      (r) => !!r.status && ["completed", "failed", "cancelled"].includes(r.status),
+      // A trace-mode report is saved `completed` with `metricsStatus:
+      // 'pending'`/'calculating' before the background judge runs — that
+      // snapshot is NOT terminal (issue #333). Wait for the judge verdict.
+      (r) => !!r.status && ["completed", "failed", "cancelled"].includes(r.status) && r.metricsStatus !== "pending" && r.metricsStatus !== "calculating",
       { timeoutMs, onPoll }
     );
     if (!report) return null;
@@ -6370,6 +6528,7 @@ var ApiClient = class {
       id: report.id,
       status: report.status || "unknown",
       passFailStatus: report.passFailStatus,
+      metricsStatus: report.metricsStatus,
       metrics: report.metrics,
       trajectorySteps: report.trajectory?.length || 0,
       llmJudgeReasoning: report.llmJudgeReasoning
@@ -6500,6 +6659,71 @@ var ApiClient = class {
     }
     return completedRun;
   }
+  /**
+   * List benchmark images (content-addressed evaluation-condition snapshots).
+   */
+  async listImages() {
+    const res = await fetch(`${this.baseUrl}/api/storage/images`);
+    if (!res.ok) throw new ServerError(`Failed to list images: ${res.statusText}`);
+    const data = await res.json();
+    return data.images || [];
+  }
+  /**
+   * Get an image and its runs (the comparable set — all runs sharing the digest).
+   */
+  async getImage(digest) {
+    const res = await fetch(`${this.baseUrl}/api/storage/images/${encodeURIComponent(digest)}`);
+    if (res.status === 404) return null;
+    if (!res.ok) throw new ServerError(`Failed to get image: ${res.statusText}`);
+    return res.json();
+  }
+  /**
+   * Add a docker-style tag to an image (label, never identity). Idempotent.
+   */
+  async tagImage(digest, tag) {
+    const res = await fetch(`${this.baseUrl}/api/storage/images/${encodeURIComponent(digest)}/tags`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ tag })
+    });
+    if (!res.ok) throw new ServerError(`Failed to tag image: ${res.statusText}`);
+    return (await res.json()).image;
+  }
+  /**
+   * List evaluation runs (optionally filtered).
+   */
+  async listEvaluationRuns(filters = {}) {
+    const params = new URLSearchParams();
+    if (filters.benchmarkId) params.set("benchmarkId", filters.benchmarkId);
+    if (filters.imageDigest) params.set("imageDigest", filters.imageDigest);
+    params.set("size", String(filters.size ?? 500));
+    const res = await fetch(`${this.baseUrl}/api/storage/evaluation-runs?${params}`);
+    if (!res.ok) throw new ServerError(`Failed to list evaluation runs: ${res.statusText}`);
+    const data = await res.json();
+    return data.evaluationRuns || [];
+  }
+  /**
+   * Delete a benchmark by id.
+   */
+  async deleteBenchmark(id) {
+    const res = await fetch(`${this.baseUrl}/api/storage/benchmarks/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return res.ok;
+  }
+  /**
+   * Update an evaluation run (e.g. re-point benchmarkId during doctor merge).
+   */
+  async updateEvaluationRun(id, updates) {
+    const res = await fetch(`${this.baseUrl}/api/storage/evaluation-runs/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(updates)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.evaluationRun || data;
+  }
   /**
    * Promote an ad-hoc evaluation run to a benchmark.
    */
@@ -6657,6 +6881,49 @@ async function listTestCases(format, config) {
     cleanup();
   }
 }
+async function listImages(format, config) {
+  const serverResult = await ensureServer(config.server);
+  const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+  try {
+    const client = new ApiClient(serverResult.baseUrl);
+    const images = await client.listImages();
+    if (format === "json") {
+      console.log(formatJson({ images, total: images.length }));
+      return;
+    }
+    const headers = ["Digest", "Tags", "Test Cases", "Judge Model", "Evaluator", "Created"];
+    const rows = images.map((img) => [
+      img.digest.slice(0, 12),
+      img.tags.join(", ") || "-",
+      String(img.testCaseCount),
+      img.evalConditions.judgeModelId || "-",
+      img.evalConditions.evaluatorId || "-",
+      new Date(img.createdAt).toLocaleDateString()
+    ]);
+    if (format === "markdown") {
+      console.log(formatMarkdownTable(headers, rows));
+      return;
+    }
+    const table = new Table({
+      head: headers.map((h) => chalk.cyan(h)),
+      colWidths: [16, 24, 12, 24, 20, 14],
+      wordWrap: true
+    });
+    for (const row of rows) table.push(row);
+    console.log(chalk.bold("\nBenchmark Images:\n"));
+    console.log(table.toString());
+    console.log(chalk.gray(`
+  Total: ${images.length} images`));
+    console.log(chalk.gray("  Runs sharing a digest ran under identical conditions and are directly comparable.\n"));
+  } catch (error) {
+    console.error(chalk.red(`
+  Error: ${error.message}`));
+    console.log(chalk.gray("  Is the server running? Start with: npm run dev:server\n"));
+    process.exit(1);
+  } finally {
+    cleanup();
+  }
+}
 async function listBenchmarks(format, config) {
   const serverResult = await ensureServer(config.server);
   const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
@@ -6856,7 +7123,7 @@ async function listModels(format, config) {
   }
 }
 function createListCommand() {
-  const command = new Command("list").description("List available resources").argument("<resource>", "Resource type: agents, test-cases, benchmarks, evaluators, connectors, models").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").action(async (resource, options) => {
+  const command = new Command("list").description("List available resources").argument("<resource>", "Resource type: agents, test-cases, benchmarks, images, evaluators, connectors, models").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").action(async (resource, options) => {
     const format = parseOutputFormat(options.output);
     const config = await loadConfig();
     for (const connector of config.connectors) {
@@ -6875,6 +7142,10 @@ function createListCommand() {
       case "bench":
         await listBenchmarks(format, config);
         break;
+      case "images":
+      case "img":
+        await listImages(format, config);
+        break;
       case "evaluators":
       case "eval":
         await listEvaluators(format, config);
@@ -6888,7 +7159,7 @@ function createListCommand() {
       default:
         console.error(chalk.red(`
   Unknown resource type: ${resource}`));
-        console.log(chalk.gray("  Available: agents, test-cases, benchmarks, evaluators, connectors, models\n"));
+        console.log(chalk.gray("  Available: agents, test-cases, benchmarks, images, evaluators, connectors, models\n"));
         process.exit(1);
     }
   });
@@ -6972,15 +7243,22 @@ async function runForAgent(client, testCaseId, agent, modelId, verbose, evaluato
           spinner.text = `${agent.name}: Step ${event.stepIndex + 1} (${event.step.type})`;
         } else if (event.type === "started") {
           spinner.text = `${agent.name}: Started evaluation...`;
+        } else if (event.type === "awaiting-judge" || event.type === "polling") {
+          spinner.text = `${agent.name}: Waiting for traces / judge verdict...`;
         }
       },
       evaluatorId,
       judgeModelId
     );
-    if (report.status === "completed" && report.passFailStatus === "passed") {
+    const judgePending = report.metricsStatus === "pending" || report.metricsStatus === "calculating";
+    if (report.status === "completed" && judgePending) {
+      spinner.warn(`${agent.name}: ${chalk3.yellow("PENDING")} (judge has not run yet \u2014 check the report later)`);
+    } else if (report.status === "completed" && report.passFailStatus === "passed") {
       spinner.succeed(`${agent.name}: ${chalk3.green("PASSED")}`);
+    } else if (report.status === "completed" && report.passFailStatus === "failed") {
+      spinner.fail(`${agent.name}: ${chalk3.red("FAILED")}`);
     } else if (report.status === "completed") {
-      spinner.succeed(`${agent.name}: ${chalk3.red("FAILED")}`);
+      spinner.warn(`${agent.name}: ${chalk3.yellow("NO VERDICT")}`);
     } else {
       spinner.fail(`${agent.name}: ${chalk3.yellow(report.status)}`);
     }
@@ -6995,7 +7273,8 @@ function buildResultRows(results) {
     if (!r.report) {
       return [r.agent.name, "ERROR", "-", "-", "-"];
     }
-    const status = r.report.passFailStatus === "passed" ? "PASSED" : r.report.passFailStatus === "failed" ? "FAILED" : r.report.status;
+    const judgePending = r.report.metricsStatus === "pending" || r.report.metricsStatus === "calculating";
+    const status = judgePending ? "PENDING" : r.report.passFailStatus === "passed" ? "PASSED" : r.report.passFailStatus === "failed" ? "FAILED" : r.report.status;
     return [
       r.agent.name,
       status,
@@ -7022,7 +7301,8 @@ function displayResults(results, format) {
       table.push([r.agent.name, chalk3.red("ERROR"), "-", "-", "-"]);
       continue;
     }
-    const statusStr = r.report.passFailStatus === "passed" ? chalk3.green("PASSED") : r.report.passFailStatus === "failed" ? chalk3.red("FAILED") : chalk3.yellow(r.report.status);
+    const judgePending = r.report.metricsStatus === "pending" || r.report.metricsStatus === "calculating";
+    const statusStr = judgePending ? chalk3.yellow("PENDING") : r.report.passFailStatus === "passed" ? chalk3.green("PASSED") : r.report.passFailStatus === "failed" ? chalk3.red("FAILED") : chalk3.yellow(r.report.status);
     table.push([
       r.agent.name,
       statusStr,
@@ -7035,7 +7315,7 @@ function displayResults(results, format) {
   console.log(table.toString());
 }
 function createRunCommand() {
-  const command = new Command2("run").description("Run a test case against agents").requiredOption("-t, --test-case <id>", "Test case ID or name").option("-a, --agent <key>", "Agent key (can be specified multiple times)", (val, arr) => [...arr, val], []).option("-e, --evaluator <id>", "Evaluator ID (uses RCA default if not specified)").option("--judge-model <id>", "Judge LLM model id, distinct from --model. Falls back to evaluator's inferenceConfig.modelId, then BEDROCK_MODEL_ID env. Ignored by agentic-provider judges (pi/agent/agentic/claude-code) which pick their own model.").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").option("-v, --verbose", "Show detailed trajectory output").option("--agent-path <path>", "Path to the agent repository to use as judge grounding context (or set AH_AGENT_PATH)").action(async (options) => {
+  const command = new Command2("run").description("Run a test case against agents").requiredOption("-t, --test-case <id>", "Test case ID or name").option("-a, --agent <key>", "Agent key (can be specified multiple times)", (val, arr) => [...arr, val], []).option("-e, --evaluator <id>", "Evaluator ID (uses RCA default if not specified)").option("--judge-model <id>", "Judge LLM model id (the agent's own model is owned by its config, not a flag). Falls back to evaluator's inferenceConfig.modelId, then BEDROCK_MODEL_ID env. Ignored by agentic-provider judges (pi/agent/agentic/claude-code) which pick their own model.").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").option("-v, --verbose", "Show detailed trajectory output").option("--agent-path <path>", "Path to the agent repository to use as judge grounding context (or set AH_AGENT_PATH)").action(async (options) => {
     console.log(chalk3.bold("\nAgent Health - Test Case Runner\n"));
     applyAgentPathOption(options);
     const config = await loadConfig();
@@ -7121,13 +7401,30 @@ function createRunCommand() {
 
 // cli/commands/benchmark.ts
 init_config2();
-import { Command as Command3 } from "commander";
-import chalk4 from "chalk";
+import { Command as Command4 } from "commander";
+import chalk5 from "chalk";
 import ora2 from "ora";
 import Table3 from "cli-table3";
 import { readFileSync as readFileSync3, writeFileSync } from "fs";
 import * as path2 from "path";
 
+// cli/utils/evaluationRunOutcome.ts
+function resolveUnifiedRunOutcome(run, completedCount) {
+  if (!run) {
+    return { kind: "success", doneCount: completedCount };
+  }
+  if (run.status === "failed" || run.status === "cancelled") {
+    return { kind: "failed", message: `Evaluation run ${run.status}${run.error ? `: ${run.error}` : ""}` };
+  }
+  if (run.status === "pending" || run.status === "running") {
+    return { kind: "timeout" };
+  }
+  const doneCount = Object.values(run.results || {}).filter(
+    (r) => r.status !== "pending" && r.status !== "running"
+  ).length;
+  return { kind: "success", doneCount };
+}
+
 // lib/testCaseValidation.ts
 import { z } from "zod";
 var contextItemSchema = z.object({
@@ -7271,6 +7568,321 @@ function getReportIdsFromRun(run) {
 // cli/commands/benchmark.ts
 init_loader2();
 import { existsSync as existsSync3, statSync } from "fs";
+
+// cli/commands/benchmarkDoctor.ts
+init_config2();
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+
+// services/benchmarkDoctor.ts
+var QUICK_DEBRIS = /^quick-\d+$/;
+var TS_SUFFIX_DEBRIS = /-\d{13}$/;
+var DEBRIS_MIN_AGE_MS = 24 * 60 * 60 * 1e3;
+function isSample(b) {
+  return b.id.startsWith("demo-");
+}
+function embeddedRunCount(b) {
+  return Array.isArray(b.runs) ? b.runs.length : 0;
+}
+function buildDoctorPlan(benchmarks2, evalRuns, opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const real = benchmarks2.filter((b) => !isSample(b));
+  const refsByBenchmark = /* @__PURE__ */ new Map();
+  for (const run of evalRuns) {
+    if (!run.benchmarkId) continue;
+    const list = refsByBenchmark.get(run.benchmarkId) ?? [];
+    list.push(run);
+    refsByBenchmark.set(run.benchmarkId, list);
+  }
+  const refCount = (id) => refsByBenchmark.get(id)?.length ?? 0;
+  const debrisDeletions = [];
+  const debrisIds = /* @__PURE__ */ new Set();
+  for (const b of real) {
+    const isDebrisName = QUICK_DEBRIS.test(b.name) || TS_SUFFIX_DEBRIS.test(b.name);
+    if (!isDebrisName) continue;
+    if (embeddedRunCount(b) > 0 || refCount(b.id) > 0) continue;
+    const ageMs = now.getTime() - new Date(b.createdAt || 0).getTime();
+    if (ageMs < DEBRIS_MIN_AGE_MS) continue;
+    debrisDeletions.push({
+      id: b.id,
+      name: b.name,
+      reason: QUICK_DEBRIS.test(b.name) ? "quick-mode debris (timestamped, no runs, unreferenced)" : "timestamped debris (no runs, unreferenced)"
+    });
+    debrisIds.add(b.id);
+  }
+  const groupsByKey = /* @__PURE__ */ new Map();
+  for (const b of real) {
+    if (debrisIds.has(b.id)) continue;
+    const ids = b.testCaseIds ?? [];
+    if (ids.length === 0) continue;
+    const key = [...ids].sort().join("|");
+    const list = groupsByKey.get(key) ?? [];
+    list.push(b);
+    groupsByKey.set(key, list);
+  }
+  const contentDupGroups = [];
+  for (const [key, group] of groupsByKey) {
+    if (group.length < 2) continue;
+    const sorted = [...group].sort((a, b) => {
+      const runDiff = embeddedRunCount(b) - embeddedRunCount(a);
+      if (runDiff !== 0) return runDiff;
+      const refDiff = refCount(b.id) - refCount(a.id);
+      if (refDiff !== 0) return refDiff;
+      return new Date(a.createdAt || 0).getTime() - new Date(b.createdAt || 0).getTime();
+    });
+    const canonical = sorted[0];
+    const husks = sorted.slice(1);
+    const runRepoints = [];
+    for (const husk of husks) {
+      for (const run of refsByBenchmark.get(husk.id) ?? []) {
+        runRepoints.push({
+          runId: run.id,
+          fromBenchmarkId: husk.id,
+          toBenchmarkId: canonical.id
+        });
+      }
+    }
+    contentDupGroups.push({
+      key,
+      canonicalId: canonical.id,
+      canonicalName: canonical.name,
+      husks: husks.map((h) => ({
+        id: h.id,
+        name: h.name,
+        embeddedRunCount: embeddedRunCount(h)
+      })),
+      runRepoints
+    });
+  }
+  return {
+    debrisDeletions,
+    contentDupGroups,
+    summary: {
+      totalBenchmarks: real.length,
+      debrisCount: debrisDeletions.length,
+      dupGroupCount: contentDupGroups.length,
+      husksToMerge: contentDupGroups.reduce((n, g) => n + g.husks.length, 0),
+      runsToRepoint: contentDupGroups.reduce((n, g) => n + g.runRepoints.length, 0)
+    }
+  };
+}
+async function applyDoctorPlan(api, plan) {
+  const result = {
+    husksDeleted: 0,
+    debrisDeleted: 0,
+    runsRepointed: 0,
+    embeddedRunsMerged: 0,
+    errors: []
+  };
+  for (const group of plan.contentDupGroups) {
+    try {
+      const canonical = await api.getBenchmark(group.canonicalId);
+      if (!canonical) {
+        result.errors.push(`canonical not found: ${group.canonicalId}`);
+        continue;
+      }
+      const mergedRuns = [...canonical.runs || []];
+      const huskDocs = [];
+      for (const husk of group.husks) {
+        const doc = await api.getBenchmark(husk.id);
+        if (!doc) continue;
+        huskDocs.push(doc);
+        for (const run of doc.runs || []) {
+          if (!mergedRuns.some((r) => r.id === run.id)) {
+            mergedRuns.push(run);
+            result.embeddedRunsMerged++;
+          }
+        }
+      }
+      if (mergedRuns.length > (canonical.runs || []).length) {
+        await api.updateBenchmark(group.canonicalId, { runs: mergedRuns });
+      }
+      const failedRepointSources = /* @__PURE__ */ new Set();
+      for (const repoint of group.runRepoints) {
+        const updated = await api.updateEvaluationRun(repoint.runId, {
+          benchmarkId: repoint.toBenchmarkId
+        });
+        if (updated) {
+          result.runsRepointed++;
+        } else {
+          result.errors.push(`failed to re-point run ${repoint.runId}`);
+          failedRepointSources.add(repoint.fromBenchmarkId);
+        }
+      }
+      for (const husk of huskDocs) {
+        if (failedRepointSources.has(husk.id)) {
+          result.errors.push(`skipped deleting husk ${husk.id}: a run re-point to it failed`);
+          continue;
+        }
+        const ok = await api.deleteBenchmark(husk.id);
+        if (ok) result.husksDeleted++;
+        else result.errors.push(`failed to delete husk ${husk.id}`);
+      }
+    } catch (e) {
+      result.errors.push(`group ${group.canonicalName}: ${e?.message ?? e}`);
+    }
+  }
+  for (const debris of plan.debrisDeletions) {
+    try {
+      const ok = await api.deleteBenchmark(debris.id);
+      if (ok) result.debrisDeleted++;
+      else result.errors.push(`failed to delete debris ${debris.id}`);
+    } catch (e) {
+      result.errors.push(`debris ${debris.name}: ${e?.message ?? e}`);
+    }
+  }
+  return result;
+}
+async function migrateBenchmarksToImages(api, baseUrl, opts = {}) {
+  const result = { migrated: [], skipped: [], errors: [] };
+  let benchmarks2 = await api.listBenchmarks();
+  if (opts.benchmarkIds) {
+    const allow = new Set(opts.benchmarkIds);
+    benchmarks2 = benchmarks2.filter((b) => allow.has(b.id));
+  }
+  for (const b of benchmarks2) {
+    if (b.id.startsWith("demo-")) {
+      result.skipped.push({ benchmarkId: b.id, name: b.name, reason: "sample data" });
+      continue;
+    }
+    if (!b.testCaseIds || b.testCaseIds.length === 0) {
+      result.skipped.push({ benchmarkId: b.id, name: b.name, reason: "no test cases" });
+      continue;
+    }
+    try {
+      const res = await fetch(`${baseUrl}/api/storage/images`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ testCaseIds: b.testCaseIds, tags: [b.name] })
+      });
+      if (!res.ok) {
+        result.errors.push(`${b.name}: ${await res.text()}`);
+        continue;
+      }
+      const body = await res.json();
+      const missingTestCaseIds = body.missingTestCaseIds;
+      result.migrated.push({
+        benchmarkId: b.id,
+        name: b.name,
+        digest: body.image.digest,
+        ...missingTestCaseIds && missingTestCaseIds.length > 0 ? { missingTestCaseIds } : {}
+      });
+      if (missingTestCaseIds && missingTestCaseIds.length > 0) {
+        result.errors.push(
+          `${b.name}: migrated from a PARTIAL test-case set \u2014 missing ${missingTestCaseIds.length} id(s): ${missingTestCaseIds.join(", ")}`
+        );
+      }
+    } catch (e) {
+      result.errors.push(`${b.name}: ${e?.message ?? e}`);
+    }
+  }
+  return result;
+}
+
+// cli/commands/benchmarkDoctor.ts
+function printPlan(plan) {
+  console.log(chalk4.bold("\nBenchmark Doctor \u2014 plan\n"));
+  console.log(chalk4.gray(`  Benchmarks scanned: ${plan.summary.totalBenchmarks}`));
+  if (plan.debrisDeletions.length === 0 && plan.contentDupGroups.length === 0) {
+    console.log(chalk4.green("\n  \u2713 No debris or content duplicates found. Nothing to do.\n"));
+    return;
+  }
+  if (plan.debrisDeletions.length > 0) {
+    console.log(chalk4.yellow(`
+  Debris to delete (${plan.debrisDeletions.length}):`));
+    for (const d of plan.debrisDeletions) {
+      console.log(chalk4.gray(`    - ${d.name} (${d.id}) \u2014 ${d.reason}`));
+    }
+  }
+  if (plan.contentDupGroups.length > 0) {
+    console.log(chalk4.yellow(`
+  Content-duplicate groups (${plan.contentDupGroups.length}):`));
+    for (const g of plan.contentDupGroups) {
+      console.log(chalk4.white(`    Canonical: ${g.canonicalName} (${g.canonicalId})`));
+      for (const h of g.husks) {
+        console.log(chalk4.gray(`      merge+delete: ${h.name} (${h.id}, ${h.embeddedRunCount} embedded runs)`));
+      }
+      if (g.runRepoints.length > 0) {
+        console.log(chalk4.gray(`      re-point ${g.runRepoints.length} eval-run(s) \u2192 canonical`));
+      }
+    }
+  }
+  console.log(
+    chalk4.cyan(
+      `
+  Summary: delete ${plan.summary.debrisCount} debris, merge ${plan.summary.husksToMerge} duplicates, re-point ${plan.summary.runsToRepoint} runs.`
+    )
+  );
+  console.log(chalk4.gray("  Runs and reports are never deleted.\n"));
+}
+function createBenchmarkDoctorCommand() {
+  return new Command3("doctor").description("Detect and clean up duplicated / debris benchmarks (dry-run by default)").option("--dry-run", "Preview only \u2014 this is already the default; use --apply to execute").option("--apply", "Execute the plan (default: dry-run report only)").option("--migrate-images", "Also convert remaining benchmarks into tagged benchmark images").option("--json", "Output as JSON instead of the human-readable report", false).addHelpText("after", "\n  Dry-run by default. Nothing is changed without --apply.\n").action(async (options) => {
+    if (options.dryRun && options.apply) {
+      console.error(chalk4.red("\n  Error: --dry-run and --apply are mutually exclusive."));
+      console.error(chalk4.gray("  Dry-run is the default. Use --apply to execute changes.\n"));
+      process.exit(1);
+    }
+    const config = await loadConfig();
+    const isReadOnly = !options.apply && !options.migrateImages;
+    config.server.readOnly = isReadOnly;
+    const serverResult = await ensureServer(config.server);
+    const cleanup = createServerCleanup(serverResult, false);
+    try {
+      const api = new ApiClient(serverResult.baseUrl);
+      const [benchmarks2, evalRuns] = await Promise.all([
+        api.listBenchmarks(),
+        api.listEvaluationRuns({ size: 1e3 })
+      ]);
+      const plan = buildDoctorPlan(benchmarks2, evalRuns);
+      const isJson = options.json === true;
+      const jsonOutput = { plan };
+      if (!isJson) {
+        printPlan(plan);
+      }
+      if (options.apply) {
+        const result = await applyDoctorPlan(api, plan);
+        if (isJson) {
+          jsonOutput.result = result;
+        } else {
+          console.log(chalk4.green(
+            `  Applied: ${result.debrisDeleted} debris deleted, ${result.husksDeleted} husks merged+deleted, ${result.runsRepointed} runs re-pointed, ${result.embeddedRunsMerged} embedded runs merged.`
+          ));
+          for (const err of result.errors) console.log(chalk4.red(`  ! ${err}`));
+          console.log();
+        }
+      } else if (!isJson && (plan.debrisDeletions.length > 0 || plan.contentDupGroups.length > 0)) {
+        console.log(chalk4.gray("  Dry-run only. Re-run with --apply to execute.\n"));
+      }
+      if (options.migrateImages) {
+        const migration = await migrateBenchmarksToImages(api, serverResult.baseUrl);
+        if (isJson) {
+          jsonOutput.migration = migration;
+        } else {
+          console.log(chalk4.bold("  Image migration:"));
+          for (const m2 of migration.migrated) {
+            console.log(chalk4.green(`    \u2713 ${m2.name} \u2192 ${m2.digest.slice(0, 12)}`));
+          }
+          for (const s of migration.skipped) {
+            console.log(chalk4.gray(`    - ${s.name}: skipped (${s.reason})`));
+          }
+          for (const err of migration.errors) console.log(chalk4.red(`    ! ${err}`));
+          console.log();
+        }
+      }
+      if (isJson) {
+        console.log(JSON.stringify(jsonOutput, null, 2));
+      }
+    } catch (error) {
+      console.error(chalk4.red(`
+  Error: ${error.message}`));
+      process.exit(1);
+    } finally {
+      cleanup();
+    }
+  });
+}
+
+// cli/commands/benchmark.ts
 function findAgent2(identifier, config) {
   return config.agents.find(
     (a) => a.key === identifier || a.name.toLowerCase() === identifier.toLowerCase()
@@ -7342,10 +7954,10 @@ async function runBenchmarkForAgent(api, agent, modelId, benchmark, verbose, con
           const completed = event.completedCount ?? 0;
           const testCaseName = event.currentTestCase?.name || `Test ${current}`;
           if (event.result) {
-            const status = event.result.status === "completed" ? chalk4.green("\u2713") : chalk4.red("\u2717");
+            const status = event.result.status === "completed" ? chalk5.green("\u2713") : chalk5.red("\u2717");
             spinner.text = `${agent.name}: ${testCaseName} ${status} (${completed}/${totalTestCases} evaluated)`;
             if (verbose && event.result.status === "failed" && event.result.error) {
-              spinner.info(`${agent.name}: ${testCaseName} ${chalk4.red("\u2717")} - ${event.result.error}`);
+              spinner.info(`${agent.name}: ${testCaseName} ${chalk5.red("\u2717")} - ${event.result.error}`);
               spinner.start(`${agent.name}: (${completed}/${totalTestCases} evaluated)`);
             }
           } else {
@@ -7361,18 +7973,18 @@ async function runBenchmarkForAgent(api, agent, modelId, benchmark, verbose, con
     results.failed = stats.failed;
     results.reports = Object.values(reportsMap).filter((r) => r !== null);
     const passRate = stats.passRate;
-    const erroredSuffix = stats.errored > 0 ? chalk4.yellow(` (${stats.errored} errored \u2014 evaluator could not run)`) : "";
+    const erroredSuffix = stats.errored > 0 ? chalk5.yellow(` (${stats.errored} errored \u2014 evaluator could not run)`) : "";
     if (passRate >= 80) {
       spinner.succeed(
-        `${agent.name}: ${chalk4.green(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)${erroredSuffix}`
+        `${agent.name}: ${chalk5.green(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)${erroredSuffix}`
       );
     } else if (passRate >= 50) {
       spinner.warn(
-        `${agent.name}: ${chalk4.yellow(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)${erroredSuffix}`
+        `${agent.name}: ${chalk5.yellow(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)${erroredSuffix}`
       );
     } else {
       spinner.fail(
-        `${agent.name}: ${chalk4.red(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)${erroredSuffix}`
+        `${agent.name}: ${chalk5.red(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)${erroredSuffix}`
       );
     }
   } catch (error) {
@@ -7393,24 +8005,24 @@ async function runBenchmarkForAgent(api, agent, modelId, benchmark, verbose, con
             const passRate = stats.passRate;
             if (passRate >= 80) {
               spinner.succeed(
-                `${agent.name}: ${chalk4.green(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+                `${agent.name}: ${chalk5.green(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
               );
             } else if (passRate >= 50) {
               spinner.warn(
-                `${agent.name}: ${chalk4.yellow(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+                `${agent.name}: ${chalk5.yellow(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
               );
             } else {
               spinner.fail(
-                `${agent.name}: ${chalk4.red(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+                `${agent.name}: ${chalk5.red(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
               );
             }
             return results;
           }
           if (run.status === "failed") {
             const runError = run.error || errorMessage;
-            spinner.fail(`${agent.name}: ${chalk4.red("Failed")} - ${runError}`);
+            spinner.fail(`${agent.name}: ${chalk5.red("Failed")} - ${runError}`);
             if (stats.passed > 0 || stats.failed > 0) {
-              console.log(chalk4.gray(`  Partial results: ${stats.passed} passed, ${stats.failed} failed out of ${stats.total}`));
+              console.log(chalk5.gray(`  Partial results: ${stats.passed} passed, ${stats.failed} failed out of ${stats.total}`));
             }
             return results;
           }
@@ -7419,31 +8031,31 @@ async function runBenchmarkForAgent(api, agent, modelId, benchmark, verbose, con
       }
     }
     if (isServerError) {
-      spinner.fail(`${agent.name}: ${chalk4.red("Failed")} - ${errorMessage}`);
+      spinner.fail(`${agent.name}: ${chalk5.red("Failed")} - ${errorMessage}`);
     } else {
       const isStreamError = errorMessage.includes("terminated") || errorMessage.includes("network") || errorMessage.includes("stream") || errorMessage.includes("aborted");
       if (isStreamError && startedRunId) {
-        spinner.warn(`${agent.name}: ${chalk4.yellow("Stream disconnected")} - server may still be processing`);
-        console.log(chalk4.gray(`  Check status: Use the UI to monitor progress`));
+        spinner.warn(`${agent.name}: ${chalk5.yellow("Stream disconnected")} - server may still be processing`);
+        console.log(chalk5.gray(`  Check status: Use the UI to monitor progress`));
       } else {
-        spinner.fail(`${agent.name}: ${chalk4.red("Failed")} - ${errorMessage}`);
+        spinner.fail(`${agent.name}: ${chalk5.red("Failed")} - ${errorMessage}`);
       }
     }
     const lowerError = errorMessage.toLowerCase();
     if (lowerError.includes("401") || lowerError.includes("403") || lowerError.includes("unauthorized") || lowerError.includes("forbidden") || lowerError.includes("token") || lowerError.includes("auth")) {
-      console.log(chalk4.gray(`  Hint: This looks like an authentication issue. Check your agent-health.config.ts`));
-      console.log(chalk4.gray(`        (headers, hooks.beforeRequest, or credentials) and re-run.`));
+      console.log(chalk5.gray(`  Hint: This looks like an authentication issue. Check your agent-health.config.ts`));
+      console.log(chalk5.gray(`        (headers, hooks.beforeRequest, or credentials) and re-run.`));
     } else if (lowerError.includes("econnrefused") || lowerError.includes("enotfound") || lowerError.includes("connect")) {
-      console.log(chalk4.gray(`  Hint: Could not connect to the agent endpoint. Verify the endpoint in agent-health.config.ts`));
-      console.log(chalk4.gray(`        is reachable: npx @opensearch-project/agent-health doctor`));
+      console.log(chalk5.gray(`  Hint: Could not connect to the agent endpoint. Verify the endpoint in agent-health.config.ts`));
+      console.log(chalk5.gray(`        is reachable: npx @opensearch-project/agent-health doctor`));
     } else if (lowerError.includes("not found") || lowerError.includes("agent not found")) {
-      console.log(chalk4.gray(`  Hint: Agent key not found. List available agents: npx @opensearch-project/agent-health list agents`));
+      console.log(chalk5.gray(`  Hint: Agent key not found. List available agents: npx @opensearch-project/agent-health list agents`));
     } else if (lowerError.includes("hook") || lowerError.includes("beforerequest")) {
-      console.log(chalk4.gray(`  Hint: The beforeRequest hook in agent-health.config.ts threw an error.`));
-      console.log(chalk4.gray(`        Check the hook logic and any external services it calls.`));
+      console.log(chalk5.gray(`  Hint: The beforeRequest hook in agent-health.config.ts threw an error.`));
+      console.log(chalk5.gray(`        Check the hook logic and any external services it calls.`));
     }
     if (errorMessage !== "terminated") {
-      console.log(chalk4.gray(`  Debug: Run with DEBUG=true for verbose server logs`));
+      console.log(chalk5.gray(`  Debug: Run with DEBUG=true for verbose server logs`));
     }
   }
   return results;
@@ -7470,22 +8082,22 @@ function displaySummary(allResults, totalTestCases, format) {
     return;
   }
   const table = new Table3({
-    head: headers.map((h) => chalk4.cyan(h)),
+    head: headers.map((h) => chalk5.cyan(h)),
     colWidths: [25, 10, 10, 12, 35]
   });
   for (const results of allResults) {
     const passRate = totalTestCases > 0 ? results.passed / totalTestCases * 100 : 0;
-    const passRateColor = passRate >= 80 ? chalk4.green : passRate >= 50 ? chalk4.yellow : chalk4.red;
+    const passRateColor = passRate >= 80 ? chalk5.green : passRate >= 50 ? chalk5.yellow : chalk5.red;
     table.push([
       results.agent.name,
-      chalk4.green(results.passed.toString()),
-      chalk4.red(results.failed.toString()),
+      chalk5.green(results.passed.toString()),
+      chalk5.red(results.failed.toString()),
       passRateColor(`${passRate.toFixed(0)}%`),
-      results.run?.id || results.runId || chalk4.gray("N/A")
+      results.run?.id || results.runId || chalk5.gray("N/A")
     ]);
   }
   console.log("\n");
-  console.log(chalk4.bold("Benchmark Summary"));
+  console.log(chalk5.bold("Benchmark Summary"));
   console.log(table.toString());
 }
 async function exportResults(benchmark, allResults, exportPath, format, serverBaseUrl) {
@@ -7499,7 +8111,7 @@ async function exportResults(benchmark, allResults, exportPath, format, serverBa
     const response = await fetch(url);
     if (!response.ok) {
       const errorBody = await response.json().catch(() => ({ error: "Unknown error" }));
-      console.error(chalk4.red(`
+      console.error(chalk5.red(`
 Export failed: ${errorBody.error}`));
       return;
     }
@@ -7532,7 +8144,7 @@ Export failed: ${errorBody.error}`));
     };
     writeFileSync(exportPath, JSON.stringify(exportData, null, 2));
   }
-  console.log(chalk4.green(`
+  console.log(chalk5.green(`
 Results exported to: ${exportPath}`));
 }
 function buildFileSources(fileArray) {
@@ -7554,7 +8166,7 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
     const api2 = new ApiClient(`http://localhost:${serverConfig.port}`);
     const benchmark = await api2.findBenchmark(options.name);
     if (!benchmark) {
-      console.error(chalk4.red(`  Error: Benchmark not found: "${options.name}"`));
+      console.error(chalk5.red(`  Error: Benchmark not found: "${options.name}"`));
       process.exit(1);
     }
     sources.push({ type: "benchmark", benchmarkId: benchmark.id });
@@ -7562,7 +8174,7 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
   if (fileArray.length > 0) {
     for (const f of fileArray) {
       if (!existsSync3(f)) {
-        console.error(chalk4.red(`  Error: File not found: ${f}`));
+        console.error(chalk5.red(`  Error: File not found: ${f}`));
         process.exit(1);
       }
     }
@@ -7571,7 +8183,7 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
   if (options.dir && options.dir.length > 0) {
     for (const d of options.dir) {
       if (!existsSync3(d) || !statSync(d).isDirectory()) {
-        console.error(chalk4.red(`  Error: Directory not found: ${d}`));
+        console.error(chalk5.red(`  Error: Directory not found: ${d}`));
         process.exit(1);
       }
     }
@@ -7584,8 +8196,8 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
     sources.push({ type: "label-filter", labels: options.label });
   }
   if (sources.length === 0) {
-    console.error(chalk4.red("  Error: No test case sources specified."));
-    console.log(chalk4.gray("  Use -n, -f, -d, -t, or --label to specify sources."));
+    console.error(chalk5.red("  Error: No test case sources specified."));
+    console.log(chalk5.gray("  Use -n, -f, -d, -t, or --label to specify sources."));
     process.exit(1);
   }
   const connectSpinner = ora2("Connecting to server...").start();
@@ -7605,14 +8217,14 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
   if (options.agent.length === 0) {
     const enabledAgent = config.agents.find((a) => a.enabled !== false);
     if (!enabledAgent) {
-      console.error(chalk4.red("  Error: No enabled agents found."));
+      console.error(chalk5.red("  Error: No enabled agents found."));
       process.exit(1);
     }
     agentKey = enabledAgent.key;
-    console.log(chalk4.gray(`  Agent: ${enabledAgent.name} (default)`));
+    console.log(chalk5.gray(`  Agent: ${enabledAgent.name} (default)`));
   } else {
     agentKey = options.agent[0];
-    console.log(chalk4.gray(`  Agent: ${agentKey}`));
+    console.log(chalk5.gray(`  Agent: ${agentKey}`));
   }
   const modelId = resolveAgentModel(config.agents.find((a) => a.key === agentKey), getDefaultModel2(config));
   const concurrency = Math.max(1, Math.min(20, parseInt(options.concurrency, 10) || 1));
@@ -7630,11 +8242,11 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
       benchmarkId = created.id;
     }
   }
-  console.log(chalk4.gray(`  Sources: ${sources.length} source(s)`));
-  console.log(chalk4.gray(`  Model: ${modelId}`));
-  if (concurrency > 1) console.log(chalk4.gray(`  Concurrency: ${concurrency}`));
-  if (benchmarkId) console.log(chalk4.gray(`  Benchmark: ${options.name}`));
-  else console.log(chalk4.gray(`  Mode: Ad-hoc (no benchmark association)`));
+  console.log(chalk5.gray(`  Sources: ${sources.length} source(s)`));
+  console.log(chalk5.gray(`  Model: ${modelId}`));
+  if (concurrency > 1) console.log(chalk5.gray(`  Concurrency: ${concurrency}`));
+  if (benchmarkId) console.log(chalk5.gray(`  Benchmark: ${options.name}`));
+  else console.log(chalk5.gray(`  Mode: Ad-hoc (no benchmark association)`));
   console.log("");
   const spinner = ora2("Starting evaluation run...").start();
   try {
@@ -7665,59 +8277,87 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
     let totalTestCases = 0;
     let completedCount = 0;
     let runId = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("event: ")) {
-          const eventType = line.slice(7);
-          continue;
-        }
-        if (line.startsWith("data: ")) {
-          try {
-            const data = JSON.parse(line.slice(6));
-            if (data.runId && data.testCases) {
-              runId = data.runId;
-              totalTestCases = data.testCases.length;
-              spinner.text = `Running evaluation (0/${totalTestCases})`;
-            } else if (data.completedCount !== void 0) {
-              completedCount = data.completedCount;
-              spinner.text = `Running evaluation (${completedCount}/${totalTestCases})`;
-            } else if (data.status === "completed" || data.status === "cancelled") {
-              break;
-            } else if (data.error) {
-              spinner.fail(`Run failed: ${data.error}`);
-              process.exit(1);
+    let sseSawTerminal = false;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            const eventType = line.slice(7);
+            continue;
+          }
+          if (line.startsWith("data: ")) {
+            try {
+              const data = JSON.parse(line.slice(6));
+              if (data.runId && data.testCases) {
+                runId = data.runId;
+                totalTestCases = data.testCases.length;
+                spinner.text = `Running evaluation (0/${totalTestCases})`;
+              } else if (data.completedCount !== void 0) {
+                completedCount = data.completedCount;
+                spinner.text = `Running evaluation (${completedCount}/${totalTestCases})`;
+              } else if (data.status === "completed" || data.status === "cancelled") {
+                sseSawTerminal = true;
+                break;
+              } else if (data.error) {
+                spinner.fail(`Run failed: ${data.error}`);
+                process.exit(1);
+              }
+            } catch {
             }
-          } catch {
           }
         }
       }
+    } catch (streamErr) {
+      if (!runId) {
+        spinner.fail(`Lost connection before the run started: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);
+        process.exit(1);
+      }
+    }
+    const api2 = new ApiClient(serverResult.baseUrl);
+    let run = null;
+    if (runId && !sseSawTerminal) {
+      spinner.text = "Stream ended; waiting for the run to finish server-side\u2026";
+      run = await api2.pollEvaluationRunStatus(runId, (r) => {
+        const done = Object.values(r.results || {}).filter((x) => x.status !== "pending" && x.status !== "running").length;
+        spinner.text = `Waiting for run to finish server-side (${done}/${totalTestCases || Object.keys(r.results || {}).length})\u2026`;
+      });
+    } else if (runId) {
+      run = await api2.getEvaluationRun(runId);
+    }
+    const outcome = resolveUnifiedRunOutcome(run, completedCount);
+    if (outcome.kind === "failed") {
+      spinner.fail(outcome.message);
+      process.exit(1);
+    }
+    if (outcome.kind === "timeout") {
+      spinner.warn("Timed out waiting for the run to finish server-side \u2014 it may still be in progress.");
+      console.log(chalk5.gray(`  Check status: ${serverResult.baseUrl}/api/storage/evaluation-runs/${runId}`));
+      process.exit(1);
     }
-    spinner.succeed(`Evaluation run completed (${completedCount}/${totalTestCases} test cases)`);
-    const finalRun = await fetch(`${serverResult.baseUrl}/api/storage/evaluation-runs/${runId}`);
-    if (finalRun.ok) {
-      const run = await finalRun.json();
+    spinner.succeed(`Evaluation run completed (${outcome.doneCount}/${totalTestCases} test cases)`);
+    if (run) {
       const passed = Object.values(run.results || {}).filter((r) => r.status === "completed").length;
       const failed = Object.values(run.results || {}).filter((r) => r.status === "failed").length;
       console.log("");
-      console.log(chalk4.bold("  Results:"));
-      console.log(`    ${chalk4.green("\u2713 Passed:")} ${passed}`);
-      console.log(`    ${chalk4.red("\u2717 Failed:")} ${failed}`);
-      console.log(`    ${chalk4.gray("Total:")} ${totalTestCases}`);
+      console.log(chalk5.bold("  Results:"));
+      console.log(`    ${chalk5.green("\u2713 Passed:")} ${passed}`);
+      console.log(`    ${chalk5.red("\u2717 Failed:")} ${failed}`);
+      console.log(`    ${chalk5.gray("Total:")} ${totalTestCases}`);
       if (benchmarkId) {
         console.log("");
-        console.log(chalk4.cyan("  View results:"));
+        console.log(chalk5.cyan("  View results:"));
         console.log(
-          chalk4.gray(`  ${serverResult.baseUrl}/evaluations/benchmarks/${benchmarkId}/runs/${runId}`)
+          chalk5.gray(`  ${serverResult.baseUrl}/evaluations/benchmarks/${benchmarkId}/runs/${runId}`)
         );
       } else {
         console.log("");
-        console.log(chalk4.gray(`  This was an ad-hoc run (ID: ${runId}).`));
-        console.log(chalk4.gray('  Promote to benchmark with: -n "Benchmark Name"'));
+        console.log(chalk5.gray(`  This was an ad-hoc run (ID: ${runId}).`));
+        console.log(chalk5.gray('  Promote to benchmark with: -n "Benchmark Name"'));
       }
     }
   } catch (error) {
@@ -7727,7 +8367,7 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
   cleanup();
 }
 function createBenchmarkCommand() {
-  const command = new Command3("benchmark").description("Run a benchmark against one or more agents").option("-n, --name <name>", "Benchmark name or ID (also associates run with benchmark)").option(
+  const command = new Command4("benchmark").description("Run a benchmark against one or more agents").addCommand(createBenchmarkDoctorCommand()).option("-n, --name <name>", "Benchmark name or ID (also associates run with benchmark)").option(
     "-f, --file <path>",
     "JSON file(s) of test cases (repeatable)",
     (val, arr) => [...arr, val],
@@ -7752,8 +8392,8 @@ function createBenchmarkCommand() {
     "Agent key (can be specified multiple times)",
     (val, arr) => [...arr, val],
     []
-  ).option("-e, --evaluator <id>", "Evaluator ID (uses RCA default if not specified)").option("--judge-model <id>", "Judge LLM model id, distinct from --model. Falls back to evaluator's inferenceConfig.modelId, then BEDROCK_MODEL_ID env. Ignored by agentic-provider judges (pi/agent/agentic/claude-code) which pick their own model.").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").option("--export <path>", "Export results to file").option("--format <type>", "Report format for --export: json (default), html, pdf", "json").option("-c, --concurrency <n>", "Number of test cases to run in parallel (default: 1)", "1").option("-v, --verbose", "Show detailed output").option("--stop-server", "Stop the server after benchmark completes (default: keep running)").option("--agent-path <path>", "Path to the agent repository to use as judge grounding context (or set AH_AGENT_PATH)").action(async (options) => {
-    console.log(chalk4.bold("\nAgent Health - Benchmark Runner\n"));
+  ).option("-e, --evaluator <id>", "Evaluator ID (uses RCA default if not specified)").option("--judge-model <id>", "Judge LLM model id (the agent's own model is owned by its config, not a flag). Falls back to evaluator's inferenceConfig.modelId, then BEDROCK_MODEL_ID env. Ignored by agentic-provider judges (pi/agent/agentic/claude-code) which pick their own model.").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").option("--export <path>", "Export results to file").option("--format <type>", "Report format for --export: json (default), html, pdf", "json").option("-c, --concurrency <n>", "Number of test cases to run in parallel (default: 1)", "1").option("-v, --verbose", "Show detailed output").option("--stop-server", "Stop the server after benchmark completes (default: keep running)").option("--agent-path <path>", "Path to the agent repository to use as judge grounding context (or set AH_AGENT_PATH)").action(async (options) => {
+    console.log(chalk5.bold("\nAgent Health - Benchmark Runner\n"));
     applyAgentPathOption(options);
     const config = await loadConfig();
     const serverConfig = { ...DEFAULT_SERVER_CONFIG, ...config.server };
@@ -7770,20 +8410,20 @@ function createBenchmarkCommand() {
     const fileMode = !!filePath2;
     const quickMode = !options.name && !fileMode && !serverWasRunning;
     if (!options.name && !fileMode && serverWasRunning) {
-      console.error(chalk4.red("  Error: Benchmark name required when server is already running."));
+      console.error(chalk5.red("  Error: Benchmark name required when server is already running."));
       console.log("");
-      console.log(chalk4.cyan("  Options:"));
-      console.log(chalk4.gray('    1. Specify a benchmark:  benchmark -n "Name" -a claude-code'));
-      console.log(chalk4.gray("    2. Import from file:     benchmark -f ./test-cases.json -a mock"));
-      console.log(chalk4.gray("    3. Stop the server and run in quick mode"));
-      console.log(chalk4.gray("    4. List available:       npx agent-health list benchmarks"));
+      console.log(chalk5.cyan("  Options:"));
+      console.log(chalk5.gray('    1. Specify a benchmark:  benchmark -n "Name" -a claude-code'));
+      console.log(chalk5.gray("    2. Import from file:     benchmark -f ./test-cases.json -a mock"));
+      console.log(chalk5.gray("    3. Stop the server and run in quick mode"));
+      console.log(chalk5.gray("    4. List available:       npx agent-health list benchmarks"));
       console.log("");
       process.exit(1);
     }
     if (fileMode) {
-      console.log(chalk4.cyan(`  Running in file mode (importing test cases from ${filePath2})`));
+      console.log(chalk5.cyan(`  Running in file mode (importing test cases from ${filePath2})`));
     } else if (quickMode) {
-      console.log(chalk4.cyan("  Running in quick mode (auto-creating benchmark from test cases)"));
+      console.log(chalk5.cyan("  Running in quick mode (auto-creating benchmark from test cases)"));
     }
     const connectSpinner = ora2("Connecting to server...").start();
     let serverResult;
@@ -7817,6 +8457,8 @@ function createBenchmarkCommand() {
             const { getCategoryFromLabels: getCategoryFromLabels2, getDifficultyFromLabels: getDifficultyFromLabels2 } = await Promise.resolve().then(() => (init_testCaseLabels(), testCaseLabels_exports));
             const loaded2 = await loadTestCasesFromModule2(filePath2);
             const sourceFile = path2.relative(process.cwd(), loaded2.filePath);
+            const sourceFileName = path2.basename(sourceFile);
+            const sourceLanguage = detectSourceLanguage(sourceFile);
             groups = loaded2.benchmarks;
             const inGroup = /* @__PURE__ */ new Set();
             for (const list of groups.values()) {
@@ -7836,6 +8478,16 @@ function createBenchmarkCommand() {
                 labels,
                 sourceFile,
                 sourceHash: tc.hash,
+                // Full eval-file text + provenance metadata, captured
+                // once per import so the Test Case detail page can render
+                // an IDE-style view of the source that produced this test
+                // case (issue: "render the eval.ts file on the test case
+                // page"). Every test case from this file shares the same
+                // sourceCode -- the file is the unit of "source", not the
+                // individual test.
+                sourceCode: loaded2.fileSource,
+                sourceFileName,
+                sourceLanguage,
                 description: tc.options.description,
                 // Forward expectedOutcomes / expectedTrajectory — see
                 // services/sourceResolver.ts for rationale. Without
@@ -7920,7 +8572,7 @@ function createBenchmarkCommand() {
                 });
                 if (transientErrors > 0) {
                   console.log(
-                    chalk4.yellow(
+                    chalk5.yellow(
                       `  Note: ${transientErrors} TestCase fetch(es) failed during self-heal \u2014 keeping those IDs to avoid corrupting benchmark.testCaseIds on a network blip.`
                     )
                   );
@@ -7928,7 +8580,7 @@ function createBenchmarkCommand() {
                 const droppedCount = existingIds.length - prunedIds.length;
                 if (droppedCount > 0) {
                   console.log(
-                    chalk4.gray(
+                    chalk5.gray(
                       `  Self-healed "${spec.name}": pruned ${droppedCount} stale TestCase ID(s) from "${sdkSourceFile}" left over from pre-fix runs.`
                     )
                   );
@@ -7956,7 +8608,7 @@ function createBenchmarkCommand() {
           const testCases2 = await api.listTestCases();
           if (testCases2.length === 0) {
             testCasesSpinner.fail("No test cases found");
-            console.log(chalk4.gray("  Add test cases via the UI or provide a file with -f option."));
+            console.log(chalk5.gray("  Add test cases via the UI or provide a file with -f option."));
             process.exit(1);
           }
           testCasesSpinner.succeed(`Found ${testCases2.length} test cases`);
@@ -7975,76 +8627,76 @@ function createBenchmarkCommand() {
       } else {
         const bm = await api.findBenchmark(options.name);
         if (!bm) {
-          console.error(chalk4.red(`  Error: Benchmark not found: "${options.name}"`));
+          console.error(chalk5.red(`  Error: Benchmark not found: "${options.name}"`));
           console.log("");
-          console.log(chalk4.cyan("  The -n/--name option accepts:"));
-          console.log(chalk4.gray("    \u2022 Benchmark ID (e.g., demo-baseline)"));
-          console.log(chalk4.gray('    \u2022 Benchmark name (case-sensitive, e.g., "Baseline")'));
+          console.log(chalk5.cyan("  The -n/--name option accepts:"));
+          console.log(chalk5.gray("    \u2022 Benchmark ID (e.g., demo-baseline)"));
+          console.log(chalk5.gray('    \u2022 Benchmark name (case-sensitive, e.g., "Baseline")'));
           console.log("");
-          console.log(chalk4.cyan("  Or import from file:"));
-          console.log(chalk4.gray("    benchmark -f ./test-cases.json -a mock"));
+          console.log(chalk5.cyan("  Or import from file:"));
+          console.log(chalk5.gray("    benchmark -f ./test-cases.json -a mock"));
           console.log("");
-          console.log(chalk4.cyan("  Available benchmarks:"));
-          console.log(chalk4.gray("    npx agent-health list benchmarks"));
+          console.log(chalk5.cyan("  Available benchmarks:"));
+          console.log(chalk5.gray("    npx agent-health list benchmarks"));
           console.log("");
           process.exit(1);
         }
         if (bm.id.startsWith("demo-")) {
-          console.error(chalk4.red(`  Error: Cannot execute sample benchmarks.`));
-          console.log(chalk4.gray("  Sample data is read-only with pre-completed runs."));
-          console.log(chalk4.gray("  Create a real benchmark in the UI to run evaluations."));
+          console.error(chalk5.red(`  Error: Cannot execute sample benchmarks.`));
+          console.log(chalk5.gray("  Sample data is read-only with pre-completed runs."));
+          console.log(chalk5.gray("  Create a real benchmark in the UI to run evaluations."));
           console.log("");
           process.exit(1);
         }
         benchmarksToRun.push(bm);
       }
       if (benchmarksToRun.length === 0) {
-        console.error(chalk4.red("  Error: No benchmarks to run."));
+        console.error(chalk5.red("  Error: No benchmarks to run."));
         process.exit(1);
       }
       for (const bm of benchmarksToRun) {
-        console.log(chalk4.gray(`  Benchmark: ${bm.name} (${bm.id}) \u2014 ${bm.testCaseIds.length} test cases`));
+        console.log(chalk5.gray(`  Benchmark: ${bm.name} (${bm.id}) \u2014 ${bm.testCaseIds.length} test cases`));
       }
-      console.log(chalk4.gray(`  Server: ${serverResult.baseUrl}`));
+      console.log(chalk5.gray(`  Server: ${serverResult.baseUrl}`));
       let agents = [];
       if (options.agent.length === 0) {
         const enabledAgent = config.agents.find((a) => a.enabled !== false);
         if (!enabledAgent) {
-          console.error(chalk4.red("  Error: No enabled agents found in config."));
+          console.error(chalk5.red("  Error: No enabled agents found in config."));
           process.exit(1);
         }
         agents = [enabledAgent];
-        console.log(chalk4.gray(`  Agent: ${agents[0].name} (default)`));
+        console.log(chalk5.gray(`  Agent: ${agents[0].name} (default)`));
       } else {
         for (const agentId of options.agent) {
           const agent = findAgent2(agentId, config);
           if (!agent) {
-            console.error(chalk4.red(`  Error: Agent not found: ${agentId}`));
-            console.log(chalk4.gray("  Available agents:"));
+            console.error(chalk5.red(`  Error: Agent not found: ${agentId}`));
+            console.log(chalk5.gray("  Available agents:"));
             for (const a of config.agents) {
-              console.log(chalk4.gray(`    - ${a.name} (${a.key})`));
+              console.log(chalk5.gray(`    - ${a.name} (${a.key})`));
             }
             console.log("");
-            console.log(chalk4.gray("  To add a custom agent, configure it in agent-health.config.ts"));
-            console.log(chalk4.gray("  Generate one with: npx @opensearch-project/agent-health init"));
+            console.log(chalk5.gray("  To add a custom agent, configure it in agent-health.config.ts"));
+            console.log(chalk5.gray("  Generate one with: npx @opensearch-project/agent-health init"));
             console.log("");
             process.exit(1);
           }
           agents.push(agent);
         }
-        console.log(chalk4.gray(`  Agents: ${agents.map((a) => a.name).join(", ")}`));
+        console.log(chalk5.gray(`  Agents: ${agents.map((a) => a.name).join(", ")}`));
       }
       console.log("");
       const concurrency = Math.max(1, Math.min(20, parseInt(options.concurrency, 10) || 1));
       if (concurrency > 1) {
-        console.log(chalk4.gray(`  Concurrency: ${concurrency}`));
+        console.log(chalk5.gray(`  Concurrency: ${concurrency}`));
       }
       const allResults = [];
       let totalTestCasesAcrossBenchmarks = 0;
       for (const benchmark2 of benchmarksToRun) {
         if (benchmarksToRun.length > 1) {
           console.log("");
-          console.log(chalk4.bold(`Benchmark: ${benchmark2.name}`));
+          console.log(chalk5.bold(`Benchmark: ${benchmark2.name}`));
         }
         totalTestCasesAcrossBenchmarks += benchmark2.testCaseIds.length;
         for (const agent of agents) {
@@ -8082,22 +8734,22 @@ function createBenchmarkCommand() {
         await exportResults(benchmark, allResults, options.export, options.format, serverResult.baseUrl);
       }
       console.log("");
-      console.log(chalk4.cyan("View results:"));
+      console.log(chalk5.cyan("View results:"));
       for (const result of allResults) {
         const runId = result.run?.id || result.runId;
         const bm = result.benchmark || benchmark;
         if (runId) {
-          console.log(chalk4.gray(`  ${result.agent.name} (${bm.name}): ${serverResult.baseUrl}/evaluations/benchmarks/${bm.id}/runs/${runId}`));
+          console.log(chalk5.gray(`  ${result.agent.name} (${bm.name}): ${serverResult.baseUrl}/evaluations/benchmarks/${bm.id}/runs/${runId}`));
         }
       }
       if (process.env.OPENSEARCH_DASHBOARDS_URL) {
-        console.log(chalk4.gray(`  OpenSearch Dashboards: ${process.env.OPENSEARCH_DASHBOARDS_URL}`));
+        console.log(chalk5.gray(`  OpenSearch Dashboards: ${process.env.OPENSEARCH_DASHBOARDS_URL}`));
       }
       if (serverResult.wasStarted && !shouldStopServer) {
         console.log("");
-        console.log(chalk4.gray(`Server still running on port ${serverConfig.port}`));
-        console.log(chalk4.gray(`  Use --stop-server flag to stop after benchmark`));
-        console.log(chalk4.gray(`  Or manually: kill $(lsof -t -i:${serverConfig.port})`));
+        console.log(chalk5.gray(`Server still running on port ${serverConfig.port}`));
+        console.log(chalk5.gray(`  Use --stop-server flag to stop after benchmark`));
+        console.log(chalk5.gray(`  Or manually: kill $(lsof -t -i:${serverConfig.port})`));
       }
     } finally {
       cleanup();
@@ -8108,8 +8760,8 @@ function createBenchmarkCommand() {
 
 // cli/commands/export.ts
 init_config2();
-import { Command as Command4 } from "commander";
-import chalk5 from "chalk";
+import { Command as Command5 } from "commander";
+import chalk6 from "chalk";
 import { writeFileSync as writeFileSync2 } from "fs";
 
 // lib/benchmarkExport.ts
@@ -8120,7 +8772,7 @@ function generateExportFilename(benchmarkName) {
 
 // cli/commands/export.ts
 function createExportCommand() {
-  const command = new Command4("export").description("Export benchmark test cases as JSON").requiredOption("-b, --benchmark <id-or-name>", "Benchmark ID or name").option("-o, --output <file>", "Output file path (default: <benchmark-name>.json)").option("--stdout", "Write to stdout instead of file").action(async (options) => {
+  const command = new Command5("export").description("Export benchmark test cases as JSON").requiredOption("-b, --benchmark <id-or-name>", "Benchmark ID or name").option("-o, --output <file>", "Output file path (default: <benchmark-name>.json)").option("--stdout", "Write to stdout instead of file").action(async (options) => {
     const config = await loadConfig();
     const serverResult = await ensureServer(config.server);
     const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
@@ -8128,7 +8780,7 @@ function createExportCommand() {
       const client = new ApiClient(serverResult.baseUrl);
       const benchmark = await client.findBenchmark(options.benchmark);
       if (!benchmark) {
-        console.error(chalk5.red(`
+        console.error(chalk6.red(`
   Error: Benchmark not found: ${options.benchmark}
 `));
         process.exit(1);
@@ -8140,14 +8792,14 @@ function createExportCommand() {
       }
       const outputFile = options.output || generateExportFilename(benchmark.name);
       writeFileSync2(outputFile, JSON.stringify(exportData, null, 2) + "\n", "utf-8");
-      console.log(chalk5.green(`
-  Exported ${exportData.length} test case(s) to ${chalk5.bold(outputFile)}`));
-      console.log(chalk5.gray(`  Benchmark: ${benchmark.name} (${benchmark.id})
+      console.log(chalk6.green(`
+  Exported ${exportData.length} test case(s) to ${chalk6.bold(outputFile)}`));
+      console.log(chalk6.gray(`  Benchmark: ${benchmark.name} (${benchmark.id})
 `));
     } catch (error) {
-      console.error(chalk5.red(`
+      console.error(chalk6.red(`
   Error: ${error.message}`));
-      console.log(chalk5.gray("  Is the server running? Start with: npm run dev:server\n"));
+      console.log(chalk6.gray("  Is the server running? Start with: npm run dev:server\n"));
       process.exit(1);
     } finally {
       cleanup();
@@ -8158,12 +8810,12 @@ function createExportCommand() {
 
 // cli/commands/report.ts
 init_config2();
-import { Command as Command5 } from "commander";
-import chalk6 from "chalk";
+import { Command as Command6 } from "commander";
+import chalk7 from "chalk";
 import ora3 from "ora";
 import { writeFileSync as writeFileSync3 } from "fs";
 function createReportCommand() {
-  const command = new Command5("report").description("Generate a report for a benchmark").requiredOption("-b, --benchmark <id>", "Benchmark name or ID").option("-r, --runs <ids>", "Comma-separated run IDs (default: all runs)").option("-f, --format <type>", "Report format: json, html, pdf", "html").option("-o, --output <file>", "Output file path (auto-generates filename if omitted)").option("--stdout", "Write to stdout (JSON format only)").action(async (options) => {
+  const command = new Command6("report").description("Generate a report for a benchmark").requiredOption("-b, --benchmark <id>", "Benchmark name or ID").option("-r, --runs <ids>", "Comma-separated run IDs (default: all runs)").option("-f, --format <type>", "Report format: json, html, pdf", "html").option("-o, --output <file>", "Output file path (auto-generates filename if omitted)").option("--stdout", "Write to stdout (JSON format only)").action(async (options) => {
     const config = await loadConfig();
     const serverConfig = { ...DEFAULT_SERVER_CONFIG, ...config.server };
     const connectSpinner = ora3("Connecting to server...").start();
@@ -8190,8 +8842,8 @@ function createReportCommand() {
       if (!benchmark) {
         spinner.fail(`Benchmark not found: "${options.benchmark}"`);
         console.log("");
-        console.log(chalk6.cyan("  Available benchmarks:"));
-        console.log(chalk6.gray("    npx agent-health list benchmarks"));
+        console.log(chalk7.cyan("  Available benchmarks:"));
+        console.log(chalk7.gray("    npx agent-health list benchmarks"));
         console.log("");
         process.exit(1);
       }
@@ -8238,8 +8890,8 @@ function createReportCommand() {
 init_config2();
 init_server();
 init_portConfig();
-import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
 import { existsSync as existsSync4 } from "fs";
 import { resolve as resolve6 } from "path";
 function checkConfigFile() {
@@ -8468,22 +9120,22 @@ async function checkTracesConnectivity() {
   }
 }
 function displayResults2(results) {
-  console.log(chalk7.bold("\n  Configuration Check\n"));
+  console.log(chalk8.bold("\n  Configuration Check\n"));
   for (const result of results) {
     const icon = {
-      ok: chalk7.green("\u2713"),
-      warning: chalk7.yellow("\u26A0"),
-      error: chalk7.red("\u2717")
+      ok: chalk8.green("\u2713"),
+      warning: chalk8.yellow("\u26A0"),
+      error: chalk8.red("\u2717")
     }[result.status];
     const messageColor = {
-      ok: chalk7.green,
-      warning: chalk7.yellow,
-      error: chalk7.red
+      ok: chalk8.green,
+      warning: chalk8.yellow,
+      error: chalk8.red
     }[result.status];
-    console.log(`  ${icon} ${chalk7.bold(result.name)}: ${messageColor(result.message)}`);
+    console.log(`  ${icon} ${chalk8.bold(result.name)}: ${messageColor(result.message)}`);
     if (result.details) {
       for (const detail of result.details) {
-        console.log(chalk7.gray(`      ${detail}`));
+        console.log(chalk8.gray(`      ${detail}`));
       }
     }
   }
@@ -8491,17 +9143,17 @@ function displayResults2(results) {
   const errors = results.filter((r) => r.status === "error").length;
   const warnings = results.filter((r) => r.status === "warning").length;
   if (errors > 0) {
-    console.log(chalk7.red(`  ${errors} error(s) found. Fix these before running evaluations.
+    console.log(chalk8.red(`  ${errors} error(s) found. Fix these before running evaluations.
 `));
   } else if (warnings > 0) {
-    console.log(chalk7.yellow(`  ${warnings} warning(s). Some features may be limited.
+    console.log(chalk8.yellow(`  ${warnings} warning(s). Some features may be limited.
 `));
   } else {
-    console.log(chalk7.green("  All checks passed!\n"));
+    console.log(chalk8.green("  All checks passed!\n"));
   }
 }
 function createDoctorCommand() {
-  const command = new Command6("doctor").description("Check configuration and system requirements").option("-o, --output <format>", "Output format: text, json", "text").action(async (options) => {
+  const command = new Command7("doctor").description("Check configuration and system requirements").option("-o, --output <format>", "Output format: text, json", "text").action(async (options) => {
     const results = [];
     const config = await loadConfig();
     for (const connector of config.connectors) {
@@ -8526,8 +9178,8 @@ function createDoctorCommand() {
 }
 
 // cli/commands/init.ts
-import { Command as Command7 } from "commander";
-import chalk8 from "chalk";
+import { Command as Command8 } from "commander";
+import chalk9 from "chalk";
 import { writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
 import { resolve as resolve7 } from "path";
 var TYPESCRIPT_CONFIG = `/*
@@ -8645,8 +9297,8 @@ expectedOutcomes:
   - The agent should suggest investigating network connectivity
 `;
 function createInitCommand() {
-  const command = new Command7("init").description("Initialize configuration files").option("--force", "Overwrite existing files").option("--with-examples", "Include example test case").action(async (options) => {
-    console.log(chalk8.bold("\n  Agent Health - Initialize Configuration\n"));
+  const command = new Command8("init").description("Initialize configuration files").option("--force", "Overwrite existing files").option("--with-examples", "Include example test case").action(async (options) => {
+    console.log(chalk9.bold("\n  Agent Health - Initialize Configuration\n"));
     const cwd = process.cwd();
     const files = [];
     files.push({
@@ -8675,24 +9327,24 @@ function createInitCommand() {
     let skipped = 0;
     for (const file of files) {
       if (existsSync5(file.path) && !options.force) {
-        console.log(chalk8.yellow(`  \u26A0 Skipped: ${file.name} (already exists, use --force to overwrite)`));
+        console.log(chalk9.yellow(`  \u26A0 Skipped: ${file.name} (already exists, use --force to overwrite)`));
         skipped++;
       } else {
         writeFileSync4(file.path, file.content);
-        console.log(chalk8.green(`  \u2713 Created: ${file.name}`));
+        console.log(chalk9.green(`  \u2713 Created: ${file.name}`));
         created++;
       }
     }
     console.log("");
     if (created > 0) {
-      console.log(chalk8.gray("  Next steps:"));
-      console.log(chalk8.gray("    1. Copy .env.example to .env and fill in your values"));
-      console.log(chalk8.gray("    2. Update the config file with your agent endpoint"));
-      console.log(chalk8.gray("    3. Run `agent-health doctor` to verify configuration"));
-      console.log(chalk8.gray("    4. Run `agent-health run -t sample-rca-001` to test\n"));
+      console.log(chalk9.gray("  Next steps:"));
+      console.log(chalk9.gray("    1. Copy .env.example to .env and fill in your values"));
+      console.log(chalk9.gray("    2. Update the config file with your agent endpoint"));
+      console.log(chalk9.gray("    3. Run `agent-health doctor` to verify configuration"));
+      console.log(chalk9.gray("    4. Run `agent-health run -t sample-rca-001` to test\n"));
     }
     if (skipped > 0) {
-      console.log(chalk8.yellow(`  ${skipped} file(s) skipped. Use --force to overwrite.
+      console.log(chalk9.yellow(`  ${skipped} file(s) skipped. Use --force to overwrite.
 `));
     }
   });
@@ -8701,8 +9353,8 @@ function createInitCommand() {
 
 // cli/commands/migrate.ts
 init_config2();
-import { Command as Command8 } from "commander";
-import chalk9 from "chalk";
+import { Command as Command9 } from "commander";
+import chalk10 from "chalk";
 import ora4 from "ora";
 function computeStatsFromReports(run, reports) {
   const reportsMap = new Map(reports.map((r) => [r.id, r]));
@@ -8741,8 +9393,8 @@ function computeStatsFromReports(run, reports) {
   return { passed, failed, pending, total };
 }
 function createMigrateCommand() {
-  const command = new Command8("migrate").description("One-time migration to add stats to existing benchmark runs").option("--dry-run", "Show what would be migrated without making changes").option("-v, --verbose", "Show detailed progress").action(async (options) => {
-    console.log(chalk9.cyan.bold("\n  Benchmark Stats Migration\n"));
+  const command = new Command9("migrate").description("One-time migration to add stats to existing benchmark runs").option("--dry-run", "Show what would be migrated without making changes").option("-v, --verbose", "Show detailed progress").action(async (options) => {
+    console.log(chalk10.cyan.bold("\n  Benchmark Stats Migration\n"));
     const config = await loadConfig();
     const serverResult = await ensureServer(config.server);
     const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
@@ -8755,12 +9407,12 @@ function createMigrateCommand() {
         (b) => !b.id.startsWith("demo-") && (b.runs?.length ?? 0) > 0
       );
       if (migratable.length === 0) {
-        console.log(chalk9.yellow("\n  No benchmarks to migrate.\n"));
-        console.log(chalk9.gray("  Only user-created benchmarks with runs can be migrated."));
-        console.log(chalk9.gray("  Sample data (demo-*) already has stats computed.\n"));
+        console.log(chalk10.yellow("\n  No benchmarks to migrate.\n"));
+        console.log(chalk10.gray("  Only user-created benchmarks with runs can be migrated."));
+        console.log(chalk10.gray("  Sample data (demo-*) already has stats computed.\n"));
         return;
       }
-      console.log(chalk9.gray(`
+      console.log(chalk10.gray(`
   Migrating ${migratable.length} benchmarks with runs...
 `));
       let totalRuns = 0;
@@ -8771,13 +9423,13 @@ function createMigrateCommand() {
         const runs = benchmark.runs || [];
         totalRuns += runs.length;
         if (options.verbose) {
-          console.log(chalk9.gray(`  Processing: ${benchmark.name} (${runs.length} runs)`));
+          console.log(chalk10.gray(`  Processing: ${benchmark.name} (${runs.length} runs)`));
         }
         for (const run of runs) {
           if (run.stats && typeof run.stats.passed === "number") {
             skippedRuns++;
             if (options.verbose) {
-              console.log(chalk9.gray(`    \u2713 ${run.name} - already has stats`));
+              console.log(chalk10.gray(`    \u2713 ${run.name} - already has stats`));
             }
             continue;
           }
@@ -8791,7 +9443,7 @@ function createMigrateCommand() {
             const { runs: reports } = await reportsRes.json();
             const stats = computeStatsFromReports(run, reports || []);
             if (options.verbose) {
-              console.log(chalk9.gray(
+              console.log(chalk10.gray(
                 `    \u2192 ${run.name}: passed=${stats.passed}, failed=${stats.failed}, pending=${stats.pending}`
               ));
             }
@@ -8814,30 +9466,30 @@ function createMigrateCommand() {
             errors++;
             const msg = error instanceof Error ? error.message : "Unknown error";
             if (options.verbose) {
-              console.log(chalk9.red(`    \u2717 ${run.name} - ${msg}`));
+              console.log(chalk10.red(`    \u2717 ${run.name} - ${msg}`));
             }
           }
         }
         console.log(
-          options.dryRun ? chalk9.blue(`  [DRY RUN] ${benchmark.name} - ${runs.length} runs would be processed`) : chalk9.green(`  \u2713 ${benchmark.name} - ${runs.length} runs`)
+          options.dryRun ? chalk10.blue(`  [DRY RUN] ${benchmark.name} - ${runs.length} runs would be processed`) : chalk10.green(`  \u2713 ${benchmark.name} - ${runs.length} runs`)
         );
       }
-      console.log(chalk9.bold("\n  Migration Summary\n"));
-      console.log(chalk9.gray(`    Total runs:    ${totalRuns}`));
-      console.log(chalk9.green(`    Migrated:      ${migratedRuns}`));
-      console.log(chalk9.yellow(`    Already done:  ${skippedRuns}`));
+      console.log(chalk10.bold("\n  Migration Summary\n"));
+      console.log(chalk10.gray(`    Total runs:    ${totalRuns}`));
+      console.log(chalk10.green(`    Migrated:      ${migratedRuns}`));
+      console.log(chalk10.yellow(`    Already done:  ${skippedRuns}`));
       if (errors > 0) {
-        console.log(chalk9.red(`    Errors:        ${errors}`));
+        console.log(chalk10.red(`    Errors:        ${errors}`));
       }
       if (options.dryRun) {
-        console.log(chalk9.blue("\n  This was a dry run. No changes were made."));
-        console.log(chalk9.blue("  Run without --dry-run to apply changes.\n"));
+        console.log(chalk10.blue("\n  This was a dry run. No changes were made."));
+        console.log(chalk10.blue("  Run without --dry-run to apply changes.\n"));
       } else {
-        console.log(chalk9.green("\n  Migration complete!\n"));
+        console.log(chalk10.green("\n  Migration complete!\n"));
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk9.red(`
+      console.error(chalk10.red(`
   Error: ${msg}
 `));
       process.exit(1);
@@ -8846,8 +9498,8 @@ function createMigrateCommand() {
     }
   });
   command.command("evaluation-runs").description("Migrate embedded benchmark runs to top-level EvaluationRun documents").option("--dry-run", "Show what would be migrated without making changes").option("-v, --verbose", "Show detailed progress").action(async (opts) => {
-    console.log(chalk9.cyan.bold("\n  Evaluation Runs Migration\n"));
-    console.log(chalk9.gray("  Extracts embedded benchmark.runs[] \u2192 top-level EvaluationRun documents\n"));
+    console.log(chalk10.cyan.bold("\n  Evaluation Runs Migration\n"));
+    console.log(chalk10.gray("  Extracts embedded benchmark.runs[] \u2192 top-level EvaluationRun documents\n"));
     const config = await loadConfig();
     const serverResult = await ensureServer(config.server);
     const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
@@ -8858,7 +9510,7 @@ function createMigrateCommand() {
       spinner.succeed(`Found ${benchmarks2.length} benchmarks`);
       const withRuns = benchmarks2.filter((b) => (b.runs?.length ?? 0) > 0);
       if (withRuns.length === 0) {
-        console.log(chalk9.yellow("\n  No embedded runs found. Nothing to migrate.\n"));
+        console.log(chalk10.yellow("\n  No embedded runs found. Nothing to migrate.\n"));
         return;
       }
       let totalRuns = 0;
@@ -8876,7 +9528,7 @@ function createMigrateCommand() {
             if (checkRes.ok) {
               skipped++;
               if (opts.verbose) {
-                console.log(chalk9.gray(`    \u2713 ${run.id} already migrated`));
+                console.log(chalk10.gray(`    \u2713 ${run.id} already migrated`));
               }
               continue;
             }
@@ -8899,7 +9551,7 @@ function createMigrateCommand() {
             benchmarkId: benchmark.id
           };
           if (opts.verbose) {
-            console.log(chalk9.gray(`    \u2192 Migrating ${run.id} (${evalRun.name})`));
+            console.log(chalk10.gray(`    \u2192 Migrating ${run.id} (${evalRun.name})`));
           }
           if (!opts.dryRun) {
             try {
@@ -8914,7 +9566,7 @@ function createMigrateCommand() {
               if (!createRes.ok) {
                 errors++;
                 if (opts.verbose) {
-                  console.log(chalk9.red(`    \u2717 ${run.id} - could not create (${createRes.status})`));
+                  console.log(chalk10.red(`    \u2717 ${run.id} - could not create (${createRes.status})`));
                 }
                 continue;
               }
@@ -8923,7 +9575,7 @@ function createMigrateCommand() {
               errors++;
               if (opts.verbose) {
                 const msg = err instanceof Error ? err.message : "Unknown error";
-                console.log(chalk9.red(`    \u2717 ${run.id} - ${msg}`));
+                console.log(chalk10.red(`    \u2717 ${run.id} - ${msg}`));
               }
             }
           } else {
@@ -8931,24 +9583,24 @@ function createMigrateCommand() {
           }
         }
         console.log(
-          opts.dryRun ? chalk9.blue(`  [DRY RUN] ${benchmark.name}: ${runs.length} runs`) : chalk9.green(`  \u2713 ${benchmark.name}: ${runs.length} runs`)
+          opts.dryRun ? chalk10.blue(`  [DRY RUN] ${benchmark.name}: ${runs.length} runs`) : chalk10.green(`  \u2713 ${benchmark.name}: ${runs.length} runs`)
         );
       }
-      console.log(chalk9.bold("\n  Migration Summary\n"));
-      console.log(chalk9.gray(`    Total embedded runs: ${totalRuns}`));
-      console.log(chalk9.green(`    Migrated:           ${migrated}`));
-      console.log(chalk9.yellow(`    Already done:       ${skipped}`));
+      console.log(chalk10.bold("\n  Migration Summary\n"));
+      console.log(chalk10.gray(`    Total embedded runs: ${totalRuns}`));
+      console.log(chalk10.green(`    Migrated:           ${migrated}`));
+      console.log(chalk10.yellow(`    Already done:       ${skipped}`));
       if (errors > 0) {
-        console.log(chalk9.red(`    Errors:             ${errors}`));
+        console.log(chalk10.red(`    Errors:             ${errors}`));
       }
       if (opts.dryRun) {
-        console.log(chalk9.blue("\n  Dry run \u2014 no changes made. Run without --dry-run to apply.\n"));
+        console.log(chalk10.blue("\n  Dry run \u2014 no changes made. Run without --dry-run to apply.\n"));
       } else {
-        console.log(chalk9.green("\n  Migration complete!\n"));
+        console.log(chalk10.green("\n  Migration complete!\n"));
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk9.red(`
+      console.error(chalk10.red(`
   Error: ${msg}
 `));
       process.exit(1);
@@ -8967,8 +9619,8 @@ function createMigrateCommand() {
     const { migrateEvalSource: migrateEvalSource2 } = await Promise.resolve().then(() => (init_codemod(), codemod_exports));
     const fs3 = await import("fs");
     const fg = await import("fast-glob").then((m2) => m2.default).catch(() => null);
-    console.log(chalk9.cyan.bold("\n  Code-SDK v2 migration (codemod)\n"));
-    console.log(chalk9.gray("  Rewrites `({ result }) => ...` bodies with a prompt to `({ agent }) => { const result = await agent.run(); ... }`\n"));
+    console.log(chalk10.cyan.bold("\n  Code-SDK v2 migration (codemod)\n"));
+    console.log(chalk10.gray("  Rewrites `({ result }) => ...` bodies with a prompt to `({ agent }) => { const result = await agent.run(); ... }`\n"));
     const patterns = files && files.length > 0 ? files : ["**/*.eval.js", "**/*.eval.ts", "**/*.eval.mjs"];
     let targets = [];
     if (fg) {
@@ -8977,7 +9629,7 @@ function createMigrateCommand() {
       targets = patterns.filter((p) => fs3.existsSync(p));
     }
     if (targets.length === 0) {
-      console.log(chalk9.yellow("  No matching .eval files found.\n"));
+      console.log(chalk10.yellow("  No matching .eval files found.\n"));
       return;
     }
     let changedFiles = 0;
@@ -8995,22 +9647,22 @@ function createMigrateCommand() {
       if (changed) {
         changedFiles++;
         if (!opts.dryRun) fs3.writeFileSync(file, code2, "utf-8");
-        console.log((opts.dryRun ? chalk9.blue("  would update ") : chalk9.green("  updated ")) + chalk9.bold(file) + chalk9.gray(` (${migrated} test${migrated === 1 ? "" : "s"})`));
+        console.log((opts.dryRun ? chalk10.blue("  would update ") : chalk10.green("  updated ")) + chalk10.bold(file) + chalk10.gray(` (${migrated} test${migrated === 1 ? "" : "s"})`));
       } else if (opts.verbose) {
-        console.log(chalk9.gray(`  unchanged ${file}`));
+        console.log(chalk10.gray(`  unchanged ${file}`));
       }
       if (opts.verbose) {
-        for (const n of notes) console.log(chalk9.gray(`      ${n}`));
+        for (const n of notes) console.log(chalk10.gray(`      ${n}`));
       }
     }
-    console.log(chalk9.bold("\n  Summary\n"));
-    console.log(chalk9.gray(`    Files scanned:   ${targets.length}`));
-    console.log(chalk9.green(`    Files ${opts.dryRun ? "to change" : "changed"}:   ${changedFiles}`));
-    console.log(chalk9.green(`    Tests migrated:  ${migratedTests}`));
+    console.log(chalk10.bold("\n  Summary\n"));
+    console.log(chalk10.gray(`    Files scanned:   ${targets.length}`));
+    console.log(chalk10.green(`    Files ${opts.dryRun ? "to change" : "changed"}:   ${changedFiles}`));
+    console.log(chalk10.green(`    Tests migrated:  ${migratedTests}`));
     if (opts.dryRun) {
-      console.log(chalk9.blue("\n  Dry run \u2014 no files written. Re-run without --dry-run to apply.\n"));
+      console.log(chalk10.blue("\n  Dry run \u2014 no files written. Re-run without --dry-run to apply.\n"));
     } else {
-      console.log(chalk9.green("\n  Done. Review the diff and run your evals to verify.\n"));
+      console.log(chalk10.green("\n  Done. Review the diff and run your evals to verify.\n"));
     }
   });
   return command;
@@ -9018,8 +9670,8 @@ function createMigrateCommand() {
 
 // cli/commands/compare-services.ts
 init_config2();
-import { Command as Command9 } from "commander";
-import chalk10 from "chalk";
+import { Command as Command10 } from "commander";
+import chalk11 from "chalk";
 function analyzeErrorPatterns(spans) {
   const errorSpans = spans.filter((s) => s.status === "ERROR");
   if (errorSpans.length === 0) {
@@ -9083,7 +9735,7 @@ function extractErrorMessage(span) {
   return null;
 }
 async function analyzeServiceErrors(client, serviceName, startTime, endTime, limit = 1e3) {
-  console.log(chalk10.gray(`
+  console.log(chalk11.gray(`
 Fetching traces for service: ${serviceName}...`));
   const response = await client.fetchTraces({
     serviceName,
@@ -9092,7 +9744,7 @@ Fetching traces for service: ${serviceName}...`));
     size: limit
   });
   const spans = response.spans || [];
-  console.log(chalk10.gray(`  Found ${spans.length} spans`));
+  console.log(chalk11.gray(`  Found ${spans.length} spans`));
   const traceMap = /* @__PURE__ */ new Map();
   for (const span of spans) {
     if (!traceMap.has(span.traceId)) {
@@ -9120,89 +9772,89 @@ Fetching traces for service: ${serviceName}...`));
   };
 }
 function printServiceAnalysis(analysis) {
-  console.log(chalk10.bold.cyan(`
+  console.log(chalk11.bold.cyan(`
 ${"=".repeat(60)}`));
-  console.log(chalk10.bold.cyan(`Service: ${analysis.serviceName}`));
-  console.log(chalk10.bold.cyan("=".repeat(60)));
-  console.log(chalk10.white(`Total Traces: ${analysis.totalTraces}`));
-  console.log(chalk10.white(`Traces with Errors: ${analysis.tracesWithErrors}`));
-  const errorRateColor = analysis.errorRate > 10 ? chalk10.red : analysis.errorRate > 5 ? chalk10.yellow : chalk10.green;
+  console.log(chalk11.bold.cyan(`Service: ${analysis.serviceName}`));
+  console.log(chalk11.bold.cyan("=".repeat(60)));
+  console.log(chalk11.white(`Total Traces: ${analysis.totalTraces}`));
+  console.log(chalk11.white(`Traces with Errors: ${analysis.tracesWithErrors}`));
+  const errorRateColor = analysis.errorRate > 10 ? chalk11.red : analysis.errorRate > 5 ? chalk11.yellow : chalk11.green;
   console.log(errorRateColor(`Error Rate: ${analysis.errorRate.toFixed(2)}%`));
-  console.log(chalk10.white(`Total Error Spans: ${analysis.totalErrorSpans}`));
-  console.log(chalk10.white(`Avg Error Span Duration: ${analysis.avgErrorDurationMs.toFixed(2)}ms`));
+  console.log(chalk11.white(`Total Error Spans: ${analysis.totalErrorSpans}`));
+  console.log(chalk11.white(`Avg Error Span Duration: ${analysis.avgErrorDurationMs.toFixed(2)}ms`));
   if (analysis.errorPatterns.length > 0) {
-    console.log(chalk10.bold.white("\nError Patterns:"));
+    console.log(chalk11.bold.white("\nError Patterns:"));
     for (const pattern of analysis.errorPatterns) {
-      console.log(chalk10.yellow(`
+      console.log(chalk11.yellow(`
   \u2022 ${pattern.errorType}`));
-      console.log(chalk10.gray(`    Count: ${pattern.count}`));
-      console.log(chalk10.gray(`    Avg Duration: ${pattern.avgDurationMs.toFixed(2)}ms`));
-      console.log(chalk10.gray(`    Affected Spans: ${pattern.spanNames.join(", ")}`));
+      console.log(chalk11.gray(`    Count: ${pattern.count}`));
+      console.log(chalk11.gray(`    Avg Duration: ${pattern.avgDurationMs.toFixed(2)}ms`));
+      console.log(chalk11.gray(`    Affected Spans: ${pattern.spanNames.join(", ")}`));
       if (pattern.exampleMessages.length > 0) {
-        console.log(chalk10.gray(`    Example Messages:`));
+        console.log(chalk11.gray(`    Example Messages:`));
         pattern.exampleMessages.forEach((msg) => {
-          console.log(chalk10.gray(`      - ${msg.substring(0, 80)}${msg.length > 80 ? "..." : ""}`));
+          console.log(chalk11.gray(`      - ${msg.substring(0, 80)}${msg.length > 80 ? "..." : ""}`));
         });
       }
     }
   } else {
-    console.log(chalk10.green("\n\u2713 No error patterns detected"));
+    console.log(chalk11.green("\n\u2713 No error patterns detected"));
   }
 }
 function printComparison(service1, service2) {
-  console.log(chalk10.bold.magenta(`
+  console.log(chalk11.bold.magenta(`
 ${"=".repeat(60)}`));
-  console.log(chalk10.bold.magenta("COMPARISON SUMMARY"));
-  console.log(chalk10.bold.magenta("=".repeat(60)));
+  console.log(chalk11.bold.magenta("COMPARISON SUMMARY"));
+  console.log(chalk11.bold.magenta("=".repeat(60)));
   const errorRateDiff = service1.errorRate - service2.errorRate;
-  const diffColor = Math.abs(errorRateDiff) < 1 ? chalk10.white : errorRateDiff > 0 ? chalk10.red : chalk10.green;
+  const diffColor = Math.abs(errorRateDiff) < 1 ? chalk11.white : errorRateDiff > 0 ? chalk11.red : chalk11.green;
   const diffSymbol = errorRateDiff > 0 ? "\u2191" : errorRateDiff < 0 ? "\u2193" : "=";
-  console.log(chalk10.bold.white("\nError Rate:"));
+  console.log(chalk11.bold.white("\nError Rate:"));
   console.log(`  ${service1.serviceName}: ${service1.errorRate.toFixed(2)}%`);
   console.log(`  ${service2.serviceName}: ${service2.errorRate.toFixed(2)}%`);
   console.log(diffColor(`  Difference: ${diffSymbol} ${Math.abs(errorRateDiff).toFixed(2)}%`));
-  console.log(chalk10.bold.white("\nUnique Error Patterns:"));
+  console.log(chalk11.bold.white("\nUnique Error Patterns:"));
   const patterns1 = new Set(service1.errorPatterns.map((p) => p.errorType));
   const patterns2 = new Set(service2.errorPatterns.map((p) => p.errorType));
   const onlyIn1 = Array.from(patterns1).filter((p) => !patterns2.has(p));
   const onlyIn2 = Array.from(patterns2).filter((p) => !patterns1.has(p));
   const inBoth = Array.from(patterns1).filter((p) => patterns2.has(p));
   if (onlyIn1.length > 0) {
-    console.log(chalk10.cyan(`
+    console.log(chalk11.cyan(`
   Only in ${service1.serviceName}:`));
-    onlyIn1.forEach((p) => console.log(chalk10.gray(`    \u2022 ${p}`)));
+    onlyIn1.forEach((p) => console.log(chalk11.gray(`    \u2022 ${p}`)));
   }
   if (onlyIn2.length > 0) {
-    console.log(chalk10.cyan(`
+    console.log(chalk11.cyan(`
   Only in ${service2.serviceName}:`));
-    onlyIn2.forEach((p) => console.log(chalk10.gray(`    \u2022 ${p}`)));
+    onlyIn2.forEach((p) => console.log(chalk11.gray(`    \u2022 ${p}`)));
   }
   if (inBoth.length > 0) {
-    console.log(chalk10.cyan(`
+    console.log(chalk11.cyan(`
   Common error patterns:`));
     inBoth.forEach((p) => {
       const count1 = service1.errorPatterns.find((x) => x.errorType === p)?.count || 0;
       const count2 = service2.errorPatterns.find((x) => x.errorType === p)?.count || 0;
-      console.log(chalk10.gray(`    \u2022 ${p}: ${count1} vs ${count2}`));
+      console.log(chalk11.gray(`    \u2022 ${p}: ${count1} vs ${count2}`));
     });
   }
-  console.log(chalk10.bold.yellow("\nRecommendations:"));
+  console.log(chalk11.bold.yellow("\nRecommendations:"));
   if (service1.errorRate > service2.errorRate * 1.5) {
-    console.log(chalk10.yellow(`  \u26A0 ${service1.serviceName} has significantly higher error rate - investigate urgently`));
+    console.log(chalk11.yellow(`  \u26A0 ${service1.serviceName} has significantly higher error rate - investigate urgently`));
   } else if (service2.errorRate > service1.errorRate * 1.5) {
-    console.log(chalk10.yellow(`  \u26A0 ${service2.serviceName} has significantly higher error rate - investigate urgently`));
+    console.log(chalk11.yellow(`  \u26A0 ${service2.serviceName} has significantly higher error rate - investigate urgently`));
   } else {
-    console.log(chalk10.green(`  \u2713 Error rates are comparable`));
+    console.log(chalk11.green(`  \u2713 Error rates are comparable`));
   }
   if (onlyIn1.length > 2) {
-    console.log(chalk10.yellow(`  \u26A0 ${service1.serviceName} has ${onlyIn1.length} unique error types - review configuration`));
+    console.log(chalk11.yellow(`  \u26A0 ${service1.serviceName} has ${onlyIn1.length} unique error types - review configuration`));
   }
   if (onlyIn2.length > 2) {
-    console.log(chalk10.yellow(`  \u26A0 ${service2.serviceName} has ${onlyIn2.length} unique error types - review configuration`));
+    console.log(chalk11.yellow(`  \u26A0 ${service2.serviceName} has ${onlyIn2.length} unique error types - review configuration`));
   }
 }
 function createCompareServicesCommand() {
-  const cmd = new Command9("compare-services");
+  const cmd = new Command10("compare-services");
   cmd.description("Compare error patterns between two services from trace data").requiredOption("-s, --services <service1,service2>", 'Comma-separated service names (e.g., "lambda-api,eks-api")').option("--start <time>", 'Start time (ISO 8601 format or relative like "1h", "24h")').option("--end <time>", "End time (ISO 8601 format)").option("--limit <number>", "Maximum number of spans to fetch per service", "1000").action(async (options) => {
     try {
       const config = await loadConfig();
@@ -9210,15 +9862,15 @@ function createCompareServicesCommand() {
       const client = new ApiClient(serverResult.baseUrl);
       const serviceNames = options.services.split(",").map((s) => s.trim());
       if (serviceNames.length !== 2) {
-        console.error(chalk10.red("Error: Please provide exactly two service names"));
+        console.error(chalk11.red("Error: Please provide exactly two service names"));
         process.exit(1);
       }
       const [service1Name, service2Name] = serviceNames;
       const limit = parseInt(options.limit, 10);
-      console.log(chalk10.bold.cyan("\nComparing Error Patterns Between Services"));
-      console.log(chalk10.gray(`Service 1: ${service1Name}`));
-      console.log(chalk10.gray(`Service 2: ${service2Name}`));
-      if (options.start) console.log(chalk10.gray(`Time Range: ${options.start} to ${options.end || "now"}`));
+      console.log(chalk11.bold.cyan("\nComparing Error Patterns Between Services"));
+      console.log(chalk11.gray(`Service 1: ${service1Name}`));
+      console.log(chalk11.gray(`Service 2: ${service2Name}`));
+      if (options.start) console.log(chalk11.gray(`Time Range: ${options.start} to ${options.end || "now"}`));
       const analysis1 = await analyzeServiceErrors(client, service1Name, options.start, options.end, limit);
       const analysis2 = await analyzeServiceErrors(client, service2Name, options.start, options.end, limit);
       printServiceAnalysis(analysis1);
@@ -9226,7 +9878,7 @@ function createCompareServicesCommand() {
       printComparison(analysis1, analysis2);
       console.log();
     } catch (error) {
-      console.error(chalk10.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+      console.error(chalk11.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
       process.exit(1);
     }
   });
@@ -9234,8 +9886,8 @@ function createCompareServicesCommand() {
 }
 
 // cli/commands/remote.ts
-import { Command as Command10 } from "commander";
-import chalk11 from "chalk";
+import { Command as Command11 } from "commander";
+import chalk12 from "chalk";
 import fs2 from "fs";
 import path3 from "path";
 var CONFIG_FILENAME = "agent-health.config.json";
@@ -9258,12 +9910,12 @@ function getRemoteServers(config) {
   return Array.isArray(config.remoteServers) ? config.remoteServers : [];
 }
 function createRemoteCommand() {
-  const remote = new Command10("remote").description("Manage remote agent-health server connections");
+  const remote = new Command11("remote").description("Manage remote agent-health server connections");
   remote.command("add").description("Add a remote server").requiredOption("--name <name>", "Display name for the server").requiredOption("--url <url>", "Server URL (e.g. http://10.0.1.50:4001)").option("--api-key <key>", "API key for authentication").action((options) => {
     const config = readConfig();
     const servers = getRemoteServers(config);
     if (servers.some((s) => s.name === options.name)) {
-      console.error(chalk11.red(`
+      console.error(chalk12.red(`
   Error: Server "${options.name}" already exists. Use 'remote remove' first.
 `));
       process.exit(1);
@@ -9273,7 +9925,7 @@ function createRemoteCommand() {
     servers.push(server);
     config.remoteServers = servers;
     writeConfig(config);
-    console.log(chalk11.green(`
+    console.log(chalk12.green(`
   Added remote server: ${options.name} (${options.url})
 `));
   });
@@ -9282,7 +9934,7 @@ function createRemoteCommand() {
     const servers = getRemoteServers(config);
     const idx = servers.findIndex((s) => s.name === name);
     if (idx === -1) {
-      console.error(chalk11.red(`
+      console.error(chalk12.red(`
   Error: Server "${name}" not found.
 `));
       process.exit(1);
@@ -9290,7 +9942,7 @@ function createRemoteCommand() {
     servers.splice(idx, 1);
     config.remoteServers = servers;
     writeConfig(config);
-    console.log(chalk11.green(`
+    console.log(chalk12.green(`
   Removed remote server: ${name}
 `));
   });
@@ -9298,16 +9950,16 @@ function createRemoteCommand() {
     const config = readConfig();
     const servers = getRemoteServers(config);
     if (servers.length === 0) {
-      console.log(chalk11.gray("\n  No remote servers configured.\n"));
-      console.log(chalk11.gray("  Add one with: agent-health remote add --name <name> --url <url>\n"));
+      console.log(chalk12.gray("\n  No remote servers configured.\n"));
+      console.log(chalk12.gray("  Add one with: agent-health remote add --name <name> --url <url>\n"));
       return;
     }
-    console.log(chalk11.cyan(`
+    console.log(chalk12.cyan(`
   Remote Servers (${servers.length}):
 `));
     for (const s of servers) {
-      const auth = s.apiKey ? chalk11.green(" [auth]") : chalk11.gray(" [no auth]");
-      console.log(`  ${chalk11.bold(s.name)}  ${s.url}${auth}`);
+      const auth = s.apiKey ? chalk12.green(" [auth]") : chalk12.gray(" [no auth]");
+      console.log(`  ${chalk12.bold(s.name)}  ${s.url}${auth}`);
     }
     console.log("");
   });
@@ -9315,10 +9967,10 @@ function createRemoteCommand() {
     const config = readConfig();
     const servers = getRemoteServers(config);
     if (servers.length === 0) {
-      console.log(chalk11.gray("\n  No remote servers configured.\n"));
+      console.log(chalk12.gray("\n  No remote servers configured.\n"));
       return;
     }
-    console.log(chalk11.cyan(`
+    console.log(chalk12.cyan(`
   Testing ${servers.length} remote server(s)...
 `));
     for (const s of servers) {
@@ -9335,13 +9987,13 @@ function createRemoteCommand() {
         if (response.ok) {
           const data = await response.json();
           const agentCount = data.agents?.length ?? 0;
-          console.log(chalk11.green(`  \u2713 ${s.name} \u2014 OK (${agentCount} agents detected)`));
+          console.log(chalk12.green(`  \u2713 ${s.name} \u2014 OK (${agentCount} agents detected)`));
         } else {
-          console.log(chalk11.red(`  \u2717 ${s.name} \u2014 HTTP ${response.status} ${response.statusText}`));
+          console.log(chalk12.red(`  \u2717 ${s.name} \u2014 HTTP ${response.status} ${response.statusText}`));
         }
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        console.log(chalk11.red(`  \u2717 ${s.name} \u2014 ${msg}`));
+        console.log(chalk12.red(`  \u2717 ${s.name} \u2014 ${msg}`));
       }
     }
     console.log("");
@@ -9350,8 +10002,8 @@ function createRemoteCommand() {
 }
 
 // cli/commands/configure.ts
-import { Command as Command11 } from "commander";
-import chalk12 from "chalk";
+import { Command as Command12 } from "commander";
+import chalk13 from "chalk";
 import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
 import { join as join5 } from "path";
 import { execSync as execSync2, spawnSync } from "child_process";
@@ -9416,34 +10068,34 @@ function getStackOutputs(stackName, region, profile) {
   }
 }
 function createConfigureCommand() {
-  const cmd = new Command11("configure").description("Configure Agent Health from infrastructure outputs").option("--from-stack <stackName>", "Import observability config from a CloudFormation stack").option("--region <region>", "AWS region for the CloudFormation stack").option("--profile <profile>", "AWS CLI profile to use").option("--dry-run", "Show what would be written without making changes").action(async (options) => {
+  const cmd = new Command12("configure").description("Configure Agent Health from infrastructure outputs").option("--from-stack <stackName>", "Import observability config from a CloudFormation stack").option("--region <region>", "AWS region for the CloudFormation stack").option("--profile <profile>", "AWS CLI profile to use").option("--dry-run", "Show what would be written without making changes").action(async (options) => {
     if (options.fromStack) {
       await configureFromStack(options.fromStack, options.region, options.profile, options.dryRun);
     } else {
-      console.log(chalk12.yellow("\n  No configuration source specified.\n"));
-      console.log(chalk12.gray("  Usage:"));
-      console.log(chalk12.gray("    agent-health configure --from-stack <stack-name>"));
-      console.log(chalk12.gray("    agent-health configure --from-stack AgentHealthObservability --region us-west-2"));
-      console.log(chalk12.gray("    agent-health configure --from-stack AgentHealthObservability --dry-run\n"));
+      console.log(chalk13.yellow("\n  No configuration source specified.\n"));
+      console.log(chalk13.gray("  Usage:"));
+      console.log(chalk13.gray("    agent-health configure --from-stack <stack-name>"));
+      console.log(chalk13.gray("    agent-health configure --from-stack AgentHealthObservability --region us-west-2"));
+      console.log(chalk13.gray("    agent-health configure --from-stack AgentHealthObservability --dry-run\n"));
     }
   });
   return cmd;
 }
 async function configureFromStack(stackName, region, profile, dryRun) {
-  console.log(chalk12.cyan(`
-  Importing configuration from CloudFormation stack: ${chalk12.bold(stackName)}
+  console.log(chalk13.cyan(`
+  Importing configuration from CloudFormation stack: ${chalk13.bold(stackName)}
 `));
   try {
     execSync2("aws --version", { stdio: ["pipe", "pipe", "pipe"] });
   } catch {
-    console.error(chalk12.red("  AWS CLI is not installed. Install it from https://aws.amazon.com/cli/\n"));
+    console.error(chalk13.red("  AWS CLI is not installed. Install it from https://aws.amazon.com/cli/\n"));
     process.exit(1);
   }
   let outputs;
   try {
     outputs = getStackOutputs(stackName, region, profile);
   } catch (err) {
-    console.error(chalk12.red(`  ${err instanceof Error ? err.message : err}
+    console.error(chalk13.red(`  ${err instanceof Error ? err.message : err}
 `));
     process.exit(1);
   }
@@ -9453,8 +10105,8 @@ async function configureFromStack(stackName, region, profile, dryRun) {
   const stackRegion = outputMap.get("Region") || region;
   const ingestionRoleArn = outputMap.get("IngestionRoleArn");
   if (!endpoint) {
-    console.error(chalk12.red("  Stack does not have an OpenSearchEndpoint output."));
-    console.error(chalk12.gray("  Available outputs: " + outputs.map((o) => o.OutputKey).join(", ") + "\n"));
+    console.error(chalk13.red("  Stack does not have an OpenSearchEndpoint output."));
+    console.error(chalk13.gray("  Available outputs: " + outputs.map((o) => o.OutputKey).join(", ") + "\n"));
     process.exit(1);
   }
   const observabilityConfig = {
@@ -9464,48 +10116,48 @@ async function configureFromStack(stackName, region, profile, dryRun) {
     awsService: "es",
     tlsSkipVerify: false
   };
-  console.log(chalk12.green("  Stack outputs found:"));
-  console.log(chalk12.gray(`    OpenSearch Endpoint:  ${endpoint}`));
+  console.log(chalk13.green("  Stack outputs found:"));
+  console.log(chalk13.gray(`    OpenSearch Endpoint:  ${endpoint}`));
   if (osisEndpoint) {
-    console.log(chalk12.gray(`    OSIS Ingest Endpoint: ${osisEndpoint}`));
+    console.log(chalk13.gray(`    OSIS Ingest Endpoint: ${osisEndpoint}`));
   }
   if (stackRegion) {
-    console.log(chalk12.gray(`    Region:               ${stackRegion}`));
+    console.log(chalk13.gray(`    Region:               ${stackRegion}`));
   }
   if (ingestionRoleArn) {
-    console.log(chalk12.gray(`    Ingestion Role:       ${ingestionRoleArn}`));
+    console.log(chalk13.gray(`    Ingestion Role:       ${ingestionRoleArn}`));
   }
   console.log();
   if (dryRun) {
-    console.log(chalk12.yellow("  Dry run \u2014 would write this to agent-health.config.json:\n"));
-    console.log(chalk12.gray(JSON.stringify({ observability: observabilityConfig }, null, 2)));
+    console.log(chalk13.yellow("  Dry run \u2014 would write this to agent-health.config.json:\n"));
+    console.log(chalk13.gray(JSON.stringify({ observability: observabilityConfig }, null, 2)));
     console.log();
     return;
   }
   const config = readConfig2();
   if (config.observability) {
-    console.log(chalk12.yellow("  Existing observability config found \u2014 overwriting.\n"));
+    console.log(chalk13.yellow("  Existing observability config found \u2014 overwriting.\n"));
   }
   config.observability = observabilityConfig;
   writeConfig2(config);
-  console.log(chalk12.green(`  \u2713 Observability config written to ${CONFIG_FILENAME2}
+  console.log(chalk13.green(`  \u2713 Observability config written to ${CONFIG_FILENAME2}
 `));
   if (osisEndpoint) {
-    console.log(chalk12.cyan("  Next step: Configure your agent to send traces to:"));
-    console.log(chalk12.bold(`    OTEL_EXPORTER_OTLP_ENDPOINT=${osisEndpoint}
+    console.log(chalk13.cyan("  Next step: Configure your agent to send traces to:"));
+    console.log(chalk13.bold(`    OTEL_EXPORTER_OTLP_ENDPOINT=${osisEndpoint}
 `));
   }
   if (ingestionRoleArn) {
-    console.log(chalk12.gray(`  Your agents should assume this role for SigV4 auth:`));
-    console.log(chalk12.gray(`    ${ingestionRoleArn}
+    console.log(chalk13.gray(`  Your agents should assume this role for SigV4 auth:`));
+    console.log(chalk13.gray(`    ${ingestionRoleArn}
 `));
   }
-  console.log(chalk12.green("  Done! Start Agent Health with: npx @opensearch-project/agent-health\n"));
+  console.log(chalk13.green("  Done! Start Agent Health with: npx @opensearch-project/agent-health\n"));
 }
 
 // cli/commands/kill.ts
-import { Command as Command12 } from "commander";
-import chalk13 from "chalk";
+import { Command as Command13 } from "commander";
+import chalk14 from "chalk";
 
 // server/services/observioAgent.ts
 import { join as join6, dirname as dirname4 } from "path";
@@ -9572,27 +10224,27 @@ async function killObservioAgent(port = getObservioPort()) {
 
 // cli/commands/kill.ts
 function createKillCommand() {
-  const command = new Command12("kill").description("Kill a running agent process").argument("<target>", "What to kill: sample-agent").action(async (target) => {
+  const command = new Command13("kill").description("Kill a running agent process").argument("<target>", "What to kill: sample-agent").action(async (target) => {
     switch (target) {
       case "sample-agent": {
         const port = getObservioPort();
         const free = await isPortFree(port);
         if (free) {
-          console.log(chalk13.yellow(`  No process found on port ${port}`));
+          console.log(chalk14.yellow(`  No process found on port ${port}`));
           return;
         }
         const killed = await killObservioAgent();
         if (killed) {
-          console.log(chalk13.green("  \u2713 Sample agent stopped"));
+          console.log(chalk14.green("  \u2713 Sample agent stopped"));
         } else {
-          console.log(chalk13.red("  \u2717 Failed to stop sample agent"));
+          console.log(chalk14.red("  \u2717 Failed to stop sample agent"));
           process.exitCode = 1;
         }
         break;
       }
       default:
-        console.error(chalk13.red(`  Unknown target: ${target}`));
-        console.log(`  Available targets: ${chalk13.cyan("sample-agent")}`);
+        console.error(chalk14.red(`  Unknown target: ${target}`));
+        console.log(`  Available targets: ${chalk14.cyan("sample-agent")}`);
         process.exitCode = 1;
     }
   });
@@ -9600,8 +10252,8 @@ function createKillCommand() {
 }
 
 // cli/commands/setup-telemetry.ts
-import { Command as Command13 } from "commander";
-import chalk14 from "chalk";
+import { Command as Command14 } from "commander";
+import chalk15 from "chalk";
 import { existsSync as existsSync7, readFileSync as readFileSync5, appendFileSync, writeFileSync as writeFileSync6 } from "fs";
 import { join as join7, dirname as dirname5 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
@@ -9757,36 +10409,36 @@ function buildRcBlock(endpoint) {
   return "\n" + lines.join("\n") + "\n";
 }
 function createSetupTelemetryCommand() {
-  const command = new Command13("setup-telemetry").description("Configure Claude Code to send telemetry to Agent Health").option("--stack <name>", "CloudFormation stack name", "AgentHealthObservability").option("--region <region>", "AWS region for the CloudFormation stack").option("--profile <profile>", "AWS CLI profile to use").option("--endpoint <url>", "OTLP endpoint URL (skip stack lookup)").option("--dry-run", "Show what would be written without making changes").option("--skip-rc", "Print env vars without writing to shell rc file").option("--status", "Check current telemetry configuration status").option("--deploy", "Deploy the CloudFormation stack before configuring telemetry").option("--force", "Replace existing telemetry block in shell rc file").action(async (options) => {
-    console.log(chalk14.cyan.bold("\n  Agent Health \u2014 Claude Code Telemetry Setup\n"));
+  const command = new Command14("setup-telemetry").description("Configure Claude Code to send telemetry to Agent Health").option("--stack <name>", "CloudFormation stack name", "AgentHealthObservability").option("--region <region>", "AWS region for the CloudFormation stack").option("--profile <profile>", "AWS CLI profile to use").option("--endpoint <url>", "OTLP endpoint URL (skip stack lookup)").option("--dry-run", "Show what would be written without making changes").option("--skip-rc", "Print env vars without writing to shell rc file").option("--status", "Check current telemetry configuration status").option("--deploy", "Deploy the CloudFormation stack before configuring telemetry").option("--force", "Replace existing telemetry block in shell rc file").action(async (options) => {
+    console.log(chalk15.cyan.bold("\n  Agent Health \u2014 Claude Code Telemetry Setup\n"));
     if (options.status) {
       await showStatus();
       return;
     }
-    console.log(chalk14.bold("  Checking prerequisites...\n"));
+    console.log(chalk15.bold("  Checking prerequisites...\n"));
     if (!isClaudeInstalled()) {
-      console.log(chalk14.yellow("  \u26A0 Claude Code CLI not found"));
-      console.log(chalk14.gray("    Install: npm install -g @anthropic-ai/claude-code\n"));
+      console.log(chalk15.yellow("  \u26A0 Claude Code CLI not found"));
+      console.log(chalk15.gray("    Install: npm install -g @anthropic-ai/claude-code\n"));
     } else {
-      console.log(chalk14.green("  \u2713 Claude Code CLI installed"));
+      console.log(chalk15.green("  \u2713 Claude Code CLI installed"));
     }
     if (options.deploy && !options.endpoint) {
       if (!isAwsCliInstalled()) {
-        console.error(chalk14.red("  \u2717 AWS CLI not found. Install it first or use --endpoint <url>.\n"));
+        console.error(chalk15.red("  \u2717 AWS CLI not found. Install it first or use --endpoint <url>.\n"));
         process.exit(1);
       }
-      console.log(chalk14.green("  \u2713 AWS CLI installed"));
+      console.log(chalk15.green("  \u2713 AWS CLI installed"));
       const templatePath = getCfnTemplatePath();
       if (!existsSync7(templatePath)) {
-        console.error(chalk14.red(`
+        console.error(chalk15.red(`
   \u2717 CFN template not found at ${templatePath}`));
-        console.error(chalk14.gray("    This can happen if running from source. Try: npx @goyamegh/agent-health setup-telemetry --deploy\n"));
+        console.error(chalk15.gray("    This can happen if running from source. Try: npx @goyamegh/agent-health setup-telemetry --deploy\n"));
         process.exit(1);
       }
-      console.log(chalk14.gray(`
-  Deploying stack ${chalk14.bold(options.stack)}...`));
-      console.log(chalk14.gray(`  Template: ${templatePath}`));
-      console.log(chalk14.gray("  This may take 10-15 minutes on first deploy.\n"));
+      console.log(chalk15.gray(`
+  Deploying stack ${chalk15.bold(options.stack)}...`));
+      console.log(chalk15.gray(`  Template: ${templatePath}`));
+      console.log(chalk15.gray("  This may take 10-15 minutes on first deploy.\n"));
       const deployArgs = [
         "cloudformation",
         "deploy",
@@ -9808,81 +10460,81 @@ function createSetupTelemetryCommand() {
       });
       if (deployResult.status !== 0) {
         const stderr = (deployResult.stderr || "").trim();
-        console.error(chalk14.red(`
+        console.error(chalk15.red(`
   \u2717 Stack deployment failed:
     ${stderr}
 `));
         process.exit(1);
       }
-      console.log(chalk14.green(`  \u2713 Stack ${options.stack} deployed successfully`));
+      console.log(chalk15.green(`  \u2713 Stack ${options.stack} deployed successfully`));
     }
     let endpoint;
     let stackOutputs = null;
     if (options.endpoint) {
       endpoint = options.endpoint;
-      console.log(chalk14.green(`  \u2713 Using provided endpoint: ${endpoint}`));
+      console.log(chalk15.green(`  \u2713 Using provided endpoint: ${endpoint}`));
     } else {
       if (!isAwsCliInstalled()) {
-        console.error(chalk14.red("  \u2717 AWS CLI not found. Install it or use --endpoint <url> to skip stack lookup.\n"));
+        console.error(chalk15.red("  \u2717 AWS CLI not found. Install it or use --endpoint <url> to skip stack lookup.\n"));
         process.exit(1);
       }
-      if (!options.deploy) console.log(chalk14.green("  \u2713 AWS CLI installed"));
-      console.log(chalk14.gray(`
-  Reading stack outputs from ${chalk14.bold(options.stack)}...`));
+      if (!options.deploy) console.log(chalk15.green("  \u2713 AWS CLI installed"));
+      console.log(chalk15.gray(`
+  Reading stack outputs from ${chalk15.bold(options.stack)}...`));
       try {
         stackOutputs = getStackOutputs2(options.stack, options.region, options.profile);
         endpoint = stackOutputs.otlpEndpoint;
-        console.log(chalk14.green(`  \u2713 OTLP endpoint: ${endpoint}`));
+        console.log(chalk15.green(`  \u2713 OTLP endpoint: ${endpoint}`));
         if (stackOutputs.opensearchEndpoint) {
-          console.log(chalk14.green(`  \u2713 OpenSearch endpoint: ${stackOutputs.opensearchEndpoint}`));
+          console.log(chalk15.green(`  \u2713 OpenSearch endpoint: ${stackOutputs.opensearchEndpoint}`));
         }
       } catch (err) {
-        console.error(chalk14.red(`
+        console.error(chalk15.red(`
   \u2717 ${err instanceof Error ? err.message : err}
 `));
         process.exit(1);
       }
     }
     validateInput2(endpoint, "endpoint");
-    console.log(chalk14.gray("\n  Testing OTLP endpoint connectivity..."));
+    console.log(chalk15.gray("\n  Testing OTLP endpoint connectivity..."));
     const connectivity = await testEndpoint(endpoint);
     if (connectivity.ok) {
-      console.log(chalk14.green(`  \u2713 ${connectivity.message}`));
+      console.log(chalk15.green(`  \u2713 ${connectivity.message}`));
     } else {
-      console.log(chalk14.yellow(`  \u26A0 ${connectivity.message}`));
-      console.log(chalk14.gray("    Telemetry may not work until the endpoint is reachable."));
+      console.log(chalk15.yellow(`  \u26A0 ${connectivity.message}`));
+      console.log(chalk15.gray("    Telemetry may not work until the endpoint is reachable."));
     }
     if (stackOutputs?.opensearchEndpoint) {
       const effectiveRegion = stackOutputs.region || options.region;
       if (effectiveRegion) {
         if (options.dryRun) {
-          console.log(chalk14.yellow("\n  Dry run \u2014 would write server config:"));
-          console.log(chalk14.gray(`    OpenSearch endpoint: ${stackOutputs.opensearchEndpoint}`));
-          console.log(chalk14.gray(`    Auth: SigV4, Region: ${effectiveRegion}
+          console.log(chalk15.yellow("\n  Dry run \u2014 would write server config:"));
+          console.log(chalk15.gray(`    OpenSearch endpoint: ${stackOutputs.opensearchEndpoint}`));
+          console.log(chalk15.gray(`    Auth: SigV4, Region: ${effectiveRegion}
 `));
         } else {
           const configPaths = writeServerConfig(stackOutputs.opensearchEndpoint, effectiveRegion);
           for (const p of configPaths) {
-            console.log(chalk14.green(`  \u2713 Server config written to ${p}`));
+            console.log(chalk15.green(`  \u2713 Server config written to ${p}`));
           }
-          console.log(chalk14.gray(`    Agent Health server will read traces from this OpenSearch domain.`));
+          console.log(chalk15.gray(`    Agent Health server will read traces from this OpenSearch domain.`));
         }
       } else {
-        console.log(chalk14.yellow("\n  \u26A0 Could not determine region for server config. Set --region explicitly."));
+        console.log(chalk15.yellow("\n  \u26A0 Could not determine region for server config. Set --region explicitly."));
       }
     }
     const { shell, rcPath } = detectRcFile();
-    console.log(chalk14.gray(`
+    console.log(chalk15.gray(`
   Detected shell: ${shell} \u2192 ${rcPath}`));
     if (options.dryRun) {
-      console.log(chalk14.yellow("\n  Dry run \u2014 would append to " + rcPath + ":\n"));
-      console.log(chalk14.gray(buildRcBlock(endpoint)));
-      console.log(chalk14.yellow("  No changes made.\n"));
+      console.log(chalk15.yellow("\n  Dry run \u2014 would append to " + rcPath + ":\n"));
+      console.log(chalk15.gray(buildRcBlock(endpoint)));
+      console.log(chalk15.yellow("  No changes made.\n"));
       return;
     }
     if (options.skipRc) {
-      console.log(chalk14.yellow("\n  Add these to your shell profile:\n"));
-      console.log(chalk14.gray(buildRcBlock(endpoint)));
+      console.log(chalk15.yellow("\n  Add these to your shell profile:\n"));
+      console.log(chalk15.gray(buildRcBlock(endpoint)));
       return;
     }
     if (rcFileHasTelemetryBlock(rcPath)) {
@@ -9891,31 +10543,31 @@ function createSetupTelemetryCommand() {
         const regex = new RegExp(`${RC_BLOCK_START}[\\s\\S]*?${RC_BLOCK_END}\\n?`, "g");
         const cleaned = content.replace(regex, "");
         writeFileSync6(rcPath, cleaned + buildRcBlock(endpoint), "utf-8");
-        console.log(chalk14.green(`
+        console.log(chalk15.green(`
   \u2713 Telemetry env vars updated in ${rcPath}`));
       } else {
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
   \u26A0 Telemetry block already exists in ${rcPath}`));
-        console.log(chalk14.gray(`    Use --force to replace it, or manually remove the block between "${RC_BLOCK_START}" and "${RC_BLOCK_END}".
+        console.log(chalk15.gray(`    Use --force to replace it, or manually remove the block between "${RC_BLOCK_START}" and "${RC_BLOCK_END}".
 `));
       }
     } else {
       appendFileSync(rcPath, buildRcBlock(endpoint));
-      console.log(chalk14.green(`
+      console.log(chalk15.green(`
   \u2713 Telemetry env vars written to ${rcPath}`));
     }
-    console.log(chalk14.cyan.bold("\n  Next steps:\n"));
-    console.log(chalk14.gray(`    1. Reload your shell:  ${chalk14.white(`source ${rcPath}`)}`));
-    console.log(chalk14.gray(`    2. Start Claude Code:  ${chalk14.white("cc-otel")} (launches Claude with telemetry)`));
-    console.log(chalk14.gray(`    3. View traces:        ${chalk14.white("http://localhost:4001/coding-agents")}`));
-    console.log(chalk14.gray(`
-    The ${chalk14.white("cc-otel")} alias combines Bedrock auth + OTel telemetry + Claude launch.
+    console.log(chalk15.cyan.bold("\n  Next steps:\n"));
+    console.log(chalk15.gray(`    1. Reload your shell:  ${chalk15.white(`source ${rcPath}`)}`));
+    console.log(chalk15.gray(`    2. Start Claude Code:  ${chalk15.white("cc-otel")} (launches Claude with telemetry)`));
+    console.log(chalk15.gray(`    3. View traces:        ${chalk15.white("http://localhost:4001/coding-agents")}`));
+    console.log(chalk15.gray(`
+    The ${chalk15.white("cc-otel")} alias combines Bedrock auth + OTel telemetry + Claude launch.
 `));
   });
   return command;
 }
 async function showStatus() {
-  console.log(chalk14.bold("  Current Telemetry Status\n"));
+  console.log(chalk15.bold("  Current Telemetry Status\n"));
   const checks = [
     { name: "Telemetry enabled", envVar: "CLAUDE_CODE_ENABLE_TELEMETRY", expected: "1" },
     { name: "Service name", envVar: "OTEL_SERVICE_NAME", expected: "claude-code-agent" },
@@ -9929,57 +10581,57 @@ async function showStatus() {
   for (const check of checks) {
     const value = process.env[check.envVar];
     if (!value) {
-      console.log(chalk14.yellow(`  \u26A0 ${check.name}: ${chalk14.gray("not set")} (${check.envVar})`));
+      console.log(chalk15.yellow(`  \u26A0 ${check.name}: ${chalk15.gray("not set")} (${check.envVar})`));
       allOk = false;
     } else if (check.expected && value !== check.expected) {
-      console.log(chalk14.yellow(`  \u26A0 ${check.name}: ${value} (expected ${check.expected})`));
+      console.log(chalk15.yellow(`  \u26A0 ${check.name}: ${value} (expected ${check.expected})`));
       allOk = false;
     } else {
-      console.log(chalk14.green(`  \u2713 ${check.name}: ${value}`));
+      console.log(chalk15.green(`  \u2713 ${check.name}: ${value}`));
     }
   }
   console.log("");
   if (isClaudeInstalled()) {
-    console.log(chalk14.green("  \u2713 Claude Code CLI installed"));
+    console.log(chalk15.green("  \u2713 Claude Code CLI installed"));
   } else {
-    console.log(chalk14.yellow("  \u26A0 Claude Code CLI not found"));
+    console.log(chalk15.yellow("  \u26A0 Claude Code CLI not found"));
     allOk = false;
   }
   const { rcPath } = detectRcFile();
   if (rcFileHasTelemetryBlock(rcPath)) {
-    console.log(chalk14.green(`  \u2713 Telemetry block in ${rcPath}`));
+    console.log(chalk15.green(`  \u2713 Telemetry block in ${rcPath}`));
   } else {
-    console.log(chalk14.yellow(`  \u26A0 No telemetry block in ${rcPath}`));
+    console.log(chalk15.yellow(`  \u26A0 No telemetry block in ${rcPath}`));
     allOk = false;
   }
   const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
   if (endpoint) {
-    console.log(chalk14.gray("\n  Testing endpoint..."));
+    console.log(chalk15.gray("\n  Testing endpoint..."));
     const result = await testEndpoint(endpoint);
     if (result.ok) {
-      console.log(chalk14.green(`  \u2713 ${result.message}`));
+      console.log(chalk15.green(`  \u2713 ${result.message}`));
     } else {
-      console.log(chalk14.yellow(`  \u26A0 ${result.message}`));
+      console.log(chalk15.yellow(`  \u26A0 ${result.message}`));
       allOk = false;
     }
   }
   console.log("");
   if (allOk) {
-    console.log(chalk14.green("  All checks passed! Telemetry is configured.\n"));
+    console.log(chalk15.green("  All checks passed! Telemetry is configured.\n"));
   } else {
-    console.log(chalk14.yellow("  Some checks failed. Run `agent-health setup-telemetry` to fix.\n"));
+    console.log(chalk15.yellow("  Some checks failed. Run `agent-health setup-telemetry` to fix.\n"));
   }
 }
 
 // cli/commands/skill.ts
 init_config2();
-import { Command as Command14 } from "commander";
-import chalk15 from "chalk";
+import { Command as Command15 } from "commander";
+import chalk16 from "chalk";
 import ora5 from "ora";
 import Table4 from "cli-table3";
 function createSkillCommand() {
-  return new Command14("skill").description("Evaluate and improve an AgentSkill (A/B eval + propose improvements)").argument("<path>", "Path to skill directory (must contain SKILL.md)").option("--auto", "Auto-apply proposed improvements to SKILL.md").option("-a, --agent <key>", "Agent key (default: first claude-code agent)").option("-j, --judge <id>", "Judge model ID (default: first Bedrock model)").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").action(async (skillPath, options) => {
-    console.log(chalk15.bold("\nAgent Health - Skill Evaluator\n"));
+  return new Command15("skill").description("Evaluate and improve an AgentSkill (A/B eval + propose improvements)").argument("<path>", "Path to skill directory (must contain SKILL.md)").option("--auto", "Auto-apply proposed improvements to SKILL.md").option("-a, --agent <key>", "Agent key (default: first claude-code agent)").option("-j, --judge <id>", "Judge model ID (default: first Bedrock model)").option("-o, --output <format>", OUTPUT_FORMAT_DESCRIPTION, "table").action(async (skillPath, options) => {
+    console.log(chalk16.bold("\nAgent Health - Skill Evaluator\n"));
     const config = await loadConfig();
     const serverResult = await ensureServer(config.server);
     const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
@@ -9992,24 +10644,24 @@ function createSkillCommand() {
       });
       const validation = await validateRes.json();
       if (!validation.valid) {
-        validateSpinner.fail(chalk15.red("Invalid skill"));
+        validateSpinner.fail(chalk16.red("Invalid skill"));
         for (const err of validation.errors) {
-          console.log(chalk15.red(`    - ${err}`));
+          console.log(chalk16.red(`    - ${err}`));
         }
         process.exitCode = 1;
         return;
       }
       validateSpinner.succeed(
-        chalk15.green(`Valid skill: ${validation.skill.metadata.name}`) + chalk15.gray(` \u2014 ${validation.skill.metadata.description}`)
+        chalk16.green(`Valid skill: ${validation.skill.metadata.name}`) + chalk16.gray(` \u2014 ${validation.skill.metadata.description}`)
       );
       if (validation.evalsFile) {
-        console.log(chalk15.gray(`  Evals: ${validation.evalsFile.evals.length} test cases`));
+        console.log(chalk16.gray(`  Evals: ${validation.evalsFile.evals.length} test cases`));
       } else {
-        console.log(chalk15.gray(`  Evals: none found (will auto-generate)`));
+        console.log(chalk16.gray(`  Evals: none found (will auto-generate)`));
       }
       if (validation.warnings.length > 0) {
         for (const warn of validation.warnings) {
-          console.log(chalk15.yellow(`  \u26A0 ${warn}`));
+          console.log(chalk16.yellow(`  \u26A0 ${warn}`));
         }
       }
       console.log("");
@@ -10026,11 +10678,11 @@ function createSkillCommand() {
       });
       if (!evalRes.ok) {
         const error = await evalRes.json();
-        evalSpinner.fail(chalk15.red(error.error || "Evaluation failed"));
+        evalSpinner.fail(chalk16.red(error.error || "Evaluation failed"));
         if (error.details) {
           const details = Array.isArray(error.details) ? error.details : [error.details];
           for (const d of details) {
-            console.log(chalk15.red(`    - ${d}`));
+            console.log(chalk16.red(`    - ${d}`));
           }
         }
         process.exitCode = 1;
@@ -10063,7 +10715,7 @@ function createSkillCommand() {
                   evalSpinner.text = `Eval #${event.evalId} [${event.condition}]: grading...`;
                   break;
                 case "eval_done":
-                  evalSpinner.text = `Eval #${event.evalId} [${event.condition}]: ${chalk15.cyan(`${Math.round(event.passRate * 100)}%`)}`;
+                  evalSpinner.text = `Eval #${event.evalId} [${event.condition}]: ${chalk16.cyan(`${Math.round(event.passRate * 100)}%`)}`;
                   break;
                 case "improving":
                   evalSpinner.text = "Analyzing failures and proposing improvements...";
@@ -10075,7 +10727,7 @@ function createSkillCommand() {
                   benchmark = event.benchmark;
                   break;
                 case "error":
-                  evalSpinner.fail(chalk15.red(event.message));
+                  evalSpinner.fail(chalk16.red(event.message));
                   process.exitCode = 1;
                   return;
               }
@@ -10091,31 +10743,31 @@ function createSkillCommand() {
       if (improvement) {
         console.log("");
         if (improvement.applied) {
-          console.log(chalk15.green.bold("  \u2713 Improvement applied to SKILL.md"));
-          console.log(chalk15.gray(`    Changes: ${improvement.changes}`));
-          console.log(chalk15.gray(`    Reasoning: ${improvement.reasoning}`));
+          console.log(chalk16.green.bold("  \u2713 Improvement applied to SKILL.md"));
+          console.log(chalk16.gray(`    Changes: ${improvement.changes}`));
+          console.log(chalk16.gray(`    Reasoning: ${improvement.reasoning}`));
         } else {
-          console.log(chalk15.yellow.bold("  \u2B06 Improvement proposed (not applied)"));
-          console.log(chalk15.gray(`    Changes: ${improvement.changes}`));
-          console.log(chalk15.gray(`    Reasoning: ${improvement.reasoning}`));
+          console.log(chalk16.yellow.bold("  \u2B06 Improvement proposed (not applied)"));
+          console.log(chalk16.gray(`    Changes: ${improvement.changes}`));
+          console.log(chalk16.gray(`    Reasoning: ${improvement.reasoning}`));
           if (improvement.improvedInstructions) {
             console.log("");
-            console.log(chalk15.cyan("  Proposed instructions:"));
-            console.log(chalk15.gray("  " + "\u2500".repeat(60)));
+            console.log(chalk16.cyan("  Proposed instructions:"));
+            console.log(chalk16.gray("  " + "\u2500".repeat(60)));
             const lines = improvement.improvedInstructions.split("\n");
             for (const l of lines) {
-              console.log(chalk15.white(`  ${l}`));
+              console.log(chalk16.white(`  ${l}`));
             }
-            console.log(chalk15.gray("  " + "\u2500".repeat(60)));
-            console.log(chalk15.yellow(`
-  Run with ${chalk15.bold("--auto")} to apply automatically.
+            console.log(chalk16.gray("  " + "\u2500".repeat(60)));
+            console.log(chalk16.yellow(`
+  Run with ${chalk16.bold("--auto")} to apply automatically.
 `));
           }
         }
       } else if (benchmark) {
         const delta = benchmark.run_summary.delta.pass_rate;
         if (delta >= 0) {
-          console.log(chalk15.green(`
+          console.log(chalk16.green(`
   Skill already performing well \u2014 no improvements needed.
 `));
         }
@@ -10128,23 +10780,23 @@ function createSkillCommand() {
 function displayBenchmark(benchmark, format) {
   const { run_summary } = benchmark;
   const delta = run_summary.delta;
-  console.log(chalk15.cyan(`
+  console.log(chalk16.cyan(`
   Skill: ${benchmark.skill_name} (iteration ${benchmark.iteration})`));
-  console.log(chalk15.gray(`  Agent: ${benchmark.agent_key} | Model: ${benchmark.model_id || "default"}`));
-  console.log(chalk15.gray(`  Created: ${benchmark.created_at}`));
+  console.log(chalk16.gray(`  Agent: ${benchmark.agent_key} | Model: ${benchmark.model_id || "default"}`));
+  console.log(chalk16.gray(`  Created: ${benchmark.created_at}`));
   if (format === "json") {
     console.log(JSON.stringify(benchmark, null, 2));
     return;
   }
   const table = new Table4({
-    head: ["Metric", "With Skill", "Without Skill", "Delta"].map((h) => chalk15.cyan(h))
+    head: ["Metric", "With Skill", "Without Skill", "Delta"].map((h) => chalk16.cyan(h))
   });
   const fmtPct = (n) => `${Math.round(n * 100)}%`;
   const fmtTime = (n) => `${n.toFixed(1)}s`;
   const fmtTokens = (n) => Math.round(n).toString();
   const fmtDelta = (n, unit, higherIsBetter) => {
     const sign = n >= 0 ? "+" : "";
-    const color = (higherIsBetter ? n >= 0 : n <= 0) ? chalk15.green : chalk15.red;
+    const color = (higherIsBetter ? n >= 0 : n <= 0) ? chalk16.green : chalk16.red;
     return color(`${sign}${unit === "%" ? Math.round(n * 100) + "%" : n.toFixed(1) + unit}`);
   };
   table.push(
@@ -10154,15 +10806,15 @@ function displayBenchmark(benchmark, format) {
   );
   console.log("");
   console.log(table.toString());
-  console.log(chalk15.gray(`
+  console.log(chalk16.gray(`
   Results: .agent-health/data/skill-evals/${benchmark.skill_path}/iteration-${benchmark.iteration}/`));
 }
 
 // cli/commands/profile.ts
 init_config2();
 init_statePaths();
-import { Command as Command15 } from "commander";
-import chalk16 from "chalk";
+import { Command as Command16 } from "commander";
+import chalk17 from "chalk";
 import ora6 from "ora";
 import { mkdirSync, writeFileSync as writeFileSync7 } from "fs";
 import { join as join9 } from "path";
@@ -10211,20 +10863,20 @@ function sumAttr(spans, keys) {
   return total;
 }
 function createProfileCommand() {
-  return new Command15("profile").description("Profile a live agent session and surface what to fix in its codebase (uses your evaluator as the rubric)").option("-e, --evaluator <id>", "Evaluator id to use as the profiling rubric (default: system-rca-default)").option("-s, --session <id>", "Coding-agent session id (default: auto-detected)").option("-f, --feedback <text>", 'Your upfront steering/feedback on the session (e.g. "focus on routing; it ignored the SOP")').option("--service <name>", "OTel service name used to extract the trajectory (default: auto \u2014 pi-agent for pi sessions, else claude-code)").option("-o, --output <format>", "Output format: table | json", "table").action(async (options) => {
+  return new Command16("profile").description("Profile a live agent session and surface what to fix in its codebase (uses your evaluator as the rubric)").option("-e, --evaluator <id>", "Evaluator id to use as the profiling rubric (default: system-rca-default)").option("-s, --session <id>", "Coding-agent session id (default: auto-detected)").option("-f, --feedback <text>", 'Your upfront steering/feedback on the session (e.g. "focus on routing; it ignored the SOP")').option("--service <name>", "OTel service name used to extract the trajectory (default: auto \u2014 pi-agent for pi sessions, else claude-code)").option("-o, --output <format>", "Output format: table | json", "table").action(async (options) => {
     const asJson = options.output === "json";
-    if (!asJson) console.log(chalk16.bold("\nAgent Health - Profile\n"));
+    if (!asJson) console.log(chalk17.bold("\nAgent Health - Profile\n"));
     const { sessionId, source: source2, agent } = resolveSessionId(options.session);
     if (!sessionId) {
       const msg = "Could not determine the current session id. Pass --session <id>, or run `agent-health setup` (Claude Code) / install the agent-health pi package (pi) to record the session id.";
       if (asJson) console.log(JSON.stringify({ error: msg }, null, 2));
-      else console.log(chalk16.red(`  ${msg}
+      else console.log(chalk17.red(`  ${msg}
 `));
       process.exitCode = 1;
       return;
     }
     const service = options.service || (agent === "pi" ? "pi-agent" : "claude-code");
-    if (!asJson) console.log(chalk16.gray(`  Session: ${sessionId} (via ${source2}, service ${service})`));
+    if (!asJson) console.log(chalk17.gray(`  Session: ${sessionId} (via ${source2}, service ${service})`));
     const config = await loadConfig();
     const serverResult = await ensureServer(config.server);
     const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
@@ -10236,7 +10888,7 @@ function createProfileCommand() {
       const evaluator = evaluators.find((e) => e.id === evaluatorId);
       if (!evaluator) {
         const msg = `Evaluator not found: ${evaluatorId}`;
-        spinner?.fail(chalk16.red(msg));
+        spinner?.fail(chalk17.red(msg));
         if (asJson) console.log(JSON.stringify({ error: msg }, null, 2));
         process.exitCode = 1;
         return;
@@ -10246,7 +10898,7 @@ function createProfileCommand() {
       const spans = traceResult.spans || [];
       if (spans.length === 0) {
         const msg = `No spans found for session ${sessionId}. Is telemetry flowing? (see: agent-health setup-telemetry)`;
-        spinner?.fail(chalk16.yellow(msg));
+        spinner?.fail(chalk17.yellow(msg));
         if (asJson) console.log(JSON.stringify({ error: msg, sessionId }, null, 2));
         process.exitCode = 1;
         return;
@@ -10309,27 +10961,27 @@ function createProfileCommand() {
         console.log(JSON.stringify(profile, null, 2));
         return;
       }
-      console.log(chalk16.cyan(`
+      console.log(chalk17.cyan(`
   Evaluator: ${evaluator.name} (${evaluator.id})`));
-      if (options.feedback) console.log(chalk16.magenta(`  Your feedback: "${options.feedback}"`));
-      console.log(chalk16.gray(
+      if (options.feedback) console.log(chalk17.magenta(`  Your feedback: "${options.feedback}"`));
+      console.log(chalk17.gray(
         `  ${profile.session.spanCount} spans \xB7 ${profile.session.trajectorySteps} steps \xB7 ${(durationMs / 1e3).toFixed(1)}s \xB7 ${tokens.toLocaleString()} tokens`
       ));
       if (signals.length === 0) {
-        console.log(chalk16.green("\n  No notable signals \u2014 the session looks clean."));
-        console.log(chalk16.gray("  (Nothing obvious to fix from traces alone; the rubric review may still find subtler issues.)"));
+        console.log(chalk17.green("\n  No notable signals \u2014 the session looks clean."));
+        console.log(chalk17.gray("  (Nothing obvious to fix from traces alone; the rubric review may still find subtler issues.)"));
       } else {
-        console.log(chalk16.bold("\n  Signals:"));
+        console.log(chalk17.bold("\n  Signals:"));
         for (const s of signals) {
-          const color = s.severity === "high" ? chalk16.red : s.severity === "medium" ? chalk16.yellow : chalk16.gray;
-          console.log(`    ${color(`[${s.severity}]`)} ${s.title}${s.count > 1 ? chalk16.gray(` (\xD7${s.count})`) : ""}`);
-          if (s.evidence) console.log(chalk16.gray(`           ${s.evidence}`));
+          const color = s.severity === "high" ? chalk17.red : s.severity === "medium" ? chalk17.yellow : chalk17.gray;
+          console.log(`    ${color(`[${s.severity}]`)} ${s.title}${s.count > 1 ? chalk17.gray(` (\xD7${s.count})`) : ""}`);
+          if (s.evidence) console.log(chalk17.gray(`           ${s.evidence}`));
         }
       }
-      console.log(chalk16.gray(`
+      console.log(chalk17.gray(`
   Profile written: ${outFile}`));
-      console.log(chalk16.cyan("\n  Next: with the evaluator rubric + this profile + the current chat + the codebase,"));
-      console.log(chalk16.cyan("  propose concrete edits (file, change, why, priority) and apply them on a branch.\n"));
+      console.log(chalk17.cyan("\n  Next: with the evaluator rubric + this profile + the current chat + the codebase,"));
+      console.log(chalk17.cyan("  propose concrete edits (file, change, why, priority) and apply them on a branch.\n"));
     } finally {
       cleanup();
     }
@@ -10337,8 +10989,8 @@ function createProfileCommand() {
 }
 
 // cli/commands/setup.ts
-import { Command as Command16 } from "commander";
-import chalk17 from "chalk";
+import { Command as Command17 } from "commander";
+import chalk18 from "chalk";
 import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync8, mkdirSync as mkdirSync2 } from "fs";
 import { join as join10, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
@@ -10428,40 +11080,40 @@ function installSkill(skillsDir, name, invoke, force) {
   return "written";
 }
 function createSetupCommand() {
-  return new Command16("setup").description("Install Agent Health skills + the agent-profiling hook into your coding tool (Claude Code)").option("--force", "Overwrite existing skill/command files").action(async (options) => {
-    console.log(chalk17.bold("\nAgent Health - Setup\n"));
+  return new Command17("setup").description("Install Agent Health skills + the agent-profiling hook into your coding tool (Claude Code)").option("--force", "Overwrite existing skill/command files").action(async (options) => {
+    console.log(chalk18.bold("\nAgent Health - Setup\n"));
     if (!existsSync9(".claude")) {
-      console.log(chalk17.gray("  No .claude directory found \u2014 creating Claude Code layout."));
+      console.log(chalk18.gray("  No .claude directory found \u2014 creating Claude Code layout."));
     }
     const hook = installHook();
     console.log(
-      hook === "added" ? chalk17.green("  \u2713 Installed PreToolUse session hook \u2192 .claude/settings.json") : chalk17.gray("  \u2022 Session hook already present in .claude/settings.json")
+      hook === "added" ? chalk18.green("  \u2713 Installed PreToolUse session hook \u2192 .claude/settings.json") : chalk18.gray("  \u2022 Session hook already present in .claude/settings.json")
     );
     const invoke = resolveInvoke();
     const cmd = writeIfNeeded(join10(".claude", "commands", "agent-health", "profile.md"), buildCommandBody(invoke), !!options.force);
     console.log(
-      cmd === "written" ? chalk17.green("  \u2713 Installed slash command \u2192 /agent-health:profile") : chalk17.gray("  \u2022 Slash command already present (use --force to overwrite)")
+      cmd === "written" ? chalk18.green("  \u2713 Installed slash command \u2192 /agent-health:profile") : chalk18.gray("  \u2022 Slash command already present (use --force to overwrite)")
     );
     const skillsDir = getBundledSkillsDir();
-    console.log(chalk17.bold("\n  Skills:"));
+    console.log(chalk18.bold("\n  Skills:"));
     for (const name of CUSTOMER_SKILLS) {
       const result = installSkill(skillsDir, name, invoke, !!options.force);
-      if (result === "written") console.log(chalk17.green(`    \u2713 ${name}`));
-      else if (result === "exists") console.log(chalk17.gray(`    \u2022 ${name} (already present, use --force to overwrite)`));
-      else console.log(chalk17.yellow(`    \u26A0 ${name} (not found in bundle: ${skillsDir})`));
-    }
-    console.log(chalk17.cyan("\n  Next steps:"));
-    console.log(chalk17.gray("    1. Enable telemetry so sessions stream to Agent Health:"));
-    console.log(chalk17.gray("         agent-health setup-telemetry"));
-    console.log(chalk17.gray("    2. Use your agent normally (steer it as you like)."));
-    console.log(chalk17.gray("    3. When done, run /agent-health:profile -e <evaluator-id>"));
-    console.log(chalk17.gray("       (or: agent-health profile -e <evaluator-id>)\n"));
+      if (result === "written") console.log(chalk18.green(`    \u2713 ${name}`));
+      else if (result === "exists") console.log(chalk18.gray(`    \u2022 ${name} (already present, use --force to overwrite)`));
+      else console.log(chalk18.yellow(`    \u26A0 ${name} (not found in bundle: ${skillsDir})`));
+    }
+    console.log(chalk18.cyan("\n  Next steps:"));
+    console.log(chalk18.gray("    1. Enable telemetry so sessions stream to Agent Health:"));
+    console.log(chalk18.gray("         agent-health setup-telemetry"));
+    console.log(chalk18.gray("    2. Use your agent normally (steer it as you like)."));
+    console.log(chalk18.gray("    3. When done, run /agent-health:profile -e <evaluator-id>"));
+    console.log(chalk18.gray("       (or: agent-health profile -e <evaluator-id>)\n"));
   });
 }
 
 // cli/commands/workflow.ts
-import { Command as Command17 } from "commander";
-import chalk18 from "chalk";
+import { Command as Command18 } from "commander";
+import chalk19 from "chalk";
 import { existsSync as existsSync10 } from "fs";
 import { resolve as resolve8 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
@@ -10476,28 +11128,28 @@ async function importWorkflow(absPath2) {
   return candidate;
 }
 function createWorkflowCommand() {
-  const cmd = new Command17("workflow").description("Run a deterministic agent workflow over a work source");
+  const cmd = new Command18("workflow").description("Run a deterministic agent workflow over a work source");
   cmd.command("run").description("Run a workflow file (default export of workflow())").requiredOption("-f, --file <path>", "Path to a .workflow.{ts,js,mjs} file").option("-m, --mode <mode>", "new | existing | both", "new").option("-s, --since <duration>", "Lookback window passed to the source (e.g. 24h, 5m)").option("-c, --concurrency <n>", "Max concurrent agent calls (overrides workflow config)").option("-l, --limit <n>", "Cap total items processed (e.g. 5 for a smoke loop)").option("--no-dry-run", "Actually raise PRs (default: dry-run, PRs are logged only)").option("-o, --output <format>", "table | json", "table").action(async (options) => {
     const asJson = options.output === "json";
     const absPath2 = resolve8(options.file);
     if (!existsSync10(absPath2)) {
       const msg = `Workflow file not found: ${absPath2}`;
       if (asJson) console.log(JSON.stringify({ error: msg }, null, 2));
-      else console.log(chalk18.red(`
+      else console.log(chalk19.red(`
   ${msg}
 `));
       process.exitCode = 1;
       return;
     }
-    if (!asJson) console.log(chalk18.bold("\nAgent Health - Workflow\n"));
+    if (!asJson) console.log(chalk19.bold("\nAgent Health - Workflow\n"));
     let wf;
     try {
       wf = await importWorkflow(absPath2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (asJson) console.log(JSON.stringify({ error: msg }, null, 2));
-      else console.log(chalk18.red(`  ${msg}
-`) + chalk18.gray("  (For .ts files run via tsx, or compile to .mjs first.)\n"));
+      else console.log(chalk19.red(`  ${msg}
+`) + chalk19.gray("  (For .ts files run via tsx, or compile to .mjs first.)\n"));
       process.exitCode = 1;
       return;
     }
@@ -10508,15 +11160,15 @@ function createWorkflowCommand() {
       ["--limit", options.limit, limit]
     ]) {
       if (val !== void 0 && (!Number.isFinite(val) || val < 1)) {
-        console.error(chalk18.red(`  ${flag} must be a positive integer (got "${raw}")`));
+        console.error(chalk19.red(`  ${flag} must be a positive integer (got "${raw}")`));
         process.exitCode = 1;
         return;
       }
     }
     const dryRun = options.dryRun !== false;
     if (!asJson) {
-      console.log(chalk18.gray(`  Workflow: ${wf.name}  (agent: ${wf.config.agent})`));
-      console.log(chalk18.gray(
+      console.log(chalk19.gray(`  Workflow: ${wf.name}  (agent: ${wf.config.agent})`));
+      console.log(chalk19.gray(
         `  mode=${options.mode} since=${options.since ?? "-"} concurrency=${concurrency ?? wf.config.concurrency ?? 1} limit=${limit ?? "-"} dryRun=${dryRun}`
       ));
     }
@@ -10531,15 +11183,15 @@ function createWorkflowCommand() {
       console.log(JSON.stringify(result, null, 2));
       return;
     }
-    console.log(chalk18.cyan(`
+    console.log(chalk19.cyan(`
   Processed: ${result.staged.length} item(s)`));
-    console.log(chalk18.gray(`  Peak concurrency: ${result.peakConcurrency}`));
-    console.log(chalk18.gray(`  Feedback ledger entries: ${result.ledgerSize}`));
-    console.log(chalk18.gray(`  Clusters: ${result.clusters.length}  \xB7  PRs ${dryRun ? "(dry-run) " : ""}raised: ${result.prsRaised}`));
+    console.log(chalk19.gray(`  Peak concurrency: ${result.peakConcurrency}`));
+    console.log(chalk19.gray(`  Feedback ledger entries: ${result.ledgerSize}`));
+    console.log(chalk19.gray(`  Clusters: ${result.clusters.length}  \xB7  PRs ${dryRun ? "(dry-run) " : ""}raised: ${result.prsRaised}`));
     if (result.clusters.length > 0) {
-      console.log(chalk18.bold("\n  Consolidated fix-classes:"));
+      console.log(chalk19.bold("\n  Consolidated fix-classes:"));
       for (const c of result.clusters) {
-        console.log(`    \u2022 ${chalk18.yellow(c.label)} \u2014 ${c.tickets.length} ticket(s)`);
+        console.log(`    \u2022 ${chalk19.yellow(c.label)} \u2014 ${c.tickets.length} ticket(s)`);
       }
     }
     console.log();
@@ -10547,38 +11199,353 @@ function createWorkflowCommand() {
   return cmd;
 }
 
+// cli/commands/import.ts
+import { Command as Command19 } from "commander";
+import chalk20 from "chalk";
+import ora7 from "ora";
+import { writeFileSync as writeFileSync9 } from "fs";
+
+// cli/converters/holmesgpt.ts
+import { parse as parseYaml } from "yaml";
+import { readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync3, existsSync as existsSync11 } from "fs";
+import { join as join11, relative as relative2, basename as basename2, dirname as dirname7 } from "path";
+var DEFAULT_REPO = "robusta-dev/holmesgpt";
+var DEFAULT_BRANCH = "master";
+var FIXTURES_PATH = "tests/llm/fixtures";
+async function fetchTestCasePathsFromGitHub(repo = DEFAULT_REPO, branch = DEFAULT_BRANCH) {
+  const url = `https://api.github.com/repos/${repo}/git/trees/${encodeURIComponent(branch)}?recursive=1`;
+  const response = await fetch(url, {
+    headers: { "User-Agent": "agent-health-cli" }
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.tree.filter(
+    (item) => item.type === "blob" && item.path.startsWith(`${FIXTURES_PATH}/`) && item.path.endsWith("/test_case.yaml")
+  ).map((item) => item.path);
+}
+async function fetchFileFromGitHub(filePath2, repo = DEFAULT_REPO, branch = DEFAULT_BRANCH) {
+  const url = `https://raw.githubusercontent.com/${repo}/${encodeURIComponent(branch)}/${filePath2}`;
+  const response = await fetch(url, {
+    headers: { "User-Agent": "agent-health-cli" }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${filePath2}: ${response.status}`);
+  }
+  return response.text();
+}
+function discoverLocalTestCases(basePath) {
+  const results = [];
+  function walk(dir) {
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      const fullPath = join11(dir, entry);
+      const stat = statSync3(fullPath);
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else if (entry === "test_case.yaml") {
+        results.push(fullPath);
+      }
+    }
+  }
+  const testDirs = ["test_ask_holmes", "test_holmes_checks", "compaction"];
+  for (const testDir of testDirs) {
+    const fullDir = join11(basePath, testDir);
+    if (existsSync11(fullDir)) {
+      walk(fullDir);
+    }
+  }
+  if (results.length === 0) {
+    walk(basePath);
+  }
+  return results;
+}
+function parseTestCaseYaml(content) {
+  return parseYaml(content);
+}
+function inferCategory(tags = []) {
+  const lower = tags.map((t) => t.toLowerCase());
+  if (lower.some((t) => t === "kubernetes" || t === "k8s")) return "Kubernetes";
+  if (lower.some((t) => t === "logs" || t === "logging")) return "Log Analysis";
+  if (lower.some((t) => t === "prometheus" || t === "grafana" || t === "metrics")) return "Metrics";
+  if (lower.some((t) => t === "elasticsearch" || t === "opensearch")) return "Search";
+  if (lower.some((t) => t === "postgres" || t === "mysql" || t === "mongodb" || t === "redis" || t === "database"))
+    return "Database";
+  if (lower.some((t) => t === "bash" || t === "shell")) return "Bash";
+  if (lower.some((t) => t === "confluence" || t === "wiki")) return "Confluence";
+  if (lower.some((t) => t === "jira")) return "Jira";
+  return "General";
+}
+function inferDifficulty(tags = []) {
+  const lower = tags.map((t) => t.toLowerCase());
+  if (lower.includes("easy")) return "Easy";
+  if (lower.includes("hard") || lower.includes("complex")) return "Hard";
+  return "Medium";
+}
+function humanizeFolderName(folderName) {
+  const stripped = folderName.replace(/^\d+_/, "");
+  return stripped.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function buildStableName(parentDir, folderName) {
+  return `holmesgpt/${parentDir}/${folderName}`;
+}
+function buildContextItems(tc) {
+  const context = [];
+  if (tc.before_test) {
+    context.push({ description: "Setup Script (before_test)", value: tc.before_test });
+  }
+  if (tc.after_test) {
+    context.push({ description: "Teardown Script (after_test)", value: tc.after_test });
+  }
+  if (tc.toolsets && Object.keys(tc.toolsets).length > 0) {
+    context.push({ description: "Toolsets", value: JSON.stringify(tc.toolsets, null, 2) });
+  }
+  if (tc.conversation_history && tc.conversation_history.length > 0) {
+    context.push({
+      description: "Conversation History",
+      value: JSON.stringify(tc.conversation_history, null, 2)
+    });
+  }
+  if (tc.runbooks && tc.runbooks.length > 0) {
+    context.push({ description: "Runbooks", value: JSON.stringify(tc.runbooks, null, 2) });
+  }
+  if (tc.cluster_name) {
+    context.push({ description: "Cluster Name", value: tc.cluster_name });
+  }
+  if (tc.port_forwards && tc.port_forwards.length > 0) {
+    context.push({ description: "Port Forwards", value: JSON.stringify(tc.port_forwards, null, 2) });
+  }
+  if (tc.test_env_vars && Object.keys(tc.test_env_vars).length > 0) {
+    context.push({ description: "Environment Variables", value: JSON.stringify(tc.test_env_vars, null, 2) });
+  }
+  if (tc.mocked_date) {
+    context.push({ description: "Mocked Date", value: tc.mocked_date });
+  }
+  return context;
+}
+function resolvePrompt(tc) {
+  if (typeof tc.user_prompt === "string") {
+    return tc.user_prompt;
+  }
+  if (Array.isArray(tc.user_prompt)) {
+    return tc.user_prompt.join("\n");
+  }
+  if (tc.checks && tc.checks.length > 0) {
+    const checkDescriptions = tc.checks.map((c) => c.query || c.description).join("; ");
+    return `Run health checks: ${checkDescriptions}`;
+  }
+  if (tc.description) {
+    return tc.description;
+  }
+  return "";
+}
+function convertTestCase(tc, folderName, parentDir) {
+  const expectedOutcomes = Array.isArray(tc.expected_output) ? [...tc.expected_output] : [tc.expected_output];
+  if (tc.checks && tc.expected_results) {
+    for (const [checkName, expectedResult] of Object.entries(tc.expected_results)) {
+      expectedOutcomes.push(`Check '${checkName}' should result in: ${expectedResult}`);
+    }
+  }
+  return {
+    name: buildStableName(parentDir, folderName),
+    description: tc.description || humanizeFolderName(folderName),
+    category: inferCategory(tc.tags),
+    subcategory: tc.tags?.filter((t) => !["easy", "medium", "hard"].includes(t.toLowerCase())).join(", "),
+    difficulty: inferDifficulty(tc.tags),
+    initialPrompt: resolvePrompt(tc),
+    context: buildContextItems(tc),
+    expectedOutcomes
+  };
+}
+function extractPathParts(filePath2) {
+  const folder = dirname7(filePath2);
+  const folderName = basename2(folder);
+  const parentDir = basename2(dirname7(folder));
+  return { parentDir, folderName };
+}
+function convertAllFromLocal(basePath) {
+  const testCases2 = [];
+  const skipped = [];
+  const errors = [];
+  const files = discoverLocalTestCases(basePath);
+  for (const file of files) {
+    try {
+      const content = readFileSync8(file, "utf-8");
+      const tc = parseTestCaseYaml(content);
+      if (tc.skip) {
+        skipped.push({ path: file, reason: tc.skip_reason || "Marked as skip" });
+        continue;
+      }
+      const relPath = relative2(basePath, file);
+      const { parentDir, folderName } = extractPathParts(relPath);
+      const converted = convertTestCase(tc, folderName, parentDir);
+      const result = testCaseSchema.safeParse(converted);
+      if (result.success) {
+        testCases2.push(converted);
+      } else {
+        errors.push({
+          path: file,
+          error: result.error.errors.map((e) => e.message).join("; ")
+        });
+      }
+    } catch (err) {
+      errors.push({ path: file, error: err.message });
+    }
+  }
+  return { testCases: testCases2, skipped, errors };
+}
+async function convertAllFromGitHub(repo = DEFAULT_REPO, branch = DEFAULT_BRANCH, onProgress) {
+  const testCases2 = [];
+  const skipped = [];
+  const errors = [];
+  const paths = await fetchTestCasePathsFromGitHub(repo, branch);
+  for (let i = 0; i < paths.length; i++) {
+    const filePath2 = paths[i];
+    onProgress?.(i + 1, paths.length);
+    try {
+      const content = await fetchFileFromGitHub(filePath2, repo, branch);
+      const tc = parseTestCaseYaml(content);
+      if (tc.skip) {
+        skipped.push({ path: filePath2, reason: tc.skip_reason || "Marked as skip" });
+        continue;
+      }
+      const relPath = filePath2.replace(`${FIXTURES_PATH}/`, "");
+      const { parentDir, folderName } = extractPathParts(relPath);
+      const converted = convertTestCase(tc, folderName, parentDir);
+      const result = testCaseSchema.safeParse(converted);
+      if (result.success) {
+        testCases2.push(converted);
+      } else {
+        errors.push({
+          path: filePath2,
+          error: result.error.errors.map((e) => e.message).join("; ")
+        });
+      }
+    } catch (err) {
+      errors.push({ path: filePath2, error: err.message });
+    }
+  }
+  return { testCases: testCases2, skipped, errors };
+}
+
+// cli/commands/import.ts
+var SUPPORTED_FORMATS = ["holmesgpt"];
+function createImportCommand() {
+  const command = new Command19("import").description(
+    "Convert test cases from an external evaluation framework (e.g. holmesgpt) into agent-health's format. For test cases already in agent-health's native JSON format, use 'benchmark -f <file>' directly instead."
+  ).argument("[source]", "Local path to fixtures directory (alias for --source; positional wins if both given)").requiredOption("--from <format>", `Source format (${SUPPORTED_FORMATS.join(", ")})`).option("--source <path>", "Local path to fixtures directory (fetches from GitHub if omitted)").option("-o, --output <file>", "Output JSON file path (default: <format>-test-cases.json)").option("--dry-run", "Show conversion summary without writing files").option("--repo <owner/name>", "GitHub repository, GitHub-fetching formats only (e.g. holmesgpt) (default: robusta-dev/holmesgpt)").option("--branch <name>", "GitHub branch, GitHub-fetching formats only (e.g. holmesgpt) (default: master)").action(async (sourceArg, options) => {
+    const format = options.from.toLowerCase();
+    if (!SUPPORTED_FORMATS.includes(format)) {
+      console.error(chalk20.red(`
+  Error: Unsupported format '${format}'`));
+      console.log(chalk20.gray(`  Supported formats: ${SUPPORTED_FORMATS.join(", ")}
+`));
+      process.exit(1);
+    }
+    const source2 = sourceArg ?? options.source;
+    const output = options.output ?? `${format}-test-cases.json`;
+    console.log(chalk20.cyan.bold("\n  Agent Health - Import Test Cases\n"));
+    if (format === "holmesgpt") {
+      await importHolmesGPT({ ...options, source: source2, output });
+    }
+  });
+  return command;
+}
+async function importHolmesGPT(options) {
+  const spinner = ora7();
+  try {
+    if (options.source) {
+      spinner.start(`Reading test cases from ${options.source}...`);
+      const result = convertAllFromLocal(options.source);
+      spinner.succeed(`Found ${result.testCases.length} test case(s)`);
+      outputResults(result.testCases, result.skipped, result.errors, options);
+    } else {
+      const repo = options.repo || "robusta-dev/holmesgpt";
+      const branch = options.branch || "master";
+      spinner.start(`Fetching test cases from GitHub (${repo}@${branch})...`);
+      const result = await convertAllFromGitHub(repo, branch, (current, total) => {
+        spinner.text = `Fetching test cases from GitHub (${current}/${total})...`;
+      });
+      spinner.succeed(`Fetched and converted ${result.testCases.length} test case(s)`);
+      outputResults(result.testCases, result.skipped, result.errors, options);
+    }
+  } catch (error) {
+    spinner.fail("Import failed");
+    console.error(chalk20.red(`
+  Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+function outputResults(testCases2, skipped, errors, options) {
+  console.log(chalk20.gray(`  Converted: ${testCases2.length}`));
+  if (skipped.length > 0) {
+    console.log(chalk20.gray(`  Skipped:   ${skipped.length}`));
+  }
+  if (errors.length > 0) {
+    console.log(chalk20.red(`  Errors:    ${errors.length}`));
+    for (const err of errors) {
+      console.log(chalk20.red(`    - ${err.path}: ${err.error}`));
+    }
+  }
+  if (options.dryRun) {
+    console.log(chalk20.gray("\n  Dry run \u2014 no files written.\n"));
+    if (testCases2.length > 0) {
+      console.log(chalk20.cyan("  Sample test case:"));
+      console.log(chalk20.gray(`  ${JSON.stringify(testCases2[0], null, 2).split("\n").join("\n  ")}
+`));
+    }
+    return;
+  }
+  writeFileSync9(options.output, JSON.stringify(testCases2, null, 2) + "\n", "utf-8");
+  console.log(chalk20.green(`
+  Output: ${chalk20.bold(options.output)}`));
+  console.log(
+    chalk20.gray(
+      `
+  Next step: run a benchmark with these test cases:
+    ${chalk20.cyan(`agent-health benchmark -f ${options.output} -a holmesgpt -n "HolmesGPT Evaluations"`)}
+`
+    )
+  );
+  if (errors.length > 0) {
+    process.exit(1);
+  }
+}
+
 // cli/index.ts
 var __filename4 = fileURLToPath6(import.meta.url);
-var __dirname6 = dirname7(__filename4);
-var packageJsonPath2 = join11(__dirname6, "..", "..", "package.json");
+var __dirname6 = dirname8(__filename4);
+var packageJsonPath2 = join12(__dirname6, "..", "..", "package.json");
 var version = "0.1.0";
 try {
-  const packageJson = JSON.parse(readFileSync8(packageJsonPath2, "utf-8"));
+  const packageJson = JSON.parse(readFileSync9(packageJsonPath2, "utf-8"));
   version = packageJson.version;
 } catch {
 }
 function loadEnvFile(envPath) {
   const absolutePath = resolve9(process.cwd(), envPath);
-  if (!existsSync11(absolutePath)) {
-    console.error(chalk19.red(`
+  if (!existsSync12(absolutePath)) {
+    console.error(chalk21.red(`
   Error: Environment file not found: ${absolutePath}
 `));
     process.exit(1);
   }
   const result = loadDotenv({ path: absolutePath, quiet: true });
   if (result.error) {
-    console.error(chalk19.red(`
+    console.error(chalk21.red(`
   Error loading environment file: ${result.error.message}
 `));
     process.exit(1);
   }
-  console.log(chalk19.gray(`  Loaded environment from: ${envPath}`));
+  console.log(chalk21.gray(`  Loaded environment from: ${envPath}`));
 }
 var defaultEnvPath = resolve9(process.cwd(), ".env");
-if (existsSync11(defaultEnvPath)) {
+if (existsSync12(defaultEnvPath)) {
   loadDotenv({ path: defaultEnvPath, quiet: true });
 }
-var program = new Command18();
+var program = new Command20();
 program.name("agent-health").description("Agent Health Evaluation Framework - Evaluate and monitor AI agent performance").version(version).enablePositionalOptions().passThroughOptions().configureHelp({
   sortSubcommands: false,
   // Hide default command list — replaced by grouped custom help below
@@ -10591,116 +11558,120 @@ program.name("agent-health").description("Agent Health Evaluation Framework - Ev
     if (desc) {
       output.push(desc, "");
     }
-    output.push(`${chalk19.cyan.bold("Usage:")} ${helper.commandUsage(cmd)}`, "");
+    output.push(`${chalk21.cyan.bold("Usage:")} ${helper.commandUsage(cmd)}`, "");
     const optionList = helper.visibleOptions(cmd).map((opt) => {
       const term = helper.optionTerm(opt);
       const desc2 = helper.optionDescription(opt);
       return `  ${term.padEnd(termWidth)}  ${desc2}`;
     }).join("\n");
     if (optionList) {
-      output.push(`${chalk19.cyan.bold("Options:")}`, optionList, "");
+      output.push(`${chalk21.cyan.bold("Options:")}`, optionList, "");
     }
     return output.join("\n");
   }
 });
 program.addHelpText("after", `
-${chalk19.cyan.bold("Getting Started:")}
-  ${chalk19.yellow("agent-health")}                        Launch the web UI and evaluation server
-  ${chalk19.yellow("agent-health init")}                   Generate an agent-health.config.ts file
-  ${chalk19.yellow("agent-health doctor")}                 Verify your setup (AWS creds, OpenSearch, agents)
+${chalk21.cyan.bold("Getting Started:")}
+  ${chalk21.yellow("agent-health")}                        Launch the web UI and evaluation server
+  ${chalk21.yellow("agent-health init")}                   Generate an agent-health.config.ts file
+  ${chalk21.yellow("agent-health doctor")}                 Verify your setup (AWS creds, OpenSearch, agents)
+
+${chalk21.cyan.bold("Running Evaluations:")}
+  ${chalk21.yellow("agent-health run")} ${chalk21.gray("-t <case> -a <agent>")}   Run a single test case against an agent
+  ${chalk21.yellow("agent-health benchmark")} ${chalk21.gray("-f <file>")}        Run a full benchmark from a test cases JSON file
+  ${chalk21.yellow("agent-health benchmark")} ${chalk21.gray("-b <id>")}          Re-run an existing benchmark
 
-${chalk19.cyan.bold("Running Evaluations:")}
-  ${chalk19.yellow("agent-health run")} ${chalk19.gray("-t <case> -a <agent>")}   Run a single test case against an agent
-  ${chalk19.yellow("agent-health benchmark")} ${chalk19.gray("-f <file>")}        Run a full benchmark from a test cases JSON file
-  ${chalk19.yellow("agent-health benchmark")} ${chalk19.gray("-b <id>")}          Re-run an existing benchmark
+${chalk21.cyan.bold("Viewing Results:")}
+  ${chalk21.yellow("agent-health list")} ${chalk21.gray("agents|benchmarks|...")}  List agents, connectors, test cases, or benchmarks
+  ${chalk21.yellow("agent-health report")} ${chalk21.gray("-b <benchmark>")}       Generate an HTML/PDF/JSON report
+  ${chalk21.yellow("agent-health export")} ${chalk21.gray("-b <benchmark>")}       Export test cases as re-importable JSON
+  ${chalk21.yellow("agent-health compare-services")} ${chalk21.gray("-s A B")}    Compare error patterns between services
 
-${chalk19.cyan.bold("Viewing Results:")}
-  ${chalk19.yellow("agent-health list")} ${chalk19.gray("agents|benchmarks|...")}  List agents, connectors, test cases, or benchmarks
-  ${chalk19.yellow("agent-health report")} ${chalk19.gray("-b <benchmark>")}       Generate an HTML/PDF/JSON report
-  ${chalk19.yellow("agent-health export")} ${chalk19.gray("-b <benchmark>")}       Export test cases as re-importable JSON
-  ${chalk19.yellow("agent-health compare-services")} ${chalk19.gray("-s A B")}    Compare error patterns between services
+${chalk21.cyan.bold("Remote Servers:")}
+  ${chalk21.yellow("agent-health remote add")} ${chalk21.gray("--name <n> --url <u>")}  Add a remote server
+  ${chalk21.yellow("agent-health remote list")}             List configured remote servers
+  ${chalk21.yellow("agent-health remote test")}             Test connectivity to all remotes
 
-${chalk19.cyan.bold("Remote Servers:")}
-  ${chalk19.yellow("agent-health remote add")} ${chalk19.gray("--name <n> --url <u>")}  Add a remote server
-  ${chalk19.yellow("agent-health remote list")}             List configured remote servers
-  ${chalk19.yellow("agent-health remote test")}             Test connectivity to all remotes
+${chalk21.cyan.bold("Infrastructure:")}
+  ${chalk21.yellow("agent-health configure")} ${chalk21.gray("--from-stack <name>")}  Import config from a CloudFormation stack
+  ${chalk21.yellow("agent-health setup-telemetry")}            Configure Claude Code \u2192 Agent Health telemetry
+  ${chalk21.yellow("agent-health setup-telemetry")} ${chalk21.gray("--status")}  Check current telemetry status
 
-${chalk19.cyan.bold("Infrastructure:")}
-  ${chalk19.yellow("agent-health configure")} ${chalk19.gray("--from-stack <name>")}  Import config from a CloudFormation stack
-  ${chalk19.yellow("agent-health setup-telemetry")}            Configure Claude Code \u2192 Agent Health telemetry
-  ${chalk19.yellow("agent-health setup-telemetry")} ${chalk19.gray("--status")}  Check current telemetry status
+${chalk21.cyan.bold("Agent Profiling:")}
+  ${chalk21.yellow("agent-health setup")}                   Install the agent-profiling hook + skill (Claude Code)
+  ${chalk21.yellow("agent-health profile")} ${chalk21.gray("-e <evaluator>")}    Profile the current session, surface what to fix in the agent
 
-${chalk19.cyan.bold("Agent Profiling:")}
-  ${chalk19.yellow("agent-health setup")}                   Install the agent-profiling hook + skill (Claude Code)
-  ${chalk19.yellow("agent-health profile")} ${chalk19.gray("-e <evaluator>")}    Profile the current session, surface what to fix in the agent
+${chalk21.cyan.bold("Importing:")}
+  ${chalk21.yellow("agent-health import")} ${chalk21.gray("--from holmesgpt")}     Import HolmesGPT test cases from GitHub
+  ${chalk21.yellow("agent-health import")} ${chalk21.gray("--from holmesgpt --source <path>")}  Import from local fixtures
 
-${chalk19.cyan.bold("Maintenance:")}
-  ${chalk19.yellow("agent-health migrate")}                Migrate legacy benchmark data to current format
-  ${chalk19.yellow("agent-health kill")} ${chalk19.gray("sample-agent")}       Stop a running sample agent by name
-  ${chalk19.yellow("agent-health serve")}                  Start the server (same as default, explicit command)
+${chalk21.cyan.bold("Maintenance:")}
+  ${chalk21.yellow("agent-health migrate")}                Migrate legacy benchmark data to current format
+  ${chalk21.yellow("agent-health kill")} ${chalk21.gray("sample-agent")}       Stop a running sample agent by name
+  ${chalk21.yellow("agent-health serve")}                  Start the server (same as default, explicit command)
 
-${chalk19.cyan.bold("Examples:")}
-  ${chalk19.gray("$")} npx @opensearch-project/agent-health
-  ${chalk19.gray("$")} npx @opensearch-project/agent-health --port 8080 --no-browser
-  ${chalk19.gray("$")} npx @opensearch-project/agent-health run -t "RCA for 500 errors" -a langgraph
-  ${chalk19.gray("$")} npx @opensearch-project/agent-health benchmark -f ./test-cases.json -a my-agent
-  ${chalk19.gray("$")} npx @opensearch-project/agent-health list agents
-  ${chalk19.gray("$")} npx @opensearch-project/agent-health report -b bench-123 -f pdf -o report.pdf
-  ${chalk19.gray("$")} npx @opensearch-project/agent-health serve --headless --api-key sk-secret
+${chalk21.cyan.bold("Examples:")}
+  ${chalk21.gray("$")} npx @opensearch-project/agent-health
+  ${chalk21.gray("$")} npx @opensearch-project/agent-health --port 8080 --no-browser
+  ${chalk21.gray("$")} npx @opensearch-project/agent-health run -t "RCA for 500 errors" -a langgraph
+  ${chalk21.gray("$")} npx @opensearch-project/agent-health benchmark -f ./test-cases.json -a my-agent
+  ${chalk21.gray("$")} npx @opensearch-project/agent-health list agents
+  ${chalk21.gray("$")} npx @opensearch-project/agent-health report -b bench-123 -f pdf -o report.pdf
+  ${chalk21.gray("$")} npx @opensearch-project/agent-health serve --headless --api-key sk-secret
 `);
 program.option("-p, --port <number>", "Server port (or set AH_PORT env var)", readEnv("AH_PORT", "AGENT_HEALTH_PORT") || "4001").option("-e, --env-file <path>", "Load environment variables from file (e.g., .env)").option("--no-browser", "Do not open browser automatically").option("--headless", "Run API server only (no frontend, no browser)").option("--api-key <key>", "Require API key for coding-agents endpoints").option("--agent-path <path>", "Path to the agent repository the judge and assistant should use as grounding context (or set AH_AGENT_PATH)");
 program.action(async (options) => {
-  console.log(chalk19.cyan.bold(`
+  console.log(chalk21.cyan.bold(`
   Agent Health v${version} - AI Agent Evaluation Framework
 `));
-  console.log(chalk19.gray(`  Working directory: ${process.cwd()}`));
-  console.log(chalk19.gray(`  Package directory: ${__dirname6}`));
+  console.log(chalk21.gray(`  Working directory: ${process.cwd()}`));
+  console.log(chalk21.gray(`  Package directory: ${__dirname6}`));
   if (options.envFile) {
     loadEnvFile(options.envFile);
-  } else if (existsSync11(defaultEnvPath)) {
-    console.log(chalk19.gray("  Auto-loaded .env from current directory"));
+  } else if (existsSync12(defaultEnvPath)) {
+    console.log(chalk21.gray("  Auto-loaded .env from current directory"));
   }
   if (options.agentPath) {
     const abs = resolve9(options.agentPath);
     process.env.AH_AGENT_PATH = abs;
-    console.log(chalk19.gray(`  Agent path: ${abs}`));
+    console.log(chalk21.gray(`  Agent path: ${abs}`));
   } else if (process.env.AH_AGENT_PATH) {
-    console.log(chalk19.gray(`  Agent path: ${process.env.AH_AGENT_PATH} (from AH_AGENT_PATH)`));
+    console.log(chalk21.gray(`  Agent path: ${process.env.AH_AGENT_PATH} (from AH_AGENT_PATH)`));
   }
   const port = parseInt(options.port, 10);
   const headless = options.headless || false;
-  const spinner = ora7(headless ? "Starting headless API server..." : "Starting server...").start();
+  const spinner = ora8(headless ? "Starting headless API server..." : "Starting server...").start();
   try {
     const actualPort = await startServer({ port, headless, apiKey: options.apiKey });
     spinner.succeed(headless ? "Headless API server started" : "Server started");
     if (actualPort !== port) {
-      console.log(chalk19.yellow(`
+      console.log(chalk21.yellow(`
   Port ${port} was in use, started on port ${actualPort} instead`));
     }
     if (headless) {
-      console.log(chalk19.green(`
+      console.log(chalk21.green(`
   API server running on http://0.0.0.0:${actualPort}`));
-      if (options.apiKey) console.log(chalk19.gray("  API key authentication enabled"));
-      console.log(chalk19.gray("  Mode: headless (API only, no frontend)\n"));
+      if (options.apiKey) console.log(chalk21.gray("  API key authentication enabled"));
+      console.log(chalk21.gray("  Mode: headless (API only, no frontend)\n"));
     } else {
-      console.log(chalk19.gray("\n  Configuration:"));
-      console.log(chalk19.gray(`    Storage: Sample data (configure OpenSearch for persistence)`));
-      console.log(chalk19.gray(`    Agent: Select in UI (Demo Agent for mock, real agents require endpoints)`));
-      console.log(chalk19.gray(`    Judge: Select in UI (Demo Judge for mock, Bedrock requires AWS creds)
+      console.log(chalk21.gray("\n  Configuration:"));
+      console.log(chalk21.gray(`    Storage: Sample data (configure OpenSearch for persistence)`));
+      console.log(chalk21.gray(`    Agent: Select in UI (Demo Agent for mock, real agents require endpoints)`));
+      console.log(chalk21.gray(`    Judge: Select in UI (Demo Judge for mock, Bedrock requires AWS creds)
 `));
       const url = `http://localhost:${actualPort}`;
-      console.log(chalk19.green(`  Server running at ${chalk19.bold(url)}
+      console.log(chalk21.green(`  Server running at ${chalk21.bold(url)}
 `));
-      console.log(chalk19.green(`  Demo data loaded`));
+      console.log(chalk21.green(`  Demo data loaded`));
       if (options.browser !== false) {
-        console.log(chalk19.gray("  Opening browser..."));
+        console.log(chalk21.gray("  Opening browser..."));
         await open(url);
       }
     }
-    console.log(chalk19.gray("  Press Ctrl+C to stop\n"));
+    console.log(chalk21.gray("  Press Ctrl+C to stop\n"));
   } catch (error) {
     spinner.fail("Failed to start server");
-    console.error(chalk19.red(`
+    console.error(chalk21.red(`
   Error: ${error instanceof Error ? error.message : error}
 `));
     process.exit(1);
@@ -10723,44 +11694,45 @@ program.addCommand(createSkillCommand());
 program.addCommand(createSetupCommand());
 program.addCommand(createProfileCommand());
 program.addCommand(createWorkflowCommand());
+program.addCommand(createImportCommand());
 program.command("serve").description("Start the Agent Health server (same as default action)").option("-p, --port <number>", "Server port (or set AH_PORT env var)", readEnv("AH_PORT", "AGENT_HEALTH_PORT") || "4001").option("--no-browser", "Do not open browser automatically").option("--headless", "Run API server only (no frontend, no browser)").option("--api-key <key>", "Require API key for coding-agents endpoints").option("--agent-path <path>", "Path to the agent repository the judge and assistant should use as grounding context (or set AH_AGENT_PATH)").action(async (options) => {
-  console.log(chalk19.cyan.bold(`
+  console.log(chalk21.cyan.bold(`
   Agent Health v${version} - AI Agent Evaluation Framework
 `));
   if (options.agentPath) {
     const abs = resolve9(options.agentPath);
     process.env.AH_AGENT_PATH = abs;
-    console.log(chalk19.gray(`  Agent path: ${abs}`));
+    console.log(chalk21.gray(`  Agent path: ${abs}`));
   } else if (process.env.AH_AGENT_PATH) {
-    console.log(chalk19.gray(`  Agent path: ${process.env.AH_AGENT_PATH} (from AH_AGENT_PATH)`));
+    console.log(chalk21.gray(`  Agent path: ${process.env.AH_AGENT_PATH} (from AH_AGENT_PATH)`));
   }
   const port = parseInt(options.port, 10);
   const headless = options.headless || false;
-  const spinner = ora7(headless ? "Starting headless API server..." : "Starting server...").start();
+  const spinner = ora8(headless ? "Starting headless API server..." : "Starting server...").start();
   try {
     const actualPort = await startServer({ port, headless, apiKey: options.apiKey });
     spinner.succeed(headless ? "Headless API server started" : "Server started");
     if (actualPort !== port) {
-      console.log(chalk19.yellow(`
+      console.log(chalk21.yellow(`
   Port ${port} was in use, started on port ${actualPort} instead`));
     }
     const url = `http://localhost:${actualPort}`;
     if (headless) {
-      console.log(chalk19.green(`  API server running on http://0.0.0.0:${actualPort}`));
-      if (options.apiKey) console.log(chalk19.gray("  API key authentication enabled"));
-      console.log(chalk19.gray("  Mode: headless (API only, no frontend)\n"));
+      console.log(chalk21.green(`  API server running on http://0.0.0.0:${actualPort}`));
+      if (options.apiKey) console.log(chalk21.gray("  API key authentication enabled"));
+      console.log(chalk21.gray("  Mode: headless (API only, no frontend)\n"));
     } else {
-      console.log(chalk19.green(`  Server running at ${chalk19.bold(url)}
+      console.log(chalk21.green(`  Server running at ${chalk21.bold(url)}
 `));
       if (options.browser !== false) {
-        console.log(chalk19.gray("  Opening browser..."));
+        console.log(chalk21.gray("  Opening browser..."));
         await open(url);
       }
     }
-    console.log(chalk19.gray("  Press Ctrl+C to stop\n"));
+    console.log(chalk21.gray("  Press Ctrl+C to stop\n"));
   } catch (error) {
     spinner.fail("Failed to start server");
-    console.error(chalk19.red(`
+    console.error(chalk21.red(`
   Error: ${error instanceof Error ? error.message : error}
 `));
     process.exit(1);
@@ -10769,15 +11741,15 @@ program.command("serve").description("Start the Agent Health server (same as def
 program.on("command:*", (operands) => {
   const unknownCommand = operands[0];
   const availableCommands = program.commands.map((cmd) => cmd.name());
-  console.error(chalk19.red(`
+  console.error(chalk21.red(`
   Error: Unknown command '${unknownCommand}'`));
   console.log("");
-  console.log(chalk19.cyan("  Available commands:"));
+  console.log(chalk21.cyan("  Available commands:"));
   for (const cmd of availableCommands) {
-    console.log(chalk19.gray(`    - ${cmd}`));
+    console.log(chalk21.gray(`    - ${cmd}`));
   }
   console.log("");
-  console.log(chalk19.gray(`  Run ${chalk19.cyan("agent-health --help")} for usage information.
+  console.log(chalk21.gray(`  Run ${chalk21.cyan("agent-health --help")} for usage information.
 `));
   process.exitCode = 1;
 });