@elench/testkit 0.1.101 → 0.1.103

package/lib/cli/assistant/app.mjs

@@ -281,6 +281,9 @@ function colorWelcomeValue(label, value) {
 function colorMarker(block) {
   if (block.kind === "user") return cyan(block.marker);
   if (block.kind === "system") return red(block.marker);
+  if (block.kind === "provider-error") return red(block.marker);
+  if (block.kind === "provider-activity") return dim(block.marker);
+  if (block.kind === "provider-tool") return yellow(block.marker);
   if (block.kind === "tool-running") return yellow(block.marker);
   if (block.kind === "testkit-run") return green(block.marker);
   return block.marker;
@@ -289,6 +292,9 @@ function colorMarker(block) {
 function colorBlockText(block, text) {
   if (block.kind === "user") return text;
   if (block.kind === "system") return red(text);
+  if (block.kind === "provider-error") return red(text);
+  if (block.kind === "provider-activity") return dim(text);
+  if (block.kind === "provider-tool") return yellow(text);
   if (block.kind === "tool-running") return yellow(text);
   return text;
 }

package/lib/cli/assistant/providers/claude.mjs

@@ -4,14 +4,15 @@ import {
   buildStatusEvent,
   buildToolEvent,
   createHostedSessionRunner,
-  extractTextFragments,
 } from "./shared.mjs";
+import { providerAssistantDelta, providerAssistantFinal, providerToolStart } from "./events.mjs";
 
 export function startClaudeHostedSession({
   command = "claude",
   cwd,
   prompt,
   onEvent,
+  onRawLine,
   purpose = "assistant",
   model = null,
   effort = null,
@@ -49,6 +50,7 @@ export function startClaudeHostedSession({
     provider: "claude",
     child,
     onEvent,
+    onRawLine,
     parsePayload: parseClaudePayload,
     readFinalText(result) {
       return readClaudeFinalText(result?.stdout || "") || null;
@@ -77,7 +79,20 @@ export function parseClaudePayload(payload) {
     const streamEvent = payload.event || {};
     if (streamEvent.type === "content_block_delta" && streamEvent.delta?.type === "text_delta") {
       const text = String(streamEvent.delta.text || "");
-      if (text) events.push({ type: "delta", text });
+      const event = providerAssistantDelta(text);
+      if (event) events.push(event);
+      return events;
+    }
+    if (streamEvent.type === "content_block_start" && streamEvent.content_block?.type === "tool_use") {
+      const tool = streamEvent.content_block;
+      const event = providerToolStart(
+        tool.name || tool.tool_name || "tool_use",
+        {
+          id: tool.id || streamEvent.index,
+          input: tool.input || null,
+        }
+      );
+      if (event) events.push(event);
       return events;
     }
     if (streamEvent.type === "tool_use" || streamEvent.content_block?.type === "tool_use") {
@@ -102,10 +117,9 @@ export 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 });
-    }
+    const fragments = extractClaudeTextFragments(payload.message?.content || payload.content || []);
+    const event = providerAssistantFinal(fragments.join(""));
+    if (event) events.push(event);
     return events;
   }
 
@@ -113,6 +127,9 @@ export function parseClaudePayload(payload) {
     if (payload.is_error || payload.subtype === "error") {
       const event = buildErrorEvent(payload.result || payload.error || "Claude command failed");
       if (event) events.push(event);
+    } else if (typeof payload.result === "string") {
+      const event = providerAssistantFinal(payload.result);
+      if (event) events.push(event);
     }
     return events;
   }
@@ -147,10 +164,27 @@ export function readClaudeFinalText(stdout) {
     }
 
     if (payload.type === "assistant") {
-      const fragments = [...new Set(extractTextFragments(payload.message?.content || payload.content || [], []))];
+      const fragments = extractClaudeTextFragments(payload.message?.content || payload.content || []);
       if (fragments.length > 0) fallback = fragments.join("");
     }
   }
 
   return fallback;
 }
+
+function extractClaudeTextFragments(content) {
+  const entries = Array.isArray(content) ? content : [content];
+  const fragments = [];
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      const text = entry.trim();
+      if (text) fragments.push(text);
+      continue;
+    }
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.type !== "text") continue;
+    const text = String(entry.text || "").trim();
+    if (text) fragments.push(text);
+  }
+  return [...new Set(fragments)];
+}

package/lib/cli/assistant/providers/codex.mjs

@@ -4,18 +4,25 @@ import path from "path";
 import { execa } from "execa";
 import {
   buildErrorEvent,
-  buildStatusEvent,
   buildToolEvent,
   createHostedSessionRunner,
-  extractTextFragments,
   readTextFileIfPresent,
 } from "./shared.mjs";
+import {
+  providerAssistantDelta,
+  providerAssistantFinal,
+  providerStatus,
+  providerToolEnd,
+  providerToolStart,
+  providerToolUpdate,
+} from "./events.mjs";
 
 export function startCodexHostedSession({
   command = "codex",
   cwd,
   prompt,
   onEvent,
+  onRawLine,
   purpose = "assistant",
   model = null,
   providerArgs = [],
@@ -44,6 +51,7 @@ export function startCodexHostedSession({
     provider: "codex",
     child,
     onEvent,
+    onRawLine,
     parsePayload: parseCodexPayload,
     shouldIgnoreStatus(message) {
       return String(message || "").trim() === "Reading additional input from stdin...";
@@ -96,6 +104,48 @@ export function parseCodexPayload(payload) {
     return events;
   }
 
+  if (type === "thread.started") {
+    const event = providerStatus(
+      payload.thread_id ? `Codex thread ${payload.thread_id} started` : "Codex thread started",
+      { transient: true }
+    );
+    if (event) events.push(event);
+    return events;
+  }
+
+  if (type === "turn.started") {
+    const event = providerStatus("Codex turn started", { transient: true });
+    if (event) events.push(event);
+    return events;
+  }
+
+  if (type === "turn.completed") {
+    const event = providerStatus("Codex turn completed", { transient: true, usage: payload.usage || null });
+    if (event) events.push(event);
+    return events;
+  }
+
+  if (type === "item.started") {
+    const item = payload.item || {};
+    const event = codexItemStartedEvent(item);
+    if (event) events.push(event);
+    return events;
+  }
+
+  if (type === "item.updated") {
+    const item = payload.item || {};
+    const event = codexItemUpdatedEvent(item);
+    if (event) events.push(event);
+    return events;
+  }
+
+  if (type === "item.completed") {
+    const item = payload.item || {};
+    const event = codexItemCompletedEvent(item);
+    if (event) events.push(event);
+    return events;
+  }
+
   if (type && /(tool|command|patch|exec)/i.test(type)) {
     const event = buildToolEvent(
       payload.name || payload.tool_name || payload.command || type,
@@ -105,15 +155,73 @@ export function parseCodexPayload(payload) {
     return events;
   }
 
-  const fragments = [...new Set(extractTextFragments(payload, []))];
-  if (fragments.length > 0) {
-    for (const fragment of fragments) {
-      events.push({ type: "delta", text: fragment });
-    }
-    return events;
-  }
-
-  const statusEvent = buildStatusEvent(type ? `Codex event: ${type}` : JSON.stringify(payload));
+  const statusEvent = providerStatus(type ? `Codex event: ${type}` : JSON.stringify(payload));
   if (statusEvent) events.push(statusEvent);
   return events;
 }
+
+function codexItemStartedEvent(item) {
+  if (!item || typeof item !== "object") return null;
+  if (item.type === "command_execution") {
+    return providerToolStart("command", {
+      id: item.id || null,
+      input: item.command || item.input || null,
+    });
+  }
+  if (item.type === "tool_call") {
+    return providerToolStart(item.name || item.type, {
+      id: item.id || null,
+      input: item.arguments || item.input || null,
+    });
+  }
+  if (item.type === "agent_message") return providerStatus("Codex started response", { transient: true });
+  if (item.type) return providerStatus(`Codex started ${item.type}`);
+  return null;
+}
+
+function codexItemUpdatedEvent(item) {
+  if (!item || typeof item !== "object") return null;
+  if (item.type === "agent_message" && typeof item.text === "string") {
+    return providerAssistantDelta(item.text);
+  }
+  if (item.type === "command_execution") {
+    return providerToolUpdate("command", {
+      id: item.id || null,
+      text: item.output || item.status || null,
+      data: item,
+    });
+  }
+  if (item.type === "tool_call") {
+    return providerToolUpdate(item.name || item.type, {
+      id: item.id || null,
+      text: item.output || item.status || null,
+      data: item,
+    });
+  }
+  return null;
+}
+
+function codexItemCompletedEvent(item) {
+  if (!item || typeof item !== "object") return null;
+  if (item.type === "agent_message" && typeof item.text === "string") {
+    return providerAssistantFinal(item.text);
+  }
+  if (item.type === "command_execution") {
+    return providerToolEnd("command", {
+      id: item.id || null,
+      status: item.status === "failed" ? "error" : "ok",
+      output: item.output || null,
+      data: item,
+    });
+  }
+  if (item.type === "tool_call") {
+    return providerToolEnd(item.name || item.type, {
+      id: item.id || null,
+      status: item.status === "failed" ? "error" : "ok",
+      output: item.output || null,
+      data: item,
+    });
+  }
+  if (item.type) return providerStatus(`Codex completed ${item.type}`);
+  return null;
+}

package/lib/cli/assistant/providers/events.mjs

@@ -0,0 +1,71 @@
+export const PROVIDER_EVENT_TYPES = new Set([
+  "session-start",
+  "status",
+  "assistant-delta",
+  "assistant-final",
+  "tool-start",
+  "tool-update",
+  "tool-end",
+  "error",
+  "session-end",
+]);
+
+export function providerEvent(type, fields = {}) {
+  if (!PROVIDER_EVENT_TYPES.has(type)) {
+    throw new Error(`Unknown provider event type: ${type}`);
+  }
+  return {
+    type,
+    ...fields,
+  };
+}
+
+export function providerStatus(text, fields = {}) {
+  const normalized = normalizeText(text);
+  if (!normalized) return null;
+  return providerEvent("status", { text: normalized, ...fields });
+}
+
+export function providerAssistantDelta(text, fields = {}) {
+  if (!text) return null;
+  return providerEvent("assistant-delta", { text: String(text), ...fields });
+}
+
+export function providerAssistantFinal(text, fields = {}) {
+  const normalized = normalizeText(text);
+  if (!normalized) return null;
+  return providerEvent("assistant-final", { text: normalized, ...fields });
+}
+
+export function providerToolStart(name, fields = {}) {
+  const normalized = normalizeText(name);
+  if (!normalized) return null;
+  return providerEvent("tool-start", { name: normalized, ...fields });
+}
+
+export function providerToolUpdate(name, fields = {}) {
+  const normalized = normalizeText(name);
+  if (!normalized && !fields.text && !fields.data) return null;
+  return providerEvent("tool-update", { ...(normalized ? { name: normalized } : {}), ...fields });
+}
+
+export function providerToolEnd(name, fields = {}) {
+  const normalized = normalizeText(name);
+  if (!normalized) return null;
+  return providerEvent("tool-end", { name: normalized, status: fields.status || "ok", ...fields });
+}
+
+export function providerError(text, fields = {}) {
+  const normalized = normalizeText(text);
+  if (!normalized) return null;
+  return providerEvent("error", { text: normalized, ...fields });
+}
+
+export function providerSessionEnd(fields = {}) {
+  return providerEvent("session-end", fields);
+}
+
+export function normalizeText(value) {
+  const text = String(value || "").trim();
+  return text || null;
+}

package/lib/cli/assistant/providers/index.mjs

@@ -3,7 +3,7 @@ import path from "path";
 import { startClaudeHostedSession } from "./claude.mjs";
 import { startCodexHostedSession } from "./codex.mjs";
 
-const PROVIDERS = ["codex", "claude"];
+export const HOSTED_ASSISTANT_PROVIDERS = Object.freeze(["codex", "claude"]);
 
 export function resolvePreferredProvider(preferred = null, env = process.env) {
   if (preferred && preferred !== "auto") {
@@ -13,7 +13,7 @@ export function resolvePreferredProvider(preferred = null, env = process.env) {
     return preferred;
   }
 
-  for (const provider of PROVIDERS) {
+  for (const provider of HOSTED_ASSISTANT_PROVIDERS) {
     if (isProviderInstalled(provider, env)) return provider;
   }
   throw new Error("Neither codex nor claude was found on PATH");
@@ -63,13 +63,14 @@ export function startProviderSession({
   cwd,
   prompt,
   onEvent,
+  onRawLine,
   purpose = "assistant",
   env = process.env,
 } = {}) {
   const resolvedProvider = resolvePreferredProvider(provider, env);
   const command = resolveProviderBinary(resolvedProvider, env);
   if (resolvedProvider === "claude") {
-    return startClaudeHostedSession({ command, cwd, prompt, onEvent, purpose, model, effort, providerArgs, env });
+    return startClaudeHostedSession({ command, cwd, prompt, onEvent, onRawLine, purpose, model, effort, providerArgs, env });
   }
-  return startCodexHostedSession({ command, cwd, prompt, onEvent, purpose, model, providerArgs, env });
+  return startCodexHostedSession({ command, cwd, prompt, onEvent, onRawLine, purpose, model, providerArgs, env });
 }

package/lib/cli/assistant/providers/shared.mjs

@@ -1,29 +1,51 @@
 import fs from "fs";
 import readline from "readline";
+import {
+  providerError,
+  providerEvent,
+  providerSessionEnd,
+  providerStatus,
+  providerToolStart,
+} from "./events.mjs";
 
-export function createHostedSessionRunner({ provider, child, onEvent, parsePayload, readFinalText, shouldIgnoreStatus } = {}) {
+export function createHostedSessionRunner({
+  provider,
+  child,
+  onEvent,
+  onRawLine,
+  parsePayload,
+  readFinalText,
+  shouldIgnoreStatus,
+} = {}) {
   let cancelled = false;
   let settled = false;
   let assistantText = "";
+  let finalText = null;
   let lastErrorMessage = null;
 
   const emit = (event) => {
-    if (event?.type === "delta" || event?.type === "final") {
+    if (!event) return;
+    if (event.type === "assistant-delta") {
       assistantText += event.text || "";
     }
-    if (event?.type === "error") {
-      lastErrorMessage = event.message || lastErrorMessage;
+    if (event.type === "assistant-final") {
+      finalText = event.text || finalText;
+    }
+    if (event.type === "error") {
+      lastErrorMessage = event.text || lastErrorMessage;
     }
     if (typeof onEvent === "function" && event) onEvent({ provider, ...event });
   };
 
-  emit({ type: "start" });
+  emit(providerEvent("session-start"));
 
   const stdoutReader = readline.createInterface({ input: child.stdout });
+  const stdoutClosed = waitForReaderClose(stdoutReader);
   stdoutReader.on("line", (line) => {
+    onRawLine?.({ provider, stream: "stdout", line });
     const parsed = tryParseJson(line);
     if (parsed == null) {
-      emit({ type: "status", message: line });
+      emit(providerStatus(line));
       return;
     }
     const events = parsePayload ? parsePayload(parsed) : [];
@@ -32,28 +54,34 @@ export function createHostedSessionRunner({ provider, child, onEvent, parsePaylo
   });
 
   const stderrReader = readline.createInterface({ input: child.stderr });
+  const stderrClosed = waitForReaderClose(stderrReader);
   stderrReader.on("line", (line) => {
+    onRawLine?.({ provider, stream: "stderr", line });
     if (shouldIgnoreStatus?.(line)) return;
-    emit({ type: "status", message: line });
+    emit(providerStatus(line, { stream: "stderr" }));
   });
 
   const completion = (async () => {
     const result = await child;
-    const finalText = (readFinalText ? readFinalText(result) : null) || assistantText.trim() || null;
+    await Promise.all([stdoutClosed, stderrClosed]);
+    const fileFinalText = readFinalText ? readFinalText(result) : null;
+    const resolvedFinalText = fileFinalText || finalText || assistantText.trim() || null;
     if ((result.exitCode ?? 0) !== 0) {
       const message = lastErrorMessage || result.stderr || `${provider} exited with code ${result.exitCode ?? 1}`;
-      emit({ type: "error", message });
+      emit(providerError(message));
       throw new Error(message);
     }
-    if (finalText) emit({ type: "final", text: finalText });
-    emit({ type: "exit", code: result.exitCode ?? 0 });
+    if (resolvedFinalText && resolvedFinalText !== finalText) {
+      emit(providerEvent("assistant-final", { text: resolvedFinalText }));
+    }
+    emit(providerSessionEnd({ exitCode: result.exitCode ?? 0 }));
     settled = true;
     return {
       provider,
       exitCode: result.exitCode ?? 0,
       stdout: result.stdout || "",
       stderr: result.stderr || "",
-      finalText: finalText || result.stdout || "",
+      finalText: resolvedFinalText || result.stdout || "",
       cancelled,
     };
   })();
@@ -72,6 +100,12 @@ export function createHostedSessionRunner({ provider, child, onEvent, parsePaylo
   };
 }
 
+function waitForReaderClose(reader) {
+  return new Promise((resolve) => {
+    reader.once("close", resolve);
+  });
+}
+
 export function tryParseJson(line) {
   const normalized = String(line || "").trim();
   if (!normalized) return null;
@@ -84,21 +118,15 @@ export function tryParseJson(line) {
 
 export function buildToolEvent(name, detail = null) {
   if (!name) return null;
-  return {
-    type: "tool",
-    name: String(name),
-    ...(detail ? { detail: String(detail) } : {}),
-  };
+  return providerToolStart(name, detail ? { detail: String(detail) } : {});
 }
 
 export function buildStatusEvent(message) {
-  if (!message) return null;
-  return { type: "status", message: String(message) };
+  return providerStatus(message);
 }
 
 export function buildErrorEvent(message) {
-  if (!message) return null;
-  return { type: "error", message: String(message) };
+  return providerError(message);
 }
 
 export function extractTextFragments(payload, fragments = [], depth = 0) {

package/lib/cli/assistant/session.mjs

@@ -1,3 +1,5 @@
+import fs from "fs";
+import path from "path";
 import { startProviderSession, resolvePreferredProvider } from "./providers/index.mjs";
 import { buildAssistantPrompt } from "./prompt-builder.mjs";
 import { createAssistantCommandObserver } from "./command-observer.mjs";
@@ -14,6 +16,7 @@ export async function runAssistantConversationTurn({
   commandLog,
   onStatus,
   onToolEvent,
+  onProviderEvent,
   onResolvedProvider,
   onPrompt,
 } = {}) {
@@ -36,6 +39,12 @@ export async function runAssistantConversationTurn({
   const runtimeSettings = settings || { provider };
   const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
   const providerEnv = commandLog?.providerEnv?.(env) || env;
+  const tracePath = shouldTraceProviderEvents(env, providerEnv)
+    ? path.join(commandLog?.contextDir || path.join(productDir, ".testkit", "assistant"), "provider-events.jsonl")
+    : null;
+  const rawTracePath = shouldTraceProviderEvents(env, providerEnv)
+    ? path.join(commandLog?.contextDir || path.join(productDir, ".testkit", "assistant"), "provider-raw.jsonl")
+    : null;
   onResolvedProvider?.(resolvedProvider);
   onPrompt?.({
     prompt,
@@ -44,6 +53,12 @@ export async function runAssistantConversationTurn({
     effort: runtimeSettings.effort || null,
   });
   onStatus?.(`Thinking with ${resolvedProvider}...`);
+  onProviderEvent?.({
+    type: "status",
+    provider: resolvedProvider,
+    text: `Thinking with ${resolvedProvider}...`,
+    transient: true,
+  });
 
   observer.start();
   try {
@@ -56,25 +71,53 @@ export async function runAssistantConversationTurn({
       prompt,
       purpose: "assistant",
       env: providerEnv,
+      onRawLine(line) {
+        appendProviderTrace(rawTracePath, line);
+      },
       onEvent(event) {
-        if (event.type === "status" || event.type === "tool") onStatus?.(formatProviderEvent(event));
+        appendProviderTrace(tracePath, event);
+        onProviderEvent?.(event);
+        if (event.type === "status" || event.type === "tool-start" || event.type === "tool-update" || event.type === "tool-end") {
+          onStatus?.(formatProviderEvent(event));
+        }
       },
     });
-    const result = await session.completion;
+    await session.completion;
     observer.scan();
     commandLog?.refresh?.();
-    return [{
-      role: "assistant",
-      text: result.finalText || "",
-    }];
+    return { provider: resolvedProvider };
   } finally {
     observer.stop();
   }
 }
 
 function formatProviderEvent(event) {
-  if (event.type === "tool") {
+  if (event.type === "tool-start") {
     return `${event.provider}: ${event.name}${event.detail ? ` (${event.detail})` : ""}`;
   }
-  return `${event.provider}: ${event.message}`;
+  if (event.type === "tool-update") {
+    return `${event.provider}: ${event.name || "tool"}${event.text ? ` (${event.text})` : ""}`;
+  }
+  if (event.type === "tool-end") {
+    return `${event.provider}: ${event.name || "tool"} ${event.status || "done"}`;
+  }
+  return `${event.provider}: ${event.text || "working"}`;
+}
+
+function shouldTraceProviderEvents(...envs) {
+  return envs.some((entry) => String(entry?.TESTKIT_PROVIDER_TRACE || "").trim() === "1");
+}
+
+function appendProviderTrace(tracePath, event) {
+  if (!tracePath || !event) return;
+  try {
+    fs.mkdirSync(path.dirname(tracePath), { recursive: true });
+    fs.appendFileSync(
+      tracePath,
+      `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`,
+      "utf8"
+    );
+  } catch {
+    // Provider tracing must never interfere with the assistant turn.
+  }
 }

package/lib/cli/assistant/settings.mjs

@@ -1,7 +1,8 @@
 import fs from "fs";
 import path from "path";
+import { HOSTED_ASSISTANT_PROVIDERS } from "./providers/index.mjs";
 
-export const ASSISTANT_PROVIDERS = ["auto", "codex", "claude"];
+export const ASSISTANT_PROVIDERS = ["auto", ...HOSTED_ASSISTANT_PROVIDERS];
 export const ASSISTANT_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 
 export const DEFAULT_ASSISTANT_SETTINGS = Object.freeze({

package/lib/cli/assistant/state.mjs

@@ -99,11 +99,25 @@ export function createAssistantState({
   }
 
   function appendMessage(message) {
-    messages.push({
+    const entry = {
       id: `msg-${messages.length + 1}`,
       ...message,
-    });
+    };
+    messages.push(entry);
+    notify();
+    return entry.id;
+  }
+
+  function updateMessage(id, updater) {
+    const index = messages.findIndex((message) => message.id === id);
+    if (index < 0) return false;
+    const next = updater(messages[index]);
+    messages[index] = {
+      ...messages[index],
+      ...next,
+    };
     notify();
+    return true;
   }
 
   function setBusy(nextBusy, status = null) {
@@ -354,10 +368,11 @@ export function createAssistantState({
 
       try {
         setBusy(true, `Thinking with ${settings.provider === "auto" ? "provider" : settings.provider}...`);
-        const emitted = await runAssistantConversationTurn({
+        const providerTurn = createProviderTurnState();
+        await runAssistantConversationTurn({
           productDir,
           runState,
-          transcript: messages.map((entry) => ({ role: entry.role, text: entry.text })),
+          transcript: buildConversationTranscript(messages),
           userMessage: trimmed,
           settings,
           env,
@@ -379,11 +394,20 @@ export function createAssistantState({
             });
             notify();
           },
+          onProviderEvent(event) {
+            handleProviderEvent(providerTurn, event, {
+              appendMessage,
+              updateMessage,
+              setStatus(status) {
+                activeStatus = status;
+                notify();
+              },
+            });
+          },
           onToolEvent(event) {
             handleAssistantToolEvent(state, event, appendMessage);
           },
         });
-        for (const message of emitted) appendMessage(message);
       } catch (error) {
         appendMessage({
           role: "system",
@@ -608,6 +632,139 @@ function handleAssistantToolEvent(state, event, appendMessage) {
   }
 }
 
+function createProviderTurnState() {
+  return {
+    assistantMessageId: null,
+    lastActivityText: null,
+  };
+}
+
+function handleProviderEvent(turn, event, { appendMessage, updateMessage, setStatus } = {}) {
+  if (!event) return;
+  if (event.transient || event.display === false) {
+    if (event.type === "status" && event.text) setStatus?.(event.text);
+    return;
+  }
+  if (event.type === "assistant-delta") {
+    appendAssistantDelta(turn, event, { appendMessage, updateMessage });
+    setStatus?.(`${event.provider || "provider"} responding`);
+    return;
+  }
+  if (event.type === "assistant-final") {
+    finalizeAssistantMessage(turn, event, { appendMessage, updateMessage });
+    setStatus?.(`${event.provider || "provider"} complete`);
+    return;
+  }
+  if (event.type === "session-start") {
+    setStatus?.(`${event.provider || "provider"} session started`);
+    return;
+  }
+  if (event.type === "session-end") {
+    setStatus?.(`${event.provider || "provider"} session ended`);
+    return;
+  }
+  if (event.type === "status") {
+    appendProviderActivity(turn, {
+      role: "provider-activity",
+      title: formatProviderName(event.provider),
+      text: event.text || "Working",
+      data: event,
+    }, { appendMessage, setStatus });
+    return;
+  }
+  if (event.type === "tool-start" || event.type === "tool-update" || event.type === "tool-end") {
+    appendProviderActivity(turn, {
+      role: "provider-tool",
+      title: formatProviderToolTitle(event),
+      text: formatProviderToolText(event),
+      data: event,
+    }, { appendMessage, setStatus });
+    return;
+  }
+  if (event.type === "error") {
+    appendMessage({
+      role: "provider-error",
+      title: formatProviderName(event.provider),
+      text: event.text || "Provider error",
+      data: event,
+    });
+    setStatus?.(`${event.provider || "provider"} error`);
+  }
+}
+
+function appendAssistantDelta(turn, event, { appendMessage, updateMessage }) {
+  if (!turn.assistantMessageId) {
+    turn.assistantMessageId = appendMessage({
+      role: "assistant",
+      status: "streaming",
+      provider: event.provider || null,
+      text: "",
+    });
+  }
+  updateMessage(turn.assistantMessageId, (message) => ({
+    text: `${message.text || ""}${event.text || ""}`,
+    status: "streaming",
+  }));
+}
+
+function finalizeAssistantMessage(turn, event, { appendMessage, updateMessage }) {
+  const finalText = event.text || "";
+  if (!turn.assistantMessageId) {
+    turn.assistantMessageId = appendMessage({
+      role: "assistant",
+      provider: event.provider || null,
+      text: finalText,
+    });
+    return;
+  }
+  updateMessage(turn.assistantMessageId, (message) => ({
+    text: finalText || message.text || "",
+    status: null,
+  }));
+}
+
+function appendProviderActivity(turn, message, { appendMessage, setStatus }) {
+  const text = String(message.text || "").trim();
+  if (!text) return;
+  const signature = `${message.role}:${message.title || ""}:${text}`;
+  if (turn.lastActivityText === signature) return;
+  turn.lastActivityText = signature;
+  appendMessage(message);
+  setStatus?.(message.title ? `${message.title}: ${text}` : text);
+}
+
+function formatProviderName(provider) {
+  return provider ? String(provider) : "provider";
+}
+
+function formatProviderToolTitle(event) {
+  const provider = formatProviderName(event.provider);
+  const name = event.name || "tool";
+  if (event.type === "tool-end") return `${provider} finished ${name}`;
+  if (event.type === "tool-update") return `${provider} updated ${name}`;
+  return `${provider} started ${name}`;
+}
+
+function formatProviderToolText(event) {
+  const lines = [];
+  if (event.detail) lines.push(String(event.detail));
+  if (event.text) lines.push(String(event.text));
+  if (event.input) lines.push(formatProviderData("input", event.input));
+  if (event.output) lines.push(formatProviderData("output", event.output));
+  if (event.status) lines.push(`status: ${event.status}`);
+  return lines.filter(Boolean).join("\n") || event.name || "Provider tool activity";
+}
+
+function formatProviderData(label, value) {
+  if (value == null) return null;
+  if (typeof value === "string") return `${label}: ${value}`;
+  try {
+    return `${label}: ${JSON.stringify(value)}`;
+  } catch {
+    return `${label}: ${String(value)}`;
+  }
+}
+
 function formatSettings(snapshot) {
   const rows = [
     ["Provider", snapshot.provider || "auto"],
@@ -654,6 +811,12 @@ function serializeRunSession(session) {
   };
 }
 
+function buildConversationTranscript(messages) {
+  return (messages || [])
+    .filter((entry) => !["provider-activity", "provider-tool", "provider-error"].includes(entry.role))
+    .map((entry) => ({ role: entry.role, text: entry.text }));
+}
+
 function formatObservedCommandTitle(command) {
   const kind = command?.kind || "command";
   return `testkit ${kind}`;

package/lib/cli/assistant/transcript-text.mjs

@@ -0,0 +1,35 @@
+import stripAnsi from "strip-ansi";
+import { buildAssistantViewModel } from "./view-model.mjs";
+import { renderMarkdownToAnsi } from "./markdown-block.mjs";
+
+export function renderAssistantSnapshotText(snapshot, { cwd = process.cwd(), ansi = false } = {}) {
+  const view = buildAssistantViewModel(snapshot || {}, { cwd });
+  const lines = [view.title, view.welcome.rows.find(([label]) => label === "Provider")?.[1] || ""]
+    .filter(Boolean);
+  for (const block of view.blocks || []) {
+    lines.push("");
+    lines.push(...renderBlockLines(block, { ansi }));
+  }
+  lines.push("");
+  lines.push(view.statusLine);
+  const text = `${lines.join("\n").trimEnd()}\n`;
+  return ansi ? text : stripAnsi(text);
+}
+
+function renderBlockLines(block, { ansi = false } = {}) {
+  const marker = block.marker || "";
+  const title = block.title ? ` ${block.title}` : "";
+  const text = String(block.text || "").trimEnd();
+  if (block.format === "markdown") {
+    const rendered = text ? renderMarkdownToAnsi(text) : "";
+    const normalized = ansi ? rendered : stripAnsi(rendered);
+    return prefixLines(`${marker}${title}`, normalized);
+  }
+  return prefixLines(`${marker}${title}`, text);
+}
+
+function prefixLines(prefix, text) {
+  const lines = String(text || "").split(/\r?\n/);
+  if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) return [prefix];
+  return lines.map((line, index) => (index === 0 ? `${prefix}${prefix && line ? " " : ""}${line}` : `  ${line}`));
+}

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

@@ -65,6 +65,17 @@ export function buildTranscriptBlocks(messages) {
         exitCode: message.data?.exitCode ?? null,
       };
     }
+    if (role === "provider-activity" || role === "provider-tool" || role === "provider-error") {
+      return {
+        id: message.id,
+        kind: role,
+        format: "plain",
+        marker: role === "provider-error" ? "!" : "◌",
+        title: message.title || null,
+        text: message.text || "",
+        status: message.status || null,
+      };
+    }
     if (role === "user") {
       return {
         id: message.id,

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.101"
+    "@elench/testkit-protocol": "0.1.103"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "description": "Assistant-first CLI for running, inspecting, and debugging local testkit suites",
   "type": "module",
   "workspaces": [
@@ -58,11 +58,12 @@
   "scripts": {
     "build:packages": "npm --workspace packages/testkit-protocol run build && npm --workspace packages/ts-analysis run build && npm --workspace packages/next-analysis run build && npm --workspace packages/testkit-bridge run build",
     "typecheck:packages": "npm --workspace packages/testkit-protocol run typecheck && npm --workspace packages/ts-analysis run typecheck && npm --workspace packages/next-analysis run typecheck && npm --workspace packages/testkit-bridge run typecheck && npm --workspace packages/testkit-extension run compile",
-    "test": "npm run build:packages && vitest run && node scripts/live-sandbox/harness.mjs",
+    "test": "npm run build:packages && vitest run && npm run test:live",
     "test:audit": "node scripts/test-boundary-audit.mjs",
+    "test:live": "node scripts/live-sandbox/harness.mjs",
     "test:unit": "npm run build:packages && npm run test:audit && vitest run --config vitest.unit.config.mjs",
     "test:integration": "npm run build:packages && vitest run test/integration",
-    "test:system": "npm run build:packages && vitest run test/system --passWithNoTests"
+    "test:system": "npm run build:packages && vitest run test/system"
   },
   "files": [
     "bin/",
@@ -89,10 +90,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.101",
-    "@elench/testkit-bridge": "0.1.101",
-    "@elench/testkit-protocol": "0.1.101",
-    "@elench/ts-analysis": "0.1.101",
+    "@elench/next-analysis": "0.1.103",
+    "@elench/testkit-bridge": "0.1.103",
+    "@elench/testkit-protocol": "0.1.103",
+    "@elench/ts-analysis": "0.1.103",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",
@@ -109,6 +110,11 @@
     "wrap-ansi": "^10.0.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=24.14.1",
+    "npm": ">=11.11.0"
+  },
+  "volta": {
+    "node": "24.14.1",
+    "npm": "11.11.0"
   }
 }