@elench/testkit 0.1.93 → 0.1.96

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/prompt-builder.mjs

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

package/lib/cli/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();
@@ -270,6 +277,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 +309,8 @@ export function createAssistantState({
     getSnapshot() {
       return {
         context: buildContextSelection(inspectState.getSnapshot()),
+        inspect: inspectState.getSnapshot(),
+        productDir,
         messages: [...messages],
         composer: composerState.text,
         composerCursor: composerState.cursor,
@@ -302,6 +322,7 @@ export function createAssistantState({
         effort: settings.effort,
         providerArgs: [...settings.providerArgs],
         activeStatus,
+        contextUsage,
         contextPaths: {
           contextPath: commandLog.contextPath,
           summaryPath: commandLog.summaryPath,
@@ -317,6 +338,13 @@ 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;
+}
+
 async function executeSlashCommand({
   slash,
   state,
@@ -385,7 +413,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 +439,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"],

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

@@ -5,6 +5,7 @@ import { loadCurrentRunArtifact, loadLatestRunArtifact, resolveFileSubject } fro
 import {
   readContextContent,
 } from "../context-resources.mjs";
+import { extractShellCommand, planShellCommand } from "./command-plan.mjs";
 
 const COMMAND_OUTPUT_LIMIT = 14_000;
 const COMMAND_LINE_LIMIT = 220;
@@ -14,7 +15,7 @@ export function listAssistantTools() {
   return [
     {
       name: "shell_exec",
-      description: "Execute a shell command inside the repository. Prefer real repo commands such as npm, npx, and testkit.",
+      description: "Execute a shell command inside the repository. Use local testkit commands for testkit work.",
     },
     {
       name: "read_context",
@@ -48,10 +49,10 @@ export async function executeAssistantTool(name, argumentsObject, context) {
 }
 
 async function shellExecTool(args, context) {
-  const command = String(args.command || "").trim();
+  const command = extractShellCommand(args).trim();
   if (!command) throw new Error("shell_exec requires a command string");
 
-  const shellCommand = classifyShellCommand(command);
+  const shellCommand = planShellCommand(command);
   const commandId = `cmd-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
   context.commandLog?.appendCommandLog({
     type: "command_start",
@@ -59,14 +60,22 @@ async function shellExecTool(args, context) {
     commandId,
     cwd: context.productDir,
     raw: command,
+    executable: shellCommand.executableCommand,
+    normalized: shellCommand.normalized,
   });
   context.onEvent?.({
-    type: "tool-status",
+    type: "tool-start",
     tool: "shell_exec",
-    message: `Running ${shellCommand.display}`,
+    command: shellCommand.executableCommand,
+    rawCommand: command,
+    title: shellCommand.title,
+    testkitRelated: shellCommand.testkitRelated,
+    message: shellCommand.normalized
+      ? `Running ${shellCommand.displayCommand} (${shellCommand.normalizationReason})`
+      : `Running ${shellCommand.displayCommand}`,
   });
 
-  const result = await execaCommand(command, {
+  const result = await execaCommand(shellCommand.executableCommand, {
     cwd: context.productDir,
     reject: false,
     shell: true,
@@ -84,8 +93,21 @@ async function shellExecTool(args, context) {
     commandId,
     cwd: context.productDir,
     raw: command,
+    executable: shellCommand.executableCommand,
+    normalized: shellCommand.normalized,
+    code: result.exitCode ?? 0,
+    signal: result.signal ?? null,
+  });
+  context.onEvent?.({
+    type: "tool-exit",
+    tool: "shell_exec",
+    command: shellCommand.executableCommand,
+    rawCommand: command,
+    title: shellCommand.title,
+    testkitRelated: shellCommand.testkitRelated,
     code: result.exitCode ?? 0,
     signal: result.signal ?? null,
+    message: `${shellCommand.displayCommand} exited ${result.exitCode ?? 0}`,
   });
 
   if (shellCommand.testkitRelated) {
@@ -93,13 +115,15 @@ async function shellExecTool(args, context) {
   }
   context.commandLog?.refresh?.();
 
-  const lines = formatCommandResult(command, result, shellCommand);
+  const lines = formatCommandResult(result, shellCommand);
   return {
     ok: (result.exitCode ?? 0) === 0,
     title: shellCommand.title,
     text: lines.join("\n"),
     data: {
       command,
+      executableCommand: shellCommand.executableCommand,
+      normalizedCommand: shellCommand.normalized,
       stdout: result.stdout || "",
       stderr: result.stderr || "",
       exitCode: result.exitCode ?? 0,
@@ -203,42 +227,11 @@ async function searchRepoTool(args, context) {
   };
 }
 
-function classifyShellCommand(command) {
-  const normalized = command.trim();
-  if (/^(testkit)\b/.test(normalized)) {
-    return {
-      command: "testkit",
-      display: normalized,
-      title: "testkit command",
-      testkitRelated: true,
-    };
+function formatCommandResult(result, shellCommand) {
+  const lines = [`$ ${shellCommand.displayCommand}`];
+  if (shellCommand.normalized) {
+    lines.push(`normalized from: ${shellCommand.rawCommand}`);
   }
-  if (/^(npx)\s+testkit\b/.test(normalized)) {
-    return {
-      command: "npx testkit",
-      display: normalized,
-      title: "npx testkit",
-      testkitRelated: true,
-    };
-  }
-  if (/^(npm)\s+run\s+testkit\b/.test(normalized) || /^(npm)\s+run\s+testkit:/.test(normalized)) {
-    return {
-      command: "npm run testkit",
-      display: normalized,
-      title: "npm testkit script",
-      testkitRelated: true,
-    };
-  }
-  return {
-    command: normalized.split(/\s+/)[0] || "command",
-    display: normalized,
-    title: "Shell command",
-    testkitRelated: false,
-  };
-}
-
-function formatCommandResult(command, result, shellCommand) {
-  const lines = [`$ ${command}`];
   const stdout = (result.stdout || "").trim();
   const stderr = (result.stderr || "").trim();
   const merged = [];

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/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.96",
   "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.96",
   "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.96"
   },
   "private": false
 }