@opensearch-project/agent-health 0.6.0 → 0.7.0

package/cli/dist/index.js

@@ -560,7 +560,19 @@ async function loadUserConfig(configPath) {
     return module2.default ?? module2;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to load config file ${configPath}: ${message}`);
+    let helpText = "";
+    if (message.includes("ERR_MODULE_NOT_FOUND") || message.includes("Cannot find")) {
+      helpText = `
+
+  Ensure your cwd package.json has: {"type":"module"}`;
+    }
+    if (message.includes("tsconfig")) {
+      helpText = `
+
+  Set TSX_TSCONFIG_PATH to your tsconfig.json location, e.g.:
+  TSX_TSCONFIG_PATH=/path/to/agent-health/tsconfig.json npx @opensearch-project/agent-health`;
+    }
+    throw new Error(`Failed to load config file ${configPath}: ${message}${helpText}`);
   }
 }
 async function loadConfig(cwd = process.cwd(), force = false) {
@@ -2308,9 +2320,6 @@ var init_SubprocessConnector = __esm({
          * `serviceName` to point at their OpenSearch service.name for Strategy C.
          */
         this.traceContext = { propagateEnv: true };
-        /** Buffer of clean stdout lines accumulated during streaming.
-         *  Used by onBeforeStreamEnd() to emit a consolidated `response` step. */
-        this.streamBuffer = [];
         this.config = { ...DEFAULT_SUBPROCESS_CONFIG, ...config };
       }
       /**
@@ -2332,31 +2341,24 @@ Question: ${prompt}`;
        */
       async execute(endpoint, request, auth, onProgress, onRawEvent) {
         this.debug("========== execute() STARTED ==========");
-        this.streamBuffer = [];
-        const cfgOverride = request.connectorConfig || {};
-        if (cfgOverride.command !== void 0) this.config.command = cfgOverride.command;
-        if (cfgOverride.args !== void 0) this.config.args = cfgOverride.args;
-        if (cfgOverride.env !== void 0) this.config.env = { ...this.config.env || {}, ...cfgOverride.env };
-        if (cfgOverride.inputMode !== void 0) this.config.inputMode = cfgOverride.inputMode;
-        if (cfgOverride.outputParser !== void 0) this.config.outputParser = cfgOverride.outputParser;
-        if (cfgOverride.timeout !== void 0) this.config.timeout = cfgOverride.timeout;
-        if (cfgOverride.workingDir !== void 0) this.config.workingDir = cfgOverride.workingDir;
-        const command = endpoint || this.config.command;
-        const args = this.config.args || [];
+        const state = this.createExecutionState();
+        const config = this.resolveExecutionConfig(request);
+        const command = endpoint || config.command;
+        const args = config.args || [];
         const input = request.payload || this.buildPayload(request);
         const runId = `subprocess-${Date.now()}`;
         this.debug("Command:", command);
         this.debug("Args:", args);
-        this.debug("Input mode:", this.config.inputMode);
-        this.debug("Output parser:", this.config.outputParser);
-        this.debug("Timeout:", this.config.timeout);
+        this.debug("Input mode:", config.inputMode);
+        this.debug("Output parser:", config.outputParser);
+        this.debug("Timeout:", config.timeout);
         this.debug("Input (first 500 chars):", input.substring(0, 500));
-        this.debug("Working dir:", this.config.workingDir || process.cwd());
+        this.debug("Working dir:", config.workingDir || process.cwd());
         this.debug("Run ID:", runId);
         const env = {
           ...process.env,
           ...this.buildAuthEnv(auth),
-          ...this.config.env,
+          ...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
@@ -2373,12 +2375,12 @@ Question: ${prompt}`;
           let stdout = "";
           let stderr = "";
           let settled = false;
-          const finalArgs = this.config.inputMode === "arg" ? [...args, input] : args;
+          const finalArgs = config.inputMode === "arg" ? [...args, input] : args;
           this.debug("Spawning process...");
           this.debug("Full command:", command, finalArgs.join(" "));
           const proc = spawn(command, finalArgs, {
             env,
-            cwd: this.config.workingDir,
+            cwd: config.workingDir,
             shell: false
           });
           this.debug("Process spawned, PID:", proc.pid);
@@ -2387,9 +2389,9 @@ Question: ${prompt}`;
             settled = true;
             this.debug("TIMEOUT reached, killing process");
             proc.kill("SIGTERM");
-            reject(new Error(`Subprocess timed out after ${this.config.timeout}ms`));
-          }, this.config.timeout);
-          if (this.config.inputMode === "stdin") {
+            reject(new Error(`Subprocess timed out after ${config.timeout}ms`));
+          }, config.timeout);
+          if (config.inputMode === "stdin") {
             this.debug("Writing input to stdin...");
             proc.stdin.write(input);
             proc.stdin.end();
@@ -2402,8 +2404,8 @@ Question: ${prompt}`;
             stdout += chunk;
             rawOutput.push({ type: "stdout", data: chunk, timestamp: Date.now() });
             onRawEvent?.({ type: "stdout", data: chunk });
-            if (this.config.outputParser === "streaming") {
-              this.parseStreamingOutput(chunk, trajectory, onProgress);
+            if (config.outputParser === "streaming") {
+              this.parseStreamingOutput(chunk, trajectory, onProgress, state);
             }
           });
           proc.stderr.on("data", (data) => {
@@ -2413,8 +2415,8 @@ Question: ${prompt}`;
             stderr += chunk;
             rawOutput.push({ type: "stderr", data: chunk, timestamp: Date.now() });
             onRawEvent?.({ type: "stderr", data: chunk });
-            if (this.config.outputParser === "streaming") {
-              this.parseStderrChunk(chunk, trajectory, onProgress);
+            if (config.outputParser === "streaming") {
+              this.parseStderrChunk(chunk, trajectory, onProgress, state);
             }
           });
           proc.on("close", (code2, signal) => {
@@ -2427,8 +2429,8 @@ Question: ${prompt}`;
               this.error(`Process exited with code ${code2}`);
               this.error("stderr:", stderr);
             }
-            if (this.config.outputParser === "streaming") {
-              this.onBeforeStreamEnd(trajectory, onProgress);
+            if (config.outputParser === "streaming") {
+              this.onBeforeStreamEnd(trajectory, onProgress, state);
               if (code2 !== 0 && trajectory.length === 0) {
                 const errorContent = stderr.trim() ? `Error: Process exited with code ${code2}. ${stderr.trim()}` : `Error: Process exited with code ${code2}`;
                 const errorStep = this.createStep("tool_result", errorContent, {
@@ -2438,8 +2440,8 @@ Question: ${prompt}`;
                 onProgress?.(errorStep);
               }
             }
-            const finalTrajectory = this.config.outputParser === "streaming" ? trajectory : this.parseResponse({ stdout, stderr, exitCode: code2 });
-            if (this.config.outputParser !== "streaming") {
+            const finalTrajectory = config.outputParser === "streaming" ? trajectory : this.parseResponse({ stdout, stderr, exitCode: code2 }, config);
+            if (config.outputParser !== "streaming") {
               finalTrajectory.forEach((step) => onProgress?.(step));
             }
             this.debug("Resolving with trajectory of", finalTrajectory.length, "steps");
@@ -2452,7 +2454,7 @@ Question: ${prompt}`;
                 args: finalArgs,
                 exitCode: code2,
                 stderr: stderr || void 0,
-                ...this.extraResultMetadata()
+                ...this.extraResultMetadata(state)
               }
             });
           });
@@ -2477,22 +2479,55 @@ Question: ${prompt}`;
         });
         this.debug("========== execute() COMPLETED ==========");
       }
+      /**
+       * Create the per-invocation parse state for one `execute()` call.
+       * Subclasses that buffer anything while streaming (partial NDJSON lines,
+       * pending tool names, captured ids) override this to add their fields —
+       * and must NOT keep that data on the instance.
+       */
+      createExecutionState() {
+        return { streamBuffer: [] };
+      }
+      /**
+       * Resolve the effective config for one `execute()` call: constructor
+       * defaults overlaid with the request's `connectorConfig` (so any agent
+       * registered with `connectorType: 'subprocess'` can specify command / args /
+       * inputMode / outputParser / timeout / workingDir / env per agent). Pure —
+       * MUST NOT write to `this.config`. Subclasses override to translate their
+       * own `connectorConfig` shape (Claude Code flags, Pi package/model) into the
+       * base fields, typically by calling `super.resolveExecutionConfig()` on a
+       * request whose `connectorConfig` has been rewritten into base shape.
+       */
+      resolveExecutionConfig(request) {
+        const o = request.connectorConfig || {};
+        return {
+          ...this.config,
+          ...o.command !== void 0 ? { command: o.command } : {},
+          ...o.args !== void 0 ? { args: [...o.args] } : { args: [...this.config.args || []] },
+          env: { ...this.config.env || {}, ...o.env || {} },
+          ...o.inputMode !== void 0 ? { inputMode: o.inputMode } : {},
+          ...o.outputParser !== void 0 ? { outputParser: o.outputParser } : {},
+          ...o.timeout !== void 0 ? { timeout: o.timeout } : {},
+          ...o.workingDir !== void 0 ? { workingDir: o.workingDir } : {}
+        };
+      }
       /**
        * Parse a stderr chunk in streaming mode. Default is a no-op.
        *
        * Override in subclasses for CLIs that carry tool-event markers on stderr.
        * Implementations should buffer partial lines (chunks rarely align with
-       * line boundaries) and emit steps via `onProgress` AND push them onto
-       * `trajectory` so they appear in the final response.
+       * line boundaries) in `state` and emit steps via `onProgress` AND push them
+       * onto `trajectory` so they appear in the final response.
        */
-      parseStderrChunk(_chunk, _trajectory, _onProgress) {
+      parseStderrChunk(_chunk, _trajectory, _onProgress, _state) {
       }
       /**
        * Subclass hook: extra protocol-specific fields to merge into the
-       * connector result `metadata`. Default: none. Claude Code overrides this to
-       * surface the captured `sessionId` (Strategy D trace correlation).
+       * connector result `metadata`, read from the per-invocation `state` (Claude
+       * Code surfaces its captured `sessionId` for Strategy D trace correlation).
+       * Default: none.
        */
-      extraResultMetadata() {
+      extraResultMetadata(_state) {
         return {};
       }
       /**
@@ -2506,7 +2541,8 @@ Question: ${prompt}`;
        *      `response` step containing the full coherent answer (good for the
        *      judge) — without losing the live stream.
        */
-      parseStreamingOutput(chunk, trajectory, onProgress) {
+      parseStreamingOutput(chunk, trajectory, onProgress, state) {
+        const buf = state?.streamBuffer ?? [];
         const stripped = chunk.replace(/\x1b\][^\x07\x1b]*(\x07|\x1b\\)/g, "").replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").replace(/\x1b[=>NOP\\]/g, "").replace(/\r/g, "\n");
         const lines = stripped.split("\n");
         for (const raw of lines) {
@@ -2514,7 +2550,7 @@ Question: ${prompt}`;
           if (!line) continue;
           if (/^[⠁-⣿\s]+$/.test(line)) continue;
           if (line.length < 2 && !/[A-Za-z0-9]/.test(line)) continue;
-          this.streamBuffer.push(line);
+          buf.push(line);
           const step = this.createStep("assistant", line);
           trajectory.push(step);
           onProgress?.(step);
@@ -2525,10 +2561,10 @@ Question: ${prompt}`;
        * clean output. Streaming gave the user real-time visibility; this final
        * step gives the judge a single coherent answer to grade against.
        */
-      onBeforeStreamEnd(trajectory, onProgress) {
-        if (this.streamBuffer.length > 0) {
-          const finalText = this.streamBuffer.join("\n").trim();
-          this.streamBuffer = [];
+      onBeforeStreamEnd(trajectory, onProgress, state) {
+        if (state?.streamBuffer?.length) {
+          const finalText = state.streamBuffer.join("\n").trim();
+          state.streamBuffer = [];
           if (finalText) {
             const step = this.createStep("response", finalText);
             trajectory.push(step);
@@ -2539,9 +2575,9 @@ Question: ${prompt}`;
       /**
        * Parse final subprocess output
        */
-      parseResponse(data) {
+      parseResponse(data, config = this.config) {
         const steps = [];
-        if (this.config.outputParser === "json") {
+        if (config.outputParser === "json") {
           try {
             const parsed = JSON.parse(data.stdout);
             return this.parseJsonOutput(parsed);
@@ -2599,6 +2635,24 @@ Question: ${prompt}`;
 });
 
 // services/connectors/claude-code/ClaudeCodeConnector.ts
+function toolResultText(block, event) {
+  const c = block?.content;
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) {
+    return c.map(
+      (part) => part && part.type === "text" && typeof part.text === "string" ? part.text : JSON.stringify(part)
+    ).join("\n");
+  }
+  if (c != null) return JSON.stringify(c);
+  const mirror = event?.tool_use_result;
+  if (mirror === void 0 || mirror === null) return "";
+  return typeof mirror === "string" ? mirror : JSON.stringify(mirror);
+}
+function boundToolOutput(text, max = CLAUDE_CODE_MAX_TOOL_OUTPUT_CHARS) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}
+\u2026 [tool output truncated: showing ${max} of ${text.length} chars]`;
+}
 function createBedrockClaudeCodeConnector() {
   const env = {
     AWS_PROFILE: process.env.AWS_PROFILE || "Bedrock",
@@ -2626,11 +2680,12 @@ function createBedrockClaudeCodeConnector() {
   }
   return new ClaudeCodeConnector({ env });
 }
-var CLAUDE_CODE_DEFAULT_CONFIG, ClaudeCodeConnector, claudeCodeConnector;
+var CLAUDE_CODE_MAX_TOOL_OUTPUT_CHARS, CLAUDE_CODE_DEFAULT_CONFIG, ClaudeCodeConnector, claudeCodeConnector;
 var init_ClaudeCodeConnector = __esm({
   "services/connectors/claude-code/ClaudeCodeConnector.ts"() {
     init_types();
     init_SubprocessConnector();
+    CLAUDE_CODE_MAX_TOOL_OUTPUT_CHARS = 32 * 1024;
     CLAUDE_CODE_DEFAULT_CONFIG = {
       command: "claude",
       args: ["--print", "--verbose", "--output-format", "stream-json"],
@@ -2653,10 +2708,6 @@ var init_ClaudeCodeConnector = __esm({
         this.type = "claude-code";
         this.name = "Claude Code CLI";
         this.traceContext = { propagateEnv: true, serviceName: "claude-code-agent" };
-        this.outputBuffer = "";
-        this.thinkingBuffer = "";
-        this.textBuffer = "";
-        this.isInThinking = false;
       }
       /**
        * Build prompt for Claude Code
@@ -2676,20 +2727,29 @@ var init_ClaudeCodeConnector = __esm({
         parts.push(request.testCase.initialPrompt);
         return parts.join("\n");
       }
+      createExecutionState() {
+        return {
+          ...super.createExecutionState(),
+          outputBuffer: "",
+          thinkingBuffer: "",
+          textBuffer: "",
+          pendingToolUses: /* @__PURE__ */ new Map()
+        };
+      }
       /**
        * Parse Claude Code streaming output (stream-json format)
        * Each line is a JSON object with type and content
        */
-      parseStreamingOutput(chunk, trajectory, onProgress) {
-        this.outputBuffer += chunk;
-        const lines = this.outputBuffer.split("\n");
-        this.outputBuffer = lines.pop() || "";
+      parseStreamingOutput(chunk, trajectory, onProgress, state) {
+        state.outputBuffer += chunk;
+        const lines = state.outputBuffer.split("\n");
+        state.outputBuffer = lines.pop() || "";
         for (const line of lines) {
           const trimmed = line.trim();
           if (!trimmed) continue;
           try {
             const event = JSON.parse(trimmed);
-            const steps = this.parseJsonEvent(event);
+            const steps = this.parseJsonEvent(event, state);
             for (const step of steps) {
               trajectory.push(step);
               onProgress?.(step);
@@ -2706,10 +2766,10 @@ var init_ClaudeCodeConnector = __esm({
       /**
        * Parse a single JSON event from stream-json output
        */
-      parseJsonEvent(event) {
+      parseJsonEvent(event, state) {
         const steps = [];
         if (typeof event.session_id === "string" && event.session_id) {
-          this.sessionId = event.session_id;
+          state.sessionId = event.session_id;
         }
         if (event.type === "assistant" && event.message?.content) {
           for (const block of event.message.content) {
@@ -2718,6 +2778,9 @@ var init_ClaudeCodeConnector = __esm({
             } else if (block.type === "text" && block.text) {
               steps.push(this.createStep("assistant", block.text));
             } else if (block.type === "tool_use") {
+              if (typeof block.id === "string" && block.id) {
+                state.pendingToolUses.set(block.id, { name: block.name, input: block.input });
+              }
               steps.push(this.createStep("action", JSON.stringify(block.input || {}), {
                 toolName: block.name,
                 toolArgs: block.input
@@ -2727,10 +2790,14 @@ var init_ClaudeCodeConnector = __esm({
         } else if (event.type === "user" && event.message?.content) {
           for (const block of event.message.content) {
             if (block.type === "tool_result") {
-              const content = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+              const paired = typeof block.tool_use_id === "string" ? state.pendingToolUses.get(block.tool_use_id) : void 0;
+              if (paired && typeof block.tool_use_id === "string") state.pendingToolUses.delete(block.tool_use_id);
+              const output = boundToolOutput(toolResultText(block, event));
               steps.push(
-                this.createStep("tool_result", content, {
-                  status: block.is_error ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */
+                this.createStep("tool_result", output, {
+                  status: block.is_error ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */,
+                  ...paired?.name ? { toolName: paired.name } : {},
+                  ...output ? { toolOutput: output } : {}
                 })
               );
             } else if (block.type === "text" && block.text) {
@@ -2739,18 +2806,18 @@ var init_ClaudeCodeConnector = __esm({
           }
         } else if (event.type === "content_block_delta") {
           if (event.delta?.type === "thinking_delta" && event.delta.thinking) {
-            this.thinkingBuffer += event.delta.thinking;
+            state.thinkingBuffer += event.delta.thinking;
           } else if (event.delta?.type === "text_delta" && event.delta.text) {
-            this.textBuffer += event.delta.text;
+            state.textBuffer += event.delta.text;
           }
         } else if (event.type === "content_block_stop") {
-          if (this.thinkingBuffer) {
-            steps.push(this.createStep("thinking", this.thinkingBuffer));
-            this.thinkingBuffer = "";
+          if (state.thinkingBuffer) {
+            steps.push(this.createStep("thinking", state.thinkingBuffer));
+            state.thinkingBuffer = "";
           }
-          if (this.textBuffer) {
-            steps.push(this.createStep("assistant", this.textBuffer));
-            this.textBuffer = "";
+          if (state.textBuffer) {
+            steps.push(this.createStep("assistant", state.textBuffer));
+            state.textBuffer = "";
           }
         } else if (event.type === "result" && event.result) {
           steps.push(this.createStep(
@@ -2785,45 +2852,36 @@ var init_ClaudeCodeConnector = __esm({
         }
         return steps;
       }
-      /**
-       * Reset state for new execution
-       */
-      resetState() {
-        this.outputBuffer = "";
-        this.thinkingBuffer = "";
-        this.textBuffer = "";
-        this.isInThinking = false;
-      }
       /**
        * Flush remaining buffers when the subprocess stream ends.
        */
-      onBeforeStreamEnd(trajectory, onProgress) {
-        if (this.outputBuffer.trim()) {
+      onBeforeStreamEnd(trajectory, onProgress, state) {
+        if (state.outputBuffer.trim()) {
           try {
-            const event = JSON.parse(this.outputBuffer.trim());
-            const steps = this.parseJsonEvent(event);
+            const event = JSON.parse(state.outputBuffer.trim());
+            const steps = this.parseJsonEvent(event, state);
             for (const step of steps) {
               trajectory.push(step);
               onProgress?.(step);
             }
           } catch {
-            const step = this.createStep("assistant", this.outputBuffer.trim());
+            const step = this.createStep("assistant", state.outputBuffer.trim());
             trajectory.push(step);
             onProgress?.(step);
           }
-          this.outputBuffer = "";
+          state.outputBuffer = "";
         }
-        if (this.thinkingBuffer) {
-          const step = this.createStep("thinking", this.thinkingBuffer);
+        if (state.thinkingBuffer) {
+          const step = this.createStep("thinking", state.thinkingBuffer);
           trajectory.push(step);
           onProgress?.(step);
-          this.thinkingBuffer = "";
+          state.thinkingBuffer = "";
         }
-        if (this.textBuffer) {
-          const step = this.createStep("response", this.textBuffer);
+        if (state.textBuffer) {
+          const step = this.createStep("response", state.textBuffer);
           trajectory.push(step);
           onProgress?.(step);
-          this.textBuffer = "";
+          state.textBuffer = "";
         }
       }
       /**
@@ -2859,61 +2917,52 @@ var init_ClaudeCodeConnector = __esm({
         return args;
       }
       /**
-       * Override execute to reset state and apply connectorConfig
+       * Translate `ClaudeCodeConnectorConfig` (the agent's `connectorConfig`) into
+       * the effective per-execution subprocess config. Pure: builds a fresh
+       * snapshot from the constructor defaults — `this.config` is never written,
+       * so concurrent executions on the shared singleton cannot compound each
+       * other's flags (spawns were once observed with --append-system-prompt /
+       * --allowed-tools duplicated up to 5× at concurrency 3) or swap env /
+       * timeout / cwd.
+       */
+      resolveExecutionConfig(request) {
+        const ccConfig = request.connectorConfig || {};
+        const base = super.resolveExecutionConfig({
+          ...request,
+          // Only `env` / `timeout` / `workingDir` are base-shaped on the Claude
+          // Code config; everything else is translated to CLI flags below.
+          connectorConfig: {
+            ...ccConfig.env ? { env: ccConfig.env } : {},
+            ...ccConfig.timeout !== void 0 ? { timeout: ccConfig.timeout } : {},
+            ...ccConfig.workingDir ? { workingDir: ccConfig.workingDir } : {}
+          }
+        });
+        const configArgs = this.buildConfigArgs(ccConfig);
+        if (configArgs.length > 0) this.debug("Config args added:", configArgs);
+        let env = base.env || {};
+        if (env.CLAUDE_CODE_USE_BEDROCK === "1") {
+          env = { ...env, ANTHROPIC_API_KEY: "" };
+          this.debug("Bedrock mode: cleared ANTHROPIC_API_KEY to bypass credit check");
+        }
+        return {
+          ...base,
+          env,
+          args: [...this.config.args || [], ...configArgs],
+          ...ccConfig.usePromptArg ? { inputMode: "arg" } : {}
+        };
+      }
+      /**
+       * Override execute for debug logging around the base implementation.
        */
       async execute(endpoint, request, auth, onProgress, onRawEvent) {
         this.debug("========== execute() STARTED ==========");
         this.debug("Endpoint:", endpoint);
         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.pristineArgs];
-        const originalInputMode = this.config.inputMode;
-        const originalTimeout = this.config.timeout;
-        const originalWorkingDir = this.config.workingDir;
-        const ccConfig = request.connectorConfig;
-        if (ccConfig) {
-          this.debug("Applying connectorConfig:", Object.keys(ccConfig));
-          if (ccConfig.env) {
-            this.config.env = { ...this.config.env, ...ccConfig.env };
-          }
-          if (ccConfig.usePromptArg) {
-            this.config.inputMode = "arg";
-          }
-          if (ccConfig.timeout !== void 0) {
-            this.config.timeout = ccConfig.timeout;
-          }
-          if (ccConfig.workingDir) {
-            this.config.workingDir = ccConfig.workingDir;
-          }
-        }
-        if (this.config.env?.CLAUDE_CODE_USE_BEDROCK === "1") {
-          this.config.env = { ...this.config.env, ANTHROPIC_API_KEY: "" };
-          this.debug("Bedrock mode: cleared ANTHROPIC_API_KEY to bypass credit check");
-        }
-        if (ccConfig) {
-          const configArgs = this.buildConfigArgs(ccConfig);
-          this.config.args = [...this.pristineArgs, ...configArgs];
-          if (configArgs.length > 0) {
-            this.debug("Config args added:", configArgs);
-          }
-        }
-        try {
-          this.debug("State reset, calling super.execute()...");
-          this.sessionId = void 0;
-          const result = await super.execute(endpoint, request, auth, onProgress, onRawEvent);
-          this.debug("super.execute() returned with", result.trajectory.length, "steps");
-          this.debug("========== execute() COMPLETED ==========");
-          return result;
-        } finally {
-          this.config.env = originalEnv;
-          this.config.args = originalArgs;
-          this.config.inputMode = originalInputMode;
-          this.config.timeout = originalTimeout;
-          this.config.workingDir = originalWorkingDir;
-        }
+        if (request.connectorConfig) this.debug("Applying connectorConfig:", Object.keys(request.connectorConfig));
+        const result = await super.execute(endpoint, request, auth, onProgress, onRawEvent);
+        this.debug("super.execute() returned with", result.trajectory.length, "steps");
+        this.debug("========== execute() COMPLETED ==========");
+        return result;
       }
       /**
        * Health check - verify claude command exists
@@ -2923,10 +2972,15 @@ var init_ClaudeCodeConnector = __esm({
       }
       /**
        * Surface the captured Claude Code `session_id` so the runner can persist it
-       * as `report.sessionId` for Strategy D trace correlation.
+       * as `report.sessionId` for Strategy D trace correlation. Read from the
+       * per-invocation state — never from the instance — so concurrent runs on
+       * the shared singleton can't swap session ids.
        */
-      extraResultMetadata() {
-        return this.sessionId ? { sessionId: this.sessionId } : {};
+      extraResultMetadata(state) {
+        return {
+          ...super.extraResultMetadata(state),
+          ...state.sessionId ? { sessionId: state.sessionId } : {}
+        };
       }
     };
     claudeCodeConnector = new ClaudeCodeConnector();
@@ -2960,39 +3014,36 @@ var init_KiroConnector = __esm({
         this.type = "kiro";
         this.name = "Kiro CLI";
         this.traceContext = { propagateEnv: true, serviceName: "kiro-agent" };
-        /** Carry-over for a partial last line on stderr stream */
-        this.stderrLineBuffer = "";
-        /** Tool name from the last unmatched `[tool] Running:` line, used to
-         *  attach the same toolName to the corresponding `[tool] status:` row. */
-        this.pendingToolName = null;
+      }
+      createExecutionState() {
+        return { ...super.createExecutionState(), stderrLineBuffer: "", pendingToolName: null };
       }
       /**
        * Convert kiro-cli's stderr `[tool]` markers into trajectory steps.
        *
        * Each chunk may straddle line boundaries, so we accumulate into
-       * `stderrLineBuffer` and only consume complete lines (the trailing
+       * `state.stderrLineBuffer` and only consume complete lines (the trailing
        * partial line is held until the next chunk or `onBeforeStreamEnd`).
        */
-      parseStderrChunk(chunk, trajectory, onProgress) {
-        this.stderrLineBuffer += chunk;
-        const lines = this.stderrLineBuffer.split("\n");
-        this.stderrLineBuffer = lines.pop() || "";
+      parseStderrChunk(chunk, trajectory, onProgress, state) {
+        state.stderrLineBuffer += chunk;
+        const lines = state.stderrLineBuffer.split("\n");
+        state.stderrLineBuffer = lines.pop() || "";
         for (const raw of lines) {
-          this.processStderrLine(raw, trajectory, onProgress);
+          this.processStderrLine(raw, trajectory, onProgress, state);
         }
       }
       /**
-       * Drain any held partial line from the stderr buffer and reset
-       * per-run state, then defer to the base class to flush the
-       * consolidated stdout response step.
+       * Drain any held partial line from the stderr buffer, then defer to the
+       * base class to flush the consolidated stdout response step.
        */
-      onBeforeStreamEnd(trajectory, onProgress) {
-        if (this.stderrLineBuffer.trim()) {
-          this.processStderrLine(this.stderrLineBuffer, trajectory, onProgress);
+      onBeforeStreamEnd(trajectory, onProgress, state) {
+        if (state.stderrLineBuffer.trim()) {
+          this.processStderrLine(state.stderrLineBuffer, trajectory, onProgress, state);
         }
-        this.stderrLineBuffer = "";
-        this.pendingToolName = null;
-        super.onBeforeStreamEnd(trajectory, onProgress);
+        state.stderrLineBuffer = "";
+        state.pendingToolName = null;
+        super.onBeforeStreamEnd(trajectory, onProgress, state);
       }
       /**
        * Parse a single stderr line. Recognised forms:
@@ -3004,7 +3055,7 @@ var init_KiroConnector = __esm({
        *
        * Other stderr lines (AWS SDK warnings, telemetry info, etc.) are ignored.
        */
-      processStderrLine(raw, trajectory, onProgress) {
+      processStderrLine(raw, trajectory, onProgress, state) {
         const line = raw.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "").trim();
         if (!line.startsWith("[tool]")) return;
         const m2 = line.match(/^\[tool\]\s+(Running|status):\s*(.*)$/i);
@@ -3014,7 +3065,7 @@ var init_KiroConnector = __esm({
         if (kind === "running") {
           const toolName = payload.split(/\s+/)[0] || "unknown";
           const toolArgs = { command: payload };
-          this.pendingToolName = toolName;
+          state.pendingToolName = toolName;
           const step = this.createStep("action", JSON.stringify(toolArgs), {
             toolName,
             toolArgs
@@ -3030,12 +3081,12 @@ var init_KiroConnector = __esm({
             `status: ${payload}`,
             {
               status: success ? "SUCCESS" /* SUCCESS */ : "FAILURE" /* FAILURE */,
-              toolName: this.pendingToolName ?? void 0
+              toolName: state.pendingToolName ?? void 0
             }
           );
           trajectory.push(step);
           onProgress?.(step);
-          this.pendingToolName = null;
+          state.pendingToolName = null;
         }
       }
       async healthCheck(endpoint, auth) {
@@ -3076,9 +3127,9 @@ var init_PiConnector = __esm({
         this.type = "pi";
         this.name = "Pi (pi.dev)";
         this.traceContext = { propagateEnv: true, serviceName: "pi-agent" };
-        this.piOutputBuffer = "";
-        this.piThinkingBuffer = "";
-        this.piTextBuffer = "";
+      }
+      createExecutionState() {
+        return { ...super.createExecutionState(), piOutputBuffer: "", piThinkingBuffer: "", piTextBuffer: "" };
       }
       /**
        * Build prompt for Pi
@@ -3101,16 +3152,16 @@ var init_PiConnector = __esm({
        * Parse Pi streaming output (JSON format)
        * Pi's --mode json produces NDJSON lines
        */
-      parseStreamingOutput(chunk, trajectory, onProgress) {
-        this.piOutputBuffer += chunk;
-        const lines = this.piOutputBuffer.split("\n");
-        this.piOutputBuffer = lines.pop() || "";
+      parseStreamingOutput(chunk, trajectory, onProgress, state) {
+        state.piOutputBuffer += chunk;
+        const lines = state.piOutputBuffer.split("\n");
+        state.piOutputBuffer = lines.pop() || "";
         for (const line of lines) {
           const trimmed = line.trim();
           if (!trimmed) continue;
           try {
             const event = JSON.parse(trimmed);
-            const steps = this.parsePiEvent(event);
+            const steps = this.parsePiEvent(event, state);
             for (const step of steps) {
               trajectory.push(step);
               onProgress?.(step);
@@ -3133,7 +3184,7 @@ var init_PiConnector = __esm({
        *  - message_start / message_end — full message with content blocks
        *  - message_update — streaming deltas with assistantMessageEvent
        */
-      parsePiEvent(event) {
+      parsePiEvent(event, state) {
         const steps = [];
         if (event.type === "message_end" && event.message?.role === "assistant") {
           const content = event.message.content;
@@ -3154,9 +3205,9 @@ var init_PiConnector = __esm({
         } else if (event.type === "message_update") {
           const assistantEvent = event.assistantMessageEvent;
           if (assistantEvent?.type === "text_delta" && assistantEvent.delta) {
-            this.piTextBuffer += assistantEvent.delta;
+            state.piTextBuffer += assistantEvent.delta;
           } else if (assistantEvent?.type === "thinking_delta" && assistantEvent.delta) {
-            this.piThinkingBuffer += assistantEvent.delta;
+            state.piThinkingBuffer += assistantEvent.delta;
           }
         } else if (event.type === "tool_result") {
           const content = event.content || event.output || JSON.stringify(event);
@@ -3166,13 +3217,13 @@ var init_PiConnector = __esm({
             { status: event.is_error ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */ }
           ));
         } else if (event.type === "agent_end") {
-          if (this.piThinkingBuffer) {
-            steps.push(this.createStep("thinking", this.piThinkingBuffer));
-            this.piThinkingBuffer = "";
+          if (state.piThinkingBuffer) {
+            steps.push(this.createStep("thinking", state.piThinkingBuffer));
+            state.piThinkingBuffer = "";
           }
-          if (this.piTextBuffer) {
-            steps.push(this.createStep("response", this.piTextBuffer));
-            this.piTextBuffer = "";
+          if (state.piTextBuffer) {
+            steps.push(this.createStep("response", state.piTextBuffer));
+            state.piTextBuffer = "";
           }
         }
         return steps;
@@ -3196,90 +3247,105 @@ var init_PiConnector = __esm({
       /**
        * Flush remaining buffers when the subprocess stream ends.
        */
-      onBeforeStreamEnd(trajectory, onProgress) {
-        if (this.piOutputBuffer.trim()) {
+      onBeforeStreamEnd(trajectory, onProgress, state) {
+        if (state.piOutputBuffer.trim()) {
           try {
-            const event = JSON.parse(this.piOutputBuffer.trim());
-            const steps = this.parsePiEvent(event);
+            const event = JSON.parse(state.piOutputBuffer.trim());
+            const steps = this.parsePiEvent(event, state);
             for (const step of steps) {
               trajectory.push(step);
               onProgress?.(step);
             }
           } catch {
-            const step = this.createStep("assistant", this.piOutputBuffer.trim());
+            const step = this.createStep("assistant", state.piOutputBuffer.trim());
             trajectory.push(step);
             onProgress?.(step);
           }
-          this.piOutputBuffer = "";
+          state.piOutputBuffer = "";
         }
-        if (this.piThinkingBuffer) {
-          const step = this.createStep("thinking", this.piThinkingBuffer);
+        if (state.piThinkingBuffer) {
+          const step = this.createStep("thinking", state.piThinkingBuffer);
           trajectory.push(step);
           onProgress?.(step);
-          this.piThinkingBuffer = "";
+          state.piThinkingBuffer = "";
         }
-        if (this.piTextBuffer) {
-          const step = this.createStep("response", this.piTextBuffer);
+        if (state.piTextBuffer) {
+          const step = this.createStep("response", state.piTextBuffer);
           trajectory.push(step);
           onProgress?.(step);
-          this.piTextBuffer = "";
+          state.piTextBuffer = "";
         }
       }
       /**
-       * Reset state and apply connectorConfig
+       * Translate `PiConnectorConfig` into the effective per-execution subprocess
+       * config. Pure — `this.config` is never written, so concurrent executions
+       * on the shared singleton cannot see each other's args / env / timeout.
        */
-      async execute(endpoint, request, auth, onProgress, onRawEvent) {
-        this.piOutputBuffer = "";
-        this.piThinkingBuffer = "";
-        this.piTextBuffer = "";
-        const originalArgs = this.config.args ? [...this.config.args] : [];
-        const originalEnv = this.config.env ? structuredClone(this.config.env) : {};
-        const originalTimeout = this.config.timeout;
-        const originalWorkingDir = this.config.workingDir;
-        const piConfig = request.connectorConfig;
-        if (piConfig) {
-          if (piConfig.env) {
-            this.config.env = { ...this.config.env, ...piConfig.env };
-          }
-          if (piConfig.timeout !== void 0) {
-            this.config.timeout = piConfig.timeout;
-          }
-          if (piConfig.workingDir) {
-            this.config.workingDir = piConfig.workingDir;
-          }
-          const extraArgs = [];
-          if (piConfig.packagePath) {
-            extraArgs.push("--skill", `${piConfig.packagePath}/skills/*`);
-            extraArgs.push("--extension", `${piConfig.packagePath}/extensions/agent-health.ts`);
-            extraArgs.push("--append-system-prompt", `${piConfig.packagePath}/prompts/agent-health.md`);
-          }
-          if (piConfig.model) {
-            extraArgs.push("--model", piConfig.model);
-          }
-          if (piConfig.additionalArgs) {
-            extraArgs.push(...piConfig.additionalArgs);
-          }
-          if (extraArgs.length > 0) {
-            this.config.args = [...this.config.args || [], ...extraArgs];
+      resolveExecutionConfig(request) {
+        const piConfig = request.connectorConfig || {};
+        const base = super.resolveExecutionConfig({
+          ...request,
+          connectorConfig: {
+            ...piConfig.env ? { env: piConfig.env } : {},
+            ...piConfig.timeout !== void 0 ? { timeout: piConfig.timeout } : {},
+            ...piConfig.workingDir ? { workingDir: piConfig.workingDir } : {}
           }
+        });
+        const extraArgs = [];
+        if (piConfig.packagePath) {
+          extraArgs.push("--skill", `${piConfig.packagePath}/skills/*`);
+          extraArgs.push("--extension", `${piConfig.packagePath}/extensions/agent-health.ts`);
+          extraArgs.push("--append-system-prompt", `${piConfig.packagePath}/prompts/agent-health.md`);
         }
-        if (request.modelId) {
-          this.config.args = [...this.config.args || [], "--model", request.modelId];
+        if (piConfig.model) {
+          extraArgs.push("--model", piConfig.model);
         }
-        if (process.env.AWS_PROFILE) {
-          this.config.env = { ...this.config.env, AWS_PROFILE: process.env.AWS_PROFILE };
+        if (piConfig.additionalArgs) {
+          extraArgs.push(...piConfig.additionalArgs);
         }
-        if (process.env.AWS_REGION) {
-          this.config.env = { ...this.config.env, AWS_REGION: process.env.AWS_REGION };
+        let args = [...this.config.args || [], ...extraArgs];
+        if (request.modelId) {
+          args = [...this.stripModelFlag(args), "--model", request.modelId];
         }
-        try {
-          return await super.execute(endpoint, request, auth, onProgress, onRawEvent);
-        } finally {
-          this.config.args = originalArgs;
-          this.config.env = originalEnv;
-          this.config.timeout = originalTimeout;
-          this.config.workingDir = originalWorkingDir;
+        const env = { ...base.env || {} };
+        if (process.env.AWS_PROFILE) env.AWS_PROFILE = process.env.AWS_PROFILE;
+        if (process.env.AWS_REGION) env.AWS_REGION = process.env.AWS_REGION;
+        return { ...base, args, env };
+      }
+      /**
+       * Remove any `--model <value>` (two-token) or `--model=<value>` (single-
+       * token) occurrence from an argv array. Used so `request.modelId` can
+       * override `connectorConfig.model` without leaving a stale second
+       * `--model` flag in the final argv.
+       *
+       * This connector only ever generates the two-token form itself, but
+       * `connectorConfig.additionalArgs` is user-supplied and could plausibly
+       * contain the `--model=value` form, so both are handled (codex_review
+       * finding: a stray `--model=value` from `additionalArgs` would otherwise
+       * survive alongside the newly-appended two-token flag, recreating the
+       * duplicate-flag bug). If a bare `--model` has no following value (or is
+       * the last element), only the bare flag is removed — the next token is
+       * left alone rather than being swallowed as a "value" when it's actually
+       * another flag (codex_review finding: guards against corrupting unrelated
+       * malformed argv, e.g. `['--foo', '--model', '--bar']`).
+       */
+      stripModelFlag(args) {
+        const result = [];
+        for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          if (arg === "--model") {
+            const next = args[i + 1];
+            if (next !== void 0 && !next.startsWith("-")) {
+              i++;
+            }
+            continue;
+          }
+          if (arg.startsWith("--model=")) {
+            continue;
+          }
+          result.push(arg);
         }
+        return result;
       }
       /**
        * Health check - verify pi command exists
@@ -3557,21 +3623,38 @@ var init_server = __esm({
 });
 
 // lib/testCases/define.ts
+function getSharedState() {
+  const g = globalThis;
+  let state = g[REGISTRY_KEY];
+  if (!state) {
+    state = {
+      registries: /* @__PURE__ */ new Map(),
+      hookRegistries: /* @__PURE__ */ new Map(),
+      activeFile: null,
+      describeStack: [],
+      experimentalWarningEmitted: false
+    };
+    g[REGISTRY_KEY] = state;
+  }
+  return state;
+}
 function emitExperimentalWarningOnce() {
-  if (experimentalWarningEmitted) return;
-  experimentalWarningEmitted = true;
+  const state = getSharedState();
+  if (state.experimentalWarningEmitted) return;
+  state.experimentalWarningEmitted = true;
   if (readEnv("AH_SUPPRESS_EXPERIMENTAL", "AGENT_HEALTH_SUPPRESS_EXPERIMENTAL") === "1") return;
   console.warn(
     "[agent-health] The code-based test SDK (test()/judge()/expect()) is experimental. The API may change in a minor release without a deprecation cycle. Pin your @opensearch-project/agent-health version, or set AH_SUPPRESS_EXPERIMENTAL=1 to silence this notice."
   );
 }
 function setActiveFile(filePath2) {
-  activeFile = filePath2;
-  if (!registries.has(filePath2)) {
-    registries.set(filePath2, []);
+  const state = getSharedState();
+  state.activeFile = filePath2;
+  if (!state.registries.has(filePath2)) {
+    state.registries.set(filePath2, []);
   }
-  if (!hookRegistries.has(filePath2)) {
-    hookRegistries.set(filePath2, []);
+  if (!state.hookRegistries.has(filePath2)) {
+    state.hookRegistries.set(filePath2, []);
   }
 }
 function test(name, optionsOrBody, maybeBody) {
@@ -3591,14 +3674,15 @@ function test(name, optionsOrBody, maybeBody) {
   if (typeof evaluate2 !== "function") {
     throw new Error(`test("${name}") requires a body function`);
   }
-  const key = activeFile ?? DEFAULT_KEY;
-  if (!registries.has(key)) {
-    registries.set(key, []);
+  const state = getSharedState();
+  const key = state.activeFile ?? DEFAULT_KEY;
+  if (!state.registries.has(key)) {
+    state.registries.set(key, []);
   }
-  const registry2 = registries.get(key);
-  const benchmarkPath = describeStack.length > 0 ? describeStack.join(" > ") : void 0;
+  const registry2 = state.registries.get(key);
+  const benchmarkPath = state.describeStack.length > 0 ? state.describeStack.join(" > ") : void 0;
   if (registry2.some((t) => t.name === name && t.benchmarkPath === benchmarkPath)) {
-    const fileLabel = activeFile ? ` in ${activeFile}` : "";
+    const fileLabel = state.activeFile ? ` in ${state.activeFile}` : "";
     const groupLabel = benchmarkPath ? ` (in describe "${benchmarkPath}")` : "";
     throw new Error(
       `Duplicate test name "${name}"${groupLabel}${fileLabel}. Test names must be unique within their describe block. Move one of the tests to a different describe() or rename it.`
@@ -3608,7 +3692,7 @@ function test(name, optionsOrBody, maybeBody) {
     name,
     options,
     evaluate: evaluate2,
-    sourceFile: activeFile ?? void 0,
+    sourceFile: state.activeFile ?? void 0,
     benchmarkPath
   });
 }
@@ -3620,7 +3704,8 @@ function describe(name, fn) {
   if (typeof fn !== "function") {
     throw new Error(`describe("${name}") requires a body function`);
   }
-  describeStack.push(name);
+  const state = getSharedState();
+  state.describeStack.push(name);
   try {
     const result = fn();
     if (result && typeof result.then === "function") {
@@ -3629,41 +3714,45 @@ function describe(name, fn) {
       );
     }
   } finally {
-    describeStack.pop();
+    state.describeStack.pop();
   }
 }
 function getRegisteredTests(filePath2) {
-  if (filePath2) return [...registries.get(filePath2) ?? []];
-  return [...registries.values()].flatMap((r) => [...r]);
+  const state = getSharedState();
+  if (filePath2) return [...state.registries.get(filePath2) ?? []];
+  return [...state.registries.values()].flatMap((r) => [...r]);
 }
 function getRegisteredHooks(filePath2) {
-  if (filePath2) return [...hookRegistries.get(filePath2) ?? []];
-  return [...hookRegistries.values()].flatMap((r) => [...r]);
+  const state = getSharedState();
+  if (filePath2) return [...state.hookRegistries.get(filePath2) ?? []];
+  return [...state.hookRegistries.values()].flatMap((r) => [...r]);
 }
 function clearRegistry(filePath2) {
+  const state = getSharedState();
   if (filePath2) {
-    registries.delete(filePath2);
-    hookRegistries.delete(filePath2);
+    state.registries.delete(filePath2);
+    state.hookRegistries.delete(filePath2);
   } else {
-    registries.clear();
-    hookRegistries.clear();
+    state.registries.clear();
+    state.hookRegistries.clear();
   }
-  activeFile = null;
+  state.activeFile = null;
 }
 function registerHook(kind, fn) {
   emitExperimentalWarningOnce();
   if (typeof fn !== "function") {
     throw new Error(`${kind}() requires a function as its first argument`);
   }
-  const key = activeFile ?? DEFAULT_KEY;
-  if (!hookRegistries.has(key)) {
-    hookRegistries.set(key, []);
+  const state = getSharedState();
+  const key = state.activeFile ?? DEFAULT_KEY;
+  if (!state.hookRegistries.has(key)) {
+    state.hookRegistries.set(key, []);
   }
-  const describePath = describeStack.length > 0 ? describeStack.join(" > ") : void 0;
-  hookRegistries.get(key).push({
+  const describePath = state.describeStack.length > 0 ? state.describeStack.join(" > ") : void 0;
+  state.hookRegistries.get(key).push({
     kind,
     fn,
-    sourceFile: activeFile ?? void 0,
+    sourceFile: state.activeFile ?? void 0,
     describePath
   });
 }
@@ -3679,16 +3768,12 @@ function beforeEach(fn) {
 function afterEach(fn) {
   registerHook("afterEach", fn);
 }
-var registries, hookRegistries, activeFile, DEFAULT_KEY, describeStack, experimentalWarningEmitted;
+var DEFAULT_KEY, REGISTRY_KEY;
 var init_define = __esm({
   "lib/testCases/define.ts"() {
     init_envCompat();
-    registries = /* @__PURE__ */ new Map();
-    hookRegistries = /* @__PURE__ */ new Map();
-    activeFile = null;
     DEFAULT_KEY = "__default__";
-    describeStack = [];
-    experimentalWarningEmitted = false;
+    REGISTRY_KEY = /* @__PURE__ */ Symbol.for("agent-health.test-registry.v1");
     ((test2) => {
       test2.beforeAll = (fn) => registerHook("beforeAll", fn);
       test2.afterAll = (fn) => registerHook("afterAll", fn);
@@ -3790,10 +3875,10 @@ async function runJudge(resultOrTrajectory, claimOrClaims, options, role) {
   if (runId) requestBody.runId = runId;
   if (Array.isArray(judgeAgents) && judgeAgents.length > 0) requestBody.agents = judgeAgents;
   const finalize = (raw2, durationMs) => {
-    const accuracy = raw2.metrics?.accuracy ?? 0;
+    const headline = typeof raw2.metrics?.accuracy === "number" ? raw2.metrics.accuracy : typeof raw2.overallScore === "number" ? raw2.overallScore : void 0;
     const verdict = makeVerdict({
       passFailStatus: raw2.passFailStatus ?? "failed",
-      accuracy,
+      accuracy: headline ?? 0,
       reasoning: raw2.llmJudgeReasoning ?? "",
       role,
       skipped: false,
@@ -3805,15 +3890,22 @@ async function runJudge(resultOrTrajectory, claimOrClaims, options, role) {
       method: "llm-judge",
       role,
       durationMs,
-      score: verdict.score,
+      // Only record a score when the judge actually produced a headline
+      // number — a fabricated 0 renders as a misleading "score 0%".
+      ...headline !== void 0 ? { score: headline / 100 } : {},
       reasoning: verdict.reasoning,
       model: options?.model,
-      errorMessage: verdict.passFailStatus === "failed" ? verdict.reasoning : void 0,
+      // NOTE: no `errorMessage` mirror. It used to copy `reasoning` verbatim
+      // on failure, which persisted the same multi-KB string twice and made
+      // the UI render it twice (once red as "error", once as "reasoning").
+      // `reasoning` is the single source of truth; consumers that need a
+      // failure detail fall back to it (see expect.toPass()).
       // Preserve the rest of the judge payload — these were silently
       // dropped before, which made SDK `judge()` calls strictly less
       // informative than the legacy auto-judge path. See MatcherResult.
       ...Array.isArray(raw2.improvementStrategies) && raw2.improvementStrategies.length > 0 ? { improvementStrategies: raw2.improvementStrategies } : {},
-      ...raw2.metrics && typeof raw2.metrics === "object" ? { judgeMetrics: { ...raw2.metrics } } : {}
+      ...raw2.metrics && typeof raw2.metrics === "object" ? { judgeMetrics: { ...raw2.metrics } } : {},
+      ...raw2.extraFields && typeof raw2.extraFields === "object" && Object.keys(raw2.extraFields).length > 0 ? { judgeExtraFields: raw2.extraFields } : {}
     });
     return verdict;
   };
@@ -4076,6 +4168,9 @@ function ensurePluginsInstalled() {
           errorMessage: err?.message || String(err)
         });
       }
+      if (utils.flag(this, "ahSoft")) {
+        return;
+      }
       throw err;
     }
   };
@@ -4147,6 +4242,11 @@ function ensurePluginsInstalled() {
     );
   });
 }
+function softExpect(val, msg) {
+  const assertion = chai.expect(val, msg);
+  chai.util.flag(assertion, "ahSoft", true);
+  return assertion;
+}
 function describeAssertion(ctx, _expr, msg, negateMsg, expected, actual, utils) {
   const rawMsg = typeof msg === "function" ? msg() : msg;
   const rawNeg = typeof negateMsg === "function" ? negateMsg() : negateMsg;
@@ -4202,6 +4302,7 @@ var init_expect = __esm({
     pluginsInstalled = false;
     ensurePluginsInstalled();
     expect2 = chai.expect;
+    expect2.soft = softExpect;
   }
 });
 
@@ -4627,8 +4728,8 @@ function claudeNativeTrajectory(spans) {
       const redacted = !prompt || prompt === "<REDACTED>";
       steps.push({
         ...base,
-        type: "thinking",
-        content: redacted ? `User: [prompt redacted \u2014 set OTEL_LOG_USER_PROMPTS=1 to capture] (${a["user_prompt_length"] ?? "?"} chars)` : `User: ${prompt}`
+        type: "user",
+        content: redacted ? `[prompt redacted \u2014 set OTEL_LOG_USER_PROMPTS=1 to capture] (${a["user_prompt_length"] ?? "?"} chars)` : String(prompt)
       });
     } else if (t === "llm_request") {
       const model = a["model"] || a["gen_ai.request.model"] || "";
@@ -4839,7 +4940,7 @@ function genericTrajectory(spans, serviceName) {
         break;
       }
       case "user":
-        steps.push({ ...base, type: "thinking", content: `User: ${m2.content}` });
+        steps.push({ ...base, type: "user", content: m2.content });
         break;
       default:
         steps.push({ ...base, type: "thinking", content: m2.content });
@@ -5260,6 +5361,8 @@ var init_utils = __esm({
 // lib/testCases/loader.ts
 var loader_exports = {};
 __export(loader_exports, {
+  DEFINITION_BODY_SOURCE_MAX_CHARS: () => DEFINITION_BODY_SOURCE_MAX_CHARS,
+  captureTestDefinition: () => captureTestDefinition,
   computeTestCaseHash: () => computeTestCaseHash,
   detectSourceLanguage: () => detectSourceLanguage,
   isCodeFile: () => isCodeFile,
@@ -5300,58 +5403,144 @@ function computeTestCaseHash(tc, fileSource2) {
   });
   return createHash("sha256").update(content).digest("hex");
 }
+function captureTestDefinition(tc) {
+  let options = {};
+  try {
+    const parsed = JSON.parse(JSON.stringify(tc.options ?? {}));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) options = parsed;
+  } catch {
+  }
+  let bodySource = "";
+  try {
+    bodySource = typeof tc.evaluate === "function" ? Function.prototype.toString.call(tc.evaluate) : "";
+  } catch {
+    bodySource = "";
+  }
+  let bodyTruncated = false;
+  if (bodySource.length > DEFINITION_BODY_SOURCE_MAX_CHARS) {
+    bodySource = bodySource.slice(0, DEFINITION_BODY_SOURCE_MAX_CHARS) + BODY_TRUNCATION_MARKER;
+    bodyTruncated = true;
+  }
+  return {
+    registeredAs: "sdk",
+    options,
+    bodySource,
+    ...bodyTruncated ? { bodyTruncated: true } : {}
+  };
+}
+function getEsbuildTransformSync() {
+  if (!esbuildTransformSyncPromise) {
+    esbuildTransformSyncPromise = import("esbuild").then((m2) => m2.transformSync);
+  }
+  return esbuildTransformSyncPromise;
+}
 async function loadTestCasesFromModule(filePath) {
   const absPath = resolve4(filePath);
   const fileSource = readFileSync2(absPath, "utf-8");
   clearRegistry(absPath);
   setActiveFile(absPath);
+  const transformSync = absPath.endsWith(".mjs") ? void 0 : await getEsbuildTransformSync();
+  const tsModuleCache = /* @__PURE__ */ new Map();
   let module;
-  if (absPath.endsWith(".js")) {
-    const code = fileSource;
-    const fileDir = dirname3(absPath);
+  const runAsSyntheticCjs = (code, modulePath) => {
+    const fileDir = dirname3(modulePath);
     const Module = NodeModule;
-    const m = new Module(absPath);
-    m.filename = absPath;
+    const m = new Module(modulePath);
+    m.filename = modulePath;
     m.paths = Module._nodeModulePaths(fileDir);
-    const fileRequire = createRequire(absPath);
+    const fileRequire = createRequire(modulePath);
     const isDefineId = (id) => {
       const normalized = id.replace(/\\/g, "/").replace(/\.js$/, "");
       return normalized === "lib/testCases/define" || normalized.endsWith("/lib/testCases/define");
     };
     const isPackageName = (id) => id === "@opensearch-project/agent-health" || id === "@opensearch/agent-health" || id === "agent-health";
     const sdkExports = getAuthoringSurface();
+    const requireLocalTsModule = (resolvedTsPath) => {
+      const cached = tsModuleCache.get(resolvedTsPath);
+      if (cached !== void 0) return cached;
+      if (!transformSync) {
+        throw new Error(
+          `Cannot import TypeScript file: ${resolvedTsPath}
+esbuild (required to load .ts files) was not resolved for this load.`
+        );
+      }
+      const helperSource = readFileSync2(resolvedTsPath, "utf-8");
+      const helperCjs = transformSync(helperSource, {
+        loader: "ts",
+        format: "cjs",
+        target: "node18",
+        sourcefile: resolvedTsPath
+      }).code;
+      const helperExports = runAsSyntheticCjs(helperCjs, resolvedTsPath);
+      tsModuleCache.set(resolvedTsPath, helperExports);
+      return helperExports;
+    };
     const wrappedRequire = (id) => {
       if (isDefineId(id) || isPackageName(id)) {
         return sdkExports;
       }
+      let resolved;
       try {
-        const resolved = fileRequire.resolve(id);
-        const normalized = resolved.replace(/\\/g, "/");
-        if (normalized.endsWith("/lib/testCases/define.js") || normalized.endsWith("/lib/testCases/define")) {
+        resolved = fileRequire.resolve(id);
+      } catch {
+      }
+      if (resolved) {
+        const normalizedResolved = resolved.replace(/\\/g, "/");
+        if (normalizedResolved.endsWith("/lib/testCases/define.js") || normalizedResolved.endsWith("/lib/testCases/define")) {
           return sdkExports;
         }
-      } catch {
+        if (normalizedResolved.endsWith(".ts")) {
+          return requireLocalTsModule(resolved);
+        }
+      }
+      try {
+        return fileRequire(id);
+      } catch (err) {
+        if (err.code === "ERR_REQUIRE_ESM") {
+          throw new Error(
+            `.eval.ts fixtures cannot import ESM-only packages via require() (attempted: '${id}').
+'${id}' has no CommonJS entry point, and .eval.ts files execute as synthetic CJS.
+Use .eval.mjs (real ESM -- can import ESM-only packages) or pre-compile to .eval.js instead.`
+          );
+        }
+        throw err;
       }
-      return fileRequire(id);
     };
     wrappedRequire.resolve = fileRequire.resolve;
     const wrapper = `(function(exports, require, module, __filename, __dirname) { ${code}
 });`;
     const compiledFn = eval(wrapper);
-    compiledFn(m.exports, wrappedRequire, m, absPath, fileDir);
-    module = m.exports;
+    compiledFn(m.exports, wrappedRequire, m, modulePath, fileDir);
+    return m.exports;
+  };
+  if (absPath.endsWith(".js")) {
+    module = runAsSyntheticCjs(fileSource, absPath);
+  } else if (absPath.endsWith(".ts")) {
+    if (!transformSync) {
+      throw new Error(`Cannot import TypeScript file: ${filePath}
+esbuild was not resolved.`);
+    }
+    let cjsSource;
+    try {
+      cjsSource = transformSync(fileSource, {
+        loader: "ts",
+        format: "cjs",
+        target: "node18",
+        sourcefile: absPath
+      }).code;
+    } catch (esbuildErr) {
+      throw new Error(
+        `Cannot import TypeScript file: ${filePath}
+esbuild (required to load .eval.ts files) failed to transpile it: ${esbuildErr.message}
+Or pre-compile .eval.ts to .eval.js before running.`
+      );
+    }
+    module = runAsSyntheticCjs(cjsSource, absPath);
   } else {
     try {
-      const fileUrl = pathToFileURL2(absPath).href;
+      const fileUrl = `${pathToFileURL2(absPath).href}?ah-reload=${Date.now()}-${Math.random().toString(36).slice(2)}`;
       module = await import(fileUrl);
     } catch (err) {
-      if (err.code === "ERR_UNKNOWN_FILE_EXTENSION" && absPath.endsWith(".ts")) {
-        throw new Error(
-          `Cannot import TypeScript file: ${filePath}
-Install tsx as a dependency: npm install tsx
-Or pre-compile .eval.ts to .eval.js before running.`
-        );
-      }
       throw new Error(`Failed to import module: ${filePath}
 ${err.message}`);
     }
@@ -5364,7 +5553,8 @@ ${err.message}`);
   }
   const loaded = testCases.map((tc) => ({
     ...tc,
-    hash: computeTestCaseHash(tc, fileSource)
+    hash: computeTestCaseHash(tc, fileSource),
+    definition: captureTestDefinition(tc)
   }));
   const benchmarks = /* @__PURE__ */ new Map();
   for (const tc of loaded) {
@@ -5377,13 +5567,15 @@ ${err.message}`);
   const hooks = getRegisteredHooks(absPath);
   return { testCases: loaded, filePath: absPath, benchmarks, hooks, fileSource };
 }
-var CODE_EXTENSIONS;
+var CODE_EXTENSIONS, DEFINITION_BODY_SOURCE_MAX_CHARS, BODY_TRUNCATION_MARKER, esbuildTransformSyncPromise;
 var init_loader2 = __esm({
   "lib/testCases/loader.ts"() {
     init_define();
     init_authoringSurface();
     init_utils();
     CODE_EXTENSIONS = [".ts", ".js", ".mjs"];
+    DEFINITION_BODY_SOURCE_MAX_CHARS = 32 * 1024;
+    BODY_TRUNCATION_MARKER = "\n/* \u2026 truncated \u2014 see whole file \u2026 */";
   }
 });
 
@@ -5619,6 +5811,10 @@ async function startServer(options) {
         if (err.code === "EADDRINUSE" && port <= options.port + MAX_PORT_ATTEMPTS) {
           console.log(`  Port ${port} is in use, trying ${port + 1}...`);
           resolve10(tryListen(port + 1));
+        } else if (err.code === "EADDRINUSE") {
+          reject(new Error(
+            `Port ${port} is in use and all fallback ports (${options.port}-${options.port + MAX_PORT_ATTEMPTS}) are occupied. Set AH_PORT=<available-port> to use a different port: \`AH_PORT=8001 npx @opensearch-project/agent-health\``
+          ));
         } else {
           reject(err);
         }
@@ -6579,6 +6775,25 @@ var ApiClient = class {
     }
     return res.json();
   }
+  /**
+   * Union test case ids into a benchmark's top-level testCaseIds AND its
+   * current version's testCaseIds, in place (no version bump). Server-side
+   * counterpart of services/benchmarkPromotion.ts:linkTestCaseIdsToBenchmark
+   * — used by `benchmark repair-links --apply` to backfill benchmarks whose
+   * current version's testCaseIds fell behind the top level.
+   */
+  async linkBenchmarkTestCaseIds(id, testCaseIds) {
+    const res = await fetch(`${this.baseUrl}/api/storage/benchmarks/${id}/link-test-case-ids`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ testCaseIds })
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Failed to link test case ids to benchmark: ${errorBody}`);
+    }
+    return res.json();
+  }
   /**
    * Fetch traces from OpenSearch with optional filters
    */
@@ -7510,6 +7725,7 @@ function calculateRunStats(run, reports) {
   let failed = 0;
   let pending = 0;
   let errored = 0;
+  let notRun = 0;
   let total = 0;
   Object.entries(run.results || {}).forEach(([testCaseId, result]) => {
     total++;
@@ -7517,7 +7733,11 @@ function calculateRunStats(run, reports) {
       pending++;
       return;
     }
-    if (result.status === "failed" || result.status === "cancelled") {
+    if (result.status === "cancelled") {
+      notRun++;
+      return;
+    }
+    if (result.status === "failed") {
       failed++;
       return;
     }
@@ -7544,13 +7764,14 @@ function calculateRunStats(run, reports) {
       pending++;
     }
   });
-  const evaluable = Math.max(0, total - errored);
+  const evaluable = Math.max(0, total - errored - notRun);
   const passRate = evaluable > 0 ? Math.round(passed / evaluable * 100) : 0;
   return {
     passed,
     failed,
     pending,
     errored,
+    notRun,
     total,
     passRate
   };
@@ -7734,7 +7955,8 @@ async function applyDoctorPlan(api, plan) {
   return result;
 }
 async function migrateBenchmarksToImages(api, baseUrl, opts = {}) {
-  const result = { migrated: [], skipped: [], errors: [] };
+  const dryRun = opts.dryRun !== false;
+  const result = { dryRun, migrated: [], skipped: [], errors: [] };
   let benchmarks2 = await api.listBenchmarks();
   if (opts.benchmarkIds) {
     const allow = new Set(opts.benchmarkIds);
@@ -7753,7 +7975,7 @@ async function migrateBenchmarksToImages(api, baseUrl, opts = {}) {
       const res = await fetch(`${baseUrl}/api/storage/images`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ testCaseIds: b.testCaseIds, tags: [b.name] })
+        body: JSON.stringify({ testCaseIds: b.testCaseIds, tags: [b.name], dryRun })
       });
       if (!res.ok) {
         result.errors.push(`${b.name}: ${await res.text()}`);
@@ -7765,11 +7987,13 @@ async function migrateBenchmarksToImages(api, baseUrl, opts = {}) {
         benchmarkId: b.id,
         name: b.name,
         digest: body.image.digest,
+        ...dryRun ? { alreadyExists: body.alreadyExists === true } : {},
+        ...dryRun && Array.isArray(body.wouldAddTags) && body.wouldAddTags.length > 0 ? { wouldAddTags: body.wouldAddTags } : {},
         ...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(", ")}`
+          `${b.name}: ${dryRun ? "would migrate" : "migrated"} from a PARTIAL test-case set \u2014 missing ${missingTestCaseIds.length} id(s): ${missingTestCaseIds.join(", ")}`
         );
       }
     } catch (e) {
@@ -7816,14 +8040,14 @@ function printPlan(plan) {
   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) => {
+  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", "Preview (or, with --apply, execute) converting 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;
+    const isReadOnly = !options.apply;
     config.server.readOnly = isReadOnly;
     const serverResult = await ensureServer(config.server);
     const cleanup = createServerCleanup(serverResult, false);
@@ -7854,18 +8078,23 @@ function createBenchmarkDoctorCommand() {
         console.log(chalk4.gray("  Dry-run only. Re-run with --apply to execute.\n"));
       }
       if (options.migrateImages) {
-        const migration = await migrateBenchmarksToImages(api, serverResult.baseUrl);
+        const migration = await migrateBenchmarksToImages(api, serverResult.baseUrl, { dryRun: !options.apply });
         if (isJson) {
           jsonOutput.migration = migration;
         } else {
-          console.log(chalk4.bold("  Image migration:"));
+          console.log(chalk4.bold(migration.dryRun ? "  Image migration plan (dry-run):" : "  Image migration:"));
           for (const m2 of migration.migrated) {
-            console.log(chalk4.green(`    \u2713 ${m2.name} \u2192 ${m2.digest.slice(0, 12)}`));
+            const verb = migration.dryRun ? m2.alreadyExists ? m2.wouldAddTags?.length ? "= already an image, would add tag(s)" : "= already an image, no change" : "+ would create" : "\u2713";
+            const tagSuffix = migration.dryRun && m2.wouldAddTags?.length ? ` [${m2.wouldAddTags.join(", ")}]` : "";
+            console.log(chalk4.green(`    ${verb} ${m2.name} \u2192 ${m2.digest.slice(0, 12)}${tagSuffix}`));
           }
           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}`));
+          if (migration.dryRun && migration.migrated.length > 0) {
+            console.log(chalk4.gray("    Dry-run only. Re-run with --migrate-images --apply to execute."));
+          }
           console.log();
         }
       }
@@ -7882,6 +8111,60 @@ function createBenchmarkDoctorCommand() {
   });
 }
 
+// cli/utils/benchmarkDoctor.ts
+function computeBenchmarkRepairPlan(benchmark, evaluationRuns) {
+  const existing = new Set(benchmark.testCaseIds || []);
+  const missing = /* @__PURE__ */ new Set();
+  const affectedRunIds = [];
+  for (const run of evaluationRuns) {
+    if (run.benchmarkId !== benchmark.id) continue;
+    let runHasMissing = false;
+    for (const snapshot of run.testCaseSnapshots || []) {
+      if (snapshot?.id && !existing.has(snapshot.id)) {
+        missing.add(snapshot.id);
+        runHasMissing = true;
+      }
+    }
+    if (runHasMissing) affectedRunIds.push(run.id);
+  }
+  if (missing.size === 0) return null;
+  return {
+    benchmarkId: benchmark.id,
+    benchmarkName: benchmark.name,
+    missingTestCaseIds: Array.from(missing),
+    affectedRunIds
+  };
+}
+function applyRepairPlan(existingTestCaseIds, plan) {
+  const existing = new Set(existingTestCaseIds || []);
+  const result = [...existingTestCaseIds];
+  for (const id of plan.missingTestCaseIds) {
+    if (!existing.has(id)) {
+      existing.add(id);
+      result.push(id);
+    }
+  }
+  return result;
+}
+function computeVersionLinkRepairPlan(benchmark) {
+  const topLevelIds = benchmark.testCaseIds || [];
+  if (topLevelIds.length === 0) return null;
+  const versions = benchmark.versions || [];
+  if (versions.length === 0) return null;
+  const currentVersion = benchmark.currentVersion ?? 1;
+  const currentEntry = versions.find((v) => v.version === currentVersion) || versions[versions.length - 1];
+  const existing = new Set(currentEntry?.testCaseIds || []);
+  const missing = topLevelIds.filter((id) => !existing.has(id));
+  if (missing.length === 0) return null;
+  return {
+    benchmarkId: benchmark.id,
+    benchmarkName: benchmark.name,
+    currentVersion: currentEntry?.version ?? currentVersion,
+    missingTestCaseIds: missing,
+    needsManualReview: versions.length > 1
+  };
+}
+
 // cli/commands/benchmark.ts
 function findAgent2(identifier, config) {
   return config.agents.find(
@@ -7891,6 +8174,16 @@ function findAgent2(identifier, config) {
 function getDefaultModel2(config) {
   return Object.keys(config.models)[0] || "claude-sonnet";
 }
+function resolveDefaultAgentKey(config) {
+  const enabledAgent = config.agents.find((a) => a.enabled !== false);
+  if (!enabledAgent) {
+    console.error(chalk5.red("  Error: No enabled agents found."));
+    process.exit(1);
+    throw new Error("No enabled agents found (process.exit(1) did not terminate the process).");
+  }
+  console.log(chalk5.gray(`  Agent: ${enabledAgent.name} (default)`));
+  return enabledAgent.key;
+}
 function isFilePath(value) {
   return value.toLowerCase().endsWith(".json") || isCodeFile(value);
 }
@@ -8215,13 +8508,7 @@ async function runUnifiedMode(options, config, serverConfig, isCI, fileArray) {
   const api = new ApiClient(serverResult.baseUrl);
   let agentKey;
   if (options.agent.length === 0) {
-    const enabledAgent = config.agents.find((a) => a.enabled !== false);
-    if (!enabledAgent) {
-      console.error(chalk5.red("  Error: No enabled agents found."));
-      process.exit(1);
-    }
-    agentKey = enabledAgent.key;
-    console.log(chalk5.gray(`  Agent: ${enabledAgent.name} (default)`));
+    agentKey = resolveDefaultAgentKey(config);
   } else {
     agentKey = options.agent[0];
     console.log(chalk5.gray(`  Agent: ${agentKey}`));
@@ -8488,6 +8775,10 @@ function createBenchmarkCommand() {
                 sourceCode: loaded2.fileSource,
                 sourceFileName,
                 sourceLanguage,
+                // Per-test slice of the above: THIS test's resolved
+                // options + evaluate body. Lets the run report show one
+                // test's definition instead of the whole file.
+                definition: tc.definition,
                 description: tc.options.description,
                 // Forward expectedOutcomes / expectedTrajectory — see
                 // services/sourceResolver.ts for rationale. Without
@@ -8755,8 +9046,106 @@ function createBenchmarkCommand() {
       cleanup();
     }
   });
+  command.addCommand(createBenchmarkLinkRepairCommand());
   return command;
 }
+function createBenchmarkLinkRepairCommand() {
+  return new Command4("repair-links").description("Detect benchmarks whose testCaseIds are out of sync (run-referenced ids missing from testCaseIds, or testCaseIds missing from the current version) \u2014 use --apply to fix").option("--apply", "Apply the repair (default: dry-run, report only)").option("--stop-server", "Stop the server after the check completes (default: keep running)").action(async (options) => {
+    console.log(chalk5.bold("\nAgent Health - Benchmark Link Repair\n"));
+    const config = await loadConfig();
+    const serverConfig = { ...DEFAULT_SERVER_CONFIG, ...config.server };
+    const isCI = !!process.env.CI;
+    const connectSpinner = ora2("Connecting to server...").start();
+    let serverResult;
+    let cleanup;
+    try {
+      serverResult = await ensureServer(serverConfig);
+      cleanup = createServerCleanup(serverResult, isCI || options.stopServer);
+      connectSpinner.succeed(serverResult.wasStarted ? `Started server on port ${serverConfig.port}` : `Connected to existing server on port ${serverConfig.port}`);
+    } catch (error) {
+      connectSpinner.fail(`Failed to connect: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+    const api = new ApiClient(serverResult.baseUrl);
+    try {
+      const benchmarks2 = await api.listBenchmarks();
+      let shellFlagged = 0;
+      let shellRepaired = 0;
+      let versionFlagged = 0;
+      let versionRepaired = 0;
+      let versionNeedsReview = 0;
+      for (let bm of benchmarks2) {
+        let evaluationRuns = [];
+        try {
+          const res = await fetch(
+            `${serverResult.baseUrl}/api/storage/evaluation-runs?benchmarkId=${encodeURIComponent(bm.id)}&size=500`
+          );
+          if (res.ok) {
+            const data = await res.json();
+            evaluationRuns = data.evaluationRuns || [];
+          }
+        } catch {
+        }
+        if (evaluationRuns.length > 0) {
+          const shellPlan = computeBenchmarkRepairPlan(bm, evaluationRuns);
+          if (shellPlan) {
+            shellFlagged++;
+            console.log("");
+            console.log(chalk5.yellow(`  Stale shell: ${shellPlan.benchmarkName} (${shellPlan.benchmarkId})`));
+            console.log(chalk5.gray(`    ${shellPlan.missingTestCaseIds.length} test case id(s) missing from testCaseIds, referenced by ${shellPlan.affectedRunIds.length} run(s)`));
+            console.log(chalk5.gray(`    Missing: ${shellPlan.missingTestCaseIds.join(", ")}`));
+            if (options.apply) {
+              const newTestCaseIds = applyRepairPlan(bm.testCaseIds || [], shellPlan);
+              await api.updateBenchmark(bm.id, { testCaseIds: newTestCaseIds });
+              shellRepaired++;
+              console.log(chalk5.green(`    \u2713 Repaired: testCaseIds now has ${newTestCaseIds.length} id(s)`));
+              const refreshed = await api.getBenchmark(bm.id);
+              if (refreshed) bm = refreshed;
+            }
+          }
+        }
+        const versionPlan = computeVersionLinkRepairPlan(bm);
+        if (versionPlan) {
+          versionFlagged++;
+          console.log("");
+          console.log(chalk5.yellow(`  Stale version: ${versionPlan.benchmarkName} (${versionPlan.benchmarkId})`));
+          console.log(chalk5.gray(`    v${versionPlan.currentVersion}'s testCaseIds is missing ${versionPlan.missingTestCaseIds.length} id(s) present at the top level`));
+          console.log(chalk5.gray(`    Missing: ${versionPlan.missingTestCaseIds.join(", ")}`));
+          if (versionPlan.needsManualReview) {
+            versionNeedsReview++;
+            console.log(chalk5.red("    \u26A0 Skipped: this benchmark has more than one version. The top-level"));
+            console.log(chalk5.red("      testCaseIds can contain ids from an OLDER version's runs (see"));
+            console.log(chalk5.red("      cli/utils/benchmarkDoctor.ts) -- copying them into the CURRENT"));
+            console.log(chalk5.red("      version could mix in test cases that do not belong to it. Review"));
+            console.log(chalk5.red(`      manually: POST /api/storage/benchmarks/${versionPlan.benchmarkId}/link-test-case-ids`));
+            console.log(chalk5.red("      with the exact ids you intend for the current version, or edit the"));
+            console.log(chalk5.red("      benchmark in the UI."));
+          } else if (options.apply) {
+            const { benchmark: repaired } = await api.linkBenchmarkTestCaseIds(bm.id, bm.testCaseIds || []);
+            versionRepaired++;
+            const fixedVersion = (repaired.versions || []).find((v) => v.version === (repaired.currentVersion ?? versionPlan.currentVersion));
+            console.log(chalk5.green(`    \u2713 Repaired: v${versionPlan.currentVersion}'s testCaseIds now has ${fixedVersion?.testCaseIds?.length ?? "?"} id(s)`));
+          }
+        }
+      }
+      const flagged = shellFlagged + versionFlagged;
+      console.log("");
+      if (flagged === 0) {
+        console.log(chalk5.green("  All benchmarks healthy \u2014 no missing test case links found."));
+      } else if (options.apply) {
+        console.log(chalk5.green(`  Repaired ${shellRepaired}/${shellFlagged} stale shell benchmark(s), ${versionRepaired}/${versionFlagged - versionNeedsReview} stale version benchmark(s).`));
+        if (versionNeedsReview > 0) {
+          console.log(chalk5.red(`  ${versionNeedsReview} multi-version benchmark(s) need manual review (not auto-repaired) -- see above.`));
+        }
+      } else {
+        console.log(chalk5.yellow(`  Found ${shellFlagged} stale shell benchmark(s), ${versionFlagged} stale version benchmark(s) (${versionNeedsReview} of which need manual review, not auto-fixable).`));
+        console.log(chalk5.gray("  Re-run with --apply to fix the auto-fixable ones."));
+      }
+    } finally {
+      cleanup();
+    }
+  });
+}
 
 // cli/commands/export.ts
 init_config2();
@@ -8834,6 +9223,7 @@ function createReportCommand() {
         `Failed to connect to server: ${error instanceof Error ? error.message : error}`
       );
       process.exit(1);
+      return;
     }
     const api = new ApiClient(serverResult.baseUrl);
     try {
@@ -8846,6 +9236,7 @@ function createReportCommand() {
         console.log(chalk7.gray("    npx agent-health list benchmarks"));
         console.log("");
         process.exit(1);
+        return;
       }
       spinner.succeed(`Found benchmark: ${benchmark.name} (${benchmark.id})`);
       const params = new URLSearchParams({ format: options.format });
@@ -8859,6 +9250,7 @@ function createReportCommand() {
         const errorBody = await response.json().catch(() => ({ error: "Unknown error" }));
         reportSpinner.fail(`Report generation failed: ${errorBody.error}`);
         process.exit(1);
+        return;
       }
       const contentDisposition = response.headers.get("content-disposition") || "";
       const filenameMatch = contentDisposition.match(/filename="([^"]+)"/);