@elench/testkit 0.1.96 → 0.1.98

package/lib/app/browser-bridge.mjs

@@ -1,6 +1,6 @@
 import { loadConfigContext, resolveProductDir } from "../config/index.mjs";
 import { discoverTests } from "../discovery/index.mjs";
-import { loadCurrentRunArtifact } from "../cli/viewer.mjs";
+import { loadCurrentRunArtifact } from "../results/artifacts.mjs";
 
 export async function loadBrowserBridgeContext(options = {}) {
   const productDir = resolveProductDir(process.cwd(), options.dir);

package/lib/cli/assistant/app.mjs

@@ -1,7 +1,8 @@
-import React, { createElement, useEffect, useMemo, useState } from "react";
-import { Box, Text, useApp, useInput, useStdout } from "ink";
-import { bold, cyan, dim, green, red, yellow } from "../presentation/colors.mjs";
-import { getComposerRenderParts } from "./composer.mjs";
+import React, { createElement, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useBoxMetrics, useCursor, useInput, useStdout } from "ink";
+import { bold, cyan, dim, green, red, yellow } from "../terminal/colors.mjs";
+import { RunTreeView } from "../components/blocks/run-tree.mjs";
+import { getComposerDisplayModel } from "./composer.mjs";
 import { buildAssistantViewModel } from "./view-model.mjs";
 
 const MAX_BLOCK_LINES = 18;
@@ -49,6 +50,7 @@ export function AssistantApp({
     }),
     [snapshot, stdout?.columns]
   );
+  const runSession = assistantState.getLiveRunSession?.() || assistantState.getLastRunSession?.() || null;
 
   return createElement(
     Box,
@@ -63,6 +65,28 @@ export function AssistantApp({
     view.blocks.length === 0
       ? createElement(WelcomePanel, { view })
       : createElement(Transcript, { view }),
+    runSession
+      ? createElement(
+          Box,
+          { flexDirection: "column", marginTop: 1 },
+          createElement(Text, null, bold("Run Session")),
+          createElement(
+            Box,
+            {
+              borderStyle: "round",
+              flexDirection: "column",
+              paddingLeft: 1,
+              paddingRight: 1,
+            },
+            createElement(RunTreeView, {
+              runState: runSession.runState,
+              stdout,
+              productDir: runSession.productDir,
+              interactive: false,
+            })
+          )
+        )
+      : null,
     createElement(Text, null, ""),
     createElement(ComposerBar, { view, busy: snapshot.busy }),
     createElement(Text, null, dim(view.statusLine)),
@@ -177,15 +201,30 @@ function renderBlock(block) {
 }
 
 function ComposerBar({ view, busy }) {
-  const { before, current, after, empty } = getComposerRenderParts({
-    text: view.composer.text,
-    cursor: view.composer.cursor,
-  });
+  const ref = useRef(null);
+  const metrics = useBoxMetrics(ref);
+  const { setCursorPosition } = useCursor();
+  const display = getComposerDisplayModel(
+    {
+      text: view.composer.text,
+      cursor: view.composer.cursor,
+    },
+    { placeholder: view.composer.placeholder }
+  );
+  setCursorPosition(
+    metrics.hasMeasured
+      ? {
+          x: 2 + display.cursorColumn,
+          y: metrics.top + 1,
+        }
+      : undefined
+  );
+
   const prompt = cyan("❯");
-  const promptText = empty ? dim(`${view.composer.placeholder} `) : before;
   return createElement(
     Box,
     {
+      ref,
       borderStyle: "single",
       borderLeft: false,
       borderRight: false,
@@ -196,9 +235,7 @@ function ComposerBar({ view, busy }) {
       Text,
       null,
       `${prompt} `,
-      promptText,
-      createElement(Text, { inverse: true }, current),
-      after,
+      display.empty ? dim(display.placeholder) : display.text,
       busy ? dim("  provider responding") : ""
     )
   );

package/lib/cli/assistant/composer.mjs

@@ -1,3 +1,5 @@
+import { measureWidth } from "../terminal/layout.mjs";
+
 const segmenter =
   typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
     ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
@@ -81,14 +83,30 @@ export function moveComposerCursorToEnd(state) {
 export function getComposerRenderParts(state) {
   const parts = splitGraphemes(state?.text || "");
   const cursor = clampCursor(state?.cursor ?? parts.length, parts.length);
+  const before = parts.slice(0, cursor).join("");
   return {
-    before: parts.slice(0, cursor).join(""),
+    before,
     current: parts[cursor] || " ",
     after: parts.slice(cursor + (parts[cursor] ? 1 : 0)).join(""),
     empty: parts.length === 0,
   };
 }
 
+export function getComposerDisplayModel(state, { placeholder = "" } = {}) {
+  const parts = splitGraphemes(state?.text || "");
+  const cursor = clampCursor(state?.cursor ?? parts.length, parts.length);
+  const before = parts.slice(0, cursor).join("");
+  const text = parts.join("");
+  return {
+    text,
+    before,
+    after: parts.slice(cursor).join(""),
+    cursorColumn: measureWidth(before),
+    placeholder: String(placeholder || ""),
+    empty: parts.length === 0,
+  };
+}
+
 function normalizeComposerState(state) {
   const text = String(state?.text || "");
   const parts = splitGraphemes(text);

package/lib/cli/assistant/context-pack.mjs

@@ -1,11 +1,11 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { readContextContent, buildContextSelection } from "../context-resources.mjs";
+import { readContextContent, buildContextSelection } from "../../results/context.mjs";
 
 export function prepareAssistantContextPack({
   productDir,
-  inspectState,
+  runState,
 } = {}) {
   const contextDir = path.join(productDir, ".testkit", "assistant");
   const binDir = path.join(contextDir, "bin");
@@ -23,7 +23,7 @@ export function prepareAssistantContextPack({
   const wrapperPath = path.join(binDir, "testkit");
 
   function refresh() {
-    const snapshot = inspectState?.getSnapshot?.() || {};
+    const snapshot = runState?.getSnapshot?.() || {};
     const detailContent = readContextContent({ productDir, snapshot, mode: "detail", logTail: 12 });
     const logsContent = readContextContent({ productDir, snapshot, mode: "logs", logTail: 12 });
     const artifactsContent = readContextContent({ productDir, snapshot, mode: "artifacts", logTail: 12 });
@@ -160,9 +160,8 @@ function buildContextMarkdown(productDir, snapshot, paths) {
   lines.push(
     "",
     "## Guidance",
-    "- Use the local `testkit` command directly when you need to execute or inspect tests.",
-    "- Preferred commands: `testkit run --dir . --type <type>`, `testkit discover --dir .`, `testkit status --dir .`, and `testkit doctor --dir .`.",
-    "- Do not launch testkit through pnpm, npm, yarn, bun, or npx unless the user explicitly asks for that exact package-manager command.",
+    "- Use dedicated testkit tools for run/discover/status/doctor/typecheck actions before falling back to generic shell commands.",
+    "- Do not reinterpret CLI syntax after an execution failure unless `testkit run --help` confirms a syntax problem.",
     "- Use the command log and focused context files before rereading artifacts manually.",
     "- Prefer repo-local commands over guessing project-specific wrappers.",
     ""
@@ -175,13 +174,15 @@ function buildCommandsMarkdown() {
   return [
     "# Testkit Commands",
     "",
-    "- `testkit run --dir . --type int`",
-    "- `testkit run --dir . --type e2e`",
+    "- `testkit run int --dir .`",
+    "- `testkit run e2e --dir .`",
     "- `testkit run --dir . --file path/to/file.testkit.ts`",
     "- `testkit discover --dir .`",
     "- `testkit status --dir .`",
     "- `testkit doctor --dir .`",
     "- `testkit destroy --dir .`",
+    "- `npm run testkit`",
+    "- `npx testkit run e2e --dir .`",
     "",
   ].join("\n");
 }

package/lib/cli/assistant/interactive.mjs

@@ -2,7 +2,7 @@ import React, { createElement } from "react";
 import { render } from "ink";
 import { createAssistantState } from "./state.mjs";
 import { AssistantApp } from "./app.mjs";
-import { loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { loadLatestRunArtifact, resolveFileSubject } from "../../results/artifacts.mjs";
 
 export async function runInteractiveAssistant({
   productDir,

package/lib/cli/assistant/model-discovery.mjs

@@ -0,0 +1,243 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execaCommand } from "execa";
+
+const CLAUDE_ALIASES = ["default", "best", "sonnet", "opus", "haiku", "opusplan", "sonnet[1m]", "opus[1m]"];
+const CACHE_MAX_AGE_MS = 5 * 60 * 1000;
+
+export async function discoverAssistantModels({
+  provider,
+  productDir = process.cwd(),
+  env = process.env,
+} = {}) {
+  const resolvedProvider = String(provider || "").trim();
+  if (resolvedProvider === "codex") {
+    return discoverCodexModels({ productDir, env });
+  }
+  if (resolvedProvider === "claude") {
+    return discoverClaudeModels({ productDir, env });
+  }
+  return {
+    provider: resolvedProvider || "unknown",
+    source: "none",
+    models: [providerDefaultModel()],
+    warnings: ["No provider is resolved yet."],
+  };
+}
+
+export async function discoverCodexModels({ productDir = process.cwd(), env = process.env } = {}) {
+  const cachePath = path.join(productDir, ".testkit", "assistant", "model-cache-codex.json");
+  const cached = readFreshCache(cachePath);
+  if (cached) return cached;
+
+  const command = env.TESTKIT_CODEX_BIN || "codex";
+  let catalog = null;
+  let warning = null;
+  try {
+    const result = await execaCommand(`${shellQuote(command)} debug models`, {
+      cwd: productDir,
+      reject: false,
+      shell: true,
+      env: { ...process.env, ...env },
+    });
+    if ((result.exitCode ?? 1) === 0) {
+      catalog = JSON.parse(result.stdout || "{}");
+    } else {
+      warning = (result.stderr || result.stdout || "codex debug models failed").trim();
+    }
+  } catch (error) {
+    warning = error instanceof Error ? error.message : String(error);
+  }
+
+  if (!catalog) {
+    catalog = readJson(path.join(os.homedir(), ".codex", "models_cache.json"));
+  }
+
+  const models = normalizeCodexModels(catalog);
+  const discovery = {
+    provider: "codex",
+    source: catalog ? "codex debug models" : "fallback",
+    models: [providerDefaultModel(), ...models],
+    warnings: warning && models.length === 0 ? [warning] : [],
+  };
+  writeCache(cachePath, discovery);
+  return discovery;
+}
+
+export async function discoverClaudeModels({ productDir = process.cwd(), env = process.env } = {}) {
+  const configured = readClaudeAvailableModels({ productDir });
+  const apiModels = await fetchAnthropicModels({ env });
+  const dynamicModels = apiModels.map((model) => ({
+    id: model.id,
+    label: model.displayName || model.id,
+    description: model.description || "",
+    source: "anthropic api",
+    concrete: true,
+  }));
+  const aliasModels = CLAUDE_ALIASES.map((id) => ({
+    id: id === "default" ? null : id,
+    label: id === "default" ? "provider default" : id,
+    description: id === "default" ? "Use Claude Code's selected default model." : "Claude Code model alias.",
+    source: "claude alias",
+    concrete: false,
+  }));
+
+  const merged = dedupeModels([...aliasModels, ...dynamicModels]);
+  const restricted = configured.length > 0
+    ? merged.filter((model) => model.id == null || configured.includes(model.id))
+    : merged;
+
+  return {
+    provider: "claude",
+    source: apiModels.length > 0 ? "anthropic api" : "claude aliases",
+    models: restricted,
+    warnings: apiModels.length > 0
+      ? []
+      : ["Claude Code does not expose a scriptable model catalog; showing stable aliases."],
+  };
+}
+
+export function normalizeCodexModels(catalog) {
+  const rawModels = Array.isArray(catalog?.models) ? catalog.models : [];
+  return rawModels
+    .filter((model) => model?.slug && (model.visibility == null || model.visibility === "list"))
+    .sort((a, b) => Number(a.priority ?? 999) - Number(b.priority ?? 999))
+    .map((model) => ({
+      id: String(model.slug),
+      label: String(model.display_name || model.slug),
+      description: String(model.description || ""),
+      source: "codex catalog",
+      concrete: true,
+      defaultEffort: model.default_reasoning_level || null,
+      efforts: Array.isArray(model.supported_reasoning_levels)
+        ? model.supported_reasoning_levels.map((entry) => entry.effort).filter(Boolean)
+        : [],
+    }));
+}
+
+export function getModelProviderMismatch(provider, model) {
+  const normalizedModel = String(model || "").trim().toLowerCase();
+  if (!provider || !normalizedModel) return null;
+
+  const looksClaude = /\b(?:opus|sonnet|haiku|claude|opusplan|best)\b/.test(normalizedModel);
+  const looksCodex = /\b(?:gpt|codex|o[1-9]|chatgpt)\b/.test(normalizedModel);
+
+  if (provider === "codex" && looksClaude) {
+    return `Model "${model}" looks like a Claude model, but the assistant is using Codex. Run /provider claude or /model default.`;
+  }
+  if (provider === "claude" && looksCodex) {
+    return `Model "${model}" looks like a Codex/OpenAI model, but the assistant is using Claude. Run /provider codex or /model default.`;
+  }
+  return null;
+}
+
+export function formatModelChoices(discovery, { currentModel = null } = {}) {
+  const current = currentModel || "provider default";
+  const lines = [
+    `Models for ${discovery.provider}`,
+    `Current: ${current}`,
+    "",
+    ...discovery.models.map((model) => {
+      const command = model.id ? `/model ${model.id}` : "/model default";
+      const marker = (model.id || null) === (currentModel || null) ? "*" : " ";
+      return `${marker} ${model.label}  ${command}`;
+    }),
+    "  custom...  /model custom <model>",
+  ];
+  for (const warning of discovery.warnings || []) {
+    lines.push("", `Note: ${warning}`);
+  }
+  return lines.join("\n");
+}
+
+export function providerDefaultModel() {
+  return {
+    id: null,
+    label: "provider default",
+    description: "Use the provider CLI default model.",
+    source: "provider default",
+    concrete: false,
+  };
+}
+
+function readFreshCache(filePath) {
+  const value = readJson(filePath);
+  if (!value?.fetchedAt || !Array.isArray(value.models)) return null;
+  if (Date.now() - Date.parse(value.fetchedAt) > CACHE_MAX_AGE_MS) return null;
+  return value;
+}
+
+function writeCache(filePath, discovery) {
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify({ ...discovery, fetchedAt: new Date().toISOString() }, null, 2), "utf8");
+  } catch {
+    // Model discovery is best-effort.
+  }
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function readClaudeAvailableModels({ productDir }) {
+  const paths = [
+    path.join(os.homedir(), ".claude", "settings.json"),
+    path.join(productDir, ".claude", "settings.json"),
+  ];
+  const models = [];
+  for (const filePath of paths) {
+    const settings = readJson(filePath);
+    const available = settings?.availableModels || settings?.model?.availableModels;
+    if (Array.isArray(available)) models.push(...available.map((entry) => String(entry).trim()).filter(Boolean));
+  }
+  return [...new Set(models)];
+}
+
+async function fetchAnthropicModels({ env }) {
+  const apiKey = env.ANTHROPIC_API_KEY;
+  if (!apiKey || typeof fetch !== "function") return [];
+  try {
+    const response = await fetch("https://api.anthropic.com/v1/models", {
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+    });
+    if (!response.ok) return [];
+    const body = await response.json();
+    const data = Array.isArray(body?.data) ? body.data : [];
+    return data
+      .filter((entry) => entry?.id)
+      .map((entry) => ({
+        id: String(entry.id),
+        displayName: String(entry.display_name || entry.id),
+        description: entry.created_at ? `Created ${entry.created_at}` : "",
+      }));
+  } catch {
+    return [];
+  }
+}
+
+function dedupeModels(models) {
+  const seen = new Set();
+  const result = [];
+  for (const model of models) {
+    const key = model.id || "__default__";
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(model);
+  }
+  return result;
+}
+
+function shellQuote(value) {
+  const text = String(value);
+  if (/^[a-zA-Z0-9._:/-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}

package/lib/cli/assistant/prompt-builder.mjs

@@ -1,4 +1,4 @@
-import { readContextContent } from "../context-resources.mjs";
+import { readContextContent } from "../../results/context.mjs";
 import { buildAssistantResponseContract } from "./protocol.mjs";
 
 export function buildAssistantPrompt({
@@ -16,11 +16,8 @@ export function buildAssistantPrompt({
     "You are Testkit Assistant.",
     "You help users run tests, inspect failures, read logs and artifacts, and navigate the current local test state.",
     "All user natural-language requests must be handled through your own reasoning plus the available tools.",
-    "Use shell_exec when the user asks to run tests or inspect the working repo.",
-    "For testkit work, invoke the local `testkit` command directly, for example `testkit run --dir . --type e2e` or `testkit discover --dir .`.",
-    "Do not wrap testkit with pnpm, npm, yarn, bun, or npx unless the user explicitly asks for that exact package-manager command.",
+    "Use the dedicated testkit tools for run/discover/status/doctor/typecheck actions; use shell_exec only for arbitrary repository commands outside those actions.",
     "Use read_context before repeating artifact/log inspection work, and use read_file/search_repo when you need codebase context.",
-    "After a tool result, describe only what the tool result actually says. Do not invent filesystem, sandbox, package-manager, or permission errors.",
     buildAssistantResponseContract({ tools }),
     "",
     "Current run summary:",

package/lib/cli/{agents → assistant}/providers/claude.mjs

@@ -4,6 +4,7 @@ import {
   buildStatusEvent,
   buildToolEvent,
   createHostedSessionRunner,
+  extractTextFragments,
 } from "./shared.mjs";
 
 export function startClaudeHostedSession({
@@ -50,8 +51,8 @@ export function startClaudeHostedSession({
     child,
     onEvent,
     parsePayload: parseClaudePayload,
-    readFinalText() {
-      return null;
+    readFinalText(result) {
+      return readClaudeFinalText(result?.stdout || "") || null;
     },
   });
 }
@@ -61,7 +62,7 @@ function normalizeProviderArgs(providerArgs) {
   return providerArgs.flatMap((arg) => String(arg || "").split(/\s+/).filter(Boolean));
 }
 
-function parseClaudePayload(payload) {
+export function parseClaudePayload(payload) {
   const events = [];
   if (!payload || typeof payload !== "object") return events;
 
@@ -102,6 +103,10 @@ function parseClaudePayload(payload) {
   }
 
   if (type === "assistant") {
+    const fragments = [...new Set(extractTextFragments(payload.message?.content || payload.content || [], []))];
+    for (const fragment of fragments) {
+      events.push({ type: "delta", text: fragment });
+    }
     return events;
   }
 
@@ -113,7 +118,40 @@ function parseClaudePayload(payload) {
     return events;
   }
 
+  if (type === "system" || type === "rate_limit_event") {
+    return events;
+  }
+
   const statusEvent = buildStatusEvent(type ? `Claude event: ${type}` : JSON.stringify(payload));
   if (statusEvent) events.push(statusEvent);
   return events;
 }
+
+export function readClaudeFinalText(stdout) {
+  const lines = String(stdout || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  let fallback = null;
+  for (const line of lines) {
+    let payload = null;
+    try {
+      payload = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!payload || typeof payload !== "object") continue;
+
+    if (payload.type === "result" && payload.subtype !== "error" && typeof payload.result === "string") {
+      return payload.result.trim() || null;
+    }
+
+    if (payload.type === "assistant") {
+      const fragments = [...new Set(extractTextFragments(payload.message?.content || payload.content || [], []))];
+      if (fragments.length > 0) fallback = fragments.join("");
+    }
+  }
+
+  return fallback;
+}

package/lib/cli/{agents → assistant}/providers/codex.mjs

@@ -22,17 +22,14 @@ export function startCodexHostedSession({
 } = {}) {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-codex-"));
   const outputFile = path.join(tempDir, "final-message.txt");
-  const args = ["exec", "--json", "-o", outputFile];
-
-  if (purpose === "assistant") {
-    args.push("-s", "read-only");
-  }
-  if (model) {
-    args.push("--model", String(model));
-  }
-  args.push(...normalizeProviderArgs(providerArgs));
-
-  args.push(prompt);
+  const args = buildCodexArgs({
+    outputFile,
+    purpose,
+    model,
+    providerArgs,
+    prompt,
+    sandbox: process.env.TESTKIT_CODEX_SANDBOX,
+  });
 
   const child = execa(command, args, {
     cwd,
@@ -51,7 +48,7 @@ export function startCodexHostedSession({
       return String(message || "").trim() === "Reading additional input from stdin...";
     },
     readFinalText(result) {
-      return readTextFileIfPresent(outputFile) || result.stdout || null;
+      return readTextFileIfPresent(outputFile) || null;
     },
   });
 
@@ -65,16 +62,38 @@ export function startCodexHostedSession({
   };
 }
 
+export function buildCodexArgs({
+  outputFile,
+  purpose = "assistant",
+  model = null,
+  providerArgs = [],
+  prompt = "",
+  sandbox = null,
+} = {}) {
+  const args = ["exec", "--json"];
+  if (outputFile) args.push("-o", outputFile);
+
+  if (purpose === "assistant") {
+    args.push("-s", String(sandbox || "workspace-write"));
+  }
+  if (model) {
+    args.push("--model", String(model));
+  }
+  args.push(...normalizeProviderArgs(providerArgs));
+  args.push(prompt);
+  return args;
+}
+
 function normalizeProviderArgs(providerArgs) {
   if (!Array.isArray(providerArgs)) return [];
   return providerArgs.flatMap((arg) => String(arg || "").split(/\s+/).filter(Boolean));
 }
 
-function parseCodexPayload(payload) {
+export function parseCodexPayload(payload) {
   const events = [];
   if (!payload || typeof payload !== "object") return events;
   const type = payload.type || payload.event || payload.kind || null;
-  const errorMessage = payload.error?.message || payload.error || null;
+  const errorMessage = payload.error?.message || payload.error || (type === "error" ? payload.message : null) || null;
   if (errorMessage) {
     const event = buildErrorEvent(errorMessage);
     if (event) events.push(event);

package/lib/cli/{agents → assistant/providers}/index.mjs

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
-import { startClaudeHostedSession } from "./providers/claude.mjs";
-import { startCodexHostedSession } from "./providers/codex.mjs";
+import { startClaudeHostedSession } from "./claude.mjs";
+import { startCodexHostedSession } from "./codex.mjs";
 
 const PROVIDERS = ["codex", "claude"];
 
@@ -55,7 +55,7 @@ export function isProviderInstalled(provider, env = process.env) {
   return false;
 }
 
-export function startAgentSession({
+export function startProviderSession({
   provider = "auto",
   model = null,
   effort = null,

package/lib/cli/{agents → assistant}/providers/shared.mjs

@@ -5,11 +5,15 @@ export function createHostedSessionRunner({ provider, child, onEvent, parsePaylo
   let cancelled = false;
   let settled = false;
   let assistantText = "";
+  let lastErrorMessage = null;
 
   const emit = (event) => {
     if (event?.type === "delta" || event?.type === "final") {
       assistantText += event.text || "";
     }
+    if (event?.type === "error") {
+      lastErrorMessage = event.message || lastErrorMessage;
+    }
     if (typeof onEvent === "function" && event) onEvent({ provider, ...event });
   };
 
@@ -36,8 +40,8 @@ export function createHostedSessionRunner({ provider, child, onEvent, parsePaylo
   const completion = (async () => {
     const result = await child;
     const finalText = (readFinalText ? readFinalText(result) : null) || assistantText.trim() || null;
-    if ((result.exitCode ?? 0) !== 0 && !finalText) {
-      const message = result.stderr || result.stdout || `${provider} exited with code ${result.exitCode ?? 1}`;
+    if ((result.exitCode ?? 0) !== 0) {
+      const message = lastErrorMessage || result.stderr || `${provider} exited with code ${result.exitCode ?? 1}`;
       emit({ type: "error", message });
       throw new Error(message);
     }