@elench/testkit 0.1.93 → 0.1.95

package/README.md

@@ -78,11 +78,23 @@ npx @elench/testkit db snapshot capture --service api --output scripts/testkit/s
 ```
 
 `testkit` is assistant-first in an interactive TTY. The interactive assistant
-is a testkit-owned chat shell with a bottom composer, provider-backed
-reasoning, repo context files under `.testkit/assistant/`, and inline tool
-blocks for command execution. Natural-language turns still go through Codex or
-Claude, but `testkit` owns the transcript, command execution surface, and
-rendering around `testkit`, `npm`, and `npx` commands.
+opens with a repo-aware landing panel: provider/model, current directory,
+latest run result, focused file/service, regression counts, and suggested next
+prompts. The bottom composer is the primary interaction surface, and the status
+line shows approximate context remaining when the active provider/model window
+is known, for example `[~96% remaining]`.
+
+Natural-language turns still go through Codex or Claude, but `testkit` owns the
+transcript, command execution surface, context files under `.testkit/assistant/`,
+and rendering around `testkit`, `npm`, and `npx` commands. When the provider
+runs testkit-managed commands, the assistant records structured tool lifecycle
+blocks and refreshes the latest run artifact so follow-up questions can use the
+new result immediately.
+
+Assistant provider coverage is tested against the real `codex` and `claude`
+CLIs. The test suite assumes both are installed and authenticated; provider
+adapter, assistant shell, `shell_exec`, and real testkit-run coverage do not use
+provider stand-in binaries or simulated provider sessions.
 
 Assistant runtime settings are repo-local. Use `/provider`, `/model`,
 `/effort`, and `/settings` inside the assistant to inspect or change the active
@@ -90,7 +102,8 @@ provider runtime; changes are persisted to `.testkit/assistant/settings.json`.
 CLI flags such as `--provider`, `--model`, `--effort`, and repeatable
 `--provider-arg` override those settings for the current launch. The composer
 has an always-visible cursor and supports arrow keys, Home/End, Ctrl+A/Ctrl+E,
-Backspace, Delete, and Ctrl+D.
+Backspace, Delete, Ctrl+D, and Ctrl+L to clear the visible transcript. Ctrl+C
+quits the assistant.
 
 The non-interactive `assistant --message ...` mode uses the same provider/tool
 engine for one hosted turn at a time. It is useful in scripts and tests, but
@@ -268,7 +281,7 @@ File-local execution metadata now lives next to the test when possible:
 import { defineFile } from "@elench/testkit/config";
 
 export const testkit = defineFile({
-  skip: "Billing is still stubbed locally",
+  skip: "Billing is currently unavailable locally",
   locks: ["global-worker-loop"],
 });
 ```

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

@@ -4,7 +4,6 @@ import {
   buildStatusEvent,
   buildToolEvent,
   createHostedSessionRunner,
-  extractTextFragments,
 } from "./shared.mjs";
 
 export function startClaudeHostedSession({
@@ -21,6 +20,7 @@ export function startClaudeHostedSession({
     "-p",
     "--output-format",
     "stream-json",
+    "--verbose",
     "--include-partial-messages",
   ];
 
@@ -73,6 +73,25 @@ function parseClaudePayload(payload) {
     return events;
   }
 
+  if (type === "stream_event") {
+    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 });
+      return events;
+    }
+    if (streamEvent.type === "tool_use" || streamEvent.content_block?.type === "tool_use") {
+      const tool = streamEvent.content_block || streamEvent;
+      const event = buildToolEvent(
+        tool.name || tool.tool_name || streamEvent.type,
+        tool.input ? JSON.stringify(tool.input) : null
+      );
+      if (event) events.push(event);
+      return events;
+    }
+    return events;
+  }
+
   if (type && /tool/i.test(type)) {
     const event = buildToolEvent(
       payload.name || payload.tool_name || payload.tool || type,
@@ -82,10 +101,14 @@ function parseClaudePayload(payload) {
     return events;
   }
 
-  const fragments = [...new Set(extractTextFragments(payload, []))];
-  if (fragments.length > 0) {
-    for (const fragment of fragments) {
-      events.push({ type: "delta", text: fragment });
+  if (type === "assistant") {
+    return events;
+  }
+
+  if (type === "result") {
+    if (payload.is_error || payload.subtype === "error") {
+      const event = buildErrorEvent(payload.result || payload.error || "Claude command failed");
+      if (event) events.push(event);
     }
     return events;
   }

package/lib/cli/agents/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,
@@ -65,6 +62,28 @@ 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));

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

@@ -36,6 +36,11 @@ 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}`;
+      emit({ type: "error", message });
+      throw new Error(message);
+    }
     if (finalText) emit({ type: "final", text: finalText });
     emit({ type: "exit", code: result.exitCode ?? 0 });
     settled = true;

package/lib/cli/assistant/app.mjs

@@ -1,9 +1,10 @@
 import React, { createElement, useEffect, useMemo, useState } from "react";
-import { Box, Text, useApp, useInput } from "ink";
-import { bold, dim, green, red, yellow } from "../presentation/colors.mjs";
+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 { buildAssistantViewModel } from "./view-model.mjs";
 
-const MAX_VISIBLE_MESSAGES = 22;
+const MAX_BLOCK_LINES = 18;
 
 export function AssistantApp({
   assistantState,
@@ -13,6 +14,7 @@ export function AssistantApp({
   onRequestClose,
 } = {}) {
   const { exit } = useApp();
+  const { stdout } = useStdout();
   const [snapshot, setSnapshot] = useState(() => assistantState.getSnapshot());
   const [initialPromptStarted, setInitialPromptStarted] = useState(false);
   const [initialPromptFinished, setInitialPromptFinished] = useState(false);
@@ -30,7 +32,7 @@ export function AssistantApp({
     Promise.resolve(assistantState.submitInput(initialPrompt)).finally(() => {
       setInitialPromptFinished(true);
     });
-  }, [assistantState, exit, exitAfterInitialPrompt, initialPrompt, initialPromptStarted, onRequestClose]);
+  }, [assistantState, initialPrompt, initialPromptStarted]);
 
   useEffect(() => {
     if (!exitAfterInitialPrompt || !initialPromptFinished || snapshot.busy) return;
@@ -40,9 +42,12 @@ export function AssistantApp({
     return () => clearTimeout(timer);
   }, [exit, exitAfterInitialPrompt, initialPromptFinished, onRequestClose, snapshot.busy]);
 
-  const visibleMessages = useMemo(
-    () => snapshot.messages.slice(-MAX_VISIBLE_MESSAGES),
-    [snapshot.messages]
+  const view = useMemo(
+    () => buildAssistantViewModel(snapshot, {
+      cwd: snapshot.productDir || process.cwd(),
+      terminalWidth: stdout?.columns || process.stdout?.columns || 100,
+    }),
+    [snapshot, stdout?.columns]
   );
 
   return createElement(
@@ -55,28 +60,15 @@ export function AssistantApp({
           onRequestClose,
         })
       : null,
-    createElement(Text, null, dim(buildHeader(snapshot))),
-    snapshot.notice ? createElement(Text, null, yellow(snapshot.notice)) : null,
+    view.blocks.length === 0
+      ? createElement(WelcomePanel, { view })
+      : createElement(Transcript, { view }),
     createElement(Text, null, ""),
-    createElement(
-      Box,
-      { flexDirection: "column" },
-      ...visibleMessages.flatMap((message) => renderMessage(message))
-    ),
-    createElement(Text, null, ""),
-    createElement(
-      Box,
-      {
-        borderStyle: "round",
-        flexDirection: "column",
-        paddingLeft: 1,
-        paddingRight: 1,
-      },
-      createElement(Text, null, dim("Message")),
-      renderComposer(snapshot)
-    ),
-    createElement(Text, null, ""),
-    createElement(Text, null, dim(buildFooter(snapshot, initialPromptFinished)))
+    createElement(ComposerBar, { view, busy: snapshot.busy }),
+    createElement(Text, null, dim(view.statusLine)),
+    exitAfterInitialPrompt && initialPromptFinished && !snapshot.busy
+      ? createElement(Text, null, dim("initial prompt complete"))
+      : null
   );
 }
 
@@ -88,8 +80,8 @@ function AssistantInputHandler({ assistantState, snapshot, onRequestClose }) {
       (onRequestClose || exit)();
       return;
     }
-    if (input === "q" && !snapshot.busy && snapshot.composer.length === 0) {
-      (onRequestClose || exit)();
+    if (key.ctrl && input === "l" && !snapshot.busy) {
+      assistantState.clearMessages();
       return;
     }
     if (key.return) {
@@ -130,76 +122,113 @@ function AssistantInputHandler({ assistantState, snapshot, onRequestClose }) {
   return null;
 }
 
-function renderMessage(message) {
-  const prefix = rolePrefix(message);
-  const lines = String(message.text || "").split(/\r?\n/);
-  const rendered = [];
-  if (message.title) {
-    rendered.push(createElement(Text, { key: `${message.id}-title` }, `${prefix} ${bold(message.title)}`));
-  } else if (lines.length > 0) {
-    rendered.push(createElement(Text, { key: `${message.id}-first` }, `${prefix} ${colorForRole(message.role)(lines[0] || "")}`));
-  }
+function WelcomePanel({ view }) {
+  return createElement(
+    Box,
+    {
+      borderStyle: "round",
+      flexDirection: "column",
+      paddingLeft: 1,
+      paddingRight: 1,
+    },
+    createElement(Text, null, bold(view.title)),
+    createElement(Text, null, dim(view.welcome.subtitle)),
+    createElement(Text, null, ""),
+    ...view.welcome.rows.map(([label, value]) => (
+      createElement(Text, { key: label }, `${padLabel(label)} ${colorWelcomeValue(label, value)}`)
+    )),
+    createElement(Text, null, ""),
+    createElement(Text, null, bold("Try")),
+    ...view.welcome.suggestions.map((suggestion) => (
+      createElement(Text, { key: suggestion }, `  ${dim("›")} ${suggestion}`)
+    ))
+  );
+}
 
-  const remainingLines = message.title ? lines : lines.slice(1);
-  for (let index = 0; index < remainingLines.length; index += 1) {
-    rendered.push(
-      createElement(
-        Text,
-        { key: `${message.id}-line-${index}` },
-        `${message.title ? "  " : "    "}${remainingLines[index]}`
-      )
-    );
+function Transcript({ view }) {
+  return createElement(
+    Box,
+    { flexDirection: "column" },
+    createElement(Text, null, bold(view.title)),
+    createElement(Text, null, dim(view.welcome.rows.find(([label]) => label === "Provider")?.[1] || "")),
+    createElement(Text, null, ""),
+    view.notice ? createElement(Text, null, yellow(view.notice)) : null,
+    ...view.blocks.flatMap((block) => renderBlock(block))
+  );
+}
+
+function renderBlock(block) {
+  const lines = String(block.text || "").split(/\r?\n/);
+  const visibleLines = lines.length > MAX_BLOCK_LINES
+    ? [...lines.slice(0, MAX_BLOCK_LINES - 1), `… ${lines.length - MAX_BLOCK_LINES + 1} more lines omitted`]
+    : lines;
+  const marker = colorMarker(block);
+  const title = block.title ? ` ${bold(block.title)}` : "";
+  const first = visibleLines[0] || "";
+  const rendered = [
+    createElement(Text, { key: `${block.id}-first` }, `${marker}${title}${title && first ? " " : ""}${colorBlockText(block, first)}`),
+  ];
+
+  for (let index = 1; index < visibleLines.length; index += 1) {
+    rendered.push(createElement(Text, { key: `${block.id}-${index}` }, `  ${visibleLines[index]}`));
   }
-  rendered.push(createElement(Text, { key: `${message.id}-gap` }, ""));
+  rendered.push(createElement(Text, { key: `${block.id}-gap` }, ""));
   return rendered;
 }
 
-function renderComposer(snapshot) {
+function ComposerBar({ view, busy }) {
   const { before, current, after, empty } = getComposerRenderParts({
-    text: snapshot.composer || "",
-    cursor: snapshot.composerCursor ?? 0,
+    text: view.composer.text,
+    cursor: view.composer.cursor,
   });
+  const prompt = cyan("❯");
+  const promptText = empty ? dim(`${view.composer.placeholder} `) : before;
   return createElement(
-    Text,
-    null,
-    empty ? dim("Ask testkit to run or inspect something... ") : before,
-    createElement(Text, { inverse: true }, current),
-    after
+    Box,
+    {
+      borderStyle: "single",
+      borderLeft: false,
+      borderRight: false,
+      paddingTop: 0,
+      paddingBottom: 0,
+    },
+    createElement(
+      Text,
+      null,
+      `${prompt} `,
+      promptText,
+      createElement(Text, { inverse: true }, current),
+      after,
+      busy ? dim("  provider responding") : ""
+    )
   );
 }
 
-function buildHeader(snapshot) {
-  const status = snapshot.busy ? snapshot.activeStatus || "working" : "ready";
-  const provider = snapshot.provider || "auto";
-  const resolvedProvider = snapshot.resolvedProvider && snapshot.resolvedProvider !== provider ? `→${snapshot.resolvedProvider}` : "";
-  const model = snapshot.model ? ` · ${snapshot.model}` : "";
-  const effort = snapshot.effort ? ` · ${snapshot.effort}` : "";
-  const context = snapshot.context?.selection?.filePath || snapshot.context?.selection?.serviceName || "no focus";
-  return `testkit assistant · ${provider}${resolvedProvider}${model}${effort} · ${status} · ${context}`;
+function padLabel(label) {
+  return `${dim(String(label).padEnd(10, " "))}`;
 }
 
-function buildFooter(snapshot, promptFinished) {
-  if (promptFinished && snapshot.messages.length > 0) {
-    return "initial prompt complete";
-  }
-  if (snapshot.busy) {
-    return "Enter disabled while the provider is responding · Ctrl+C quit";
-  }
-  return "Enter send · arrows/Home/End move cursor · Backspace/Delete edit · /settings · q quit";
+function colorWelcomeValue(label, value) {
+  if (label === "Latest" && /^FAILED\b/.test(String(value))) return red(value);
+  if (label === "Latest" && /^PASSED\b/.test(String(value))) return green(value);
+  if (label === "Issues" && value !== "None detected") return yellow(value);
+  if (label === "Provider") return cyan(value);
+  return value;
 }
 
-function rolePrefix(message) {
-  if (message.role === "user") return green("you>");
-  if (message.role === "assistant") return bold("ai>");
-  if (message.role === "tool") return yellow("tool>");
-  return red("sys>");
+function colorMarker(block) {
+  if (block.kind === "user") return cyan(block.marker);
+  if (block.kind === "system") return red(block.marker);
+  if (block.kind === "tool-running") return yellow(block.marker);
+  if (block.kind === "testkit-run") return green(block.marker);
+  return block.marker;
 }
 
-function colorForRole(role) {
-  if (role === "user") return green;
-  if (role === "tool") return yellow;
-  if (role === "system") return red;
-  return (value) => value;
+function colorBlockText(block, text) {
+  if (block.kind === "user") return text;
+  if (block.kind === "system") return red(text);
+  if (block.kind === "tool-running") return yellow(text);
+  return text;
 }
 
 function isPrintableInput(input, key) {

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

@@ -160,7 +160,8 @@ function buildContextMarkdown(productDir, snapshot, paths) {
   lines.push(
     "",
     "## Guidance",
-    "- Use shell commands like `npm run testkit`, `npx testkit`, or `testkit run --dir . --type <type>` when you need to execute tests.",
+    "- Use shell commands like `npm run testkit`, `npx testkit`, or `testkit run <type> --dir .` when you need to execute tests.",
+    "- 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.",
     ""
@@ -173,15 +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 --dir . --type e2e`",
+    "- `npx testkit run e2e --dir .`",
     "",
   ].join("\n");
 }

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

@@ -0,0 +1,69 @@
+const DEFAULT_CHARS_PER_TOKEN = 4;
+
+const MODEL_WINDOWS = [
+  [/claude.*opus.*4\.7/i, 1_000_000],
+  [/claude.*sonnet.*4/i, 200_000],
+  [/claude.*haiku.*4/i, 200_000],
+  [/claude/i, 200_000],
+  [/gpt-5\.5/i, 400_000],
+  [/gpt-5\.4/i, 400_000],
+  [/gpt-5\.3/i, 400_000],
+  [/gpt-5\.2/i, 400_000],
+  [/gpt-5\b/i, 400_000],
+  [/codex/i, 400_000],
+];
+
+export function resolveContextWindow({ provider, model } = {}) {
+  const label = [provider, model].filter(Boolean).join(" ");
+  for (const [pattern, tokens] of MODEL_WINDOWS) {
+    if (pattern.test(label)) return tokens;
+  }
+  return null;
+}
+
+export function estimateTokenCount(text) {
+  const value = String(text || "");
+  if (!value) return 0;
+  return Math.max(1, Math.ceil(value.length / DEFAULT_CHARS_PER_TOKEN));
+}
+
+export function buildContextUsage({
+  provider,
+  model,
+  prompt,
+  exactUsedTokens = null,
+  exactMaxTokens = null,
+} = {}) {
+  const maxTokens = normalizePositiveInteger(exactMaxTokens) || resolveContextWindow({ provider, model });
+  const usedTokens = normalizePositiveInteger(exactUsedTokens) || estimateTokenCount(prompt);
+  if (!maxTokens || !usedTokens) {
+    return {
+      known: false,
+      estimated: true,
+      usedTokens: usedTokens || null,
+      maxTokens: maxTokens || null,
+      remainingPercent: null,
+    };
+  }
+
+  const clampedUsed = Math.min(usedTokens, maxTokens);
+  return {
+    known: true,
+    estimated: !exactUsedTokens,
+    usedTokens: clampedUsed,
+    maxTokens,
+    remainingPercent: Math.max(0, Math.floor(((maxTokens - clampedUsed) / maxTokens) * 100)),
+  };
+}
+
+export function formatContextRemaining(usage) {
+  if (!usage?.known || usage.remainingPercent == null) return "[context unknown]";
+  const prefix = usage.estimated ? "~" : "";
+  return `[${prefix}${usage.remainingPercent}% remaining]`;
+}
+
+function normalizePositiveInteger(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return null;
+  return Math.floor(number);
+}

package/lib/cli/assistant/session.mjs

@@ -16,6 +16,7 @@ export async function runAssistantConversationTurn({
   onStatus,
   onToolEvent,
   onResolvedProvider,
+  onPrompt,
 } = {}) {
   const tools = listAssistantTools();
   const toolContext = {
@@ -43,6 +44,12 @@ export async function runAssistantConversationTurn({
     const runtimeSettings = settings || { provider };
     const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
     onResolvedProvider?.(resolvedProvider);
+    onPrompt?.({
+      prompt,
+      provider: resolvedProvider,
+      model: runtimeSettings.model || null,
+      effort: runtimeSettings.effort || null,
+    });
     onStatus?.(`Thinking with ${resolvedProvider}...`);
     const events = [];
     const session = startAgentSession({

package/lib/cli/assistant/state.mjs

@@ -1,6 +1,7 @@
 import { loadCurrentRunArtifact, loadLatestRunArtifact } from "../viewer.mjs";
 import { createInspectState } from "../tui/inspect-state.mjs";
 import { buildContextSelection } from "../context-resources.mjs";
+import { isProviderInstalled } from "../agents/index.mjs";
 import { parseSlashCommand, formatSlashHelpLines } from "./slash-commands.mjs";
 import { executeAssistantTool } from "./tool-registry.mjs";
 import { runAssistantConversationTurn } from "./session.mjs";
@@ -22,6 +23,7 @@ import {
   moveComposerCursorToStart as moveComposerCursorStateToStart,
   setComposerText,
 } from "./composer.mjs";
+import { buildContextUsage } from "./context-window.mjs";
 
 export function createAssistantState({
   productDir,
@@ -54,8 +56,13 @@ export function createAssistantState({
       providerArgs,
     }
   );
-  let resolvedProviderName = null;
+  let resolvedProviderName = resolveInitialProvider(settings.provider, env);
   let activeStatus = null;
+  let contextUsage = buildContextUsage({
+    provider: resolvedProviderName || settings.provider,
+    model: settings.model,
+    prompt: "",
+  });
 
   inspectState.subscribe(() => {
     commandLog.refresh();
@@ -170,11 +177,19 @@ export function createAssistantState({
     setProvider(nextProvider) {
       settings = mergeAssistantSettings(settings, { provider: nextProvider || DEFAULT_ASSISTANT_SETTINGS.provider });
       resolvedProviderName = null;
+      if (settings.model && getModelProviderMismatch(resolveInitialProvider(settings.provider, env), settings.model)) {
+        settings = mergeAssistantSettings(settings, { model: null });
+      }
       saveAssistantSettings(productDir, settings);
       notify();
     },
 
     setModel(nextModel) {
+      const resolvedProvider = resolveInitialProvider(settings.provider, env);
+      const mismatch = getModelProviderMismatch(resolvedProvider, nextModel);
+      if (mismatch) {
+        throw new Error(mismatch);
+      }
       settings = mergeAssistantSettings(settings, { model: nextModel || null });
       saveAssistantSettings(productDir, settings);
       notify();
@@ -270,6 +285,17 @@ export function createAssistantState({
             resolvedProviderName = provider;
             notify();
           },
+          onPrompt(meta) {
+            contextUsage = buildContextUsage({
+              provider: meta.provider || settings.provider,
+              model: meta.model || settings.model,
+              prompt: meta.prompt,
+            });
+            notify();
+          },
+          onToolEvent(event) {
+            handleAssistantToolEvent(event, appendMessage);
+          },
         });
         for (const message of emitted) appendMessage(message);
       } catch (error) {
@@ -291,6 +317,8 @@ export function createAssistantState({
     getSnapshot() {
       return {
         context: buildContextSelection(inspectState.getSnapshot()),
+        inspect: inspectState.getSnapshot(),
+        productDir,
         messages: [...messages],
         composer: composerState.text,
         composerCursor: composerState.cursor,
@@ -302,6 +330,7 @@ export function createAssistantState({
         effort: settings.effort,
         providerArgs: [...settings.providerArgs],
         activeStatus,
+        contextUsage,
         contextPaths: {
           contextPath: commandLog.contextPath,
           summaryPath: commandLog.summaryPath,
@@ -317,6 +346,29 @@ export function createAssistantState({
   return state;
 }
 
+function resolveInitialProvider(provider, env) {
+  if (provider && provider !== "auto") return provider;
+  if (isProviderInstalled("codex", env)) return "codex";
+  if (isProviderInstalled("claude", env)) return "claude";
+  return null;
+}
+
+function getModelProviderMismatch(provider, model) {
+  const normalizedModel = String(model || "").trim().toLowerCase();
+  if (!provider || !normalizedModel) return null;
+
+  const looksClaude = /\b(?:opus|sonnet|haiku|claude)\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;
+}
+
 async function executeSlashCommand({
   slash,
   state,
@@ -385,7 +437,18 @@ async function executeSlashCommand({
     env,
     commandLog: state.commandLog,
     onEvent(event) {
-      if (event.type === "tool-status") {
+      if (event.type === "tool-start") {
+        appendMessage({
+          role: "tool",
+          status: "running",
+          title: event.title || event.tool || "Tool",
+          text: event.message,
+          data: {
+            command: event.command || null,
+            testkitRelated: Boolean(event.testkitRelated),
+          },
+        });
+      } else if (event.type === "tool-status") {
         state.setNotice(event.message);
       }
     },
@@ -400,6 +463,20 @@ async function executeSlashCommand({
   });
 }
 
+function handleAssistantToolEvent(event, appendMessage) {
+  if (!event || event.type !== "tool-start") return;
+  appendMessage({
+    role: "tool",
+    status: "running",
+    title: event.title || event.tool || "Tool",
+    text: event.message || "Running tool",
+    data: {
+      command: event.command || null,
+      testkitRelated: Boolean(event.testkitRelated),
+    },
+  });
+}
+
 function formatSettings(snapshot) {
   const rows = [
     ["Provider", snapshot.provider || "auto"],
@@ -443,9 +520,16 @@ async function executeSlashTool(slash, context) {
 }
 
 function buildRunSlashCommand(options = {}) {
-  const parts = ["testkit", "run", "--dir", "."];
-  for (const type of options.type || []) {
-    parts.push("--type", type);
+  const types = options.type || [];
+  const parts = ["testkit", "run"];
+  if (types.length === 1) {
+    parts.push(types[0]);
+  }
+  parts.push("--dir", ".");
+  if (types.length !== 1) {
+    for (const type of types) {
+      parts.push("--type", type);
+    }
   }
   for (const suite of options.suite || []) {
     parts.push("--suite", suite);

package/lib/cli/assistant/tool-registry.mjs

@@ -61,8 +61,11 @@ async function shellExecTool(args, context) {
     raw: command,
   });
   context.onEvent?.({
-    type: "tool-status",
+    type: "tool-start",
     tool: "shell_exec",
+    command,
+    title: shellCommand.title,
+    testkitRelated: shellCommand.testkitRelated,
     message: `Running ${shellCommand.display}`,
   });
 
@@ -87,6 +90,16 @@ async function shellExecTool(args, context) {
     code: result.exitCode ?? 0,
     signal: result.signal ?? null,
   });
+  context.onEvent?.({
+    type: "tool-exit",
+    tool: "shell_exec",
+    command,
+    title: shellCommand.title,
+    testkitRelated: shellCommand.testkitRelated,
+    code: result.exitCode ?? 0,
+    signal: result.signal ?? null,
+    message: `${shellCommand.display} exited ${result.exitCode ?? 0}`,
+  });
 
   if (shellCommand.testkitRelated) {
     refreshArtifactSelection(context);

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

@@ -0,0 +1,132 @@
+import path from "path";
+import { formatContextRemaining } from "./context-window.mjs";
+
+const MAX_TRANSCRIPT_BLOCKS = 18;
+
+export function buildAssistantViewModel(snapshot, { cwd = process.cwd(), terminalWidth = 100 } = {}) {
+  const providerLabel = buildProviderLabel(snapshot);
+  const repoName = path.basename(cwd || process.cwd()) || "repository";
+  return {
+    title: `testkit · ${repoName}`,
+    welcome: buildWelcomeModel(snapshot, { cwd, providerLabel }),
+    blocks: buildTranscriptBlocks(snapshot.messages || []),
+    composer: {
+      text: snapshot.composer || "",
+      cursor: snapshot.composerCursor ?? 0,
+      placeholder: "Ask testkit to run, inspect, or explain something",
+    },
+    statusLine: buildStatusLine(snapshot, { cwd, providerLabel }),
+    busy: Boolean(snapshot.busy),
+    notice: snapshot.notice || null,
+    terminalWidth,
+  };
+}
+
+export function buildWelcomeModel(snapshot, { cwd = process.cwd(), providerLabel = null } = {}) {
+  const summaryRows = snapshot?.inspect?.summaryData?.rows || snapshot?.summaryData?.rows || [];
+  const rowValue = (label) => summaryRows.find(([key]) => key === label)?.[1] || null;
+  const contextSelection = snapshot?.context?.selection || {};
+  const latestResult = rowValue("Result");
+  const counts = [
+    rowValue("Passed") ? `${rowValue("Passed")} passed` : null,
+    rowValue("Failed") ? `${rowValue("Failed")} failed` : null,
+    rowValue("Skipped") ? `${rowValue("Skipped")} skipped` : null,
+  ].filter(Boolean);
+  const issues = [
+    rowValue("New regressions") ? `${rowValue("New regressions")} new regression${rowValue("New regressions") === "1" ? "" : "s"}` : null,
+    rowValue("Known regressions") ? `${rowValue("Known regressions")} known` : null,
+    rowValue("Catalog stale") ? `${rowValue("Catalog stale")} stale` : null,
+  ].filter(Boolean);
+
+  return {
+    subtitle: "Local testing assistant",
+    rows: [
+      ["Provider", providerLabel || buildProviderLabel(snapshot)],
+      ["Directory", shortenHome(cwd)],
+      ["Latest", latestResult ? [latestResult, ...counts].join(" · ") : "No run artifact yet"],
+      ["Focus", contextSelection.filePath || contextSelection.serviceName || "No focus"],
+      ["Issues", issues.length ? issues.join(" · ") : "None detected"],
+    ],
+    suggestions: buildSuggestions({ latestResult, contextSelection, hasArtifact: Boolean(latestResult) }),
+  };
+}
+
+export function buildTranscriptBlocks(messages) {
+  return (messages || []).slice(-MAX_TRANSCRIPT_BLOCKS).map((message) => {
+    const role = message.role || "system";
+    if (role === "tool") {
+      return {
+        id: message.id,
+        kind: classifyToolBlock(message),
+        marker: "●",
+        title: message.title || message.toolName || "Tool",
+        text: message.text || "",
+        status: message.status || null,
+        command: message.data?.command || null,
+        exitCode: message.data?.exitCode ?? null,
+      };
+    }
+    if (role === "user") {
+      return {
+        id: message.id,
+        kind: "user",
+        marker: "❯",
+        text: message.text || "",
+      };
+    }
+    if (role === "assistant") {
+      return {
+        id: message.id,
+        kind: "assistant",
+        marker: "●",
+        text: message.text || "",
+      };
+    }
+    return {
+      id: message.id,
+      kind: "system",
+      marker: "!",
+      text: message.text || "",
+    };
+  });
+}
+
+export function buildStatusLine(snapshot, { cwd = process.cwd(), providerLabel = null } = {}) {
+  const context = formatContextRemaining(snapshot.contextUsage);
+  const provider = providerLabel || buildProviderLabel(snapshot);
+  const status = snapshot.busy ? snapshot.activeStatus || "working" : "/settings";
+  return `${context} ${shortenHome(cwd)} · ${provider} · ${status}`;
+}
+
+export function buildProviderLabel(snapshot) {
+  const provider = snapshot?.provider || "auto";
+  const resolved = snapshot?.resolvedProvider && snapshot.resolvedProvider !== provider ? `→${snapshot.resolvedProvider}` : "";
+  const model = snapshot?.model ? ` ${snapshot.model}` : "";
+  const effort = snapshot?.effort ? ` ${snapshot.effort}` : "";
+  return `${provider}${resolved}${model}${effort}`.trim();
+}
+
+function buildSuggestions({ latestResult, contextSelection, hasArtifact }) {
+  if (!hasArtifact) {
+    return ["Run all tests", "Discover tests", "Run doctor checks"];
+  }
+  if (latestResult === "FAILED") {
+    const suggestions = ["Explain the latest failure", "Show new regressions", "Inspect logs"];
+    if (contextSelection?.filePath) suggestions.push(`Inspect ${path.basename(contextSelection.filePath)}`);
+    return suggestions;
+  }
+  return ["Run e2e tests", "Show latest summary", "List test files"];
+}
+
+function classifyToolBlock(message) {
+  if (message.status === "running") return "tool-running";
+  if (message.data?.testkitRelated) return "testkit-run";
+  return "tool-result";
+}
+
+function shortenHome(value) {
+  const text = String(value || "");
+  const home = process.env.HOME;
+  if (home && text.startsWith(home)) return `~${text.slice(home.length)}`;
+  return text;
+}

package/lib/database/template-steps.mjs

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { execa } from "execa";
-import { buildExecutionEnv } from "../runner/template.mjs";
+import { buildTemplateExecutionEnv } from "../runner/template.mjs";
 import {
   collectConfiguredInputs,
   runConfiguredSteps,
@@ -13,7 +13,7 @@ export async function runTemplateStage(config, stageName, databaseUrl, options =
   if (steps.length === 0) return;
 
   const env = {
-    ...buildExecutionEnv(config, {}, process.env),
+    ...buildTemplateExecutionEnv(config, {}, process.env),
     DATABASE_URL: databaseUrl,
   };
 
@@ -54,7 +54,7 @@ export async function captureTemplateSnapshot(config, outputPath, databaseUrl, o
     {
       cwd: config.productDir,
       env: {
-        ...buildExecutionEnv(config, {}, process.env),
+        ...buildTemplateExecutionEnv(config, {}, process.env),
         DATABASE_URL: templateDbUrl,
       },
       stdout: "pipe",

package/lib/runner/runtime-preparation.mjs

@@ -127,6 +127,7 @@ export async function computeRuntimePrepareFingerprint(config) {
         : null,
     })
   );
+  hash.update(JSON.stringify(collectRuntimeDatabaseFingerprintInputs(config)));
 
   for (const envFile of config.testkit.envFiles || []) {
     appendFileToHash(hash, config.productDir, resolveServiceCwd(config.productDir, envFile));
@@ -138,6 +139,41 @@ export async function computeRuntimePrepareFingerprint(config) {
   return hash.digest("hex");
 }
 
+function collectRuntimeDatabaseFingerprintInputs(config) {
+  const inputs = [];
+  const ownDatabaseUrl = readDatabaseUrl(config.stateDir);
+  if (ownDatabaseUrl) {
+    inputs.push({ service: config.name, url: ownDatabaseUrl });
+  }
+
+  const referencedServices = new Set();
+  for (const value of Object.values(config.testkit.serviceEnv || {})) {
+    collectDatabasePlaceholderServices(value, referencedServices, config.name);
+  }
+  for (const value of Object.values(config.testkit.local?.env || {})) {
+    collectDatabasePlaceholderServices(value, referencedServices, config.name);
+  }
+
+  const stateDirByService = config.testkit.templateContext?.stateDirByService;
+  for (const serviceName of [...referencedServices].sort()) {
+    const stateDir = stateDirByService?.get?.(serviceName);
+    const databaseUrl = stateDir ? readDatabaseUrl(stateDir) : null;
+    inputs.push({ service: serviceName, url: databaseUrl || null });
+  }
+
+  return inputs;
+}
+
+function collectDatabasePlaceholderServices(value, out, defaultServiceName) {
+  if (typeof value !== "string") return;
+  const matcher = /\{db(?:Url|Host|Port|Name|User|Password)(?::([a-zA-Z0-9_-]+))?\}/g;
+  let match = matcher.exec(value);
+  while (match) {
+    out.add(match[1] || defaultServiceName);
+    match = matcher.exec(value);
+  }
+}
+
 function appendResolvedInputToHash(hash, productDir, absPath) {
   const relative = path.relative(productDir, absPath);
   appendInputToHash(hash, productDir, relative);

package/lib/runner/template.mjs

@@ -204,17 +204,29 @@ export function buildExecutionEnv(config, extraEnv = {}, processEnv = process.en
   return buildExecutionEnvWithContext(config, null, extraEnv, processEnv);
 }
 
+export function buildTemplateExecutionEnv(config, extraEnv = {}, processEnv = process.env) {
+  return buildExecutionEnvWithContext(config, null, extraEnv, processEnv, {
+    omitRuntimeDatabaseBindings: true,
+  });
+}
+
 export function buildTaskExecutionEnv(config, lease, extraEnv = {}, processEnv = process.env) {
   return buildExecutionEnvWithContext(config, lease, extraEnv, processEnv);
 }
 
-function buildExecutionEnvWithContext(config, lease, extraEnv, processEnv) {
+function buildExecutionEnvWithContext(config, lease, extraEnv, processEnv, options = {}) {
   const inheritedEnv = { ...processEnv };
   const templateContext = buildTemplateContext(config, lease);
+  const serviceEnv = options.omitRuntimeDatabaseBindings
+    ? omitRuntimeDatabaseBindings(config.testkit.serviceEnv || {})
+    : config.testkit.serviceEnv || {};
+  const localEnv = options.omitRuntimeDatabaseBindings
+    ? omitRuntimeDatabaseBindings(config.testkit.local?.env || {})
+    : config.testkit.local?.env || {};
   const env = {
     ...inheritedEnv,
-    ...resolveEnvTemplates(config.testkit.serviceEnv || {}, templateContext),
-    ...resolveEnvTemplates(config.testkit.local?.env || {}, templateContext),
+    ...resolveEnvTemplates(serviceEnv, templateContext),
+    ...resolveEnvTemplates(localEnv, templateContext),
     ...resolveEnvTemplates(extraEnv, templateContext),
     TESTKIT_ACTIVE: "1",
     ...(config.runtimeId ? { TESTKIT_RUNTIME_ID: String(config.runtimeId) } : {}),
@@ -340,6 +352,15 @@ function resolveEnvTemplates(values, templateContext) {
   );
 }
 
+function omitRuntimeDatabaseBindings(values = {}) {
+  return Object.fromEntries(
+    Object.entries(values).filter(([_key, value]) => {
+      if (typeof value !== "string") return true;
+      return !/\{db(?:Url|Host|Port|Name|User|Password)(?::[a-zA-Z0-9_-]+)?\}/.test(value);
+    })
+  );
+}
+
 function finalizeRuntimePrepare(prepare, context) {
   if (!prepare) {
     return {

package/lib/runtime-src/k6/http-checks.js

@@ -6,25 +6,7 @@ import {
   expectStatus,
   expectStatusOneOf,
 } from "./http-assertions.js";
-
-const DEFAULT_PAGINATION_CASES = [
-  { qs: "limit=0", label: "limit=0", expect400: false },
-  { qs: "limit=-1", label: "limit=-1", expect400: true },
-  { qs: "limit=999999", label: "limit=999999", expect400: false },
-  { qs: "limit=abc", label: "limit=abc", expect400: true },
-  { qs: "offset=-1", label: "offset=-1", expect400: true },
-  { qs: "offset=1.5", label: "offset=1.5", expect400: true },
-];
-
-const AUDIT_LOGS_PAGINATION_CASES = [
-  { qs: "limit=1e3", label: "limit=1e3 (scientific notation)" },
-  { qs: "limit=Infinity", label: "limit=Infinity" },
-  { qs: "limit=NaN", label: "limit=NaN" },
-  { qs: "offset=NaN", label: "offset=NaN" },
-  { qs: "limit=", label: "limit= (empty)" },
-  { qs: "offset=", label: "offset= (empty)" },
-  { qs: "limit=0x10", label: "limit=0x10 (hex)" },
-];
+import { buildPaginationCases, normalizeRequestCase } from "../shared/http-check-plan.mjs";
 
 export function runAuthGateChecks(rawReq, scope, descriptors = {}) {
   const {
@@ -45,43 +27,33 @@ export function runAuthGateChecks(rawReq, scope, descriptors = {}) {
 
 export function runPaginationChecks(req, endpoint, options = {}) {
   group(`${endpoint} — pagination abuse`, () => {
-    for (const { qs, label, expect400 } of DEFAULT_PAGINATION_CASES) {
-      const url = `${endpoint}?${qs}`;
+    for (const { label, expect400, url, auditOnly } of buildPaginationCases(endpoint, options)) {
       const response = req.get(url);
 
-      expectNotStatus(response, 500, `${label} → not 500`);
+      expectNotStatus(response, 500, auditOnly ? `audit-logs ${label} → not 500` : `${label} → not 500`);
       if (response.status === 500) {
-        expectResponse(response, () => true, `BUG: ${endpoint} crashes on ${label}`);
+        expectResponse(
+          response,
+          () => true,
+          auditOnly ? `BUG: audit-logs crashes on ${label}` : `BUG: ${endpoint} crashes on ${label}`
+        );
       }
 
-      if (expect400) {
+      if (auditOnly) {
+        expectStatusOneOf(response, [400, 200], `audit-logs ${label} → 400 (not silently accepted)`);
+      } else if (expect400) {
         expectStatus(response, 400, `${label} → 400`);
         if (response.status === 200) {
           expectResponse(response, () => true, `BUG: ${endpoint} accepts ${label}`);
         }
       }
 
-      if (label === "limit=abc" && response.body) {
-        expectResponse(response, (value) => !value.body.includes("NaN"), `${label} → no NaN in response`);
-      }
-    }
-
-    if (!options.auditLogsExtra) {
-      return;
-    }
-
-    for (const { qs, label } of AUDIT_LOGS_PAGINATION_CASES) {
-      const url = `${endpoint}?${qs}`;
-      const response = req.get(url);
-
-      expectNotStatus(response, 500, `audit-logs ${label} → not 500`);
-      if (response.status === 500) {
-        expectResponse(response, () => true, `BUG: audit-logs crashes on ${label}`);
-      }
-
-      expectStatusOneOf(response, [400, 200], `audit-logs ${label} → 400 (not silently accepted)`);
-      if (response.status === 200 && response.body) {
-        expectResponse(response, (value) => !value.body.includes("NaN"), `audit-logs ${label} → no NaN in response`);
+      if ((auditOnly || label === "limit=abc") && response.status === 200 && response.body) {
+        expectResponse(
+          response,
+          (value) => !value.body.includes("NaN"),
+          auditOnly ? `audit-logs ${label} → no NaN in response` : `${label} → no NaN in response`
+        );
       }
     }
   });
@@ -104,17 +76,3 @@ function runMethodAuthGateChecks(rawReq, scope, method, cases, validateErrorShap
     }
   });
 }
-
-function normalizeRequestCase(entry) {
-  if (Array.isArray(entry)) {
-    return {
-      path: entry[0],
-      body: entry[1],
-    };
-  }
-
-  return {
-    path: entry,
-    body: undefined,
-  };
-}

package/lib/runtime-src/shared/http-check-plan.mjs

@@ -0,0 +1,53 @@
+export const DEFAULT_PAGINATION_CASES = [
+  { qs: "limit=0", label: "limit=0", expect400: false },
+  { qs: "limit=-1", label: "limit=-1", expect400: true },
+  { qs: "limit=999999", label: "limit=999999", expect400: false },
+  { qs: "limit=abc", label: "limit=abc", expect400: true },
+  { qs: "offset=-1", label: "offset=-1", expect400: true },
+  { qs: "offset=1.5", label: "offset=1.5", expect400: true },
+];
+
+export const AUDIT_LOGS_PAGINATION_CASES = [
+  { qs: "limit=1e3", label: "limit=1e3 (scientific notation)" },
+  { qs: "limit=Infinity", label: "limit=Infinity" },
+  { qs: "limit=NaN", label: "limit=NaN" },
+  { qs: "offset=NaN", label: "offset=NaN" },
+  { qs: "limit=", label: "limit= (empty)" },
+  { qs: "offset=", label: "offset= (empty)" },
+  { qs: "limit=0x10", label: "limit=0x10 (hex)" },
+];
+
+export function normalizeRequestCase(entry) {
+  if (Array.isArray(entry)) {
+    return {
+      path: entry[0],
+      body: entry[1],
+    };
+  }
+
+  return {
+    path: entry,
+    body: undefined,
+  };
+}
+
+export function buildPaginationCases(endpoint, options = {}) {
+  const cases = DEFAULT_PAGINATION_CASES.map((entry) => ({
+    ...entry,
+    url: `${endpoint}?${entry.qs}`,
+    auditOnly: false,
+  }));
+
+  if (!options.auditLogsExtra) {
+    return cases;
+  }
+
+  return [
+    ...cases,
+    ...AUDIT_LOGS_PAGINATION_CASES.map((entry) => ({
+      ...entry,
+      url: `${endpoint}?${entry.qs}`,
+      auditOnly: true,
+    })),
+  ];
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "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.93",
+  "version": "0.1.95",
   "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.93"
+    "@elench/testkit-protocol": "0.1.95"
   },
   "private": false
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "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.93",
+  "version": "0.1.95",
   "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.93",
+  "version": "0.1.95",
   "description": "Assistant-first CLI for running, inspecting, and debugging local testkit suites",
   "type": "module",
   "workspaces": [
@@ -59,7 +59,8 @@
     "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",
-    "test:unit": "npm run build:packages && vitest run lib packages",
+    "test:audit": "node scripts/test-boundary-audit.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"
   },
@@ -82,10 +83,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.93",
-    "@elench/testkit-bridge": "0.1.93",
-    "@elench/testkit-protocol": "0.1.93",
-    "@elench/ts-analysis": "0.1.93",
+    "@elench/next-analysis": "0.1.95",
+    "@elench/testkit-bridge": "0.1.95",
+    "@elench/testkit-protocol": "0.1.95",
+    "@elench/ts-analysis": "0.1.95",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",