@elench/testkit 0.1.108 → 0.1.110

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

@@ -12,6 +12,7 @@ export function buildAssistantViewModel(snapshot, { cwd = process.cwd(), termina
   return {
     title: `testkit · ${repoName}`,
     welcome: buildWelcomeModel(snapshot, { cwd, providerLabel }),
+    qualitySignal: buildQualitySignal(snapshot),
     blocks: buildTranscriptBlocks(snapshot.messages || []),
     composer: {
       text: snapshot.composer || "",
@@ -25,6 +26,84 @@ export function buildAssistantViewModel(snapshot, { cwd = process.cwd(), termina
   };
 }
 
+export function buildQualitySignal(snapshot = {}) {
+  const summaryRows = snapshot?.run?.summaryData?.rows || snapshot?.summaryData?.rows || [];
+  const rowValue = (label) => summaryRows.find(([key]) => key === label)?.[1] || null;
+  const latestResult = rowValue("Result");
+  const summaryFiles = rowValue("Files");
+  const plannedFiles = snapshot?.run?.totalCount ? String(snapshot.run.totalCount) : null;
+  const files = summaryFiles || plannedFiles;
+  const failed = rowValue("Failed");
+  const duration = rowValue("Duration");
+  const newRegressions = rowValue("New regressions");
+  const fixedKnown = rowValue("Fixed known");
+  const contextSelection = snapshot?.context?.selection || {};
+  const items = [];
+
+  if (files && files !== "0") {
+    items.push({
+      id: summaryFiles ? "tested-files" : "planned-files",
+      text: `${files} ${summaryFiles ? "tested" : "planned"}`,
+      tone: "neutral",
+    });
+  }
+
+  if (newRegressions && newRegressions !== "0") {
+    items.push({
+      id: "new-regressions",
+      text: `${newRegressions} new regression${newRegressions === "1" ? "" : "s"}`,
+      tone: "danger",
+    });
+  } else if (fixedKnown && fixedKnown !== "0") {
+    items.push({
+      id: "fixed-known",
+      text: `${fixedKnown} fixed known`,
+      tone: "good",
+    });
+  } else if (latestResult === "PASSED") {
+    items.push({
+      id: "no-regressions",
+      text: "no regressions",
+      tone: "good",
+    });
+  } else if (latestResult === "FAILED" && failed && failed !== "0") {
+    items.push({
+      id: "failed-files",
+      text: `${failed} failed`,
+      tone: "danger",
+    });
+  }
+
+  if (latestResult) {
+    const status = latestResult === "PASSED" ? "passed" : latestResult === "FAILED" ? "failed" : latestResult.toLowerCase();
+    items.push({
+      id: "latest-status",
+      text: duration ? `${status} in ${duration}` : status,
+      tone: latestResult === "PASSED" ? "good" : latestResult === "FAILED" ? "danger" : "neutral",
+    });
+  }
+
+  if (contextSelection.filePath) {
+    items.push({
+      id: "focus",
+      text: `focus ${path.basename(contextSelection.filePath)}`,
+      tone: "progress",
+    });
+  } else if (!latestResult) {
+    items.push({
+      id: "ready",
+      text: "ready to run",
+      tone: "progress",
+    });
+  }
+
+  return {
+    label: "Quality signal",
+    tone: latestResult === "FAILED" ? "danger" : latestResult === "PASSED" ? "good" : "neutral",
+    items,
+  };
+}
+
 export function buildWelcomeModel(snapshot, { cwd = process.cwd(), providerLabel = null } = {}) {
   const summaryRows = snapshot?.run?.summaryData?.rows || snapshot?.summaryData?.rows || [];
   const rowValue = (label) => summaryRows.find(([key]) => key === label)?.[1] || null;

package/lib/cli/command-flags.mjs

@@ -1,4 +1,5 @@
 import { Flags } from "@oclif/core";
+import { publicTestTypeListText } from "../domain/test-types.mjs";
 
 export const sharedFlags = {
   dir: Flags.string({
@@ -14,7 +15,7 @@ export const runFlags = {
   type: Flags.string({
     char: "t",
     multiple: true,
-    description: "Run specific suite type(s): int, e2e, scenario, dal, load, pw, all",
+    description: `Run specific suite type(s): ${publicTestTypeListText({ includeAll: true })}`,
   }),
   suite: Flags.string({
     char: "s",

package/lib/cli/commands/cleanup.mjs

@@ -1,4 +1,4 @@
-import { Command } from "@oclif/core";
+import { Command, Flags } from "@oclif/core";
 import { sharedFlags } from "../command-flags.mjs";
 import { executeCleanupOperation } from "../operations/cleanup/operation.mjs";
 import { renderCleanupResult } from "../renderers/cleanup/text.mjs";
@@ -8,7 +8,18 @@ export default class CleanupCommand extends Command {
 
   static enableJsonFlag = true;
 
-  static flags = sharedFlags;
+  static flags = {
+    ...sharedFlags,
+    "dry-run": Flags.boolean({
+      description: "Show cleanup actions without deleting state",
+      default: false,
+    }),
+    cache: Flags.string({
+      description: "Clean cache state: runtime, bundles, assistant, or all",
+      multiple: true,
+      options: ["runtime", "bundles", "assistant", "all"],
+    }),
+  };
 
   async run() {
     const { flags } = await this.parse(CleanupCommand);

package/lib/cli/commands/discover.mjs

@@ -3,6 +3,7 @@ import { executeDiscoverOperation } from "../operations/discover/operation.mjs";
 import { renderDiscoverResult } from "../renderers/discover/text.mjs";
 import { sharedFlags } from "../command-flags.mjs";
 import { withAssistantCommandResult } from "../assistant/command-results.mjs";
+import { publicTestTypeListText } from "../../domain/test-types.mjs";
 
 export default class DiscoverCommand extends Command {
   static summary = "Discover managed tests and report their metadata";
@@ -14,7 +15,7 @@ export default class DiscoverCommand extends Command {
     type: Flags.string({
       char: "t",
       multiple: true,
-      description: "Filter by suite type(s): int, e2e, scenario, dal, load, pw, all",
+      description: `Filter by suite type(s): ${publicTestTypeListText({ includeAll: true })}`,
     }),
     suite: Flags.string({
       char: "s",

package/lib/cli/commands/run.mjs

@@ -3,6 +3,7 @@ import { runFlags } from "../command-flags.mjs";
 import { buildRunRequest, executeRunRequest } from "../operations/run/operation.mjs";
 import { resolveTerminalCapabilities } from "../terminal/capabilities.mjs";
 import { withAssistantCommandResult } from "../assistant/command-results.mjs";
+import { publicTestTypeList, publicTestTypeListText } from "../../domain/test-types.mjs";
 
 export default class RunCommand extends Command {
   static summary = "Run test suites";
@@ -11,9 +12,9 @@ export default class RunCommand extends Command {
 
   static args = {
     type: Args.string({
-      description: "Optional suite type shortcut: int, e2e, scenario, dal, load, pw, all",
+      description: `Optional suite type shortcut: ${publicTestTypeListText({ includeAll: true })}`,
       required: false,
-      options: ["int", "e2e", "scenario", "dal", "load", "pw", "all"],
+      options: publicTestTypeList({ includeAll: true, includeLegacy: true }),
     }),
   };
 

package/lib/cli/entrypoint.mjs

@@ -1,3 +1,5 @@
+import { publicTestTypeList } from "../domain/test-types.mjs";
+
 export function normalizeCliArgs(argv) {
   if (argv[0] === "help") return normalizeHelpInvocation(argv);
   if (isOclifBuiltinInvocation(argv)) return argv;
@@ -14,7 +16,7 @@ export function normalizeCliArgs(argv) {
     "browser",
     "db",
   ]);
-  const runTypeShortcuts = new Set(["int", "e2e", "scenario", "dal", "load", "pw", "all"]);
+  const runTypeShortcuts = new Set(publicTestTypeList({ includeAll: true, includeLegacy: true }));
   const valueFlags = new Set([
     "--dir",
     "--service",

package/lib/cli/operations/cleanup/operation.mjs

@@ -4,5 +4,10 @@ import { loadManagedConfigs } from "../../../app/configs.mjs";
 export async function executeCleanupOperation(flags = {}) {
   const { allConfigs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
   const productDir = allConfigs[0]?.productDir || process.cwd();
-  return runner.cleanup(productDir);
+  return runner.cleanup(productDir, {
+    allConfigs,
+    serviceName: flags.service || null,
+    dryRun: flags["dry-run"],
+    cache: flags.cache || [],
+  });
 }

package/lib/cli/operations/status/operation.mjs

@@ -2,6 +2,6 @@ import * as runner from "../../../runner/index.mjs";
 import { loadManagedConfigs } from "../../../app/configs.mjs";
 
 export async function executeStatusOperation(flags = {}) {
-  const { configs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
-  return configs.map((config) => runner.showStatus(config));
+  const { allConfigs, configs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
+  return configs.map((config) => runner.showStatus(config, { allConfigs }));
 }

package/lib/cli/renderers/discover/report.mjs

@@ -10,7 +10,7 @@ import {
   statusLabel,
 } from "../../terminal/colors.mjs";
 
-const TYPE_ORDER = ["int", "e2e", "scenario", "dal", "load", "pw"];
+const TYPE_ORDER = ["ui", "e2e", "scenario", "int", "dal", "load"];
 
 const TREE_BRANCH = "\u251C\u2500\u2500 ";
 const TREE_LAST = "\u2514\u2500\u2500 ";
@@ -98,13 +98,11 @@ function buildVerboseLines(result) {
 
     const suites = result.suites.filter((suite) => suite.service === service.name).sort(compareSuites);
     for (const suite of suites) {
-      lines.push(
-        `  suite ${suite.selectionType}:${suite.name} ${muted(`[${suite.framework}]`)} ${muted(`${suite.fileCount} files`)}`
-      );
+      lines.push(`  suite ${suite.type}:${suite.name} ${muted(`${suite.fileCount} files`)}`);
       if (suite.locks.length > 0) {
         lines.push(`    locks ${suite.locks.join(", ")}`);
       }
-      for (const file of result.files.filter((entry) => entry.service === service.name && entry.suiteName === suite.name && entry.selectionType === suite.selectionType)) {
+      for (const file of result.files.filter((entry) => entry.service === service.name && entry.suiteName === suite.name && entry.type === suite.type)) {
         lines.push(`    ${file.displayName}`);
         lines.push(`      path ${file.path}`);
         lines.push(`      id ${file.id}`);
@@ -142,9 +140,9 @@ function groupSuitesByServiceAndType(suites) {
       byType = new Map();
       grouped.set(suite.service, byType);
     }
-    const list = byType.get(suite.selectionType) || [];
+    const list = byType.get(suite.type) || [];
     list.push(suite);
-    byType.set(suite.selectionType, list.sort(compareSuites));
+    byType.set(suite.type, list.sort(compareSuites));
   }
   return grouped;
 }
@@ -152,7 +150,7 @@ function groupSuitesByServiceAndType(suites) {
 function groupFilesBySuite(files) {
   const bySuite = new Map();
   for (const file of files) {
-    const suiteId = [file.service, file.selectionType, file.framework, file.suiteName].join("|");
+    const suiteId = [file.service, file.type, file.suiteName].join("|");
     const list = bySuite.get(suiteId) || [];
     list.push(file);
     bySuite.set(

package/lib/cli/renderers/run/failure.mjs

@@ -25,7 +25,7 @@ export function renderFailureBlock(task, outcome, { width, regressionCatalog } =
 }
 
 function normalizeRegressionType(task) {
-  if (task.framework === "playwright") return "pw";
+  if (task.framework === "playwright" || task.type === "ui") return "ui";
   if (task.type === "integration") return "int";
   return task.type;
 }

package/lib/cli/renderers/run/text-reporter.mjs

@@ -157,7 +157,7 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
 }
 
 function displayTaskType(task) {
-  if (task.framework === "playwright") return "pw";
+  if (task.framework === "playwright" || task.type === "ui") return "ui";
   if (task.type === "integration") return "int";
   return task.type;
 }

package/lib/cli/renderers/status/text.mjs

@@ -1,7 +1,107 @@
 export function renderStatusResult(result) {
-  return normalizeLines(result?.lines);
+  if (Array.isArray(result?.lines)) return normalizeLines(result.lines);
+  if (!result) return [];
+
+  const lines = [
+    `Testkit Status: ${result.name || result.product?.selectedService || "service"}`,
+    "",
+    "Product",
+    `  dir: ${result.product?.dir || "unknown"}`,
+    `  config: ${result.product?.configFile || "none"}`,
+    `  services: ${formatList(result.product?.services)}`,
+    `  dependencies: ${formatList(result.product?.dependencies)}`,
+    "",
+    "Runs",
+    `  active: ${result.runs?.active || 0}`,
+    `  stale: ${result.runs?.stale || 0}`,
+  ];
+
+  for (const run of (result.runs?.runs || []).slice(0, 5)) {
+    const ports = run.ports?.length ? ` ports=${run.ports.join(",")}` : "";
+    lines.push(`  ${run.runId}: ${run.status} pid=${run.pid}${ports}`);
+  }
+  if ((result.runs?.runs || []).length > 5) {
+    lines.push(`  ... ${(result.runs.runs.length - 5)} more run${result.runs.runs.length - 5 === 1 ? "" : "s"}`);
+  }
+
+  lines.push("", "Runtime Graphs");
+  if ((result.runtimeGraphs || []).length === 0) {
+    lines.push("  none");
+  } else {
+    for (const graph of result.runtimeGraphs || []) {
+      const marker = graph.orphan ? " orphan" : "";
+      lines.push(`  ${graph.name}${marker}`);
+      lines.push(`    desired instances: ${graph.desired?.instanceCount ?? "none"}`);
+      lines.push(`    runtime dirs: ${graph.runtimeDirCount || 0}`);
+      lines.push(`    current: ${formatRuntimeRange(graph.currentRuntimeDirs?.map((runtime) => runtime.id))}`);
+      lines.push(`    stale: ${formatRuntimeRange(graph.staleRuntimeDirs?.map((runtime) => runtime.id))}`);
+      lines.push(`    runtime services: ${formatList(graph.desired?.runtimeServices || graph.actual?.runtimeServices)}`);
+      lines.push(`    target services: ${formatList(graph.desired?.targetServices || graph.actual?.targetServices)}`);
+    }
+  }
+
+  lines.push(
+    "",
+    "Caches",
+    "  bundles",
+    `    size: ${formatBytes(result.caches?.bundles?.sizeBytes || 0)}`,
+    `    files: ${result.caches?.bundles?.fileCount || 0}`,
+    `    source files: ${result.caches?.bundles?.sourceFileCount || 0}`,
+    `    duplicated sources: ${result.caches?.bundles?.duplicatedSourceCount || 0}`,
+    `    inline sourcemaps: ${formatSourcemaps(result.caches?.bundles)}`,
+    `    manifest entries: ${result.caches?.bundles?.manifest?.entryCount || 0}`,
+    `    unmanaged files: ${result.caches?.bundles?.unmanagedFileCount || 0}`,
+    "  assistant command results",
+    `    size: ${formatBytes(result.caches?.assistant?.sizeBytes || 0)}`,
+    `    files: ${result.caches?.assistant?.fileCount || 0}`,
+    `    large files: ${result.caches?.assistant?.largeFileCount || 0}`
+  );
+
+  if (result.warnings?.length) {
+    lines.push("", "Warnings");
+    for (const warning of result.warnings) lines.push(`  - ${warning}`);
+  }
+
+  if (!result.hasState) {
+    lines.push("", "No state — run tests first.");
+  }
+
+  return lines;
 }
 
 function normalizeLines(lines) {
   return Array.isArray(lines) ? lines : [];
 }
+
+function formatList(values) {
+  const list = Array.isArray(values) ? values.filter(Boolean) : [];
+  return list.length > 0 ? list.join(", ") : "none";
+}
+
+function formatRuntimeRange(ids) {
+  const values = Array.isArray(ids) ? ids : [];
+  if (values.length === 0) return "none";
+  if (values.length === 1) return values[0];
+  return `${values[0]}..${values.at(-1)}`;
+}
+
+function formatBytes(value) {
+  const bytes = Number(value || 0);
+  if (bytes < 1024) return `${bytes}B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let amount = bytes / 1024;
+  let unitIndex = 0;
+  while (amount >= 1024 && unitIndex < units.length - 1) {
+    amount /= 1024;
+    unitIndex += 1;
+  }
+  return `${amount >= 10 ? amount.toFixed(0) : amount.toFixed(1)}${units[unitIndex]}`;
+}
+
+function formatSourcemaps(bundles = {}) {
+  if (bundles.sourcemapFileCount == null) return bundles.sourcemapStatus || "unknown";
+  if (bundles.sourcemapStatus && bundles.sourcemapStatus !== "present" && bundles.sourcemapStatus !== "none") {
+    return `${bundles.sourcemapFileCount} (${bundles.sourcemapStatus})`;
+  }
+  return String(bundles.sourcemapFileCount || 0);
+}

package/lib/config/discovery.mjs

@@ -15,7 +15,8 @@ const DISCOVERY_RULES = [
   { suffix: ".scenario.testkit.ts", type: "scenario", framework: "k6" },
   { suffix: ".dal.testkit.ts", type: "dal", framework: "k6" },
   { suffix: ".load.testkit.ts", type: "load", framework: "k6" },
-  { suffix: ".pw.testkit.ts", type: "e2e", framework: "playwright" },
+  { suffix: ".ui.testkit.ts", type: "ui", framework: "playwright" },
+  { suffix: ".pw.testkit.ts", type: "ui", framework: "playwright", legacySuffix: true },
 ];
 
 export function discoverProject(productDir, explicitServices = {}, options = {}) {
@@ -30,6 +31,14 @@ export function discoverProject(productDir, explicitServices = {}, options = {})
   for (const filePath of suiteFiles) {
     const rule = inferRule(filePath);
     if (!rule) continue;
+    if (rule.legacySuffix) {
+      diagnostics.push({
+        code: "legacy_ui_suffix",
+        severity: "warning",
+        message: `Legacy UI test suffix ".pw.testkit.ts" is deprecated. Rename to ".ui.testkit.ts": ${filePath}`,
+        path: filePath,
+      });
+    }
 
     const owners = inferOwners(filePath, explicitServices, repoDiscovery);
     if (owners === null) continue;

package/lib/config-api/index.mjs

@@ -225,9 +225,9 @@ function nextApp(options = {}) {
       readyTimeoutMs,
       env: mode === "start"
         ? {
-            NEXT_DIST_DIR: normalizedEnv.NEXT_DIST_DIR || ".next-testkit/{runtimeId}/dist",
+            NEXT_DIST_DIR: normalizedEnv.NEXT_DIST_DIR || "{productDir}/.next-testkit/{runtimeId}/dist",
             NEXT_TSCONFIG_PATH:
-              normalizedEnv.NEXT_TSCONFIG_PATH || ".next-testkit/{runtimeId}/tsconfig.json",
+              normalizedEnv.NEXT_TSCONFIG_PATH || "{productDir}/.next-testkit/{runtimeId}/tsconfig.json",
             ...normalizedEnv,
           }
         : normalizedEnv,

package/lib/config-api/next-runtime-tsconfig.mjs

@@ -3,12 +3,13 @@ import path from "path";
 
 export async function writeNextRuntimeTsconfig(context = {}) {
   const serviceDir = context.cwd || context.productDir;
+  const productDir = context.productDir || serviceDir;
   const runtimeId = context.runtimeId;
   if (!serviceDir || !runtimeId) {
     throw new Error("writeNextRuntimeTsconfig requires cwd and runtimeId");
   }
 
-  const runtimeRoot = path.join(serviceDir, ".next-testkit", String(runtimeId));
+  const runtimeRoot = path.join(productDir, ".next-testkit", String(runtimeId));
   const outputPath = path.join(runtimeRoot, "tsconfig.json");
   const outputDir = path.dirname(outputPath);
   const relative = (target) => path.relative(outputDir, target).replaceAll(path.sep, "/");

package/lib/coverage/graph-builder.mjs

@@ -70,8 +70,7 @@ export function buildCoverageGraph({ productDir, repoDiscovery = {}, services =
       confidence: "high",
       service: entry.serviceName,
       suiteName: entry.suiteName,
-      selectionType: toSelectionType(entry.type, entry.framework),
-      framework: entry.framework,
+      type: toSelectionType(entry.type, entry.framework),
       testFilePath: entry.filePath,
       coveredNodeIds,
       details: buildEvidenceDetails(coveredNodeIds, graph, entry, context),
@@ -173,8 +172,7 @@ function createFallbackEvidence(entry, testNodeId) {
     confidence: "medium",
     service: entry.serviceName,
     suiteName: entry.suiteName,
-    selectionType: toSelectionType(entry.type, entry.framework),
-    framework: entry.framework,
+    type: toSelectionType(entry.type, entry.framework),
     testFilePath: entry.filePath,
     coveredNodeIds: [testNodeId],
   };

package/lib/coverage/routing.mjs

@@ -53,7 +53,7 @@ export function apiRouteLookupKey(method, route) {
 }
 
 export function toSelectionType(type, framework) {
-  if (framework === "playwright") return "pw";
+  if (framework === "playwright" || type === "ui") return "ui";
   if (type === "integration") return "int";
   return type;
 }

package/lib/coverage/shared.mjs

@@ -67,7 +67,6 @@ export function createTestFileNode(graph, entry) {
       filePath: entry.filePath,
       metadata: {
         suiteName: entry.suiteName,
-        framework: entry.framework,
         type: toSelectionType(entry.type, entry.framework),
       },
     });
@@ -80,7 +79,7 @@ export function apiRouteLookupKey(method, route) {
 }
 
 export function toSelectionType(type, framework) {
-  if (framework === "playwright") return "pw";
+  if (framework === "playwright" || type === "ui") return "ui";
   if (type === "integration") return "int";
   return type;
 }

package/lib/discovery/index.d.ts

@@ -1,8 +1,7 @@
 import type { CoverageGraph } from "@elench/testkit-protocol";
 
-export type DiscoverySelectionType = "int" | "e2e" | "scenario" | "dal" | "load" | "pw";
-export type DiscoveryInternalType = "integration" | "e2e" | "scenario" | "dal" | "load";
-export type DiscoveryFramework = "k6" | "playwright";
+export type DiscoveryTestType = "ui" | "e2e" | "scenario" | "int" | "dal" | "load";
+export type DiscoveryInternalType = "ui" | "integration" | "e2e" | "scenario" | "dal" | "load";
 
 export interface DiscoveryDiagnostic {
   code: string;
@@ -28,9 +27,8 @@ export interface DiscoverySuite {
   service: string;
   name: string;
   displayName: string;
-  selectionType: DiscoverySelectionType;
+  type: DiscoveryTestType;
   internalType: DiscoveryInternalType;
-  framework: DiscoveryFramework;
   groupLabel: string;
   fileCount: number;
   activeFileCount: number;
@@ -59,9 +57,8 @@ export interface DiscoveryFile {
   service: string;
   suiteName: string;
   groupLabel: string;
-  selectionType: DiscoverySelectionType;
+  type: DiscoveryTestType;
   internalType: DiscoveryInternalType;
-  framework: DiscoveryFramework;
   skipped: boolean;
   skipReason: string | null;
   locks: string[];
@@ -79,7 +76,7 @@ export interface DiscoveryResult {
   configFile: string | null;
   filters: {
     service: string | null;
-    types: DiscoverySelectionType[] | ["all"];
+    types: DiscoveryTestType[] | ["all"];
     suiteSelectors: string[];
     fileNames: string[];
     runnableOnly: boolean;

package/lib/discovery/index.mjs

@@ -3,6 +3,7 @@ import { loadConfigContext, resolveProductDir } from "../config/index.mjs";
 import { discoverProject } from "../config/discovery.mjs";
 import { loadTestkitConfig } from "../config/config-loader.mjs";
 import { buildCoverageGraph } from "../coverage/index.mjs";
+import { formatPublicTestType } from "../domain/test-types.mjs";
 import { historyFilePath, loadHistory, summarizeHistoryForFiles } from "../history/index.mjs";
 import {
   matchesSelectedTypes,
@@ -124,12 +125,7 @@ export async function discoverTests(options = {}) {
 
 export function formatSelectionTypeLabel(type) {
   if (type === "int") return "Integration";
-  if (type === "e2e") return "E2E";
-  if (type === "scenario") return "Scenario";
-  if (type === "dal") return "DAL";
-  if (type === "load") return "Load";
-  if (type === "pw") return "Playwright";
-  return type;
+  return formatPublicTestType(type);
 }
 
 export function formatDisplayName(value) {
@@ -226,9 +222,8 @@ function buildResolvedSuiteEntries(config, suite, internalType, filters) {
       service: config.name,
       suiteName: suite.name,
       groupLabel: formatDisplayName(suite.name),
-      selectionType,
+      type: selectionType,
       internalType,
-      framework,
       skipped,
       skipReason,
       locks: [...new Set([...suiteLocks, ...fileLocks])].sort(),
@@ -239,13 +234,12 @@ function buildResolvedSuiteEntries(config, suite, internalType, filters) {
   if (visibleFiles.length === 0) return null;
   const skippedFileCount = visibleFiles.filter((entry) => entry.skipped).length;
   const suiteEntry = {
-    id: buildSuiteId(config.name, selectionType, suite.name, framework),
+    id: buildSuiteId(config.name, selectionType, suite.name),
     service: config.name,
     name: suite.name,
     displayName: formatDisplayName(suite.name),
-    selectionType,
+    type: selectionType,
     internalType,
-    framework,
     groupLabel: formatDisplayName(suite.name),
     fileCount: visibleFiles.length,
     activeFileCount: visibleFiles.length - skippedFileCount,
@@ -308,9 +302,8 @@ function buildRawDiscovery({ rawDiscovery, explicitServices, filters }) {
       service: entry.serviceName,
       suiteName: entry.suiteName,
       groupLabel: formatDisplayName(entry.suiteName),
-      selectionType,
+      type: selectionType,
       internalType: entry.type,
-      framework: entry.framework,
       skipped: false,
       skipReason: null,
       locks: [],
@@ -318,7 +311,7 @@ function buildRawDiscovery({ rawDiscovery, explicitServices, filters }) {
     };
     files.push(fileEntry);
 
-    const suiteId = buildSuiteId(entry.serviceName, selectionType, entry.suiteName, entry.framework);
+    const suiteId = buildSuiteId(entry.serviceName, selectionType, entry.suiteName);
     const existingSuite = suitesById.get(suiteId);
     if (existingSuite) {
       existingSuite.filePaths.push(entry.filePath);
@@ -330,9 +323,8 @@ function buildRawDiscovery({ rawDiscovery, explicitServices, filters }) {
         service: entry.serviceName,
         name: entry.suiteName,
         displayName: formatDisplayName(entry.suiteName),
-        selectionType,
+        type: selectionType,
         internalType: entry.type,
-        framework: entry.framework,
         groupLabel: formatDisplayName(entry.suiteName),
         fileCount: 1,
         activeFileCount: 1,
@@ -412,7 +404,7 @@ function buildSummary(services, suites, files, diagnostics) {
 
   for (const file of files) {
     byService[file.service] = (byService[file.service] || 0) + 1;
-    byType[file.selectionType] = (byType[file.selectionType] || 0) + 1;
+    byType[file.type] = (byType[file.type] || 0) + 1;
   }
 
   return {
@@ -497,12 +489,12 @@ function normalizePath(filePath) {
 export function fileDisplayName(filePath) {
   const base = path.posix
     .basename(filePath)
-    .replace(/(\.int|\.e2e|\.scenario|\.dal|\.load|\.pw)\.testkit\.ts$/, "");
+    .replace(/(\.int|\.e2e|\.scenario|\.dal|\.load|\.ui|\.pw)\.testkit\.ts$/, "");
   return formatDisplayName(base);
 }
 
-function buildSuiteId(serviceName, selectionType, suiteName, framework) {
-  return [serviceName, selectionType, framework, suiteName].join("|");
+function buildSuiteId(serviceName, selectionType, suiteName) {
+  return [serviceName, selectionType, suiteName].join("|");
 }
 
 function buildFileId(serviceName, selectionType, filePath) {
@@ -512,16 +504,15 @@ function buildFileId(serviceName, selectionType, filePath) {
 function compareSuiteEntries(left, right) {
   return (
     left.service.localeCompare(right.service) ||
-    left.selectionType.localeCompare(right.selectionType) ||
-    left.name.localeCompare(right.name) ||
-    left.framework.localeCompare(right.framework)
+    left.type.localeCompare(right.type) ||
+    left.name.localeCompare(right.name)
   );
 }
 
 function compareFileEntries(left, right) {
   return (
     left.service.localeCompare(right.service) ||
-    left.selectionType.localeCompare(right.selectionType) ||
+    left.type.localeCompare(right.type) ||
     left.suiteName.localeCompare(right.suiteName) ||
     left.path.localeCompare(right.path)
   );