diff --git a/benchmark/ci-test/README.md b/benchmark/ci-test/README.md
new file mode 100644
index 0000000000..568421a2f0
--- /dev/null
+++ b/benchmark/ci-test/README.md
@@ -0,0 +1,30 @@
+# CI Test Benchmark
+
+`ut run benchmark:ci-test` runs the reusable CI test benchmark harness and writes a Markdown report, a JSON summary, and the raw Vitest JSON reporter output.
+
+## Environment Setup
+
+- Use Node.js `>=22.18.0`.
+- Make sure the Utoo CLI is available as `ut`. The CI workflow uses `utooland/setup-utoo` before dependency installation.
+- Install workspace dependencies from the repository root with `ut install --from pnpm`, matching the CI workflow.
+- Run commands from the repository root so workspace paths and `vitest.config.ts` defaults can be detected.
+- Keep Redis and MySQL available when benchmarking suites that require them. The CI test job uses Redis 7 on the default Redis port and MySQL 8 with a `test` database; the benchmark harness mirrors the CI Vitest flags but does not start external services.
+- For CI-like metadata, set the relevant environment variables before running the command, for example `CI=1`, `GITHUB_SHA`, `RUNNER_OS`, or worker-related `VITEST_*` variables.
+
+## Usage
+
+```sh
+ut run benchmark:ci-test
+ut run benchmark:ci-test -- --coverage
+ut run benchmark:ci-test -- --output-dir .tmp/ci-benchmark -- ut execute vitest run packages/extend2/test/index.test.ts
+```
+
+The default output directory is `benchmark/ci-test/<timestamp>`. Use `--output-dir` for a deterministic path when collecting artifacts.
+
+## Outputs
+
+- `report.md`: human-readable benchmark report.
+- `report.json`: structured report containing environment, command, wall time, Vitest summary, long-tail file/project durations, and coverage/worker/isolate parameters.
+- `vitest-results.json`: raw Vitest JSON reporter output.
+
+The harness only writes reports for explicit benchmark runs. It does not change required checks or CI gate semantics. To collect reports in GitHub Actions, run the command in a manual or optional job and upload the output directory as an artifact.
diff --git a/package.json b/package.json
index 7063b24ae8..1d8b94c162 100644
--- a/package.json
+++ b/package.json
@@ -23,6 +23,7 @@
     "pretest": "ut run clean-dist && ut run pretest --workspaces --if-present",
     "test": "vitest run --bail 1 --retry 2 --testTimeout 20000 --hookTimeout 20000",
     "test:cov": "ut run test -- --coverage",
+    "benchmark:ci-test": "node scripts/ci-test-benchmark.js",
     "preci": "ut run pretest --workspaces --if-present",
     "ci": "ut run test -- --coverage",
     "site:dev": "cd site && npm run dev",
diff --git a/scripts/ci-test-benchmark.js b/scripts/ci-test-benchmark.js
new file mode 100644
index 0000000000..b067468174
--- /dev/null
+++ b/scripts/ci-test-benchmark.js
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { main } from './ci-test-benchmark/index.js';
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
diff --git a/scripts/ci-test-benchmark/cli.js b/scripts/ci-test-benchmark/cli.js
new file mode 100644
index 0000000000..43701f2c5a
--- /dev/null
+++ b/scripts/ci-test-benchmark/cli.js
@@ -0,0 +1,111 @@
+import { DEFAULT_TOP_LIMIT, VITEST_JSON_PLACEHOLDER } from './constants.js';
+
+export function printHelp() {
+  console.log(`
+Usage:
+  ut run benchmark:ci-test
+  ut run benchmark:ci-test -- --coverage
+  ut run benchmark:ci-test -- --output-dir .tmp/bench -- ut execute vitest run --maxWorkers=4
+
+Options:
+  --output-dir <dir>                 Directory for report.md, report.json, and raw Vitest JSON.
+  --name <label>                     Human-readable benchmark label.
+  --top <n>                          Number of long-tail files/projects to include. Default: ${DEFAULT_TOP_LIMIT}.
+  --coverage                         Append --coverage to the default Vitest command.
+  --no-append-vitest-json-reporter   Do not append --reporter=json/--outputFile to the command.
+  --dry-run                          Generate reports without executing the test command.
+  --help                             Show this help.
+
+Custom command:
+  Arguments after -- replace the default command. The script appends Vitest JSON reporter args by default.
+  Use ${VITEST_JSON_PLACEHOLDER} inside a custom command arg if the output path must be embedded manually.
+`);
+}
+
+export function parseArgs(argv) {
+  argv = normalizePackageManagerArgv(argv);
+  const options = {
+    appendVitestJsonReporter: true,
+    coverage: false,
+    dryRun: false,
+    name: 'CI test benchmark',
+    outputDir: '',
+    top: DEFAULT_TOP_LIMIT,
+  };
+  const command = [];
+
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === '--') {
+      command.push(...argv.slice(index + 1));
+      break;
+    }
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+    if (arg === '--coverage') {
+      options.coverage = true;
+      continue;
+    }
+    if (arg === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === '--no-append-vitest-json-reporter') {
+      options.appendVitestJsonReporter = false;
+      continue;
+    }
+    if (arg === '--output-dir') {
+      options.outputDir = readOptionValue(argv, ++index, arg);
+      continue;
+    }
+    if (arg.startsWith('--output-dir=')) {
+      options.outputDir = arg.slice('--output-dir='.length);
+      continue;
+    }
+    if (arg === '--name') {
+      options.name = readOptionValue(argv, ++index, arg);
+      continue;
+    }
+    if (arg.startsWith('--name=')) {
+      options.name = arg.slice('--name='.length);
+      continue;
+    }
+    if (arg === '--top') {
+      options.top = parsePositiveInteger(readOptionValue(argv, ++index, arg), arg);
+      continue;
+    }
+    if (arg.startsWith('--top=')) {
+      options.top = parsePositiveInteger(arg.slice('--top='.length), '--top');
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  return { command, options };
+}
+
+function normalizePackageManagerArgv(argv) {
+  if (argv[0] === '--' && argv.length > 1 && argv[1].startsWith('--')) {
+    return argv.slice(1);
+  }
+  return argv;
+}
+
+function readOptionValue(argv, index, optionName) {
+  const value = argv[index];
+  if (!value || value.startsWith('--')) {
+    throw new Error(`${optionName} requires a value`);
+  }
+  return value;
+}
+
+function parsePositiveInteger(value, optionName) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`${optionName} must be a positive integer`);
+  }
+  return parsed;
+}
diff --git a/scripts/ci-test-benchmark/command.js b/scripts/ci-test-benchmark/command.js
new file mode 100644
index 0000000000..9a9b7eff1c
--- /dev/null
+++ b/scripts/ci-test-benchmark/command.js
@@ -0,0 +1,92 @@
+import { DEFAULT_COMMAND, VITEST_JSON_PLACEHOLDER } from './constants.js';
+
+const BOOLEAN_COMMAND_OPTIONS = new Set(['--isolate', '--no-isolate']);
+
+export function buildCommand(commandArgs, options, vitestJsonPath) {
+  const command = commandArgs.length > 0 ? [...commandArgs] : [...DEFAULT_COMMAND];
+  if (options.coverage && commandArgs.length === 0) {
+    command.push('--coverage');
+  }
+
+  const replaced = command.map((arg) => arg.replaceAll(VITEST_JSON_PLACEHOLDER, vitestJsonPath));
+  if (!options.appendVitestJsonReporter) {
+    return replaced;
+  }
+
+  const reporterArgs = [];
+  if (!hasJsonReporter(replaced)) {
+    reporterArgs.push('--reporter=json');
+  }
+  if (!hasVitestOutputFile(replaced)) {
+    reporterArgs.push(`--outputFile=${vitestJsonPath}`);
+  }
+  return reporterArgs.length === 0 ? replaced : [...replaced, ...reporterArgs];
+}
+
+export function extractCommandParameters(command) {
+  return {
+    coverage: command.some((arg) => arg === '--coverage' || arg.startsWith('--coverage=')),
+    hookTimeout: collectOptionValues(command, ['--hookTimeout']),
+    isolate: collectOptionValues(command, ['--isolate', '--no-isolate']),
+    pool: collectOptionValues(command, ['--pool']),
+    reporter: collectOptionValues(command, ['--reporter']),
+    retry: collectOptionValues(command, ['--retry']),
+    testTimeout: collectOptionValues(command, ['--testTimeout']),
+    workers: collectOptionValues(command, [
+      '--maxWorkers',
+      '--minWorkers',
+      '--poolOptions.threads.maxThreads',
+      '--poolOptions.threads.minThreads',
+      '--poolOptions.forks.maxForks',
+      '--poolOptions.forks.minForks',
+    ]),
+  };
+}
+
+export function shellJoin(command) {
+  return command.map((arg) => (arg.includes(' ') ? JSON.stringify(arg) : arg)).join(' ');
+}
+
+function hasJsonReporter(command) {
+  for (let index = 0; index < command.length; index++) {
+    const arg = command[index];
+    if (arg === '--reporter=json') {
+      return true;
+    }
+    if (arg === '--reporter' && command[index + 1] === 'json') {
+      return true;
+    }
+  }
+  return false;
+}
+
+function hasVitestOutputFile(command) {
+  return command.some(
+    (arg) => arg === '--outputFile' || arg.startsWith('--outputFile=') || arg.startsWith('--outputFile.'),
+  );
+}
+
+function collectOptionValues(command, names) {
+  const values = [];
+  for (let index = 0; index < command.length; index++) {
+    const arg = command[index];
+    for (const name of names) {
+      if (arg === name) {
+        values.push({ name, value: getSeparatedOptionValue(name, command[index + 1]) });
+      } else if (arg.startsWith(`${name}=`)) {
+        values.push({ name, value: arg.slice(name.length + 1) });
+      }
+    }
+  }
+  return values;
+}
+
+function getSeparatedOptionValue(name, next) {
+  if (name.startsWith('--no-')) {
+    return false;
+  }
+  if (BOOLEAN_COMMAND_OPTIONS.has(name)) {
+    return true;
+  }
+  return next && !next.startsWith('--') ? next : true;
+}
diff --git a/scripts/ci-test-benchmark/constants.js b/scripts/ci-test-benchmark/constants.js
new file mode 100644
index 0000000000..12d5fc2447
--- /dev/null
+++ b/scripts/ci-test-benchmark/constants.js
@@ -0,0 +1,22 @@
+import path from 'node:path';
+
+export const DEFAULT_TOP_LIMIT = 20;
+export const DEFAULT_OUTPUT_ROOT = path.join('benchmark', 'ci-test');
+export const VITEST_JSON_FILENAME = 'vitest-results.json';
+export const REPORT_JSON_FILENAME = 'report.json';
+export const REPORT_MARKDOWN_FILENAME = 'report.md';
+export const VITEST_JSON_PLACEHOLDER = '{vitestJson}';
+export const DEFAULT_COMMAND = [
+  'ut',
+  'execute',
+  'vitest',
+  'run',
+  '--bail',
+  '1',
+  '--retry',
+  '2',
+  '--testTimeout',
+  '20000',
+  '--hookTimeout',
+  '20000',
+];
diff --git a/scripts/ci-test-benchmark/environment.js b/scripts/ci-test-benchmark/environment.js
new file mode 100644
index 0000000000..11acd86078
--- /dev/null
+++ b/scripts/ci-test-benchmark/environment.js
@@ -0,0 +1,84 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { extractCommandParameters } from './command.js';
+import { readJsonIfExists, readTextIfExists } from './fs.js';
+
+export async function collectEnvironment(command) {
+  const [packageJson, vitestConfig] = await Promise.all([
+    readJsonIfExists(path.resolve(process.cwd(), 'package.json')),
+    readVitestConfigDefaults(path.resolve(process.cwd(), 'vitest.config.ts')),
+  ]);
+  const cpus = os.cpus();
+
+  return {
+    arch: os.arch(),
+    ci: Boolean(process.env.CI),
+    commandParameters: extractCommandParameters(command),
+    cpuCount: cpus.length,
+    cpuModel: cpus[0]?.model ?? 'unknown',
+    cwd: process.cwd(),
+    env: pickEnv([
+      'CI',
+      'GITHUB_ACTIONS',
+      'GITHUB_EVENT_NAME',
+      'GITHUB_REF',
+      'GITHUB_RUN_ATTEMPT',
+      'GITHUB_RUN_ID',
+      'GITHUB_SHA',
+      'NODE_ENV',
+      'RUNNER_ARCH',
+      'RUNNER_NAME',
+      'RUNNER_OS',
+      'VITEST_MAX_THREADS',
+      'VITEST_MIN_THREADS',
+      'VITEST_POOL_ID',
+    ]),
+    loadavg: os.loadavg(),
+    node: process.version,
+    packageManager: packageJson?.packageManager ?? null,
+    platform: os.platform(),
+    release: os.release(),
+    totalMemoryBytes: os.totalmem(),
+    vitestConfig,
+  };
+}
+
+function pickEnv(names) {
+  const values = {};
+  for (const name of names) {
+    if (process.env[name] !== undefined) {
+      values[name] = process.env[name];
+    }
+  }
+  return values;
+}
+
+async function readVitestConfigDefaults(configPath) {
+  const source = await readTextIfExists(configPath);
+  if (!source) {
+    return null;
+  }
+  return {
+    coverageProvider: matchStringProperty(source, 'provider'),
+    isolate: matchBooleanProperty(source, 'isolate'),
+    pool: matchStringProperty(source, 'pool'),
+  };
+}
+
+function matchStringProperty(source, property) {
+  const match = new RegExp(`^\\s*(?!//|/\\*)${escapeRegExp(property)}:\\s*['"]([^'"]+)['"]`, 'm').exec(source);
+  return match?.[1] ?? null;
+}
+
+function matchBooleanProperty(source, property) {
+  const match = new RegExp(`^\\s*(?!//|/\\*)${escapeRegExp(property)}:\\s*(true|false)`, 'm').exec(source);
+  if (!match) {
+    return null;
+  }
+  return match[1] === 'true';
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
diff --git a/scripts/ci-test-benchmark/fs.js b/scripts/ci-test-benchmark/fs.js
new file mode 100644
index 0000000000..6b713ca492
--- /dev/null
+++ b/scripts/ci-test-benchmark/fs.js
@@ -0,0 +1,41 @@
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+
+export async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+
+export async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readJsonIfExists(filePath) {
+  if (!(await pathExists(filePath))) {
+    return null;
+  }
+  try {
+    return JSON.parse(await readFile(filePath, 'utf8'));
+  } catch (error) {
+    console.warn(`Failed to parse JSON report at ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+export async function readTextIfExists(filePath) {
+  if (!(await pathExists(filePath))) {
+    return null;
+  }
+  return readFile(filePath, 'utf8');
+}
+
+export async function writeJson(filePath, value) {
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function writeText(filePath, value) {
+  await writeFile(filePath, value);
+}
diff --git a/scripts/ci-test-benchmark/index.js b/scripts/ci-test-benchmark/index.js
new file mode 100644
index 0000000000..7c3b0f2b08
--- /dev/null
+++ b/scripts/ci-test-benchmark/index.js
@@ -0,0 +1,70 @@
+import path from 'node:path';
+
+import { parseArgs, printHelp } from './cli.js';
+import { buildCommand } from './command.js';
+import {
+  DEFAULT_OUTPUT_ROOT,
+  REPORT_JSON_FILENAME,
+  REPORT_MARKDOWN_FILENAME,
+  VITEST_JSON_FILENAME,
+} from './constants.js';
+import { collectEnvironment } from './environment.js';
+import { ensureDir, readJsonIfExists } from './fs.js';
+import { createReport, writeReports } from './report.js';
+import { createDryRunResult, runCommand } from './run-command.js';
+
+export async function main(argv = process.argv.slice(2)) {
+  const { command: customCommand, options } = parseArgs(argv);
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  const outputDir = normalizeOutputDir(options.outputDir);
+  await ensureDir(outputDir);
+
+  const vitestJsonPath = path.join(outputDir, VITEST_JSON_FILENAME);
+  const reportJsonPath = path.join(outputDir, REPORT_JSON_FILENAME);
+  const reportMarkdownPath = path.join(outputDir, REPORT_MARKDOWN_FILENAME);
+  const command = buildCommand(customCommand, options, vitestJsonPath);
+  const env = {
+    ...process.env,
+    CI_BENCHMARK_OUTPUT_DIR: outputDir,
+    CI_BENCHMARK_VITEST_JSON: vitestJsonPath,
+  };
+  const run = options.dryRun ? createDryRunResult() : await runCommand(command, env);
+  const [vitestJson, environment] = await Promise.all([readJsonIfExists(vitestJsonPath), collectEnvironment(command)]);
+  const report = createReport({
+    command,
+    environment,
+    name: options.name,
+    outputFiles: {
+      json: reportJsonPath,
+      markdown: reportMarkdownPath,
+      vitestJson: vitestJsonPath,
+    },
+    run,
+    topLimit: options.top,
+    vitestJson,
+  });
+
+  await writeReports(report, reportJsonPath, reportMarkdownPath);
+
+  console.log(`Benchmark report written to ${reportMarkdownPath}`);
+  console.log(`Benchmark JSON written to ${reportJsonPath}`);
+
+  if (run.error) {
+    console.error(`Benchmark command failed to start: ${run.error.message}`);
+  }
+  if (run.exitCode !== 0) {
+    process.exitCode = run.exitCode ?? 1;
+  }
+}
+
+function createRunId(date = new Date()) {
+  return date.toISOString().replaceAll(':', '').replaceAll('.', '-');
+}
+
+function normalizeOutputDir(outputDir) {
+  return path.resolve(process.cwd(), outputDir || path.join(DEFAULT_OUTPUT_ROOT, createRunId()));
+}
diff --git a/scripts/ci-test-benchmark/report.js b/scripts/ci-test-benchmark/report.js
new file mode 100644
index 0000000000..f951b1d444
--- /dev/null
+++ b/scripts/ci-test-benchmark/report.js
@@ -0,0 +1,172 @@
+import { shellJoin } from './command.js';
+import { writeJson, writeText } from './fs.js';
+import { summarizeVitest } from './vitest-summary.js';
+
+export function createReport({ command, environment, name, outputFiles, run, topLimit, vitestJson }) {
+  return {
+    command,
+    environment,
+    generatedAt: new Date().toISOString(),
+    name,
+    outputFiles,
+    run,
+    topLimit,
+    vitest: vitestJson ? summarizeVitest(vitestJson, topLimit) : null,
+  };
+}
+
+export async function writeReports(report, reportJsonPath, reportMarkdownPath) {
+  await Promise.all([writeJson(reportJsonPath, report), writeText(reportMarkdownPath, renderMarkdown(report))]);
+}
+
+function renderMarkdown(report) {
+  const run = report.run;
+  const env = report.environment;
+  const vitest = report.vitest;
+  const summary = vitest?.rawSummary ?? {};
+  const lines = [
+    `# ${report.name}`,
+    '',
+    `Generated at: ${report.generatedAt}`,
+    '',
+    '## Command',
+    '',
+    '```sh',
+    shellJoin(report.command),
+    '```',
+    '',
+    '## Run',
+    '',
+    '| Field | Value |',
+    '| --- | --- |',
+    `| Exit code | ${formatValue(run.exitCode)} |`,
+    `| Signal | ${formatValue(run.signal)} |`,
+    `| Wall time | ${formatDuration(run.wallTimeMs)} |`,
+    `| Started at | ${run.startedAt} |`,
+    `| Ended at | ${run.endedAt} |`,
+    '',
+    '## Environment',
+    '',
+    '| Field | Value |',
+    '| --- | --- |',
+    `| Node | ${env.node} |`,
+    `| Platform | ${env.platform} ${env.release} ${env.arch} |`,
+    `| CPU | ${escapeTable(`${env.cpuCount} x ${env.cpuModel}`)} |`,
+    `| Total memory | ${formatBytes(env.totalMemoryBytes)} |`,
+    `| Package manager | ${formatValue(env.packageManager)} |`,
+    `| CI | ${String(env.ci)} |`,
+    `| Vitest pool default | ${formatValue(env.vitestConfig?.pool)} |`,
+    `| Vitest isolate default | ${formatValue(env.vitestConfig?.isolate)} |`,
+    `| Vitest coverage provider | ${formatValue(env.vitestConfig?.coverageProvider)} |`,
+    '',
+    '## Parameters',
+    '',
+    '| Parameter | Value |',
+    '| --- | --- |',
+    `| Coverage | ${String(env.commandParameters.coverage)} |`,
+    `| Reporter | ${formatOptionValues(env.commandParameters.reporter)} |`,
+    `| Retry | ${formatOptionValues(env.commandParameters.retry)} |`,
+    `| Test timeout | ${formatOptionValues(env.commandParameters.testTimeout)} |`,
+    `| Hook timeout | ${formatOptionValues(env.commandParameters.hookTimeout)} |`,
+    `| Pool | ${formatOptionValues(env.commandParameters.pool)} |`,
+    `| Worker options | ${formatOptionValues(env.commandParameters.workers)} |`,
+    `| Isolate options | ${formatOptionValues(env.commandParameters.isolate)} |`,
+    '',
+    '## Vitest Summary',
+    '',
+    '| Field | Value |',
+    '| --- | --- |',
+    `| Success | ${formatValue(summary.success)} |`,
+    `| Total suites | ${formatValue(summary.numTotalTestSuites)} |`,
+    `| Passed suites | ${formatValue(summary.numPassedTestSuites)} |`,
+    `| Failed suites | ${formatValue(summary.numFailedTestSuites)} |`,
+    `| Total tests | ${formatValue(summary.numTotalTests)} |`,
+    `| Passed tests | ${formatValue(summary.numPassedTests)} |`,
+    `| Failed tests | ${formatValue(summary.numFailedTests)} |`,
+    '',
+  ];
+
+  appendLongTailTables(lines, vitest);
+  appendOutputSection(lines, report);
+  return `${lines.join('\n')}\n`;
+}
+
+function appendLongTailTables(lines, vitest) {
+  if (!vitest) {
+    lines.push('Vitest JSON reporter output was not found, so per-file and per-project tables are unavailable.', '');
+    return;
+  }
+
+  lines.push(
+    '## Long-Tail Projects',
+    '',
+    '| Project | Files | Tests | Failed | Duration |',
+    '| --- | ---: | ---: | ---: | ---: |',
+    ...vitest.longTailProjects.map(
+      (project) =>
+        `| ${escapeTable(project.project)} | ${project.files} | ${project.totalTests} | ${project.failedTests} | ${formatDuration(project.durationMs)} |`,
+    ),
+    '',
+    '## Long-Tail Files',
+    '',
+    '| File | Project | Tests | Failed | Duration |',
+    '| --- | --- | ---: | ---: | ---: |',
+    ...vitest.longTailFiles.map(
+      (file) =>
+        `| ${escapeTable(file.file)} | ${escapeTable(file.project)} | ${file.totalTests} | ${file.failedTests} | ${formatDuration(file.durationMs)} |`,
+    ),
+    '',
+  );
+}
+
+function appendOutputSection(lines, report) {
+  lines.push(
+    '## Output Files',
+    '',
+    '| File | Path |',
+    '| --- | --- |',
+    `| Markdown report | ${escapeTable(report.outputFiles.markdown)} |`,
+    `| JSON report | ${escapeTable(report.outputFiles.json)} |`,
+    `| Raw Vitest JSON | ${escapeTable(report.outputFiles.vitestJson)} |`,
+    '',
+    '## GitHub Actions Artifact',
+    '',
+    'This command does not change required checks or CI gate semantics. To collect it in a manual workflow, run the benchmark command and upload the output directory as an artifact.',
+    '',
+  );
+}
+
+function formatOptionValues(values) {
+  if (!values || values.length === 0) {
+    return 'not set';
+  }
+  return escapeTable(values.map((item) => `${item.name}=${String(item.value)}`).join(', '));
+}
+
+function formatDuration(ms) {
+  if (typeof ms !== 'number') {
+    return 'n/a';
+  }
+  if (ms < 1000) {
+    return `${ms} ms`;
+  }
+  return `${(ms / 1000).toFixed(2)} s`;
+}
+
+function formatBytes(bytes) {
+  if (typeof bytes !== 'number') {
+    return 'n/a';
+  }
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GiB`;
+}
+
+function formatValue(value) {
+  if (value === undefined || value === null || value === '') {
+    return 'n/a';
+  }
+  return escapeTable(String(value));
+}
+
+function escapeTable(value) {
+  return String(value).replaceAll('|', '\\|').replaceAll('\n', '<br>');
+}
diff --git a/scripts/ci-test-benchmark/run-command.js b/scripts/ci-test-benchmark/run-command.js
new file mode 100644
index 0000000000..199d9dacbb
--- /dev/null
+++ b/scripts/ci-test-benchmark/run-command.js
@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+
+export async function runCommand(command, env) {
+  if (command.length === 0) {
+    throw new Error('No command to run');
+  }
+  const start = process.hrtime.bigint();
+  const startedAt = new Date().toISOString();
+  const result = await spawnCommand(command, env);
+  const endedAt = new Date().toISOString();
+  const wallTimeMs = Number((process.hrtime.bigint() - start) / 1_000_000n);
+
+  return {
+    ...result,
+    endedAt,
+    startedAt,
+    wallTimeMs,
+  };
+}
+
+export function createDryRunResult() {
+  const startedAt = new Date().toISOString();
+  return {
+    endedAt: new Date().toISOString(),
+    error: null,
+    exitCode: 0,
+    signal: null,
+    startedAt,
+    wallTimeMs: 0,
+  };
+}
+
+async function spawnCommand(command, env) {
+  return new Promise((resolve) => {
+    const child = spawn(command[0], command.slice(1), {
+      env,
+      shell: process.platform === 'win32',
+      stdio: 'inherit',
+    });
+
+    child.on('error', (error) => {
+      resolve({
+        error: {
+          code: error.code,
+          message: error.message,
+        },
+        exitCode: 1,
+        signal: null,
+      });
+    });
+    child.on('close', (exitCode, signal) => {
+      resolve({
+        error: null,
+        exitCode,
+        signal,
+      });
+    });
+  });
+}
diff --git a/scripts/ci-test-benchmark/vitest-summary.js b/scripts/ci-test-benchmark/vitest-summary.js
new file mode 100644
index 0000000000..f606c0f75b
--- /dev/null
+++ b/scripts/ci-test-benchmark/vitest-summary.js
@@ -0,0 +1,113 @@
+import path from 'node:path';
+
+export function summarizeVitest(vitestJson, topLimit) {
+  const testResults = Array.isArray(vitestJson?.testResults) ? vitestJson.testResults : [];
+  const files = testResults.map((result) => summarizeFileResult(result)).sort((a, b) => b.durationMs - a.durationMs);
+  const projects = summarizeProjects(files).sort((a, b) => b.durationMs - a.durationMs);
+
+  return {
+    files,
+    longTailFiles: files.slice(0, topLimit),
+    longTailProjects: projects.slice(0, topLimit),
+    projects,
+    rawSummary: pickExisting(vitestJson ?? {}, [
+      'numFailedTestSuites',
+      'numFailedTests',
+      'numPassedTestSuites',
+      'numPassedTests',
+      'numPendingTestSuites',
+      'numPendingTests',
+      'numRuntimeErrorTestSuites',
+      'numTodoTests',
+      'numTotalTestSuites',
+      'numTotalTests',
+      'openHandles',
+      'snapshot',
+      'startTime',
+      'success',
+      'wasInterrupted',
+    ]),
+  };
+}
+
+function summarizeFileResult(result) {
+  const filePath = result.name ?? result.filepath ?? result.filePath ?? result.path ?? 'unknown';
+  const assertions = Array.isArray(result.assertionResults) ? result.assertionResults : [];
+  return {
+    durationMs: getDurationMs(result),
+    failedTests: assertions.filter((assertion) => assertion.status === 'failed').length,
+    file: normalizeFilePath(filePath),
+    passedTests: assertions.filter((assertion) => assertion.status === 'passed').length,
+    pendingTests: assertions.filter((assertion) => assertion.status === 'pending' || assertion.status === 'skipped')
+      .length,
+    project: result.projectName ?? inferProjectName(filePath),
+    status: result.status ?? 'unknown',
+    totalTests: assertions.length,
+  };
+}
+
+function getDurationMs(result) {
+  if (typeof result.duration === 'number') {
+    return Math.max(0, Math.round(result.duration));
+  }
+  if (typeof result.perfStats?.runtime === 'number') {
+    return Math.max(0, Math.round(result.perfStats.runtime));
+  }
+  if (typeof result.perfStats?.start === 'number' && typeof result.perfStats?.end === 'number') {
+    return Math.max(0, Math.round(result.perfStats.end - result.perfStats.start));
+  }
+  if (typeof result.startTime === 'number' && typeof result.endTime === 'number') {
+    return Math.max(0, Math.round(result.endTime - result.startTime));
+  }
+  return 0;
+}
+
+function normalizeFilePath(filePath) {
+  const relative = path.isAbsolute(filePath) ? path.relative(process.cwd(), filePath) : filePath;
+  return relative.split(path.sep).join('/');
+}
+
+function inferProjectName(filePath) {
+  const normalized = normalizeFilePath(filePath);
+  const parts = normalized.split('/');
+  if (parts[0] === 'packages' || parts[0] === 'plugins' || parts[0] === 'tools' || parts[0] === 'examples') {
+    return parts.slice(0, 2).join('/');
+  }
+  if (parts[0] === 'tegg' && parts.length >= 3) {
+    return parts.slice(0, 3).join('/');
+  }
+  return parts[0] || 'unknown';
+}
+
+function summarizeProjects(files) {
+  const projects = new Map();
+  for (const file of files) {
+    const current = projects.get(file.project) ?? {
+      durationMs: 0,
+      failedTests: 0,
+      files: 0,
+      passedTests: 0,
+      pendingTests: 0,
+      project: file.project,
+      totalTests: 0,
+    };
+    current.durationMs += file.durationMs;
+    current.failedTests += file.failedTests;
+    current.files++;
+    current.passedTests += file.passedTests;
+    current.pendingTests += file.pendingTests;
+    current.totalTests += file.totalTests;
+    projects.set(file.project, current);
+  }
+  return [...projects.values()];
+}
+
+function pickExisting(source, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (source[key] !== undefined) {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}