@elench/testkit 0.1.91 → 0.1.93

package/README.md

@@ -13,6 +13,8 @@ cd my-product
 
 # Launch the interactive assistant
 npx @elench/testkit
+npx @elench/testkit assistant --provider codex --model gpt-5.4
+npx @elench/testkit assistant --provider claude --model sonnet --effort high
 
 # Ask for one assistant turn non-interactively
 npx @elench/testkit assistant --message "/status"
@@ -82,6 +84,14 @@ 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.
 
+Assistant runtime settings are repo-local. Use `/provider`, `/model`,
+`/effort`, and `/settings` inside the assistant to inspect or change the active
+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.
+
 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
 it is not the primary interactive UX.

package/lib/cli/agents/index.mjs

@@ -57,6 +57,9 @@ export function isProviderInstalled(provider, env = process.env) {
 
 export function startAgentSession({
   provider = "auto",
+  model = null,
+  effort = null,
+  providerArgs = [],
   cwd,
   prompt,
   onEvent,
@@ -66,7 +69,7 @@ export function startAgentSession({
   const resolvedProvider = resolvePreferredProvider(provider, env);
   const command = resolveProviderBinary(resolvedProvider, env);
   if (resolvedProvider === "claude") {
-    return startClaudeHostedSession({ command, cwd, prompt, onEvent, purpose });
+    return startClaudeHostedSession({ command, cwd, prompt, onEvent, purpose, model, effort, providerArgs });
   }
-  return startCodexHostedSession({ command, cwd, prompt, onEvent, purpose });
+  return startCodexHostedSession({ command, cwd, prompt, onEvent, purpose, model, providerArgs });
 }

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

@@ -7,7 +7,16 @@ import {
   extractTextFragments,
 } from "./shared.mjs";
 
-export function startClaudeHostedSession({ command = "claude", cwd, prompt, onEvent, purpose = "assistant" } = {}) {
+export function startClaudeHostedSession({
+  command = "claude",
+  cwd,
+  prompt,
+  onEvent,
+  purpose = "assistant",
+  model = null,
+  effort = null,
+  providerArgs = [],
+} = {}) {
   const args = [
     "-p",
     "--output-format",
@@ -18,11 +27,19 @@ export function startClaudeHostedSession({ command = "claude", cwd, prompt, onEv
   if (purpose === "assistant") {
     args.push("--permission-mode", "plan");
   }
+  if (model) {
+    args.push("--model", String(model));
+  }
+  if (effort) {
+    args.push("--effort", String(effort));
+  }
+  args.push(...normalizeProviderArgs(providerArgs));
 
   args.push(prompt);
 
   const child = execa(command, args, {
     cwd,
+    stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",
     reject: false,
@@ -39,6 +56,11 @@ export function startClaudeHostedSession({ command = "claude", cwd, prompt, onEv
   });
 }
 
+function normalizeProviderArgs(providerArgs) {
+  if (!Array.isArray(providerArgs)) return [];
+  return providerArgs.flatMap((arg) => String(arg || "").split(/\s+/).filter(Boolean));
+}
+
 function parseClaudePayload(payload) {
   const events = [];
   if (!payload || typeof payload !== "object") return events;

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

@@ -11,7 +11,15 @@ import {
   readTextFileIfPresent,
 } from "./shared.mjs";
 
-export function startCodexHostedSession({ command = "codex", cwd, prompt, onEvent, purpose = "assistant" } = {}) {
+export function startCodexHostedSession({
+  command = "codex",
+  cwd,
+  prompt,
+  onEvent,
+  purpose = "assistant",
+  model = null,
+  providerArgs = [],
+} = {}) {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-codex-"));
   const outputFile = path.join(tempDir, "final-message.txt");
   const args = ["exec", "--json", "-o", outputFile];
@@ -19,11 +27,16 @@ export function startCodexHostedSession({ command = "codex", cwd, prompt, onEven
   if (purpose === "assistant") {
     args.push("-s", "read-only");
   }
+  if (model) {
+    args.push("--model", String(model));
+  }
+  args.push(...normalizeProviderArgs(providerArgs));
 
   args.push(prompt);
 
   const child = execa(command, args, {
     cwd,
+    stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",
     reject: false,
@@ -34,6 +47,9 @@ export function startCodexHostedSession({ command = "codex", cwd, prompt, onEven
     child,
     onEvent,
     parsePayload: parseCodexPayload,
+    shouldIgnoreStatus(message) {
+      return String(message || "").trim() === "Reading additional input from stdin...";
+    },
     readFinalText(result) {
       return readTextFileIfPresent(outputFile) || result.stdout || null;
     },
@@ -49,6 +65,11 @@ export function startCodexHostedSession({ command = "codex", cwd, prompt, onEven
   };
 }
 
+function normalizeProviderArgs(providerArgs) {
+  if (!Array.isArray(providerArgs)) return [];
+  return providerArgs.flatMap((arg) => String(arg || "").split(/\s+/).filter(Boolean));
+}
+
 function parseCodexPayload(payload) {
   const events = [];
   if (!payload || typeof payload !== "object") return events;

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

@@ -1,7 +1,7 @@
 import fs from "fs";
 import readline from "readline";
 
-export function createHostedSessionRunner({ provider, child, onEvent, parsePayload, readFinalText } = {}) {
+export function createHostedSessionRunner({ provider, child, onEvent, parsePayload, readFinalText, shouldIgnoreStatus } = {}) {
   let cancelled = false;
   let settled = false;
   let assistantText = "";
@@ -29,6 +29,7 @@ export function createHostedSessionRunner({ provider, child, onEvent, parsePaylo
 
   const stderrReader = readline.createInterface({ input: child.stderr });
   stderrReader.on("line", (line) => {
+    if (shouldIgnoreStatus?.(line)) return;
     emit({ type: "status", message: line });
   });
 

package/lib/cli/assistant/app.mjs

@@ -1,6 +1,7 @@
 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 { getComposerRenderParts } from "./composer.mjs";
 
 const MAX_VISIBLE_MESSAGES = 22;
 
@@ -113,11 +114,11 @@ function AssistantInputHandler({ assistantState, snapshot, onRequestClose }) {
       assistantState.moveComposerCursorToEnd();
       return;
     }
-    if (key.backspace || key.delete) {
+    if (key.backspace) {
       assistantState.backspaceComposer();
       return;
     }
-    if (key.ctrl && input === "d") {
+    if (key.delete || (key.ctrl && input === "d")) {
       assistantState.deleteComposer();
       return;
     }
@@ -154,19 +155,14 @@ function renderMessage(message) {
 }
 
 function renderComposer(snapshot) {
-  const composer = snapshot.composer || "";
-  const cursor = snapshot.composerCursor ?? composer.length;
-  const before = composer.slice(0, cursor);
-  const current = composer[cursor] || " ";
-  const after = composer.slice(cursor + (composer[cursor] ? 1 : 0));
-  const placeholder = composer.length === 0 ? dim("Ask testkit to run or inspect something...") : "";
-  if (composer.length === 0) {
-    return createElement(Text, null, placeholder);
-  }
+  const { before, current, after, empty } = getComposerRenderParts({
+    text: snapshot.composer || "",
+    cursor: snapshot.composerCursor ?? 0,
+  });
   return createElement(
     Text,
     null,
-    before,
+    empty ? dim("Ask testkit to run or inspect something... ") : before,
     createElement(Text, { inverse: true }, current),
     after
   );
@@ -175,8 +171,11 @@ function renderComposer(snapshot) {
 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} · ${status} · ${context}`;
+  return `testkit assistant · ${provider}${resolvedProvider}${model}${effort} · ${status} · ${context}`;
 }
 
 function buildFooter(snapshot, promptFinished) {
@@ -186,7 +185,7 @@ function buildFooter(snapshot, promptFinished) {
   if (snapshot.busy) {
     return "Enter disabled while the provider is responding · Ctrl+C quit";
   }
-  return "Enter send · Ctrl+A/Ctrl+E move cursor · Backspace delete · q quit";
+  return "Enter send · arrows/Home/End move cursor · Backspace/Delete edit · /settings · q quit";
 }
 
 function rolePrefix(message) {

package/lib/cli/assistant/composer.mjs

@@ -0,0 +1,112 @@
+const segmenter =
+  typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
+    ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+    : null;
+
+export function createComposerState(value = "") {
+  const text = String(value || "");
+  return {
+    text,
+    cursor: splitGraphemes(text).length,
+  };
+}
+
+export function setComposerText(state, value) {
+  const text = String(value || "");
+  const length = splitGraphemes(text).length;
+  return {
+    text,
+    cursor: clampCursor(state?.cursor ?? length, length),
+  };
+}
+
+export function insertComposerText(state, value) {
+  const insertText = String(value || "");
+  if (!insertText) return normalizeComposerState(state);
+  const parts = splitGraphemes(state?.text || "");
+  const cursor = clampCursor(state?.cursor ?? parts.length, parts.length);
+  const insertParts = splitGraphemes(insertText);
+  const nextParts = [...parts.slice(0, cursor), ...insertParts, ...parts.slice(cursor)];
+  return {
+    text: nextParts.join(""),
+    cursor: cursor + insertParts.length,
+  };
+}
+
+export function backspaceComposerText(state) {
+  const parts = splitGraphemes(state?.text || "");
+  const cursor = clampCursor(state?.cursor ?? parts.length, parts.length);
+  if (cursor === 0) return { text: parts.join(""), cursor };
+  const nextParts = [...parts.slice(0, cursor - 1), ...parts.slice(cursor)];
+  return {
+    text: nextParts.join(""),
+    cursor: cursor - 1,
+  };
+}
+
+export function deleteComposerText(state) {
+  const parts = splitGraphemes(state?.text || "");
+  const cursor = clampCursor(state?.cursor ?? parts.length, parts.length);
+  if (cursor >= parts.length) return { text: parts.join(""), cursor };
+  const nextParts = [...parts.slice(0, cursor), ...parts.slice(cursor + 1)];
+  return {
+    text: nextParts.join(""),
+    cursor,
+  };
+}
+
+export function moveComposerCursor(state, delta) {
+  const parts = splitGraphemes(state?.text || "");
+  return {
+    text: parts.join(""),
+    cursor: clampCursor((state?.cursor ?? parts.length) + Number(delta || 0), parts.length),
+  };
+}
+
+export function moveComposerCursorToStart(state) {
+  return {
+    text: String(state?.text || ""),
+    cursor: 0,
+  };
+}
+
+export function moveComposerCursorToEnd(state) {
+  const text = String(state?.text || "");
+  return {
+    text,
+    cursor: splitGraphemes(text).length,
+  };
+}
+
+export function getComposerRenderParts(state) {
+  const parts = splitGraphemes(state?.text || "");
+  const cursor = clampCursor(state?.cursor ?? parts.length, parts.length);
+  return {
+    before: parts.slice(0, cursor).join(""),
+    current: parts[cursor] || " ",
+    after: parts.slice(cursor + (parts[cursor] ? 1 : 0)).join(""),
+    empty: parts.length === 0,
+  };
+}
+
+function normalizeComposerState(state) {
+  const text = String(state?.text || "");
+  const parts = splitGraphemes(text);
+  return {
+    text,
+    cursor: clampCursor(state?.cursor ?? parts.length, parts.length),
+  };
+}
+
+function splitGraphemes(value) {
+  const text = String(value || "");
+  if (!text) return [];
+  if (segmenter) {
+    return [...segmenter.segment(text)].map((entry) => entry.segment);
+  }
+  return [...text];
+}
+
+function clampCursor(value, length) {
+  return Math.max(0, Math.min(Number(value || 0), length));
+}

package/lib/cli/assistant/interactive.mjs

@@ -6,7 +6,11 @@ import { loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
 
 export async function runInteractiveAssistant({
   productDir,
-  provider = "auto",
+  provider,
+  model,
+  effort,
+  providerArgs,
+  resetSettings = false,
   file = null,
   service = null,
   prompt = null,
@@ -18,6 +22,10 @@ export async function runInteractiveAssistant({
   const assistantState = createAssistantState({
     productDir,
     provider,
+    model,
+    effort,
+    providerArgs,
+    resetSettings,
     configs,
     env,
   });

package/lib/cli/assistant/session.mjs

@@ -9,11 +9,13 @@ export async function runAssistantConversationTurn({
   transcript,
   userMessage,
   provider = "auto",
+  settings = null,
   env = process.env,
   configs,
   commandLog,
   onStatus,
   onToolEvent,
+  onResolvedProvider,
 } = {}) {
   const tools = listAssistantTools();
   const toolContext = {
@@ -38,10 +40,16 @@ export async function runAssistantConversationTurn({
       userMessage,
     });
 
-    onStatus?.(`Thinking with ${resolvePreferredProvider(provider, env)}...`);
+    const runtimeSettings = settings || { provider };
+    const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
+    onResolvedProvider?.(resolvedProvider);
+    onStatus?.(`Thinking with ${resolvedProvider}...`);
     const events = [];
     const session = startAgentSession({
-      provider,
+      provider: runtimeSettings.provider || provider,
+      model: runtimeSettings.model || null,
+      effort: runtimeSettings.effort || null,
+      providerArgs: runtimeSettings.providerArgs || [],
       cwd: productDir,
       prompt,
       purpose: "assistant",

package/lib/cli/assistant/settings.mjs

@@ -0,0 +1,98 @@
+import fs from "fs";
+import path from "path";
+
+export const ASSISTANT_PROVIDERS = ["auto", "codex", "claude"];
+export const ASSISTANT_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+
+export const DEFAULT_ASSISTANT_SETTINGS = Object.freeze({
+  provider: "auto",
+  model: null,
+  effort: null,
+  providerArgs: [],
+});
+
+export function assistantSettingsPath(productDir) {
+  return path.join(productDir || process.cwd(), ".testkit", "assistant", "settings.json");
+}
+
+export function loadAssistantSettings(productDir) {
+  const filePath = assistantSettingsPath(productDir);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return normalizeAssistantSettings(parsed);
+  } catch {
+    return { ...DEFAULT_ASSISTANT_SETTINGS };
+  }
+}
+
+export function saveAssistantSettings(productDir, settings) {
+  const filePath = assistantSettingsPath(productDir);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(normalizeAssistantSettings(settings), null, 2)}\n`);
+}
+
+export function resetAssistantSettings(productDir) {
+  const filePath = assistantSettingsPath(productDir);
+  fs.rmSync(filePath, { force: true });
+  return { ...DEFAULT_ASSISTANT_SETTINGS };
+}
+
+export function mergeAssistantSettings(...settingsObjects) {
+  let merged = { ...DEFAULT_ASSISTANT_SETTINGS };
+  for (const settings of settingsObjects) {
+    if (!settings || typeof settings !== "object") continue;
+    merged = normalizeAssistantSettings({
+      ...merged,
+      ...dropNullishSettings(settings),
+      providerArgs: settings.providerArgs == null ? merged.providerArgs : settings.providerArgs,
+    });
+  }
+  return merged;
+}
+
+export function normalizeAssistantSettings(value = {}) {
+  const provider = normalizeProvider(value.provider);
+  const effort = normalizeEffort(value.effort);
+  const model = normalizeOptionalString(value.model);
+  const providerArgs = Array.isArray(value.providerArgs)
+    ? value.providerArgs.map((entry) => normalizeOptionalString(entry)).filter(Boolean)
+    : [];
+
+  return {
+    provider,
+    model,
+    effort,
+    providerArgs,
+  };
+}
+
+export function normalizeProvider(value) {
+  const provider = normalizeOptionalString(value) || DEFAULT_ASSISTANT_SETTINGS.provider;
+  if (!ASSISTANT_PROVIDERS.includes(provider)) {
+    throw new Error(`Assistant provider must be one of: ${ASSISTANT_PROVIDERS.join(", ")}`);
+  }
+  return provider;
+}
+
+export function normalizeEffort(value) {
+  const effort = normalizeOptionalString(value);
+  if (!effort) return null;
+  if (!ASSISTANT_EFFORTS.includes(effort)) {
+    throw new Error(`Assistant effort must be one of: ${ASSISTANT_EFFORTS.join(", ")}`);
+  }
+  return effort;
+}
+
+export function normalizeOptionalString(value) {
+  if (value == null) return null;
+  const stringValue = String(value).trim();
+  return stringValue || null;
+}
+
+function dropNullishSettings(settings) {
+  const result = {};
+  for (const [key, value] of Object.entries(settings)) {
+    if (value !== undefined) result[key] = value;
+  }
+  return result;
+}

package/lib/cli/assistant/slash-commands.mjs

@@ -1,5 +1,8 @@
 const RUN_TYPES = new Set(["int", "e2e", "scenario", "dal", "load", "pw", "all"]);
-const PROVIDERS = new Set(["auto", "claude", "codex"]);
+import { ASSISTANT_EFFORTS, ASSISTANT_PROVIDERS } from "./settings.mjs";
+
+const PROVIDERS = new Set(ASSISTANT_PROVIDERS);
+const EFFORTS = new Set(ASSISTANT_EFFORTS);
 
 export function parseSlashCommand(input) {
   const trimmed = String(input || "").trim();
@@ -19,6 +22,40 @@ export function parseSlashCommand(input) {
     return { type: "provider", provider };
   }
 
+  if (command === "model") {
+    const model = tokens.join(" ").trim();
+    if (!model) throw new Error("/model expects a model name or default");
+    return { type: "model", model: model === "default" ? null : model };
+  }
+
+  if (command === "effort") {
+    const effort = tokens[0] || "";
+    if (effort === "default") return { type: "effort", effort: null };
+    if (!EFFORTS.has(effort)) {
+      throw new Error(`/effort expects one of: ${[...EFFORTS, "default"].join(", ")}`);
+    }
+    return { type: "effort", effort };
+  }
+
+  if (command === "provider-arg") {
+    const action = tokens.shift() || "list";
+    if (action === "list") return { type: "provider-args-list" };
+    if (action === "clear") return { type: "provider-args-clear" };
+    if (action === "add") {
+      const value = tokens.join(" ").trim();
+      if (!value) throw new Error("/provider-arg add expects an argument");
+      return { type: "provider-args-add", value };
+    }
+    throw new Error('/provider-arg expects "add", "list", or "clear"');
+  }
+
+  if (command === "settings") {
+    const action = tokens[0] || "show";
+    if (action === "show") return { type: "settings-show" };
+    if (action === "reset") return { type: "settings-reset" };
+    throw new Error('/settings expects "show" or "reset"');
+  }
+
   if (command === "file" || command === "focus") {
     if (!tokens[0]) throw new Error(`/${command} expects a file path`);
     return { type: "file", file: tokens.join(" ") };
@@ -84,6 +121,13 @@ export function formatSlashHelpLines() {
     "/status",
     "/doctor",
     "/provider <auto|claude|codex>",
+    "/model <model|default>",
+    "/effort <low|medium|high|xhigh|max|default>",
+    "/provider-arg add <arg>",
+    "/provider-arg list",
+    "/provider-arg clear",
+    "/settings",
+    "/settings reset",
     "/clear",
     "/quit",
   ];

package/lib/cli/assistant/state.mjs

@@ -5,10 +5,31 @@ import { parseSlashCommand, formatSlashHelpLines } from "./slash-commands.mjs";
 import { executeAssistantTool } from "./tool-registry.mjs";
 import { runAssistantConversationTurn } from "./session.mjs";
 import { prepareAssistantContextPack } from "./context-pack.mjs";
+import {
+  DEFAULT_ASSISTANT_SETTINGS,
+  loadAssistantSettings,
+  mergeAssistantSettings,
+  resetAssistantSettings,
+  saveAssistantSettings,
+} from "./settings.mjs";
+import {
+  backspaceComposerText,
+  createComposerState,
+  deleteComposerText,
+  insertComposerText,
+  moveComposerCursor as moveComposerCursorState,
+  moveComposerCursorToEnd as moveComposerCursorStateToEnd,
+  moveComposerCursorToStart as moveComposerCursorStateToStart,
+  setComposerText,
+} from "./composer.mjs";
 
 export function createAssistantState({
   productDir,
-  provider = "auto",
+  provider,
+  model,
+  effort,
+  providerArgs,
+  resetSettings = false,
   dataSource = "artifact",
   configs = [],
   env = process.env,
@@ -21,11 +42,19 @@ export function createAssistantState({
 
   const listeners = new Set();
   const messages = [];
-  let composer = "";
-  let composerCursor = 0;
+  let composerState = createComposerState();
   let notice = null;
   let busy = false;
-  let providerName = provider;
+  let settings = mergeAssistantSettings(
+    resetSettings ? resetAssistantSettings(productDir) : loadAssistantSettings(productDir),
+    {
+      provider,
+      model,
+      effort,
+      providerArgs,
+    }
+  );
+  let resolvedProviderName = null;
   let activeStatus = null;
 
   inspectState.subscribe(() => {
@@ -90,16 +119,12 @@ export function createAssistantState({
     },
 
     setComposer(value) {
-      composer = String(value || "");
-      composerCursor = Math.max(0, Math.min(composer.length, composerCursor));
+      composerState = setComposerText(composerState, value);
       notify();
     },
 
     insertComposer(text) {
-      const nextText = String(text || "");
-      if (!nextText) return;
-      composer = `${composer.slice(0, composerCursor)}${nextText}${composer.slice(composerCursor)}`;
-      composerCursor += nextText.length;
+      composerState = insertComposerText(composerState, text);
       notify();
     },
 
@@ -108,30 +133,27 @@ export function createAssistantState({
     },
 
     backspaceComposer() {
-      if (composerCursor === 0) return;
-      composer = `${composer.slice(0, composerCursor - 1)}${composer.slice(composerCursor)}`;
-      composerCursor -= 1;
+      composerState = backspaceComposerText(composerState);
       notify();
     },
 
     deleteComposer() {
-      if (composerCursor >= composer.length) return;
-      composer = `${composer.slice(0, composerCursor)}${composer.slice(composerCursor + 1)}`;
+      composerState = deleteComposerText(composerState);
       notify();
     },
 
     moveComposerCursor(delta) {
-      composerCursor = Math.max(0, Math.min(composer.length, composerCursor + delta));
+      composerState = moveComposerCursorState(composerState, delta);
       notify();
     },
 
     moveComposerCursorToStart() {
-      composerCursor = 0;
+      composerState = moveComposerCursorStateToStart(composerState);
       notify();
     },
 
     moveComposerCursorToEnd() {
-      composerCursor = composer.length;
+      composerState = moveComposerCursorStateToEnd(composerState);
       notify();
     },
 
@@ -146,7 +168,41 @@ export function createAssistantState({
     },
 
     setProvider(nextProvider) {
-      providerName = nextProvider || "auto";
+      settings = mergeAssistantSettings(settings, { provider: nextProvider || DEFAULT_ASSISTANT_SETTINGS.provider });
+      resolvedProviderName = null;
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    setModel(nextModel) {
+      settings = mergeAssistantSettings(settings, { model: nextModel || null });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    setEffort(nextEffort) {
+      settings = mergeAssistantSettings(settings, { effort: nextEffort || null });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    addProviderArg(value) {
+      const arg = String(value || "").trim();
+      if (!arg) return;
+      settings = mergeAssistantSettings(settings, { providerArgs: [...settings.providerArgs, arg] });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    clearProviderArgs() {
+      settings = mergeAssistantSettings(settings, { providerArgs: [] });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    resetSettings() {
+      settings = resetAssistantSettings(productDir);
+      resolvedProviderName = null;
       notify();
     },
 
@@ -156,9 +212,8 @@ export function createAssistantState({
     },
 
     async submitCurrentComposer() {
-      const value = composer.trim();
-      composer = "";
-      composerCursor = 0;
+      const value = composerState.text.trim();
+      composerState = createComposerState();
       notify();
       if (!value) return;
       await state.submitInput(value);
@@ -180,7 +235,7 @@ export function createAssistantState({
             slash,
             state,
             productDir,
-            providerName,
+            settings,
             configs,
             env,
             appendMessage,
@@ -197,13 +252,13 @@ export function createAssistantState({
       }
 
       try {
-        setBusy(true, `Thinking with ${providerName === "auto" ? "provider" : providerName}...`);
+        setBusy(true, `Thinking with ${settings.provider === "auto" ? "provider" : settings.provider}...`);
         const emitted = await runAssistantConversationTurn({
           productDir,
           inspectState,
           transcript: messages.map((entry) => ({ role: entry.role, text: entry.text })),
           userMessage: trimmed,
-          provider: providerName,
+          settings,
           env,
           configs,
           commandLog,
@@ -211,6 +266,10 @@ export function createAssistantState({
             activeStatus = status;
             notify();
           },
+          onResolvedProvider(provider) {
+            resolvedProviderName = provider;
+            notify();
+          },
         });
         for (const message of emitted) appendMessage(message);
       } catch (error) {
@@ -233,11 +292,15 @@ export function createAssistantState({
       return {
         context: buildContextSelection(inspectState.getSnapshot()),
         messages: [...messages],
-        composer,
-        composerCursor,
+        composer: composerState.text,
+        composerCursor: composerState.cursor,
         notice,
         busy,
-        provider: providerName,
+        provider: settings.provider,
+        resolvedProvider: resolvedProviderName,
+        model: settings.model,
+        effort: settings.effort,
+        providerArgs: [...settings.providerArgs],
         activeStatus,
         contextPaths: {
           contextPath: commandLog.contextPath,
@@ -258,7 +321,7 @@ async function executeSlashCommand({
   slash,
   state,
   productDir,
-  providerName,
+  settings,
   configs,
   env,
   appendMessage,
@@ -280,6 +343,40 @@ async function executeSlashCommand({
     appendMessage({ role: "assistant", text: `Provider set to ${slash.provider}.` });
     return;
   }
+  if (slash.type === "model") {
+    state.setModel(slash.model);
+    appendMessage({ role: "assistant", text: slash.model ? `Model set to ${slash.model}.` : "Model reset to provider default." });
+    return;
+  }
+  if (slash.type === "effort") {
+    state.setEffort(slash.effort);
+    appendMessage({ role: "assistant", text: slash.effort ? `Effort set to ${slash.effort}.` : "Effort reset to provider default." });
+    return;
+  }
+  if (slash.type === "provider-args-add") {
+    state.addProviderArg(slash.value);
+    appendMessage({ role: "assistant", text: `Provider arg added: ${slash.value}` });
+    return;
+  }
+  if (slash.type === "provider-args-clear") {
+    state.clearProviderArgs();
+    appendMessage({ role: "assistant", text: "Provider args cleared." });
+    return;
+  }
+  if (slash.type === "provider-args-list") {
+    const args = state.getSnapshot().providerArgs;
+    appendMessage({ role: "assistant", text: args.length ? args.map((arg) => `- ${arg}`).join("\n") : "No provider args configured." });
+    return;
+  }
+  if (slash.type === "settings-show") {
+    appendMessage({ role: "assistant", text: formatSettings(state.getSnapshot()) });
+    return;
+  }
+  if (slash.type === "settings-reset") {
+    state.resetSettings();
+    appendMessage({ role: "assistant", text: "Assistant settings reset." });
+    return;
+  }
 
   const result = await executeSlashTool(slash, {
     productDir,
@@ -292,7 +389,7 @@ async function executeSlashCommand({
         state.setNotice(event.message);
       }
     },
-    provider: providerName,
+    provider: settings.provider,
   });
   appendMessage({
     role: "tool",
@@ -303,6 +400,17 @@ async function executeSlashCommand({
   });
 }
 
+function formatSettings(snapshot) {
+  const rows = [
+    ["Provider", snapshot.provider || "auto"],
+    ["Resolved", snapshot.resolvedProvider || "not resolved yet"],
+    ["Model", snapshot.model || "provider default"],
+    ["Effort", snapshot.effort || "provider default"],
+    ["Provider args", snapshot.providerArgs?.length ? snapshot.providerArgs.join(" ") : "none"],
+  ];
+  return rows.map(([label, value]) => `${label}: ${value}`).join("\n");
+}
+
 async function executeSlashTool(slash, context) {
   switch (slash.type) {
     case "inspect":

package/lib/cli/commands/assistant.mjs

@@ -13,7 +13,20 @@ export default class AssistantCommand extends Command {
     provider: Flags.string({
       description: "Assistant provider",
       options: ["auto", "claude", "codex"],
-      default: "auto",
+    }),
+    model: Flags.string({
+      description: "Assistant model",
+    }),
+    effort: Flags.string({
+      description: "Assistant effort",
+      options: ["low", "medium", "high", "xhigh", "max"],
+    }),
+    "provider-arg": Flags.string({
+      description: "Advanced provider-specific argument, repeatable",
+      multiple: true,
+    }),
+    "reset-assistant-settings": Flags.boolean({
+      description: "Reset persisted assistant provider/model settings before starting",
     }),
     file: Flags.string({
       description: "Initial file selection",
@@ -47,6 +60,10 @@ export default class AssistantCommand extends Command {
       const assistantState = createAssistantState({
         productDir,
         provider: flags.provider,
+        model: flags.model,
+        effort: flags.effort,
+        providerArgs: flags["provider-arg"],
+        resetSettings: flags["reset-assistant-settings"],
         configs: allConfigs,
         env: process.env,
       });
@@ -83,6 +100,10 @@ export default class AssistantCommand extends Command {
     return runInteractiveAssistant({
       productDir,
       provider: flags.provider,
+      model: flags.model,
+      effort: flags.effort,
+      providerArgs: flags["provider-arg"],
+      resetSettings: flags["reset-assistant-settings"],
       file: flags.file || null,
       service: flags.service || null,
       prompt: flags.prompt || null,

package/lib/cli/entrypoint.mjs

@@ -35,6 +35,9 @@ export function normalizeCliArgs(argv) {
     "--tail",
     "--log-tail",
     "--provider",
+    "--model",
+    "--effort",
+    "--provider-arg",
     "--message",
     "--prompt",
   ]);

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.91",
+  "version": "0.1.93",
   "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.91",
+  "version": "0.1.93",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.91",
-  "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
+  "version": "0.1.93",
+  "description": "Assistant-first CLI for running, inspecting, and debugging local testkit suites",
   "type": "module",
   "workspaces": [
     "packages/*"
@@ -82,10 +82,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.91",
-    "@elench/testkit-bridge": "0.1.91",
-    "@elench/testkit-protocol": "0.1.91",
-    "@elench/ts-analysis": "0.1.91",
+    "@elench/next-analysis": "0.1.93",
+    "@elench/testkit-bridge": "0.1.93",
+    "@elench/testkit-protocol": "0.1.93",
+    "@elench/ts-analysis": "0.1.93",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",