diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fc9857da3e3f..04769331383b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,8 +17,8 @@ env:
   FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
 
 jobs:
-  # Preflight: establish routing truth and planner-owned matrices once, then let
-  # real work fan out from a single source of truth.
+  # Preflight: establish routing truth and job matrices once, then let real
+  # work fan out from a single source of truth.
   preflight:
     if: github.event_name != 'pull_request' || !github.event.pull_request.draft
     runs-on: blacksmith-16vcpu-ubuntu-2404
@@ -302,8 +302,6 @@ jobs:
       - name: Run ${{ matrix.task }} (${{ matrix.runtime }})
         env:
           TASK: ${{ matrix.task }}
-          SHARD_COUNT: ${{ matrix.shard_count || '' }}
-          SHARD_INDEX: ${{ matrix.shard_index || '' }}
         shell: bash
         run: |
           set -euo pipefail
@@ -312,10 +310,6 @@ jobs:
               pnpm test:bundled
               ;;
             extensions)
-              if [ -n "$SHARD_COUNT" ] && [ -n "$SHARD_INDEX" ]; then
-                export OPENCLAW_TEST_SHARDS="$SHARD_COUNT"
-                export OPENCLAW_TEST_SHARD_INDEX="$SHARD_INDEX"
-              fi
               pnpm test:extensions
               ;;
             contracts|contracts-protocol)
@@ -363,21 +357,13 @@ jobs:
         if: (github.event_name != 'pull_request' || matrix.task != 'compat-node22') && matrix.runtime == 'node' && (matrix.task == 'test' || matrix.task == 'channels' || matrix.task == 'compat-node22')
         env:
           TASK: ${{ matrix.task }}
-          SHARD_COUNT: ${{ matrix.shard_count || '' }}
-          SHARD_INDEX: ${{ matrix.shard_index || '' }}
         run: |
-          # `pnpm test:planner` runs `scripts/test-parallel.mjs`, which spawns multiple Node processes.
-          # Default heap limits have been too low on Linux CI (V8 OOM near 4GB).
-          echo "OPENCLAW_TEST_WORKERS=2" >> "$GITHUB_ENV"
-          echo "OPENCLAW_TEST_MAX_OLD_SPACE_SIZE_MB=6144" >> "$GITHUB_ENV"
+          echo "NODE_OPTIONS=--max-old-space-size=6144" >> "$GITHUB_ENV"
+          echo "OPENCLAW_VITEST_MAX_WORKERS=2" >> "$GITHUB_ENV"
           if [ "$TASK" = "channels" ]; then
-            echo "OPENCLAW_TEST_WORKERS=1" >> "$GITHUB_ENV"
+            echo "OPENCLAW_VITEST_MAX_WORKERS=1" >> "$GITHUB_ENV"
             echo "OPENCLAW_TEST_ISOLATE=1" >> "$GITHUB_ENV"
           fi
-          if [ -n "$SHARD_COUNT" ] && [ -n "$SHARD_INDEX" ]; then
-            echo "OPENCLAW_TEST_SHARDS=$SHARD_COUNT" >> "$GITHUB_ENV"
-            echo "OPENCLAW_TEST_SHARD_INDEX=$SHARD_INDEX" >> "$GITHUB_ENV"
-          fi
 
       - name: Download dist artifact
         if: matrix.task == 'test'
@@ -402,7 +388,7 @@ jobs:
           set -euo pipefail
           case "$TASK" in
             test)
-              pnpm test:planner
+              pnpm test
               ;;
             channels)
               pnpm test:channels
@@ -738,8 +724,7 @@ jobs:
     env:
       NODE_OPTIONS: --max-old-space-size=6144
       # Keep total concurrency predictable on the 32 vCPU runner.
-      # Windows shard 2 has shown intermittent instability at 2 workers.
-      OPENCLAW_TEST_WORKERS: 1
+      OPENCLAW_VITEST_MAX_WORKERS: 1
     defaults:
       run:
         shell: bash
@@ -812,15 +797,6 @@ jobs:
           # caches can skip repeated rebuild/download work on later shards/runs.
           pnpm install --frozen-lockfile --prefer-offline --ignore-scripts=false --config.engine-strict=false --config.enable-pre-post-scripts=true --config.side-effects-cache=true || pnpm install --frozen-lockfile --prefer-offline --ignore-scripts=false --config.engine-strict=false --config.enable-pre-post-scripts=true --config.side-effects-cache=true
 
-      - name: Configure test shard (Windows)
-        if: matrix.task == 'test'
-        env:
-          SHARD_COUNT: ${{ matrix.shard_count }}
-          SHARD_INDEX: ${{ matrix.shard_index }}
-        run: |
-          echo "OPENCLAW_TEST_SHARDS=$SHARD_COUNT" >> "$GITHUB_ENV"
-          echo "OPENCLAW_TEST_SHARD_INDEX=$SHARD_INDEX" >> "$GITHUB_ENV"
-
       - name: Download dist artifact
         if: matrix.task == 'test'
         uses: actions/download-artifact@v8
@@ -843,7 +819,7 @@ jobs:
           set -euo pipefail
           case "$TASK" in
             test)
-              pnpm test:planner
+              pnpm test
               ;;
             *)
               echo "Unsupported Windows checks task: $TASK" >&2
@@ -884,24 +860,17 @@ jobs:
           name: canvas-a2ui-bundle
           path: src/canvas-host/a2ui/
 
-      - name: Configure test shard (macOS)
-        env:
-          SHARD_COUNT: ${{ matrix.shard_count }}
-          SHARD_INDEX: ${{ matrix.shard_index }}
-        run: |
-          echo "OPENCLAW_TEST_SHARDS=$SHARD_COUNT" >> "$GITHUB_ENV"
-          echo "OPENCLAW_TEST_SHARD_INDEX=$SHARD_INDEX" >> "$GITHUB_ENV"
-
       - name: TS tests (macOS)
         env:
           NODE_OPTIONS: --max-old-space-size=4096
+          OPENCLAW_VITEST_MAX_WORKERS: 2
           TASK: ${{ matrix.task }}
         shell: bash
         run: |
           set -euo pipefail
           case "$TASK" in
             test)
-              pnpm test:planner
+              pnpm test
               ;;
             *)
               echo "Unsupported macOS node task: $TASK" >&2
diff --git a/package.json b/package.json
index 64901d27a844..e05793295189 100644
--- a/package.json
+++ b/package.json
@@ -1047,13 +1047,13 @@
     "test:all": "pnpm lint && pnpm build && pnpm test && pnpm test:e2e && pnpm test:live && pnpm test:docker:all",
     "test:auth:compat": "vitest run --config vitest.gateway.config.ts src/gateway/server.auth.compat-baseline.test.ts src/gateway/client.test.ts src/gateway/reconnect-gating.test.ts src/gateway/protocol/connect-error-details.test.ts",
     "test:build:singleton": "node scripts/test-built-plugin-singleton.mjs",
-    "test:bundled": "node scripts/test-parallel.mjs --surface bundled",
+    "test:bundled": "vitest run --config vitest.bundled.config.ts",
     "test:changed": "pnpm test -- --changed origin/main",
-    "test:changed:max": "node scripts/test-parallel.mjs --profile max --changed origin/main",
-    "test:channels": "node scripts/test-parallel.mjs --surface channels",
+    "test:changed:max": "OPENCLAW_VITEST_MAX_WORKERS=8 node scripts/test-projects.mjs --changed origin/main",
+    "test:channels": "vitest run --config vitest.channels.config.ts",
     "test:contracts": "pnpm test:contracts:channels && pnpm test:contracts:plugins",
-    "test:contracts:channels": "OPENCLAW_TEST_PROFILE=serial pnpm exec vitest run --config vitest.contracts.config.ts src/channels/plugins/contracts",
-    "test:contracts:plugins": "OPENCLAW_TEST_PROFILE=serial pnpm exec vitest run --config vitest.contracts.config.ts src/plugins/contracts",
+    "test:contracts:channels": "pnpm exec vitest run --config vitest.contracts.config.ts --maxWorkers=1 src/channels/plugins/contracts",
+    "test:contracts:plugins": "pnpm exec vitest run --config vitest.contracts.config.ts --maxWorkers=1 src/plugins/contracts",
     "test:coverage": "vitest run --config vitest.unit.config.ts --coverage",
     "test:coverage:changed": "vitest run --config vitest.unit.config.ts --coverage --changed origin/main",
     "test:docker:all": "pnpm test:docker:live-build && OPENCLAW_SKIP_DOCKER_BUILD=1 pnpm test:docker:live-models && OPENCLAW_SKIP_DOCKER_BUILD=1 pnpm test:docker:live-gateway && pnpm test:docker:openwebui && pnpm test:docker:onboard && pnpm test:docker:gateway-network && pnpm test:docker:mcp-channels && pnpm test:docker:qr && pnpm test:docker:doctor-switch && pnpm test:docker:plugins && pnpm test:docker:cleanup",
@@ -1073,7 +1073,7 @@
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
     "test:e2e:openshell": "OPENCLAW_E2E_OPENSHELL=1 vitest run --config vitest.e2e.config.ts test/openshell-sandbox.e2e.test.ts",
     "test:extension": "node scripts/test-extension.mjs",
-    "test:extensions": "node scripts/test-parallel.mjs --surface extensions",
+    "test:extensions": "vitest run --config vitest.extensions.config.ts",
     "test:extensions:memory": "node scripts/profile-extension-memory.mjs",
     "test:fast": "vitest run --config vitest.unit.config.ts",
     "test:force": "node --import tsx scripts/test-force.ts",
@@ -1086,25 +1086,20 @@
     "test:live": "node scripts/test-live.mjs",
     "test:live:gateway-profiles": "node scripts/test-live.mjs -- src/gateway/gateway-models.profiles.live.test.ts",
     "test:live:models-profiles": "node scripts/test-live.mjs -- src/agents/models.profiles.live.test.ts",
-    "test:max": "node scripts/test-parallel.mjs --profile max",
+    "test:max": "OPENCLAW_VITEST_MAX_WORKERS=8 node scripts/test-projects.mjs",
     "test:parallels:linux": "bash scripts/e2e/parallels-linux-smoke.sh",
     "test:parallels:macos": "bash scripts/e2e/parallels-macos-smoke.sh",
     "test:parallels:npm-update": "bash scripts/e2e/parallels-npm-update-smoke.sh",
     "test:parallels:windows": "bash scripts/e2e/parallels-windows-smoke.sh",
     "test:perf:budget": "node scripts/test-perf-budget.mjs",
     "test:perf:hotspots": "node scripts/test-hotspots.mjs",
-    "test:perf:imports": "OPENCLAW_VITEST_IMPORT_DURATIONS=1 OPENCLAW_VITEST_PRINT_IMPORT_BREAKDOWN=1 pnpm test",
-    "test:perf:imports:changed": "OPENCLAW_VITEST_IMPORT_DURATIONS=1 OPENCLAW_VITEST_PRINT_IMPORT_BREAKDOWN=1 pnpm test -- --changed origin/main",
+    "test:perf:imports": "OPENCLAW_VITEST_IMPORT_DURATIONS=1 OPENCLAW_VITEST_PRINT_IMPORT_BREAKDOWN=1 node scripts/test-projects.mjs",
+    "test:perf:imports:changed": "OPENCLAW_VITEST_IMPORT_DURATIONS=1 OPENCLAW_VITEST_PRINT_IMPORT_BREAKDOWN=1 node scripts/test-projects.mjs --changed origin/main",
     "test:perf:profile:main": "node scripts/run-vitest-profile.mjs main",
     "test:perf:profile:runner": "node scripts/run-vitest-profile.mjs runner",
-    "test:perf:update-memory-hotspots": "node scripts/test-update-memory-hotspots.mjs",
-    "test:perf:update-memory-hotspots:extensions": "node scripts/test-update-memory-hotspots.mjs --config vitest.extensions.config.ts --out test/fixtures/test-memory-hotspots.extensions.json --lane extensions --lane-prefix extensions-batch- --min-delta-kb 1048576 --limit 20",
-    "test:perf:update-timings": "node scripts/test-update-timings.mjs",
-    "test:perf:update-timings:extensions": "node scripts/test-update-timings.mjs --config vitest.extensions.config.ts",
-    "test:planner": "node scripts/test-parallel.mjs",
     "test:projects": "node scripts/test-projects.mjs",
     "test:sectriage": "pnpm exec vitest run --config vitest.gateway.config.ts && vitest run --config vitest.unit.config.ts --exclude src/daemon/launchd.integration.test.ts --exclude src/process/exec.test.ts",
-    "test:serial": "node scripts/test-parallel.mjs --profile serial",
+    "test:serial": "OPENCLAW_VITEST_MAX_WORKERS=1 node scripts/test-projects.mjs",
     "test:startup:bench": "node --import tsx scripts/bench-cli-startup.ts",
     "test:startup:bench:check": "node scripts/test-cli-startup-bench-budget.mjs",
     "test:startup:bench:save": "node --import tsx scripts/bench-cli-startup.ts --preset all --runs 5 --warmup 1 --output .artifacts/cli-startup-bench-all.json",
diff --git a/scripts/ci-write-manifest-outputs.mjs b/scripts/ci-write-manifest-outputs.mjs
index 428ea8194bcd..e21c16578a41 100644
--- a/scripts/ci-write-manifest-outputs.mjs
+++ b/scripts/ci-write-manifest-outputs.mjs
@@ -1,5 +1,6 @@
 import { appendFileSync } from "node:fs";
-import { buildCIExecutionManifest } from "./test-planner/planner.mjs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 
 const WORKFLOWS = new Set(["ci", "install-smoke"]);
 
@@ -23,50 +24,159 @@ const parseArgs = (argv) => {
   return parsed;
 };
 
-const outputPath = process.env.GITHUB_OUTPUT;
-
-if (!outputPath) {
-  throw new Error("GITHUB_OUTPUT is required");
-}
-
-const { workflow } = parseArgs(process.argv.slice(2));
-const manifest = buildCIExecutionManifest(undefined, { env: process.env });
-
-const writeOutput = (name, value) => {
-  appendFileSync(outputPath, `${name}=${value}\n`, "utf8");
+const parseBooleanEnv = (value, defaultValue = false) => {
+  if (value === undefined) {
+    return defaultValue;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "") {
+    return false;
+  }
+  return defaultValue;
 };
 
-if (workflow === "ci") {
-  writeOutput("docs_only", String(manifest.scope.docsOnly));
-  writeOutput("docs_changed", String(manifest.scope.docsChanged));
-  writeOutput("run_node", String(manifest.scope.runNode));
-  writeOutput("run_macos", String(manifest.scope.runMacos));
-  writeOutput("run_android", String(manifest.scope.runAndroid));
-  writeOutput("run_skills_python", String(manifest.scope.runSkillsPython));
-  writeOutput("run_windows", String(manifest.scope.runWindows));
-  writeOutput("has_changed_extensions", String(manifest.scope.hasChangedExtensions));
-  writeOutput("changed_extensions_matrix", JSON.stringify(manifest.scope.changedExtensionsMatrix));
-  writeOutput("run_build_artifacts", String(manifest.jobs.buildArtifacts.enabled));
-  writeOutput("run_checks_fast", String(manifest.jobs.checksFast.enabled));
-  writeOutput("checks_fast_matrix", JSON.stringify(manifest.jobs.checksFast.matrix));
-  writeOutput("run_checks", String(manifest.jobs.checks.enabled));
-  writeOutput("checks_matrix", JSON.stringify(manifest.jobs.checks.matrix));
-  writeOutput("run_extension_fast", String(manifest.jobs.extensionFast.enabled));
-  writeOutput("extension_fast_matrix", JSON.stringify(manifest.jobs.extensionFast.matrix));
-  writeOutput("run_check", String(manifest.jobs.check.enabled));
-  writeOutput("run_check_additional", String(manifest.jobs.checkAdditional.enabled));
-  writeOutput("run_build_smoke", String(manifest.jobs.buildSmoke.enabled));
-  writeOutput("run_check_docs", String(manifest.jobs.checkDocs.enabled));
-  writeOutput("run_skills_python_job", String(manifest.jobs.skillsPython.enabled));
-  writeOutput("run_checks_windows", String(manifest.jobs.checksWindows.enabled));
-  writeOutput("checks_windows_matrix", JSON.stringify(manifest.jobs.checksWindows.matrix));
-  writeOutput("run_macos_node", String(manifest.jobs.macosNode.enabled));
-  writeOutput("macos_node_matrix", JSON.stringify(manifest.jobs.macosNode.matrix));
-  writeOutput("run_macos_swift", String(manifest.jobs.macosSwift.enabled));
-  writeOutput("run_android_job", String(manifest.jobs.android.enabled));
-  writeOutput("android_matrix", JSON.stringify(manifest.jobs.android.matrix));
-  writeOutput("required_check_names", JSON.stringify(manifest.requiredCheckNames));
-} else if (workflow === "install-smoke") {
-  writeOutput("docs_only", String(manifest.scope.docsOnly));
-  writeOutput("run_install_smoke", String(manifest.jobs.installSmoke.enabled));
+const parseJsonEnv = (value, fallback) => {
+  try {
+    return value ? JSON.parse(value) : fallback;
+  } catch {
+    return fallback;
+  }
+};
+
+const createMatrix = (include) => ({ include });
+
+export function buildWorkflowManifest(env = process.env, workflow = "ci") {
+  const eventName = env.GITHUB_EVENT_NAME ?? "pull_request";
+  const isPush = eventName === "push";
+  const docsOnly = parseBooleanEnv(env.OPENCLAW_CI_DOCS_ONLY);
+  const docsChanged = parseBooleanEnv(env.OPENCLAW_CI_DOCS_CHANGED);
+  const runNode = parseBooleanEnv(env.OPENCLAW_CI_RUN_NODE);
+  const runMacos = parseBooleanEnv(env.OPENCLAW_CI_RUN_MACOS);
+  const runAndroid = parseBooleanEnv(env.OPENCLAW_CI_RUN_ANDROID);
+  const runWindows = parseBooleanEnv(env.OPENCLAW_CI_RUN_WINDOWS);
+  const runSkillsPython = parseBooleanEnv(env.OPENCLAW_CI_RUN_SKILLS_PYTHON);
+  const hasChangedExtensions = parseBooleanEnv(env.OPENCLAW_CI_HAS_CHANGED_EXTENSIONS);
+  const changedExtensionsMatrix = parseJsonEnv(env.OPENCLAW_CI_CHANGED_EXTENSIONS_MATRIX, {
+    include: [],
+  });
+  const runChangedSmoke = parseBooleanEnv(env.OPENCLAW_CI_RUN_CHANGED_SMOKE);
+
+  const checksFastMatrix = createMatrix(
+    runNode
+      ? [
+          { check_name: "checks-fast-bundled", runtime: "node", task: "bundled" },
+          { check_name: "checks-fast-extensions", runtime: "node", task: "extensions" },
+          {
+            check_name: "checks-fast-contracts-protocol",
+            runtime: "node",
+            task: "contracts-protocol",
+          },
+        ]
+      : [],
+  );
+
+  const checksMatrixInclude = runNode
+    ? [
+        { check_name: "checks-node-test", runtime: "node", task: "test" },
+        { check_name: "checks-node-channels", runtime: "node", task: "channels" },
+        ...(isPush
+          ? [
+              {
+                check_name: "checks-node-compat-node22",
+                runtime: "node",
+                task: "compat-node22",
+                node_version: "22.x",
+                cache_key_suffix: "node22",
+              },
+            ]
+          : []),
+      ]
+    : [];
+
+  const windowsMatrix = createMatrix(
+    runWindows ? [{ check_name: "checks-windows-node-test", runtime: "node", task: "test" }] : [],
+  );
+  const macosNodeMatrix = createMatrix(
+    runMacos ? [{ check_name: "macos-node", runtime: "node", task: "test" }] : [],
+  );
+  const androidMatrix = createMatrix(
+    runAndroid
+      ? [
+          { check_name: "android-test-play", task: "test-play" },
+          { check_name: "android-test-third-party", task: "test-third-party" },
+          { check_name: "android-build-play", task: "build-play" },
+          { check_name: "android-build-third-party", task: "build-third-party" },
+        ]
+      : [],
+  );
+  const extensionFastMatrix = createMatrix(
+    hasChangedExtensions
+      ? (changedExtensionsMatrix.include ?? []).map((entry) => ({
+          check_name: `extension-fast-${entry.extension}`,
+          extension: entry.extension,
+        }))
+      : [],
+  );
+
+  if (workflow === "install-smoke") {
+    return {
+      docs_only: docsOnly,
+      run_install_smoke: !docsOnly && runChangedSmoke,
+    };
+  }
+
+  return {
+    docs_only: docsOnly,
+    docs_changed: docsChanged,
+    run_node: !docsOnly && runNode,
+    run_macos: !docsOnly && runMacos,
+    run_android: !docsOnly && runAndroid,
+    run_skills_python: !docsOnly && runSkillsPython,
+    run_windows: !docsOnly && runWindows,
+    has_changed_extensions: !docsOnly && hasChangedExtensions,
+    changed_extensions_matrix: changedExtensionsMatrix,
+    run_build_artifacts: !docsOnly && runNode,
+    run_checks_fast: !docsOnly && runNode,
+    checks_fast_matrix: checksFastMatrix,
+    run_checks: !docsOnly && runNode,
+    checks_matrix: createMatrix(checksMatrixInclude),
+    run_extension_fast: !docsOnly && hasChangedExtensions,
+    extension_fast_matrix: extensionFastMatrix,
+    run_check: !docsOnly && runNode,
+    run_check_additional: !docsOnly && runNode,
+    run_build_smoke: !docsOnly && runNode,
+    run_check_docs: docsChanged,
+    run_skills_python_job: !docsOnly && runSkillsPython,
+    run_checks_windows: !docsOnly && runWindows,
+    checks_windows_matrix: windowsMatrix,
+    run_macos_node: !docsOnly && runMacos,
+    macos_node_matrix: macosNodeMatrix,
+    run_macos_swift: !docsOnly && runMacos,
+    run_android_job: !docsOnly && runAndroid,
+    android_matrix: androidMatrix,
+  };
+}
+
+const entryHref = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : "";
+
+if (import.meta.url === entryHref) {
+  const outputPath = process.env.GITHUB_OUTPUT;
+
+  if (!outputPath) {
+    throw new Error("GITHUB_OUTPUT is required");
+  }
+
+  const { workflow } = parseArgs(process.argv.slice(2));
+  const manifest = buildWorkflowManifest(process.env, workflow);
+
+  const writeOutput = (name, value) => {
+    appendFileSync(outputPath, `${name}=${value}\n`, "utf8");
+  };
+
+  for (const [key, value] of Object.entries(manifest)) {
+    writeOutput(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
 }
diff --git a/scripts/pr-lib/gates.sh b/scripts/pr-lib/gates.sh
index 24e6b16c40cd..7988418b7d4d 100644
--- a/scripts/pr-lib/gates.sh
+++ b/scripts/pr-lib/gates.sh
@@ -5,7 +5,7 @@ run_prepare_push_retry_gates() {
   run_quiet_logged "pnpm build (lease-retry)" ".local/lease-retry-build.log" pnpm build
   run_quiet_logged "pnpm check (lease-retry)" ".local/lease-retry-check.log" pnpm check
   if [ "$docs_only" != "true" ]; then
-    run_quiet_logged "pnpm test:planner (lease-retry)" ".local/lease-retry-test.log" pnpm test:planner
+    run_quiet_logged "pnpm test (lease-retry)" ".local/lease-retry-test.log" pnpm test
   fi
 }
 
@@ -103,13 +103,11 @@ prepare_gates() {
       echo "Docs-only change detected with high confidence; skipping pnpm test."
     else
       gates_mode="full"
-      local prepare_unit_fast_batch_target_ms
-      prepare_unit_fast_batch_target_ms="${OPENCLAW_PREPARE_TEST_UNIT_FAST_BATCH_TARGET_MS:-5000}"
-      echo "Running pnpm test:planner with OPENCLAW_TEST_UNIT_FAST_BATCH_TARGET_MS=$prepare_unit_fast_batch_target_ms for shorter-lived unit-fast workers."
+      echo "Running pnpm test with OPENCLAW_VITEST_MAX_WORKERS=${OPENCLAW_VITEST_MAX_WORKERS:-4}."
       run_quiet_logged \
-        "pnpm test:planner" \
+        "pnpm test" \
         ".local/gates-test.log" \
-        env OPENCLAW_TEST_UNIT_FAST_BATCH_TARGET_MS="$prepare_unit_fast_batch_target_ms" pnpm test:planner
+        env OPENCLAW_VITEST_MAX_WORKERS="${OPENCLAW_VITEST_MAX_WORKERS:-4}" pnpm test
       previous_full_gates_head="$current_head"
     fi
   fi
diff --git a/scripts/prepush-ci.sh b/scripts/prepush-ci.sh
index e831d1b4300c..2f3b7b24a7e1 100644
--- a/scripts/prepush-ci.sh
+++ b/scripts/prepush-ci.sh
@@ -59,10 +59,10 @@ run_linux_ci_mirror() {
   run_step pnpm vitest run --config vitest.extensions.config.ts --maxWorkers=1
   run_step env CI=true pnpm exec vitest run --config vitest.unit.config.ts --maxWorkers=1
 
-  log_step "OPENCLAW_TEST_WORKERS=${OPENCLAW_TEST_WORKERS:-1} OPENCLAW_TEST_MAX_OLD_SPACE_SIZE_MB=${OPENCLAW_TEST_MAX_OLD_SPACE_SIZE_MB:-6144} pnpm test:planner"
-  OPENCLAW_TEST_WORKERS="${OPENCLAW_TEST_WORKERS:-1}" \
-  OPENCLAW_TEST_MAX_OLD_SPACE_SIZE_MB="${OPENCLAW_TEST_MAX_OLD_SPACE_SIZE_MB:-6144}" \
-    pnpm test:planner
+  log_step "OPENCLAW_VITEST_MAX_WORKERS=${OPENCLAW_VITEST_MAX_WORKERS:-1} NODE_OPTIONS=${NODE_OPTIONS:---max-old-space-size=6144} pnpm test"
+  OPENCLAW_VITEST_MAX_WORKERS="${OPENCLAW_VITEST_MAX_WORKERS:-1}" \
+  NODE_OPTIONS="${NODE_OPTIONS:---max-old-space-size=6144}" \
+    pnpm test
 }
 
 run_macos_ci_mirror() {
diff --git a/scripts/test-cli-startup-bench-budget.mjs b/scripts/test-cli-startup-bench-budget.mjs
index b20a97898d6a..50f35fd55e3c 100644
--- a/scripts/test-cli-startup-bench-budget.mjs
+++ b/scripts/test-cli-startup-bench-budget.mjs
@@ -2,7 +2,8 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import { floatFlag, intFlag, parseFlagArgs, readEnvNumber, stringFlag } from "./lib/arg-utils.mjs";
 import { readJsonFile } from "./test-report-utils.mjs";
-import { cliStartupBenchManifestPath } from "./test-runner-manifest.mjs";
+
+const CLI_STARTUP_BENCH_FIXTURE_PATH = "test/fixtures/cli-startup-bench.json";
 
 function formatMs(value) {
   return `${value.toFixed(1)}ms`;
@@ -42,7 +43,7 @@ if (process.argv.slice(2).includes("--help")) {
 const opts = parseFlagArgs(
   process.argv.slice(2),
   {
-    baseline: cliStartupBenchManifestPath,
+    baseline: CLI_STARTUP_BENCH_FIXTURE_PATH,
     report: "",
     entry: "openclaw.mjs",
     preset: "all",
diff --git a/scripts/test-extension.mjs b/scripts/test-extension.mjs
index 75aa30231b2d..c02d5f282046 100644
--- a/scripts/test-extension.mjs
+++ b/scripts/test-extension.mjs
@@ -9,13 +9,11 @@ import {
   BUNDLED_PLUGIN_PATH_PREFIX,
   BUNDLED_PLUGIN_ROOT_DIR,
 } from "./lib/bundled-plugin-paths.mjs";
-import { loadTestRunnerBehavior } from "./test-runner-manifest.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..");
 const pnpm = "pnpm";
-const testRunnerBehavior = loadTestRunnerBehavior();
 
 function runGit(args, options = {}) {
   return execFileSync("git", args, {
@@ -236,42 +234,15 @@ export function resolveExtensionTestPlan(params = {}) {
   const testFiles = roots
     .flatMap((root) => collectTestFiles(path.join(repoRoot, root)))
     .map((filePath) => normalizeRelative(path.relative(repoRoot, filePath)));
-  const { isolatedTestFiles, sharedTestFiles } = partitionExtensionTestFiles({ config, testFiles });
-
   return {
     config,
     extensionDir: relativeExtensionDir,
     extensionId,
-    isolatedTestFiles,
     roots,
-    sharedTestFiles,
     testFiles,
   };
 }
 
-export function partitionExtensionTestFiles(params) {
-  const testFiles = params.testFiles.map((filePath) => normalizeRelative(filePath));
-  let isolatedEntries = [];
-  let isolatedPrefixes = [];
-
-  if (params.config === "vitest.channels.config.ts") {
-    isolatedEntries = testRunnerBehavior.channels.isolated;
-    isolatedPrefixes = testRunnerBehavior.channels.isolatedPrefixes;
-  } else if (params.config === "vitest.extensions.config.ts") {
-    isolatedEntries = testRunnerBehavior.extensions.isolated;
-  }
-
-  const isolatedEntrySet = new Set(isolatedEntries.map((entry) => entry.file));
-  const isolatedTestFiles = testFiles.filter(
-    (file) =>
-      isolatedEntrySet.has(file) || isolatedPrefixes.some((prefix) => file.startsWith(prefix)),
-  );
-  const isolatedTestFileSet = new Set(isolatedTestFiles);
-  const sharedTestFiles = testFiles.filter((file) => !isolatedTestFileSet.has(file));
-
-  return { isolatedTestFiles, sharedTestFiles };
-}
-
 async function runVitestBatch(params) {
   return await new Promise((resolve, reject) => {
     const child = spawn(
@@ -412,8 +383,6 @@ async function run() {
       console.log(`config: ${plan.config}`);
       console.log(`roots: ${plan.roots.join(", ")}`);
       console.log(`tests: ${plan.testFiles.length}`);
-      console.log(`shared: ${plan.sharedTestFiles.length}`);
-      console.log(`isolated: ${plan.isolatedTestFiles.length}`);
     }
     return;
   }
@@ -425,36 +394,13 @@ async function run() {
   console.log(
     `[test-extension] Running ${plan.testFiles.length} test files for ${plan.extensionId} with ${plan.config}`,
   );
-
-  if (plan.sharedTestFiles.length > 0 && plan.isolatedTestFiles.length > 0) {
-    console.log(
-      `[test-extension] Split into ${plan.sharedTestFiles.length} shared and ${plan.isolatedTestFiles.length} isolated files`,
-    );
-  }
-
-  if (plan.sharedTestFiles.length > 0) {
-    const sharedExitCode = await runVitestBatch({
-      args: passthroughArgs,
-      config: plan.config,
-      env: process.env,
-      files: plan.sharedTestFiles,
-    });
-    if (sharedExitCode !== 0) {
-      process.exit(sharedExitCode);
-    }
-  }
-
-  if (plan.isolatedTestFiles.length > 0) {
-    const isolatedExitCode = await runVitestBatch({
-      args: passthroughArgs,
-      config: plan.config,
-      env: { ...process.env, OPENCLAW_TEST_ISOLATE: "1" },
-      files: plan.isolatedTestFiles,
-    });
-    process.exit(isolatedExitCode);
-  }
-
-  process.exit(0);
+  const exitCode = await runVitestBatch({
+    args: passthroughArgs,
+    config: plan.config,
+    env: process.env,
+    files: plan.testFiles,
+  });
+  process.exit(exitCode);
 }
 
 const entryHref = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : "";
diff --git a/scripts/test-parallel-memory.mjs b/scripts/test-parallel-memory.mjs
deleted file mode 100644
index d56b1e9259dd..000000000000
--- a/scripts/test-parallel-memory.mjs
+++ /dev/null
@@ -1,283 +0,0 @@
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-
-const ESCAPE = String.fromCodePoint(27);
-const BELL = String.fromCodePoint(7);
-const ANSI_ESCAPE_PATTERN = new RegExp(
-  // Strip CSI/OSC-style control sequences from Vitest output before parsing file lines.
-  `${ESCAPE}(?:\\][^${BELL}]*(?:${BELL}|${ESCAPE}\\\\)|\\[[0-?]*[ -/]*[@-~]|[@-Z\\\\-_])`,
-  "g",
-);
-const GITHUB_CLI_LOG_PREFIX_PATTERN =
-  /^[^\t\r\n]+\t[^\t\r\n]+\t\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\s+/u;
-const GITHUB_ACTIONS_LOG_PREFIX_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\s+/u;
-
-const COMPLETED_TEST_FILE_LINE_PATTERN =
-  /(?<file>(?:src|extensions|test|ui)\/\S+?\.(?:live\.test|e2e\.test|test)\.ts)\s+\(.*\)\s+(?<duration>\d+(?:\.\d+)?)(?<unit>ms|s)\s*$/;
-const MEMORY_TRACE_SUMMARY_PATTERN =
-  /^\[test-parallel\]\[mem\] summary (?<lane>\S+) files=(?<files>\d+) peak=(?<peak>[0-9]+(?:\.[0-9]+)?(?:GiB|MiB|KiB)) totalDelta=(?<totalDelta>[+-]?[0-9]+(?:\.[0-9]+)?(?:GiB|MiB|KiB)) peakAt=(?<peakAt>\S+) top=(?<top>.*)$/u;
-const MEMORY_TRACE_TOP_ENTRY_PATTERN =
-  /^(?<file>(?:src|extensions|test|ui)\/\S+?\.(?:live\.test|e2e\.test|test)\.ts):(?<delta>[+-]?[0-9]+(?:\.[0-9]+)?(?:GiB|MiB|KiB))$/u;
-
-const PS_COLUMNS = ["pid=", "ppid=", "rss=", "comm="];
-
-function parseDurationMs(rawValue, unit) {
-  const parsed = Number.parseFloat(rawValue);
-  if (!Number.isFinite(parsed)) {
-    return null;
-  }
-  return unit === "s" ? Math.round(parsed * 1000) : Math.round(parsed);
-}
-
-export function parseMemoryValueKb(rawValue) {
-  const match = rawValue.match(/^(?<sign>[+-]?)(?<value>\d+(?:\.\d+)?)(?<unit>GiB|MiB|KiB)$/u);
-  if (!match?.groups) {
-    return null;
-  }
-  const value = Number.parseFloat(match.groups.value);
-  if (!Number.isFinite(value)) {
-    return null;
-  }
-  const multiplier =
-    match.groups.unit === "GiB" ? 1024 ** 2 : match.groups.unit === "MiB" ? 1024 : 1;
-  const signed = Math.round(value * multiplier);
-  return match.groups.sign === "-" ? -signed : signed;
-}
-
-function stripAnsi(text) {
-  return text.replaceAll(ANSI_ESCAPE_PATTERN, "");
-}
-
-function normalizeLogLine(line) {
-  return line
-    .replace(GITHUB_CLI_LOG_PREFIX_PATTERN, "")
-    .replace(GITHUB_ACTIONS_LOG_PREFIX_PATTERN, "");
-}
-
-export function parseCompletedTestFileLines(text) {
-  return stripAnsi(text)
-    .split(/\r?\n/u)
-    .map((line) => normalizeLogLine(line))
-    .map((line) => {
-      const match = line.match(COMPLETED_TEST_FILE_LINE_PATTERN);
-      if (!match?.groups) {
-        return null;
-      }
-      return {
-        file: match.groups.file,
-        durationMs: parseDurationMs(match.groups.duration, match.groups.unit),
-      };
-    })
-    .filter((entry) => entry !== null);
-}
-
-export function parseMemoryTraceSummaryLines(text) {
-  return stripAnsi(text)
-    .split(/\r?\n/u)
-    .map((line) => normalizeLogLine(line))
-    .map((line) => {
-      const match = line.match(MEMORY_TRACE_SUMMARY_PATTERN);
-      if (!match?.groups) {
-        return null;
-      }
-      const peakRssKb = parseMemoryValueKb(match.groups.peak);
-      const totalDeltaKb = parseMemoryValueKb(match.groups.totalDelta);
-      const fileCount = Number.parseInt(match.groups.files, 10);
-      if (!Number.isInteger(fileCount) || peakRssKb === null || totalDeltaKb === null) {
-        return null;
-      }
-      const top =
-        match.groups.top === "none"
-          ? []
-          : match.groups.top
-              .split(/,\s+/u)
-              .map((entry) => {
-                const topMatch = entry.match(MEMORY_TRACE_TOP_ENTRY_PATTERN);
-                if (!topMatch?.groups) {
-                  return null;
-                }
-                const deltaKb = parseMemoryValueKb(topMatch.groups.delta);
-                if (deltaKb === null) {
-                  return null;
-                }
-                return {
-                  file: topMatch.groups.file,
-                  deltaKb,
-                };
-              })
-              .filter((entry) => entry !== null);
-      return {
-        lane: match.groups.lane,
-        files: fileCount,
-        peakRssKb,
-        totalDeltaKb,
-        peakAt: match.groups.peakAt,
-        top,
-      };
-    })
-    .filter((entry) => entry !== null);
-}
-
-export function getProcessTreeRecords(rootPid) {
-  if (!Number.isInteger(rootPid) || rootPid <= 0 || process.platform === "win32") {
-    return null;
-  }
-
-  const result = spawnSync("ps", ["-axo", PS_COLUMNS.join(",")], {
-    encoding: "utf8",
-  });
-  if (result.status !== 0 || result.error) {
-    return null;
-  }
-
-  const childPidsByParent = new Map();
-  const recordsByPid = new Map();
-  for (const line of result.stdout.split(/\r?\n/u)) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    const [pidRaw, parentRaw, rssRaw, commandRaw] = trimmed.split(/\s+/u, 4);
-    const pid = Number.parseInt(pidRaw ?? "", 10);
-    const parentPid = Number.parseInt(parentRaw ?? "", 10);
-    const rssKb = Number.parseInt(rssRaw ?? "", 10);
-    if (!Number.isInteger(pid) || !Number.isInteger(parentPid) || !Number.isInteger(rssKb)) {
-      continue;
-    }
-    const siblings = childPidsByParent.get(parentPid) ?? [];
-    siblings.push(pid);
-    childPidsByParent.set(parentPid, siblings);
-    recordsByPid.set(pid, {
-      pid,
-      parentPid,
-      rssKb,
-      command: commandRaw ?? "",
-    });
-  }
-
-  if (!recordsByPid.has(rootPid)) {
-    return null;
-  }
-
-  const queue = [rootPid];
-  const visited = new Set();
-  const records = [];
-  while (queue.length > 0) {
-    const pid = queue.shift();
-    if (pid === undefined || visited.has(pid)) {
-      continue;
-    }
-    visited.add(pid);
-    const record = recordsByPid.get(pid);
-    if (record) {
-      records.push(record);
-    }
-    for (const childPid of childPidsByParent.get(pid) ?? []) {
-      if (!visited.has(childPid)) {
-        queue.push(childPid);
-      }
-    }
-  }
-
-  return records;
-}
-
-export function sampleProcessTreeRssKb(rootPid) {
-  const records = getProcessTreeRecords(rootPid);
-  if (!records) {
-    return null;
-  }
-
-  let rssKb = 0;
-  let processCount = 0;
-  for (const record of records) {
-    rssKb += record.rssKb;
-    processCount += 1;
-  }
-
-  return { rssKb, processCount };
-}
-
-const REPORT_FILE_PATTERN =
-  /^report\.(?<date>\d+)\.(?<time>\d+)\.(?<pid>\d+)\.0\.(?<sequence>\d+)\.json$/u;
-
-function readDiagnosticReport(reportPath) {
-  try {
-    const raw = fs.readFileSync(reportPath, "utf8");
-    const parsed = JSON.parse(raw);
-    const rssBytes = parsed?.resourceUsage?.rss;
-    const usedHeapBytes = parsed?.javascriptHeap?.usedMemory;
-    const externalBytes = parsed?.javascriptHeap?.externalMemory;
-    if (
-      !Number.isFinite(rssBytes) ||
-      !Number.isFinite(usedHeapBytes) ||
-      !Number.isFinite(externalBytes)
-    ) {
-      return null;
-    }
-    return {
-      rssKb: Math.round(rssBytes / 1024),
-      usedHeapKb: Math.round(usedHeapBytes / 1024),
-      externalKb: Math.round(externalBytes / 1024),
-    };
-  } catch {
-    return null;
-  }
-}
-
-export function summarizeDiagnosticReports(reportDir) {
-  if (typeof reportDir !== "string" || reportDir.trim() === "") {
-    return [];
-  }
-  let entries;
-  try {
-    entries = fs.readdirSync(reportDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-
-  const reportsByPid = new Map();
-  for (const entry of entries) {
-    if (!entry.isFile()) {
-      continue;
-    }
-    const match = entry.name.match(REPORT_FILE_PATTERN);
-    if (!match?.groups) {
-      continue;
-    }
-    const pid = Number.parseInt(match.groups.pid, 10);
-    const sequence = Number.parseInt(match.groups.sequence, 10);
-    if (!Number.isInteger(pid) || !Number.isInteger(sequence)) {
-      continue;
-    }
-    const reportPath = path.join(reportDir, entry.name);
-    const report = readDiagnosticReport(reportPath);
-    if (!report) {
-      continue;
-    }
-    const bucket = reportsByPid.get(pid) ?? [];
-    bucket.push({ pid, sequence, ...report });
-    reportsByPid.set(pid, bucket);
-  }
-
-  return [...reportsByPid.entries()]
-    .map(([pid, reports]) => {
-      const ordered = reports.toSorted((left, right) => left.sequence - right.sequence);
-      const first = ordered[0];
-      const last = ordered.at(-1);
-      if (!first || !last) {
-        return null;
-      }
-      return {
-        pid,
-        first,
-        last,
-        rssDeltaKb: last.rssKb - first.rssKb,
-        usedHeapDeltaKb: last.usedHeapKb - first.usedHeapKb,
-        externalDeltaKb: last.externalKb - first.externalKb,
-      };
-    })
-    .filter((entry) => entry !== null)
-    .toSorted((left, right) => right.rssDeltaKb - left.rssDeltaKb);
-}
diff --git a/scripts/test-parallel-utils.mjs b/scripts/test-parallel-utils.mjs
deleted file mode 100644
index 591be46a34ea..000000000000
--- a/scripts/test-parallel-utils.mjs
+++ /dev/null
@@ -1,53 +0,0 @@
-const DEFAULT_OUTPUT_CAPTURE_LIMIT = 200_000;
-
-const fatalOutputPatterns = [
-  /FATAL ERROR:/i,
-  /JavaScript heap out of memory/i,
-  /node::OOMErrorHandler/i,
-  /ERR_WORKER_OUT_OF_MEMORY/i,
-];
-
-export function appendCapturedOutput(current, chunk, limit = DEFAULT_OUTPUT_CAPTURE_LIMIT) {
-  if (!chunk) {
-    return current;
-  }
-  const next = `${current}${chunk}`;
-  if (next.length <= limit) {
-    return next;
-  }
-  return next.slice(-limit);
-}
-
-export function hasFatalTestRunOutput(output) {
-  return fatalOutputPatterns.some((pattern) => pattern.test(output));
-}
-
-export function formatCapturedOutputTail(output, maxLines = 60, maxChars = 6000) {
-  const trimmed = output.trim();
-  if (!trimmed) {
-    return "";
-  }
-  const lines = trimmed.split(/\r?\n/u);
-  const tailLines = lines.slice(-maxLines);
-  const tail = tailLines.join("\n");
-  if (tail.length <= maxChars) {
-    return tail;
-  }
-  return tail.slice(-maxChars);
-}
-
-export function resolveTestRunExitCode({ code, signal, output, fatalSeen = false, childError }) {
-  if (typeof code === "number" && code !== 0) {
-    return code;
-  }
-  if (childError) {
-    return 1;
-  }
-  if (signal) {
-    return 1;
-  }
-  if (fatalSeen || hasFatalTestRunOutput(output)) {
-    return 1;
-  }
-  return code ?? 0;
-}
diff --git a/scripts/test-parallel.mjs b/scripts/test-parallel.mjs
deleted file mode 100644
index fce10459b16c..000000000000
--- a/scripts/test-parallel.mjs
+++ /dev/null
@@ -1,207 +0,0 @@
-import {
-  createExecutionArtifacts,
-  executePlan,
-  formatExplanation,
-  formatPlanOutput,
-} from "./test-planner/executor.mjs";
-import {
-  buildCIExecutionManifest,
-  buildExecutionPlan,
-  explainExecutionTarget,
-} from "./test-planner/planner.mjs";
-
-const parseCliArgs = (args) => {
-  const wrapper = {
-    ciManifest: false,
-    failurePolicy: null,
-    plan: false,
-    explain: null,
-    mode: null,
-    profile: null,
-    surfaces: [],
-    files: [],
-    passthroughArgs: [],
-    showHelp: false,
-  };
-  let passthroughMode = false;
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--collect-failures") {
-      wrapper.failurePolicy = "collect-all";
-      continue;
-    }
-    if (arg === "--failure-policy") {
-      const nextValue = args[index + 1] ?? "";
-      if (nextValue === "fail-fast" || nextValue === "collect-all") {
-        wrapper.failurePolicy = nextValue;
-        index += 1;
-        continue;
-      }
-      throw new Error(`Invalid --failure-policy value: ${String(nextValue || "<missing>")}`);
-    }
-    if (arg.startsWith("--failure-policy=")) {
-      const value = arg.slice("--failure-policy=".length);
-      if (value === "fail-fast" || value === "collect-all") {
-        wrapper.failurePolicy = value;
-        continue;
-      }
-      throw new Error(`Invalid --failure-policy value: ${String(value || "<missing>")}`);
-    }
-    if (passthroughMode) {
-      wrapper.passthroughArgs.push(arg);
-      continue;
-    }
-    if (arg === "--") {
-      passthroughMode = true;
-      continue;
-    }
-    if (arg === "--plan") {
-      wrapper.plan = true;
-      continue;
-    }
-    if (arg === "--ci-manifest") {
-      wrapper.ciManifest = true;
-      continue;
-    }
-    if (arg === "--help") {
-      wrapper.showHelp = true;
-      continue;
-    }
-    if (arg === "--mode") {
-      const nextValue = args[index + 1] ?? null;
-      if (nextValue === "ci" || nextValue === "local") {
-        wrapper.mode = nextValue;
-        index += 1;
-        continue;
-      }
-    }
-    if (arg === "--profile") {
-      const nextValue = args[index + 1] ?? "";
-      if (!nextValue || nextValue === "--" || nextValue.startsWith("-")) {
-        throw new Error(`Invalid --profile value: ${String(nextValue || "<missing>")}`);
-      }
-      wrapper.profile = nextValue;
-      index += 1;
-      continue;
-    }
-    if (arg === "--surface") {
-      const nextValue = args[index + 1] ?? "";
-      if (!nextValue || nextValue === "--" || nextValue.startsWith("-")) {
-        throw new Error(`Invalid --surface value: ${String(nextValue || "<missing>")}`);
-      }
-      wrapper.surfaces.push(nextValue);
-      index += 1;
-      continue;
-    }
-    if (arg === "--files") {
-      const nextValue = args[index + 1] ?? "";
-      if (!nextValue || nextValue === "--" || nextValue.startsWith("-")) {
-        throw new Error(`Invalid --files value: ${String(nextValue || "<missing>")}`);
-      }
-      wrapper.files.push(nextValue);
-      index += 1;
-      continue;
-    }
-    if (arg === "--explain") {
-      const nextValue = args[index + 1] ?? "";
-      if (!nextValue || nextValue === "--" || nextValue.startsWith("-")) {
-        throw new Error(`Invalid --explain value: ${String(nextValue || "<missing>")}`);
-      }
-      wrapper.explain = nextValue;
-      index += 1;
-      continue;
-    }
-    wrapper.passthroughArgs.push(arg);
-  }
-  return wrapper;
-};
-
-const exitWithCleanup = (artifacts, code) => {
-  artifacts?.cleanupTempArtifacts?.();
-  process.exit(code);
-};
-
-let rawCli;
-try {
-  rawCli = parseCliArgs(process.argv.slice(2));
-} catch (error) {
-  console.error(`[test-parallel] ${error instanceof Error ? error.message : String(error)}`);
-  process.exit(2);
-}
-if (rawCli.showHelp) {
-  console.log(
-    [
-      "Usage: node scripts/test-parallel.mjs [wrapper flags] [-- vitest args]",
-      "",
-      "Runs the planner-backed OpenClaw test wrapper.",
-      "",
-      "Wrapper flags:",
-      "  --plan                 Print the resolved execution plan and exit",
-      "  --ci-manifest          Print the planner-backed CI execution manifest as JSON and exit",
-      "  --explain <file>       Explain how a file is classified and run, then exit",
-      "  --surface <name>       Select a surface: unit, bundled, extensions, channels, contracts, gateway",
-      "  --files <pattern>      Add targeted files or path patterns (repeatable)",
-      "  --mode <ci|local>      Override runtime mode",
-      "  --profile <name>       Override execution intent: normal, max, serial",
-      "  --failure-policy <name> Override execution failure policy: fail-fast, collect-all",
-      "  --collect-failures     Shortcut for --failure-policy collect-all",
-      "  --help                 Show this help text",
-      "",
-      "Examples:",
-      "  node scripts/test-parallel.mjs",
-      "  node scripts/test-parallel.mjs --plan --surface unit --surface extensions",
-      "  node scripts/test-parallel.mjs --explain src/auto-reply/reply/followup-runner.test.ts",
-      "  node scripts/test-parallel.mjs --collect-failures --surface unit",
-      "  node scripts/test-parallel.mjs --files src/foo.test.ts -- --reporter=dot",
-      "",
-      "Environment:",
-      "  OPENCLAW_TEST_LIST_LANES=1          Print the resolved plan before execution",
-      "  OPENCLAW_TEST_SHOW_POOL_DECISION=1  Include thread/fork pool decisions in diagnostics",
-    ].join("\n"),
-  );
-  process.exit(0);
-}
-
-const request = {
-  failurePolicy: rawCli.failurePolicy,
-  mode: rawCli.mode,
-  profile: rawCli.profile,
-  surfaces: rawCli.surfaces,
-  fileFilters: rawCli.files,
-  passthroughArgs: rawCli.passthroughArgs,
-};
-
-if (rawCli.explain) {
-  const explanation = explainExecutionTarget(
-    { ...request, passthroughArgs: [], fileFilters: [rawCli.explain] },
-    { env: process.env },
-  );
-  console.log(formatExplanation(explanation));
-  process.exit(0);
-}
-
-if (rawCli.ciManifest) {
-  const manifest = buildCIExecutionManifest(undefined, { env: process.env });
-  console.log(`${JSON.stringify(manifest, null, 2)}\n`);
-  process.exit(0);
-}
-
-const artifacts = createExecutionArtifacts(process.env);
-let plan;
-try {
-  plan = buildExecutionPlan(request, {
-    env: process.env,
-    writeTempJsonArtifact: artifacts.writeTempJsonArtifact,
-  });
-} catch (error) {
-  console.error(`[test-parallel] ${error instanceof Error ? error.message : String(error)}`);
-  exitWithCleanup(artifacts, 2);
-}
-
-if (process.env.OPENCLAW_TEST_LIST_LANES === "1" || rawCli.plan) {
-  console.log(formatPlanOutput(plan));
-  exitWithCleanup(artifacts, 0);
-}
-
-const result = await executePlan(plan, { env: process.env, artifacts });
-process.exit(typeof result === "number" ? result : result.exitCode);
diff --git a/scripts/test-planner/catalog.mjs b/scripts/test-planner/catalog.mjs
deleted file mode 100644
index ea4dc6b9c3a7..000000000000
--- a/scripts/test-planner/catalog.mjs
+++ /dev/null
@@ -1,225 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { channelTestPrefixes, isChannelSurfaceTestFile } from "../../vitest.channel-paths.mjs";
-import {
-  isBoundaryTestFile,
-  isBundledPluginDependentUnitTestFile,
-  isUnitConfigTestFile,
-} from "../../vitest.unit-paths.mjs";
-import {
-  BUNDLED_PLUGIN_PATH_PREFIX,
-  BUNDLED_PLUGIN_ROOT_DIR,
-} from "../lib/bundled-plugin-paths.mjs";
-import { dedupeFilesPreserveOrder, loadTestRunnerBehavior } from "../test-runner-manifest.mjs";
-
-const baseConfigPrefixes = ["src/agents/", "src/auto-reply/", "src/commands/", "test/", "ui/"];
-const contractTestPrefixes = ["src/channels/plugins/contracts/", "src/plugins/contracts/"];
-
-export const normalizeRepoPath = (value) => value.split(path.sep).join("/");
-
-const toRepoRelativePath = (value) => {
-  const relativePath = normalizeRepoPath(path.relative(process.cwd(), path.resolve(value)));
-  return relativePath.startsWith("../") || relativePath === ".." ? null : relativePath;
-};
-
-const walkTestFiles = (rootDir) => {
-  if (!fs.existsSync(rootDir)) {
-    return [];
-  }
-  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = path.join(rootDir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...walkTestFiles(fullPath));
-      continue;
-    }
-    if (!entry.isFile()) {
-      continue;
-    }
-    if (
-      fullPath.endsWith(".test.ts") ||
-      fullPath.endsWith(".live.test.ts") ||
-      fullPath.endsWith(".e2e.test.ts")
-    ) {
-      files.push(normalizeRepoPath(fullPath));
-    }
-  }
-  return files;
-};
-
-export function loadTestCatalog() {
-  const behaviorManifest = loadTestRunnerBehavior();
-  const existingFiles = (entries) =>
-    entries.map((entry) => entry.file).filter((file) => fs.existsSync(file));
-  const existingUnitConfigFiles = (entries) => existingFiles(entries).filter(isUnitConfigTestFile);
-  const baseThreadPinnedFiles = existingFiles(behaviorManifest.base?.threadPinned ?? []);
-  const channelIsolatedManifestFiles = existingFiles(behaviorManifest.channels?.isolated ?? []);
-  const channelIsolatedPrefixes = behaviorManifest.channels?.isolatedPrefixes ?? [];
-  const extensionForkIsolatedFiles = existingFiles(behaviorManifest.extensions?.isolated ?? []);
-  const unitForkIsolatedFiles = existingUnitConfigFiles(behaviorManifest.unit.isolated);
-  const unitThreadPinnedFiles = existingUnitConfigFiles(behaviorManifest.unit.threadPinned);
-  const unitBehaviorOverrideSet = new Set([...unitForkIsolatedFiles, ...unitThreadPinnedFiles]);
-  const allKnownTestFiles = [
-    ...new Set([
-      ...walkTestFiles("src"),
-      ...walkTestFiles(BUNDLED_PLUGIN_ROOT_DIR),
-      ...walkTestFiles("packages"),
-      ...walkTestFiles("test"),
-      ...walkTestFiles(path.join("ui", "src", "ui")),
-    ]),
-  ];
-  const channelIsolatedFiles = dedupeFilesPreserveOrder([
-    ...channelIsolatedManifestFiles,
-    ...allKnownTestFiles.filter((file) =>
-      channelIsolatedPrefixes.some((prefix) => file.startsWith(prefix)),
-    ),
-  ]);
-  const channelIsolatedFileSet = new Set(channelIsolatedFiles);
-  const extensionForkIsolatedFileSet = new Set(extensionForkIsolatedFiles);
-  const baseThreadPinnedFileSet = new Set(baseThreadPinnedFiles);
-  const unitThreadPinnedFileSet = new Set(unitThreadPinnedFiles);
-  const unitForkIsolatedFileSet = new Set(unitForkIsolatedFiles);
-
-  const classifyTestFile = (fileFilter, options = {}) => {
-    const normalizedFile = normalizeRepoPath(fileFilter);
-    const reasons = [];
-    const isolated =
-      options.unitMemoryIsolatedFiles?.includes(normalizedFile) ||
-      options.extensionMemoryIsolatedFiles?.includes(normalizedFile) ||
-      options.extensionTimedIsolatedFiles?.includes(normalizedFile) ||
-      options.channelTimedIsolatedFiles?.includes(normalizedFile) ||
-      unitForkIsolatedFileSet.has(normalizedFile) ||
-      extensionForkIsolatedFileSet.has(normalizedFile) ||
-      channelIsolatedFileSet.has(normalizedFile);
-    if (options.unitMemoryIsolatedFiles?.includes(normalizedFile)) {
-      reasons.push("unit-memory-isolated");
-    }
-    if (options.extensionMemoryIsolatedFiles?.includes(normalizedFile)) {
-      reasons.push("extensions-memory-heavy");
-    }
-    if (options.extensionTimedIsolatedFiles?.includes(normalizedFile)) {
-      reasons.push("extensions-timed-heavy");
-    }
-    if (options.channelTimedIsolatedFiles?.includes(normalizedFile)) {
-      reasons.push("channels-timed-heavy");
-    }
-    if (unitForkIsolatedFileSet.has(normalizedFile)) {
-      reasons.push("unit-isolated-manifest");
-    }
-    if (extensionForkIsolatedFileSet.has(normalizedFile)) {
-      reasons.push("extensions-isolated-manifest");
-    }
-    if (channelIsolatedFileSet.has(normalizedFile)) {
-      reasons.push("channels-isolated-rule");
-    }
-
-    let surface = "base";
-    if (isBundledPluginDependentUnitTestFile(normalizedFile)) {
-      surface = "bundled";
-    } else if (isBoundaryTestFile(normalizedFile)) {
-      surface = "unit";
-    } else if (isUnitConfigTestFile(normalizedFile)) {
-      surface = "unit";
-    } else if (contractTestPrefixes.some((prefix) => normalizedFile.startsWith(prefix))) {
-      surface = "contracts";
-    } else if (normalizedFile.endsWith(".live.test.ts")) {
-      surface = "live";
-    } else if (normalizedFile.endsWith(".e2e.test.ts")) {
-      surface = "e2e";
-    } else if (isChannelSurfaceTestFile(normalizedFile)) {
-      surface = "channels";
-    } else if (normalizedFile.startsWith(BUNDLED_PLUGIN_PATH_PREFIX)) {
-      surface = "extensions";
-    } else if (normalizedFile.startsWith("src/gateway/")) {
-      surface = "gateway";
-    } else if (baseConfigPrefixes.some((prefix) => normalizedFile.startsWith(prefix))) {
-      surface = "base";
-    } else if (normalizedFile.startsWith("src/")) {
-      surface = "unit";
-    }
-    if (surface === "unit") {
-      reasons.push("unit-surface");
-    } else if (surface !== "base") {
-      reasons.push(`${surface}-surface`);
-    } else {
-      reasons.push("base-surface");
-    }
-
-    const legacyBasePinned = baseThreadPinnedFileSet.has(normalizedFile);
-    if (legacyBasePinned) {
-      reasons.push("base-pinned-manifest");
-    }
-    if (unitThreadPinnedFileSet.has(normalizedFile)) {
-      reasons.push("unit-pinned-manifest");
-    }
-
-    return {
-      file: normalizedFile,
-      surface,
-      isolated,
-      legacyBasePinned,
-      reasons,
-    };
-  };
-
-  const resolveFilterMatches = (fileFilter) => {
-    const normalizedFilter = normalizeRepoPath(fileFilter);
-    const repoRelativeFilter = toRepoRelativePath(fileFilter);
-    if (fs.existsSync(fileFilter)) {
-      const stats = fs.statSync(fileFilter);
-      if (stats.isFile()) {
-        if (repoRelativeFilter && allKnownTestFiles.includes(repoRelativeFilter)) {
-          return [repoRelativeFilter];
-        }
-        throw new Error(`Explicit path ${fileFilter} is not a known test file.`);
-      }
-      if (stats.isDirectory()) {
-        if (!repoRelativeFilter) {
-          throw new Error(`Explicit path ${fileFilter} is outside the repo test roots.`);
-        }
-        const prefix = repoRelativeFilter.endsWith("/")
-          ? repoRelativeFilter
-          : `${repoRelativeFilter}/`;
-        const matches = allKnownTestFiles.filter((file) => file.startsWith(prefix));
-        if (matches.length === 0) {
-          throw new Error(`Explicit path ${fileFilter} does not contain known test files.`);
-        }
-        return matches;
-      }
-    }
-    if (/[*?[\]{}]/.test(normalizedFilter)) {
-      return allKnownTestFiles.filter((file) => path.matchesGlob(file, normalizedFilter));
-    }
-    return allKnownTestFiles.filter((file) => file.includes(normalizedFilter));
-  };
-
-  return {
-    allKnownTestFiles,
-    allKnownUnitFiles: allKnownTestFiles.filter((file) => isUnitConfigTestFile(file)),
-    baseThreadPinnedFiles,
-    channelIsolatedFiles,
-    channelIsolatedFileSet,
-    channelTestPrefixes,
-    extensionForkIsolatedFiles,
-    extensionForkIsolatedFileSet,
-    unitBehaviorOverrideSet,
-    unitForkIsolatedFiles,
-    unitThreadPinnedFiles,
-    baseThreadPinnedFileSet,
-    classifyTestFile,
-    resolveFilterMatches,
-  };
-}
-
-export const testSurfaces = [
-  "unit",
-  "bundled",
-  "extensions",
-  "channels",
-  "contracts",
-  "gateway",
-  "live",
-  "e2e",
-  "base",
-];
diff --git a/scripts/test-planner/executor.mjs b/scripts/test-planner/executor.mjs
deleted file mode 100644
index 86a31f2b2fb0..000000000000
--- a/scripts/test-planner/executor.mjs
+++ /dev/null
@@ -1,1193 +0,0 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  getProcessTreeRecords,
-  parseCompletedTestFileLines,
-  sampleProcessTreeRssKb,
-  summarizeDiagnosticReports,
-} from "../test-parallel-memory.mjs";
-import {
-  appendCapturedOutput,
-  formatCapturedOutputTail,
-  hasFatalTestRunOutput,
-  resolveTestRunExitCode,
-} from "../test-parallel-utils.mjs";
-import { countExplicitEntryFilters, getExplicitEntryFilters } from "./vitest-args.mjs";
-
-const countUnitEntryFilters = (unit) => {
-  const explicitFilterCount = countExplicitEntryFilters(unit.args);
-  if (explicitFilterCount !== null) {
-    return explicitFilterCount;
-  }
-  if (Array.isArray(unit.includeFiles) && unit.includeFiles.length > 0) {
-    return unit.includeFiles.length;
-  }
-  return null;
-};
-
-export function resolvePnpmCommandInvocation(options = {}) {
-  const npmExecPath = typeof options.npmExecPath === "string" ? options.npmExecPath.trim() : "";
-  if (npmExecPath && path.isAbsolute(npmExecPath)) {
-    const npmExecBase = path.basename(npmExecPath).toLowerCase();
-    if (npmExecBase.startsWith("pnpm")) {
-      return {
-        command: options.nodeExecPath || process.execPath,
-        args: [npmExecPath],
-      };
-    }
-  }
-
-  if (options.platform === "win32") {
-    return {
-      command: options.comSpec || "cmd.exe",
-      args: ["/d", "/s", "/c", "pnpm.cmd"],
-    };
-  }
-
-  return {
-    command: "pnpm",
-    args: [],
-  };
-}
-
-const sanitizeArtifactName = (value) => {
-  const normalized = value
-    .trim()
-    .replace(/[^a-z0-9._-]+/giu, "-")
-    .replace(/^-+|-+$/gu, "");
-  return normalized || "artifact";
-};
-
-const DEFAULT_CI_MAX_OLD_SPACE_SIZE_MB = 4096;
-const WARNING_SUPPRESSION_FLAGS = [
-  "--disable-warning=ExperimentalWarning",
-  "--disable-warning=DEP0040",
-  "--disable-warning=DEP0060",
-  "--disable-warning=MaxListenersExceededWarning",
-];
-
-const formatElapsedMs = (elapsedMs) =>
-  elapsedMs >= 1000 ? `${(elapsedMs / 1000).toFixed(1)}s` : `${Math.round(elapsedMs)}ms`;
-const formatMemoryKb = (rssKb) =>
-  rssKb >= 1024 ** 2
-    ? `${(rssKb / 1024 ** 2).toFixed(2)}GiB`
-    : rssKb >= 1024
-      ? `${(rssKb / 1024).toFixed(1)}MiB`
-      : `${rssKb}KiB`;
-const formatMemoryDeltaKb = (rssKb) =>
-  `${rssKb >= 0 ? "+" : "-"}${formatMemoryKb(Math.abs(rssKb))}`;
-
-const extractFailedTestFiles = (output) => {
-  const failureFiles = new Set();
-  const pattern = /^\s*❯\s+([^\s(][^(]*?\.(?:test|spec)\.[cm]?[jt]sx?)/gmu;
-  for (const match of output.matchAll(pattern)) {
-    const file = match[1]?.trim();
-    if (file) {
-      failureFiles.add(file);
-    }
-  }
-  return [...failureFiles];
-};
-
-const classifyRunResult = ({ resolvedCode, signal, fatalSeen, childError, failedTestFiles }) => {
-  if (resolvedCode === 0) {
-    return "pass";
-  }
-  if (childError || signal || fatalSeen || failedTestFiles.length === 0) {
-    return "infra-failure";
-  }
-  return "test-failure";
-};
-
-const formatRunLabel = (result) =>
-  `unit=${result.unitId}${result.shardLabel ? ` shard=${result.shardLabel}` : ""}`;
-
-const buildFinalRunReport = (results) => {
-  const failedResults = results.filter((result) => result.exitCode !== 0);
-  const failedUnits = new Set(failedResults.map((result) => result.unitId));
-  const failedTestFiles = new Set(failedResults.flatMap((result) => result.failedTestFiles ?? []));
-  const infraFailures = failedResults.filter((result) => result.classification === "infra-failure");
-  return {
-    exitCode: failedResults.length > 0 ? 1 : 0,
-    results,
-    summary: {
-      failedRunCount: failedResults.length,
-      failedUnitCount: failedUnits.size,
-      failedTestFileCount: failedTestFiles.size,
-      infraFailureCount: infraFailures.length,
-    },
-  };
-};
-
-const printFinalRunSummary = (plan, report, reportArtifactPath) => {
-  console.log(
-    `[test-parallel] summary failurePolicy=${plan.failurePolicy} failedUnits=${String(
-      report.summary.failedUnitCount,
-    )} failedTestFiles=${String(report.summary.failedTestFileCount)} infraFailures=${String(
-      report.summary.infraFailureCount,
-    )}`,
-  );
-  if (report.summary.failedTestFileCount > 0) {
-    console.error("[test-parallel] failing tests");
-    const failedTestFiles = report.results
-      .flatMap((result) => (result.classification === "test-failure" ? result.failedTestFiles : []))
-      .filter((file) => typeof file === "string");
-    for (const file of new Set(failedTestFiles)) {
-      console.error(`- ${String(file)}`);
-    }
-  }
-  if (report.summary.infraFailureCount > 0) {
-    console.error("[test-parallel] infrastructure failures");
-    for (const result of report.results.filter(
-      (entry) => entry.classification === "infra-failure",
-    )) {
-      console.error(
-        `- ${formatRunLabel(result)} code=${String(result.exitCode)} signal=${result.signal ?? "none"} log=${result.logPath}${result.failureArtifactPath ? ` meta=${result.failureArtifactPath}` : ""}`,
-      );
-    }
-  }
-  console.error(`[test-parallel] summary artifact ${reportArtifactPath}`);
-};
-
-export function createExecutionArtifacts(env = process.env) {
-  let tempArtifactDir = null;
-  const ensureTempArtifactDir = () => {
-    if (tempArtifactDir === null) {
-      tempArtifactDir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-test-parallel-"));
-    }
-    return tempArtifactDir;
-  };
-  const writeTempJsonArtifact = (name, value) => {
-    const filePath = path.join(ensureTempArtifactDir(), `${sanitizeArtifactName(name)}.json`);
-    fs.writeFileSync(filePath, `${JSON.stringify(value)}\n`, "utf8");
-    return filePath;
-  };
-  const cleanupTempArtifacts = () => {
-    if (tempArtifactDir === null) {
-      return;
-    }
-    if (env.OPENCLAW_TEST_KEEP_TEMP_ARTIFACTS === "1") {
-      console.error(`[test-parallel] keeping temp artifacts at ${tempArtifactDir}`);
-      return;
-    }
-    fs.rmSync(tempArtifactDir, { recursive: true, force: true });
-    tempArtifactDir = null;
-  };
-  return { ensureTempArtifactDir, writeTempJsonArtifact, cleanupTempArtifacts };
-}
-
-export function createTempArtifactWriteStream(filePath) {
-  const fd = fs.openSync(filePath, "w");
-  return fs.createWriteStream(filePath, {
-    fd,
-    autoClose: true,
-  });
-}
-
-const ensureNodeOptionFlag = (nodeOptions, flagPrefix, nextValue) =>
-  nodeOptions.includes(flagPrefix) ? nodeOptions : `${nodeOptions} ${nextValue}`.trim();
-
-const ensureNodeOptionFilePathFlag = (nodeOptions, flag, filePath) => {
-  const normalized = nodeOptions.trim();
-  const emptyAssignmentPattern = new RegExp(`(^|\\s)${flag}=(?=\\s|$)`, "u");
-  if (emptyAssignmentPattern.test(normalized)) {
-    return normalized.replace(emptyAssignmentPattern, `$1${flag}=${filePath}`);
-  }
-  const bareFlagPattern = new RegExp(`(^|\\s)${flag}(?=\\s|$)`, "u");
-  if (bareFlagPattern.test(normalized)) {
-    return normalized.replace(bareFlagPattern, `$1${flag}=${filePath}`);
-  }
-  return ensureNodeOptionFlag(normalized, `${flag}=`, `${flag}=${filePath}`);
-};
-
-const isNodeLikeProcess = (command) => /(?:^|\/)node(?:$|\.exe$)/iu.test(command);
-
-const getShardLabel = (args) => {
-  const shardIndex = args.findIndex((arg) => arg === "--shard");
-  if (shardIndex < 0) {
-    return "";
-  }
-  return typeof args[shardIndex + 1] === "string" ? args[shardIndex + 1] : "";
-};
-
-const normalizeEnvFlag = (value) => value?.trim().toLowerCase();
-
-const isEnvFlagEnabled = (value) => {
-  const normalized = normalizeEnvFlag(value);
-  return normalized === "1" || normalized === "true";
-};
-
-const isEnvFlagDisabled = (value) => {
-  const normalized = normalizeEnvFlag(value);
-  return normalized === "0" || normalized === "false";
-};
-
-const isWindowsEnv = (env, platform = process.platform) => {
-  if (platform === "win32") {
-    return true;
-  }
-  return normalizeEnvFlag(env.RUNNER_OS) === "windows";
-};
-
-const isFsModuleCacheEnabled = (env, platform = process.platform) => {
-  if (isWindowsEnv(env, platform)) {
-    return isEnvFlagEnabled(env.OPENCLAW_VITEST_FS_MODULE_CACHE);
-  }
-  return !isEnvFlagDisabled(env.OPENCLAW_VITEST_FS_MODULE_CACHE);
-};
-
-export const resolveVitestFsModuleCachePath = ({
-  cwd = process.cwd(),
-  env = process.env,
-  platform = process.platform,
-  unitId = "",
-} = {}) => {
-  const explicitPath = env.OPENCLAW_VITEST_FS_MODULE_CACHE_PATH?.trim();
-  if (!isFsModuleCacheEnabled(env, platform)) {
-    return undefined;
-  }
-  if (explicitPath) {
-    return explicitPath;
-  }
-  const pathImpl = isWindowsEnv(env, platform) ? path.win32 : path.posix;
-  return pathImpl.join(
-    cwd,
-    "node_modules",
-    ".experimental-vitest-cache",
-    sanitizeArtifactName(unitId || "default"),
-  );
-};
-
-export function formatPlanOutput(plan) {
-  return [
-    `runtime=${plan.runtimeCapabilities.runtimeProfileName} mode=${plan.runtimeCapabilities.mode} intent=${plan.runtimeCapabilities.intentProfile} memoryBand=${plan.runtimeCapabilities.memoryBand} loadBand=${plan.runtimeCapabilities.loadBand} failurePolicy=${plan.failurePolicy} vitestMaxWorkers=${String(plan.executionBudget.vitestMaxWorkers ?? "default")} topLevelParallel=${plan.topLevelParallelEnabled ? String(plan.topLevelParallelLimit) : "off"}`,
-    ...plan.selectedUnits.map(
-      (unit) =>
-        `${unit.id} filters=${String(countUnitEntryFilters(unit) ?? "all")} maxWorkers=${String(
-          unit.maxWorkers ?? "default",
-        )} surface=${unit.surface} isolate=${unit.isolate ? "yes" : "no"} pool=${unit.pool}`,
-    ),
-  ].join("\n");
-}
-
-export function formatExplanation(explanation) {
-  return [
-    `file=${explanation.file}`,
-    `runtime=${explanation.runtimeProfile} intent=${explanation.intentProfile} memoryBand=${explanation.memoryBand} loadBand=${explanation.loadBand}`,
-    `surface=${explanation.surface}`,
-    `isolate=${explanation.isolate ? "yes" : "no"}`,
-    `pool=${explanation.pool}`,
-    `maxWorkers=${String(explanation.maxWorkers ?? "default")}`,
-    `reasons=${explanation.reasons.join(",")}`,
-    `command=${explanation.args.join(" ")}`,
-  ].join("\n");
-}
-
-const buildOrderedParallelSegments = (units) => {
-  const segments = [];
-  let deferredUnits = [];
-  for (const unit of units) {
-    if (unit.serialPhase) {
-      if (deferredUnits.length > 0) {
-        segments.push({ type: "deferred", units: deferredUnits });
-        deferredUnits = [];
-      }
-      const lastSegment = segments.at(-1);
-      if (lastSegment?.type === "serialPhase" && lastSegment.phase === unit.serialPhase) {
-        lastSegment.units.push(unit);
-      } else {
-        segments.push({ type: "serialPhase", phase: unit.serialPhase, units: [unit] });
-      }
-      continue;
-    }
-    deferredUnits.push(unit);
-  }
-  if (deferredUnits.length > 0) {
-    segments.push({ type: "deferred", units: deferredUnits });
-  }
-  return segments;
-};
-
-const prioritizeDeferredUnitsForPhase = (units, phase) => {
-  const preferredSurface =
-    phase === "extensions" || phase === "channels" ? phase : phase === "unit-fast" ? "unit" : null;
-  if (preferredSurface === null) {
-    return units;
-  }
-  const preferred = [];
-  const remaining = [];
-  for (const unit of units) {
-    if (unit.surface === preferredSurface) {
-      preferred.push(unit);
-    } else {
-      remaining.push(unit);
-    }
-  }
-  return preferred.length > 0 ? [...preferred, ...remaining] : units;
-};
-
-const partitionUnitsBySurface = (units, surface) => {
-  const matching = [];
-  const remaining = [];
-  for (const unit of units) {
-    if (unit.surface === surface) {
-      matching.push(unit);
-    } else {
-      remaining.push(unit);
-    }
-  }
-  return { matching, remaining };
-};
-
-export async function executePlan(plan, options = {}) {
-  const env = options.env ?? process.env;
-  const artifacts = options.artifacts ?? createExecutionArtifacts(env);
-  const spawnImpl = options.spawn ?? spawn;
-  const pnpmInvocation = resolvePnpmCommandInvocation({
-    npmExecPath: env.npm_execpath,
-    nodeExecPath: process.execPath,
-    platform: process.platform,
-    comSpec: env.ComSpec,
-  });
-  const children = new Set();
-  const windowsCiArgs = plan.runtimeCapabilities.isWindowsCi
-    ? ["--dangerouslyIgnoreUnhandledErrors"]
-    : [];
-  const silentArgs = env.OPENCLAW_TEST_SHOW_PASSED_LOGS === "1" ? [] : ["--silent=passed-only"];
-  const rawMemoryTrace = env.OPENCLAW_TEST_MEMORY_TRACE?.trim().toLowerCase();
-  const memoryTraceEnabled =
-    process.platform !== "win32" &&
-    (rawMemoryTrace === "1" ||
-      rawMemoryTrace === "true" ||
-      (rawMemoryTrace !== "0" && rawMemoryTrace !== "false" && plan.runtimeCapabilities.isCI));
-  const parseEnvNumber = (name, fallback) => {
-    const parsed = Number.parseInt(env[name] ?? "", 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
-  };
-  const memoryTracePollMs = Math.max(
-    250,
-    parseEnvNumber("OPENCLAW_TEST_MEMORY_TRACE_POLL_MS", 1000),
-  );
-  const memoryTraceTopCount = Math.max(
-    1,
-    parseEnvNumber("OPENCLAW_TEST_MEMORY_TRACE_TOP_COUNT", 6),
-  );
-  const requestedHeapSnapshotIntervalMs = Math.max(
-    0,
-    parseEnvNumber("OPENCLAW_TEST_HEAPSNAPSHOT_INTERVAL_MS", 0),
-  );
-  const heapSnapshotMinIntervalMs = 1000;
-  const heapSnapshotIntervalMs =
-    requestedHeapSnapshotIntervalMs > 0
-      ? Math.max(heapSnapshotMinIntervalMs, requestedHeapSnapshotIntervalMs)
-      : 0;
-  const heapSnapshotEnabled =
-    process.platform !== "win32" && heapSnapshotIntervalMs >= heapSnapshotMinIntervalMs;
-  const heapSnapshotSignal = env.OPENCLAW_TEST_HEAPSNAPSHOT_SIGNAL?.trim() || "SIGUSR2";
-  const closeGraceMs = Math.max(100, parseEnvNumber("OPENCLAW_TEST_CLOSE_GRACE_MS", 2000));
-  const heapSnapshotBaseDir = heapSnapshotEnabled
-    ? path.resolve(
-        env.OPENCLAW_TEST_HEAPSNAPSHOT_DIR?.trim() ||
-          path.join(os.tmpdir(), `openclaw-heapsnapshots-${Date.now()}`),
-      )
-    : null;
-  const maxOldSpaceSizeMb = (() => {
-    const raw = env.OPENCLAW_TEST_MAX_OLD_SPACE_SIZE_MB ?? "";
-    const parsed = Number.parseInt(raw, 10);
-    if (Number.isFinite(parsed) && parsed > 0) {
-      return parsed;
-    }
-    if (plan.runtimeCapabilities.isCI && !plan.runtimeCapabilities.isWindows) {
-      return DEFAULT_CI_MAX_OLD_SPACE_SIZE_MB;
-    }
-    return null;
-  })();
-
-  const shutdown = (signal) => {
-    for (const child of children) {
-      child.kill(signal);
-    }
-  };
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("exit", artifacts.cleanupTempArtifacts);
-
-  const shouldCollectAllFailures = plan.failurePolicy === "collect-all";
-
-  const runOnce = (unit, extraArgs = []) =>
-    new Promise((resolve) => {
-      const startedAt = Date.now();
-      const entryArgs = unit.args;
-      const explicitEntryFilters = getExplicitEntryFilters(entryArgs);
-      const args = unit.maxWorkers
-        ? [
-            ...entryArgs,
-            "--maxWorkers",
-            String(unit.maxWorkers),
-            ...silentArgs,
-            ...windowsCiArgs,
-            ...extraArgs,
-          ]
-        : [...entryArgs, ...silentArgs, ...windowsCiArgs, ...extraArgs];
-      const spawnArgs = [...pnpmInvocation.args, ...args];
-      const shardLabel = getShardLabel(extraArgs);
-      const artifactStem = [
-        sanitizeArtifactName(unit.id),
-        shardLabel ? `shard-${sanitizeArtifactName(shardLabel)}` : "",
-        String(startedAt),
-      ]
-        .filter(Boolean)
-        .join("-");
-      const laneLogPath = path.join(artifacts.ensureTempArtifactDir(), `${artifactStem}.log`);
-      const laneLogStream = createTempArtifactWriteStream(laneLogPath);
-      laneLogStream.write(`[test-parallel] entry=${unit.id}\n`);
-      laneLogStream.write(`[test-parallel] cwd=${process.cwd()}\n`);
-      laneLogStream.write(
-        `[test-parallel] command=${[pnpmInvocation.command, ...spawnArgs].join(" ")}\n\n`,
-      );
-      console.log(
-        `[test-parallel] start ${unit.id} workers=${unit.maxWorkers ?? "default"} filters=${String(
-          countExplicitEntryFilters(entryArgs) ?? "all",
-        )}`,
-      );
-      const nodeOptions = env.NODE_OPTIONS ?? "";
-      const nextNodeOptions = WARNING_SUPPRESSION_FLAGS.reduce(
-        (acc, flag) => (acc.includes(flag) ? acc : `${acc} ${flag}`.trim()),
-        nodeOptions,
-      );
-      const heapSnapshotDir =
-        heapSnapshotBaseDir === null ? null : path.join(heapSnapshotBaseDir, unit.id);
-      const reportOnSignalEnabled =
-        (env.OPENCLAW_TEST_REPORT_ON_SIGNAL ?? "").trim().toLowerCase() === "1";
-      let resolvedNodeOptions =
-        maxOldSpaceSizeMb && !nextNodeOptions.includes("--max-old-space-size=")
-          ? `${nextNodeOptions} --max-old-space-size=${maxOldSpaceSizeMb}`.trim()
-          : nextNodeOptions;
-      const localStorageFilePath = path.join(
-        artifacts.ensureTempArtifactDir(),
-        `${artifactStem}.localstorage.json`,
-      );
-      resolvedNodeOptions = ensureNodeOptionFilePathFlag(
-        resolvedNodeOptions,
-        "--localstorage-file",
-        localStorageFilePath,
-      );
-      if (heapSnapshotEnabled && heapSnapshotDir) {
-        try {
-          fs.mkdirSync(heapSnapshotDir, { recursive: true });
-        } catch (err) {
-          console.error(
-            `[test-parallel] failed to create heap snapshot dir ${heapSnapshotDir}: ${String(err)}`,
-          );
-          resolve({
-            unitId: unit.id,
-            shardLabel,
-            classification: "infra-failure",
-            exitCode: 1,
-            signal: null,
-            elapsedMs: Date.now() - startedAt,
-            failedTestFiles: [...explicitEntryFilters],
-            explicitEntryFilters,
-            failureArtifactPath: null,
-            logPath: laneLogPath,
-            outputTail: "",
-          });
-          return;
-        }
-        resolvedNodeOptions = ensureNodeOptionFlag(
-          resolvedNodeOptions,
-          "--diagnostic-dir=",
-          `--diagnostic-dir=${heapSnapshotDir}`,
-        );
-        resolvedNodeOptions = ensureNodeOptionFlag(
-          resolvedNodeOptions,
-          "--heapsnapshot-signal=",
-          `--heapsnapshot-signal=${heapSnapshotSignal}`,
-        );
-        if (reportOnSignalEnabled) {
-          resolvedNodeOptions = ensureNodeOptionFlag(
-            resolvedNodeOptions,
-            "--report-on-signal",
-            "--report-on-signal",
-          );
-          resolvedNodeOptions = ensureNodeOptionFlag(
-            resolvedNodeOptions,
-            "--report-signal=",
-            `--report-signal=${heapSnapshotSignal}`,
-          );
-          resolvedNodeOptions = ensureNodeOptionFlag(
-            resolvedNodeOptions,
-            "--report-directory=",
-            `--report-directory=${heapSnapshotDir}`,
-          );
-        }
-      }
-      let output = "";
-      let fatalSeen = false;
-      let childError = null;
-      let child;
-      let pendingLine = "";
-      let memoryPollTimer = null;
-      let heapSnapshotTimer = null;
-      let closeFallbackTimer = null;
-      let failureArtifactPath = null;
-      let failureTail = "";
-      const memoryFileRecords = [];
-      let initialTreeSample = null;
-      let latestTreeSample = null;
-      let peakTreeSample = null;
-      let heapSnapshotSequence = 0;
-      let childExitState = null;
-      let settled = false;
-      const updatePeakTreeSample = (sample, reason) => {
-        if (!sample) {
-          return;
-        }
-        if (!peakTreeSample || sample.rssKb > peakTreeSample.rssKb) {
-          peakTreeSample = { ...sample, reason };
-        }
-      };
-      const triggerHeapSnapshot = (reason) => {
-        if (!heapSnapshotEnabled || !child?.pid || !heapSnapshotDir) {
-          return;
-        }
-        const records = getProcessTreeRecords(child.pid) ?? [];
-        const targetPids = records
-          .filter((record) => record.pid !== process.pid && isNodeLikeProcess(record.command))
-          .map((record) => record.pid);
-        if (targetPids.length === 0) {
-          return;
-        }
-        heapSnapshotSequence += 1;
-        let signaledCount = 0;
-        for (const pid of targetPids) {
-          try {
-            process.kill(pid, heapSnapshotSignal);
-            signaledCount += 1;
-          } catch {}
-        }
-        if (signaledCount > 0) {
-          console.log(
-            `[test-parallel][heap] ${unit.id} seq=${String(heapSnapshotSequence)} reason=${reason} signaled=${String(
-              signaledCount,
-            )}/${String(targetPids.length)} dir=${heapSnapshotDir}`,
-          );
-        }
-      };
-      const captureTreeSample = (reason) => {
-        if (!memoryTraceEnabled || !child?.pid) {
-          return null;
-        }
-        const sample = sampleProcessTreeRssKb(child.pid);
-        if (!sample) {
-          return null;
-        }
-        latestTreeSample = sample;
-        if (!initialTreeSample) {
-          initialTreeSample = sample;
-        }
-        updatePeakTreeSample(sample, reason);
-        return sample;
-      };
-      const logMemoryTraceForText = (text) => {
-        if (!memoryTraceEnabled) {
-          return;
-        }
-        const combined = `${pendingLine}${text}`;
-        const lines = combined.split(/\r?\n/u);
-        pendingLine = lines.pop() ?? "";
-        const completedFiles = parseCompletedTestFileLines(lines.join("\n"));
-        for (const completedFile of completedFiles) {
-          const sample = captureTreeSample(completedFile.file);
-          if (!sample) {
-            continue;
-          }
-          const previousRssKb =
-            memoryFileRecords.length > 0
-              ? (memoryFileRecords.at(-1)?.rssKb ?? initialTreeSample?.rssKb ?? sample.rssKb)
-              : (initialTreeSample?.rssKb ?? sample.rssKb);
-          const deltaKb = sample.rssKb - previousRssKb;
-          const record = {
-            ...completedFile,
-            rssKb: sample.rssKb,
-            processCount: sample.processCount,
-            deltaKb,
-          };
-          memoryFileRecords.push(record);
-          console.log(
-            `[test-parallel][mem] ${unit.id} file=${record.file} rss=${formatMemoryKb(
-              record.rssKb,
-            )} delta=${formatMemoryDeltaKb(record.deltaKb)} peak=${formatMemoryKb(
-              peakTreeSample?.rssKb ?? record.rssKb,
-            )} procs=${record.processCount}${record.durationMs ? ` duration=${formatElapsedMs(record.durationMs)}` : ""}`,
-          );
-        }
-      };
-      const logMemoryTraceSummary = () => {
-        if (!memoryTraceEnabled) {
-          return;
-        }
-        captureTreeSample("close");
-        const fallbackRecord =
-          memoryFileRecords.length === 0 &&
-          explicitEntryFilters.length === 1 &&
-          latestTreeSample &&
-          initialTreeSample
-            ? [
-                {
-                  file: explicitEntryFilters[0],
-                  deltaKb: latestTreeSample.rssKb - initialTreeSample.rssKb,
-                },
-              ]
-            : [];
-        const totalDeltaKb =
-          initialTreeSample && latestTreeSample
-            ? latestTreeSample.rssKb - initialTreeSample.rssKb
-            : 0;
-        const topGrowthFiles = [...memoryFileRecords, ...fallbackRecord]
-          .filter((record) => record.deltaKb > 0 && typeof record.file === "string")
-          .toSorted((left, right) => right.deltaKb - left.deltaKb)
-          .slice(0, memoryTraceTopCount)
-          .map((record) => `${record.file}:${formatMemoryDeltaKb(record.deltaKb)}`);
-        const reportGrowth =
-          reportOnSignalEnabled && heapSnapshotDir
-            ? summarizeDiagnosticReports(heapSnapshotDir)
-                .filter((record) => record.rssDeltaKb > 0 || record.usedHeapDeltaKb > 0)
-                .slice(0, memoryTraceTopCount)
-                .map(
-                  (record) =>
-                    `pid=${String(record.pid)} rss=${formatMemoryDeltaKb(record.rssDeltaKb)} heap=${formatMemoryDeltaKb(record.usedHeapDeltaKb)} external=${formatMemoryDeltaKb(record.externalDeltaKb)}`,
-                )
-            : [];
-        console.log(
-          `[test-parallel][mem] summary ${unit.id} files=${memoryFileRecords.length} peak=${formatMemoryKb(
-            peakTreeSample?.rssKb ?? 0,
-          )} totalDelta=${formatMemoryDeltaKb(totalDeltaKb)} peakAt=${
-            peakTreeSample?.reason ?? "n/a"
-          } top=${topGrowthFiles.length > 0 ? topGrowthFiles.join(", ") : "none"} reports=${
-            reportGrowth.length > 0 ? reportGrowth.join(", ") : "none"
-          }`,
-        );
-      };
-      const clearChildTimers = () => {
-        if (memoryPollTimer) {
-          clearInterval(memoryPollTimer);
-          memoryPollTimer = null;
-        }
-        if (heapSnapshotTimer) {
-          clearInterval(heapSnapshotTimer);
-          heapSnapshotTimer = null;
-        }
-        if (closeFallbackTimer) {
-          clearTimeout(closeFallbackTimer);
-          closeFallbackTimer = null;
-        }
-      };
-      const finalizeRun = (code, signal, source = "close") => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearChildTimers();
-        children.delete(child);
-        const resolvedCode = resolveTestRunExitCode({
-          code,
-          signal,
-          output,
-          fatalSeen,
-          childError,
-        });
-        const elapsedMs = Date.now() - startedAt;
-        logMemoryTraceSummary();
-        if (resolvedCode !== 0) {
-          failureTail = formatCapturedOutputTail(output);
-          failureArtifactPath = artifacts.writeTempJsonArtifact(`${artifactStem}-failure`, {
-            entry: unit.id,
-            command: [pnpmInvocation.command, ...spawnArgs],
-            elapsedMs,
-            error: childError ? String(childError) : null,
-            exitCode: resolvedCode,
-            fatalSeen,
-            logPath: laneLogPath,
-            outputTail: failureTail,
-            signal: signal ?? null,
-          });
-          if (failureTail) {
-            console.error(`[test-parallel] failure tail ${unit.id}\n${failureTail}`);
-          }
-          console.error(
-            `[test-parallel] failure artifacts ${unit.id} log=${laneLogPath} meta=${failureArtifactPath}`,
-          );
-        }
-        if (source !== "close") {
-          laneLogStream.write(
-            `\n[test-parallel] finalize source=${source} after child exit without close\n`,
-          );
-        }
-        laneLogStream.write(
-          `\n[test-parallel] done ${unit.id} code=${String(resolvedCode)} signal=${
-            signal ?? "none"
-          } elapsed=${formatElapsedMs(elapsedMs)}\n`,
-        );
-        laneLogStream.end();
-        console.log(
-          `[test-parallel] done ${unit.id} code=${String(resolvedCode)} elapsed=${formatElapsedMs(elapsedMs)}`,
-        );
-        const failedTestFiles = extractFailedTestFiles(output);
-        const classification = classifyRunResult({
-          resolvedCode,
-          signal,
-          fatalSeen,
-          childError,
-          failedTestFiles,
-        });
-        resolve({
-          unitId: unit.id,
-          shardLabel,
-          classification,
-          exitCode: resolvedCode,
-          signal: signal ?? null,
-          elapsedMs,
-          failedTestFiles,
-          explicitEntryFilters,
-          failureArtifactPath,
-          logPath: laneLogPath,
-          outputTail: failureTail,
-        });
-      };
-      try {
-        const childEnv = {
-          ...env,
-          ...unit.env,
-          VITEST_GROUP: unit.id,
-          NODE_OPTIONS: resolvedNodeOptions,
-        };
-        const vitestFsModuleCachePath = resolveVitestFsModuleCachePath({
-          env: childEnv,
-          platform: process.platform,
-          unitId: unit.id,
-        });
-        if (vitestFsModuleCachePath) {
-          childEnv.OPENCLAW_VITEST_FS_MODULE_CACHE_PATH = vitestFsModuleCachePath;
-          laneLogStream.write(`[test-parallel] fsModuleCachePath=${vitestFsModuleCachePath}\n`);
-        }
-        child = spawnImpl(pnpmInvocation.command, spawnArgs, {
-          stdio: ["inherit", "pipe", "pipe"],
-          env: childEnv,
-          shell: false,
-        });
-        captureTreeSample("spawn");
-        if (memoryTraceEnabled) {
-          memoryPollTimer = setInterval(() => {
-            captureTreeSample("poll");
-          }, memoryTracePollMs);
-        }
-        if (heapSnapshotEnabled) {
-          heapSnapshotTimer = setInterval(() => {
-            triggerHeapSnapshot("interval");
-          }, heapSnapshotIntervalMs);
-        }
-      } catch (err) {
-        laneLogStream.end();
-        console.error(`[test-parallel] spawn failed: ${String(err)}`);
-        resolve({
-          unitId: unit.id,
-          shardLabel: getShardLabel(extraArgs),
-          classification: "infra-failure",
-          exitCode: 1,
-          signal: null,
-          elapsedMs: Date.now() - startedAt,
-          failedTestFiles: [...explicitEntryFilters],
-          explicitEntryFilters,
-          failureArtifactPath: null,
-          logPath: laneLogPath,
-          outputTail: String(err),
-        });
-        return;
-      }
-      children.add(child);
-      child.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        fatalSeen ||= hasFatalTestRunOutput(`${output}${text}`);
-        output = appendCapturedOutput(output, text);
-        laneLogStream.write(text);
-        logMemoryTraceForText(text);
-        process.stdout.write(chunk);
-      });
-      child.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        fatalSeen ||= hasFatalTestRunOutput(`${output}${text}`);
-        output = appendCapturedOutput(output, text);
-        laneLogStream.write(text);
-        logMemoryTraceForText(text);
-        process.stderr.write(chunk);
-      });
-      child.on("error", (err) => {
-        childError = err;
-        laneLogStream.write(`\n[test-parallel] child error: ${String(err)}\n`);
-        console.error(`[test-parallel] child error: ${String(err)}`);
-      });
-      child.on("exit", (code, signal) => {
-        childExitState = { code, signal };
-        if (settled || closeFallbackTimer) {
-          return;
-        }
-        closeFallbackTimer = setTimeout(() => {
-          child.stdout?.destroy();
-          child.stderr?.destroy();
-          finalizeRun(code, signal, "exit-timeout");
-        }, closeGraceMs);
-      });
-      child.on("close", (code, signal) => {
-        finalizeRun(childExitState?.code ?? code, childExitState?.signal ?? signal, "close");
-      });
-    });
-
-  const runUnit = async (unit, extraArgs = []) => {
-    const results = [];
-    if (unit.fixedShardIndex !== undefined) {
-      if (plan.shardIndexOverride !== null && plan.shardIndexOverride !== unit.fixedShardIndex) {
-        return results;
-      }
-      results.push(await runOnce(unit, extraArgs));
-      return results;
-    }
-    const explicitFilterCount = countUnitEntryFilters(unit);
-    const topLevelAssignedShard = plan.topLevelSingleShardAssignments.get(unit);
-    if (topLevelAssignedShard !== undefined) {
-      if (plan.shardIndexOverride !== null && plan.shardIndexOverride !== topLevelAssignedShard) {
-        return results;
-      }
-      results.push(await runOnce(unit, extraArgs));
-      return results;
-    }
-    const effectiveShardCount =
-      explicitFilterCount === null
-        ? plan.shardCount
-        : Math.min(plan.shardCount, Math.max(1, explicitFilterCount - 1));
-    if (effectiveShardCount <= 1) {
-      if (plan.shardIndexOverride !== null && plan.shardIndexOverride > effectiveShardCount) {
-        return results;
-      }
-      results.push(await runOnce(unit, extraArgs));
-      return results;
-    }
-    if (plan.shardIndexOverride !== null) {
-      if (plan.shardIndexOverride > effectiveShardCount) {
-        return results;
-      }
-      results.push(
-        await runOnce(unit, [
-          "--shard",
-          `${plan.shardIndexOverride}/${effectiveShardCount}`,
-          ...extraArgs,
-        ]),
-      );
-      return results;
-    }
-    for (let shardIndex = 1; shardIndex <= effectiveShardCount; shardIndex += 1) {
-      results.push(
-        // eslint-disable-next-line no-await-in-loop
-        await runOnce(unit, ["--shard", `${shardIndex}/${effectiveShardCount}`, ...extraArgs]),
-      );
-      if (!shouldCollectAllFailures && results.at(-1)?.exitCode !== 0) {
-        return results;
-      }
-    }
-    return results;
-  };
-
-  const runUnitsWithLimit = async (units, extraArgs = [], concurrency = 1) => {
-    const results = [];
-    if (units.length === 0) {
-      return results;
-    }
-    const normalizedConcurrency = Math.max(1, Math.floor(concurrency));
-    if (normalizedConcurrency <= 1) {
-      for (const unit of units) {
-        results.push(
-          // eslint-disable-next-line no-await-in-loop
-          ...(await runUnit(unit, extraArgs)),
-        );
-        if (!shouldCollectAllFailures && results.some((result) => result.exitCode !== 0)) {
-          return results;
-        }
-      }
-      return results;
-    }
-    let nextIndex = 0;
-    let stopScheduling = false;
-    const worker = async () => {
-      while (!stopScheduling) {
-        const unitIndex = nextIndex;
-        nextIndex += 1;
-        if (unitIndex >= units.length) {
-          return;
-        }
-        const unitResults = await runUnit(units[unitIndex], extraArgs);
-        results.push(...unitResults);
-        if (!shouldCollectAllFailures && unitResults.some((result) => result.exitCode !== 0)) {
-          stopScheduling = true;
-        }
-      }
-    };
-    const workerCount = Math.min(normalizedConcurrency, units.length);
-    await Promise.all(Array.from({ length: workerCount }, () => worker()));
-    return results;
-  };
-
-  const runUnits = async (units, extraArgs = []) => {
-    if (plan.topLevelParallelEnabled) {
-      return runUnitsWithLimit(units, extraArgs, plan.topLevelParallelLimit);
-    }
-    return runUnitsWithLimit(units, extraArgs);
-  };
-
-  if (plan.passthroughMetadataOnly) {
-    const report = buildFinalRunReport([
-      await runOnce(
-        {
-          id: "vitest-meta",
-          args: ["vitest", "run"],
-          maxWorkers: null,
-        },
-        plan.passthroughOptionArgs,
-      ),
-    ]);
-    const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-    printFinalRunSummary(plan, report, reportArtifactPath);
-    return report;
-  }
-
-  if (plan.targetedUnits.length > 0) {
-    if (plan.passthroughRequiresSingleRun && plan.targetedUnits.length > 1) {
-      console.error(
-        "[test-parallel] The provided Vitest args require a single run, but the selected test filters span multiple wrapper configs. Run one target/config at a time.",
-      );
-      return {
-        exitCode: 2,
-        results: [],
-        summary: {
-          failedRunCount: 0,
-          failedUnitCount: 0,
-          failedTestFileCount: 0,
-          infraFailureCount: 0,
-        },
-      };
-    }
-    const results = [];
-    results.push(...(await runUnits(plan.parallelUnits, plan.passthroughOptionArgs)));
-    if (!shouldCollectAllFailures && results.some((result) => result.exitCode !== 0)) {
-      const report = buildFinalRunReport(results);
-      const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-      printFinalRunSummary(plan, report, reportArtifactPath);
-      return report;
-    }
-    for (const unit of plan.serialUnits) {
-      results.push(
-        // eslint-disable-next-line no-await-in-loop
-        ...(await runUnit(unit, plan.passthroughOptionArgs)),
-      );
-      if (!shouldCollectAllFailures && results.some((result) => result.exitCode !== 0)) {
-        const report = buildFinalRunReport(results);
-        const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-        printFinalRunSummary(plan, report, reportArtifactPath);
-        return report;
-      }
-    }
-    const report = buildFinalRunReport(results);
-    const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-    printFinalRunSummary(plan, report, reportArtifactPath);
-    return report;
-  }
-
-  if (plan.passthroughRequiresSingleRun && plan.passthroughOptionArgs.length > 0) {
-    console.error(
-      "[test-parallel] The provided Vitest args require a single run. Use the dedicated npm script for that workflow (for example `pnpm test:coverage`) or target a single test file/filter.",
-    );
-    return {
-      exitCode: 2,
-      results: [],
-      summary: {
-        failedRunCount: 0,
-        failedUnitCount: 0,
-        failedTestFileCount: 0,
-        infraFailureCount: 0,
-      },
-    };
-  }
-
-  const results = [];
-  if (plan.serialPrefixUnits.length > 0) {
-    const orderedSegments = buildOrderedParallelSegments(plan.parallelUnits);
-    let pendingDeferredSegment = null;
-    let carriedDeferredPromise = null;
-    let carriedDeferredSurface = null;
-    for (const segment of orderedSegments) {
-      if (segment.type === "deferred") {
-        pendingDeferredSegment = segment;
-        continue;
-      }
-      // Preserve phase ordering, but let batches inside the same shared phase use
-      // the normal top-level concurrency budget.
-      let deferredPromise = null;
-      let deferredCarryPromise = carriedDeferredPromise;
-      let deferredCarrySurface = carriedDeferredSurface;
-      if (
-        segment.phase === "unit-fast" &&
-        pendingDeferredSegment !== null &&
-        plan.topLevelParallelEnabled
-      ) {
-        const availableSlots = Math.max(0, plan.topLevelParallelLimit - segment.units.length);
-        if (availableSlots > 0) {
-          const prePhaseDeferred = pendingDeferredSegment.units;
-          if (prePhaseDeferred.length > 0) {
-            deferredCarryPromise = runUnitsWithLimit(
-              prePhaseDeferred,
-              plan.passthroughOptionArgs,
-              availableSlots,
-            );
-            deferredCarrySurface = prePhaseDeferred.some((unit) => unit.surface === "channels")
-              ? "channels"
-              : null;
-            pendingDeferredSegment = null;
-          }
-        }
-      }
-      if (pendingDeferredSegment !== null) {
-        const prioritizedDeferred = prioritizeDeferredUnitsForPhase(
-          pendingDeferredSegment.units,
-          segment.phase,
-        );
-        if (segment.phase === "extensions") {
-          const { matching: channelDeferred, remaining: otherDeferred } = partitionUnitsBySurface(
-            prioritizedDeferred,
-            "channels",
-          );
-          deferredPromise =
-            otherDeferred.length > 0
-              ? runUnitsWithLimit(
-                  otherDeferred,
-                  plan.passthroughOptionArgs,
-                  plan.deferredRunConcurrency ?? 1,
-                )
-              : null;
-          deferredCarryPromise =
-            channelDeferred.length > 0
-              ? runUnitsWithLimit(
-                  channelDeferred,
-                  plan.passthroughOptionArgs,
-                  plan.deferredRunConcurrency ?? 1,
-                )
-              : carriedDeferredPromise;
-          deferredCarrySurface = channelDeferred.length > 0 ? "channels" : carriedDeferredSurface;
-        } else {
-          deferredPromise = runUnitsWithLimit(
-            prioritizedDeferred,
-            plan.passthroughOptionArgs,
-            plan.deferredRunConcurrency ?? 1,
-          );
-        }
-      }
-      pendingDeferredSegment = null;
-      // eslint-disable-next-line no-await-in-loop
-      const serialPhaseResults = await runUnits(segment.units, plan.passthroughOptionArgs);
-      results.push(...serialPhaseResults);
-      if (!shouldCollectAllFailures && serialPhaseResults.some((result) => result.exitCode !== 0)) {
-        const report = buildFinalRunReport(results);
-        const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-        printFinalRunSummary(plan, report, reportArtifactPath);
-        return report;
-      }
-      if (deferredCarryPromise !== null && deferredCarrySurface === segment.phase) {
-        const carriedDeferredResults =
-          // eslint-disable-next-line no-await-in-loop
-          await deferredCarryPromise;
-        results.push(...carriedDeferredResults);
-        if (
-          !shouldCollectAllFailures &&
-          carriedDeferredResults.some((result) => result.exitCode !== 0)
-        ) {
-          const report = buildFinalRunReport(results);
-          const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-          printFinalRunSummary(plan, report, reportArtifactPath);
-          return report;
-        }
-        deferredCarryPromise = null;
-        deferredCarrySurface = null;
-      }
-      if (deferredPromise !== null) {
-        const deferredResults =
-          // eslint-disable-next-line no-await-in-loop
-          await deferredPromise;
-        results.push(...deferredResults);
-        if (!shouldCollectAllFailures && deferredResults.some((result) => result.exitCode !== 0)) {
-          const report = buildFinalRunReport(results);
-          const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-          printFinalRunSummary(plan, report, reportArtifactPath);
-          return report;
-        }
-      }
-      carriedDeferredPromise = deferredCarryPromise;
-      carriedDeferredSurface = deferredCarrySurface;
-    }
-    if (pendingDeferredSegment !== null) {
-      const deferredParallelResults = await runUnitsWithLimit(
-        pendingDeferredSegment.units,
-        plan.passthroughOptionArgs,
-        plan.deferredRunConcurrency ?? 1,
-      );
-      results.push(...deferredParallelResults);
-      if (
-        !shouldCollectAllFailures &&
-        deferredParallelResults.some((result) => result.exitCode !== 0)
-      ) {
-        const report = buildFinalRunReport(results);
-        const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-        printFinalRunSummary(plan, report, reportArtifactPath);
-        return report;
-      }
-    }
-    if (carriedDeferredPromise !== null) {
-      const carriedDeferredResults = await carriedDeferredPromise;
-      results.push(...carriedDeferredResults);
-      if (
-        !shouldCollectAllFailures &&
-        carriedDeferredResults.some((result) => result.exitCode !== 0)
-      ) {
-        const report = buildFinalRunReport(results);
-        const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-        printFinalRunSummary(plan, report, reportArtifactPath);
-        return report;
-      }
-    }
-  } else {
-    const parallelResults = await runUnits(plan.parallelUnits, plan.passthroughOptionArgs);
-    results.push(...parallelResults);
-    if (!shouldCollectAllFailures && parallelResults.some((result) => result.exitCode !== 0)) {
-      const report = buildFinalRunReport(results);
-      const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-      printFinalRunSummary(plan, report, reportArtifactPath);
-      return report;
-    }
-  }
-
-  for (const unit of plan.serialUnits) {
-    results.push(
-      // eslint-disable-next-line no-await-in-loop
-      ...(await runUnit(unit, plan.passthroughOptionArgs)),
-    );
-    if (!shouldCollectAllFailures && results.some((result) => result.exitCode !== 0)) {
-      const report = buildFinalRunReport(results);
-      const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-      printFinalRunSummary(plan, report, reportArtifactPath);
-      return report;
-    }
-  }
-  const report = buildFinalRunReport(results);
-  const reportArtifactPath = artifacts.writeTempJsonArtifact("summary-report", report);
-  printFinalRunSummary(plan, report, reportArtifactPath);
-  return report;
-}
diff --git a/scripts/test-planner/planner.mjs b/scripts/test-planner/planner.mjs
deleted file mode 100644
index 6ce900548625..000000000000
--- a/scripts/test-planner/planner.mjs
+++ /dev/null
@@ -1,1874 +0,0 @@
-import path from "node:path";
-import {
-  boundaryTestFiles,
-  isBoundaryTestFile,
-  bundledPluginDependentUnitTestFiles,
-  isBundledPluginDependentUnitTestFile,
-  isUnitConfigTestFile,
-} from "../../vitest.unit-paths.mjs";
-import { BUNDLED_PLUGIN_PATH_PREFIX } from "../lib/bundled-plugin-paths.mjs";
-import {
-  loadChannelTimingManifest,
-  loadExtensionMemoryHotspotManifest,
-  loadExtensionTimingManifest,
-  loadUnitMemoryHotspotManifest,
-  loadUnitTimingManifest,
-  packFilesByDuration,
-  packFilesByDurationWithBaseLoads,
-  selectMemoryHeavyFiles,
-  selectTimedHeavyFiles,
-  selectUnitHeavyFileGroups,
-} from "../test-runner-manifest.mjs";
-import { loadTestCatalog, normalizeRepoPath } from "./catalog.mjs";
-import { resolveExecutionBudget, resolveRuntimeCapabilities } from "./runtime-profile.mjs";
-import {
-  countExplicitEntryFilters,
-  getExplicitEntryFilters,
-  parsePassthroughArgs,
-  SINGLE_RUN_ONLY_FLAGS,
-} from "./vitest-args.mjs";
-
-const countUnitEntryFilters = (unit) => {
-  const explicitFilterCount = countExplicitEntryFilters(unit.args);
-  if (explicitFilterCount !== null) {
-    return explicitFilterCount;
-  }
-  if (Array.isArray(unit.includeFiles) && unit.includeFiles.length > 0) {
-    return unit.includeFiles.length;
-  }
-  return null;
-};
-
-const parseEnvNumber = (env, name, fallback) => {
-  const parsed = Number.parseInt(env[name] ?? "", 10);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
-};
-
-const parseBooleanLike = (value, fallback = false) => {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "true" || normalized === "1") {
-      return true;
-    }
-    if (normalized === "false" || normalized === "0" || normalized === "") {
-      return false;
-    }
-  }
-  return fallback;
-};
-
-const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-
-const sumKnownManifestDurationsMs = (manifest) =>
-  Object.values(manifest.files ?? {}).reduce((totalMs, entry) => totalMs + entry.durationMs, 0);
-
-const resolveDynamicShardCount = ({
-  estimatedDurationMs,
-  fileCount,
-  targetDurationMs,
-  targetFilesPerShard,
-  minShards,
-  maxShards,
-}) => {
-  const durationDriven =
-    Number.isFinite(targetDurationMs) && targetDurationMs > 0
-      ? Math.ceil(estimatedDurationMs / targetDurationMs)
-      : 1;
-  const fileDriven =
-    Number.isFinite(targetFilesPerShard) && targetFilesPerShard > 0
-      ? Math.ceil(fileCount / targetFilesPerShard)
-      : 1;
-  return clamp(Math.max(minShards, durationDriven, fileDriven), minShards, maxShards);
-};
-
-const createShardMatrixEntries = ({ checkNamePrefix, runtime, task, command, shardCount }) =>
-  Array.from({ length: shardCount }, (_, index) => ({
-    check_name: `${checkNamePrefix}-${String(index + 1)}`,
-    runtime,
-    task,
-    command,
-    shard_index: index + 1,
-    shard_count: shardCount,
-  }));
-
-const parseChangedExtensionsMatrix = (value) => {
-  if (typeof value === "object" && value !== null && Array.isArray(value.include)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    try {
-      const parsed = JSON.parse(value);
-      if (parsed && typeof parsed === "object" && Array.isArray(parsed.include)) {
-        return parsed;
-      }
-    } catch {}
-  }
-  return { include: [] };
-};
-
-const normalizeSurfaces = (values = []) => [
-  ...new Set(
-    values
-      .flatMap((value) => String(value).split(","))
-      .map((value) => value.trim())
-      .filter(Boolean),
-  ),
-];
-
-const EXPLICIT_PLAN_SURFACES = new Set([
-  "unit",
-  "bundled",
-  "extensions",
-  "channels",
-  "contracts",
-  "gateway",
-]);
-const FAILURE_POLICIES = new Set(["fail-fast", "collect-all"]);
-
-const validateExplicitSurfaces = (surfaces) => {
-  const invalidSurfaces = surfaces.filter((surface) => !EXPLICIT_PLAN_SURFACES.has(surface));
-  if (invalidSurfaces.length > 0) {
-    throw new Error(
-      `Unsupported --surface value(s): ${invalidSurfaces.join(", ")}. Supported surfaces: unit, bundled, extensions, channels, contracts, gateway.`,
-    );
-  }
-};
-
-const buildRequestedSurfaces = (request, env) => {
-  const explicit = normalizeSurfaces(request.surfaces ?? []);
-  if (explicit.length > 0) {
-    validateExplicitSurfaces(explicit);
-    return explicit;
-  }
-  const surfaces = [];
-  const skipDefaultRuns = env.OPENCLAW_TEST_SKIP_DEFAULT === "1";
-  if (!skipDefaultRuns) {
-    surfaces.push("unit");
-  }
-  if (env.OPENCLAW_TEST_INCLUDE_BUNDLED === "1") {
-    surfaces.push("bundled");
-  }
-  if (env.OPENCLAW_TEST_INCLUDE_EXTENSIONS === "1") {
-    surfaces.push("extensions");
-  }
-  if (env.OPENCLAW_TEST_INCLUDE_CHANNELS === "1") {
-    surfaces.push("channels");
-  }
-  if (env.OPENCLAW_TEST_INCLUDE_CONTRACTS === "1") {
-    surfaces.push("contracts");
-  }
-  if (env.OPENCLAW_TEST_INCLUDE_GATEWAY === "1") {
-    surfaces.push("gateway");
-  }
-  return surfaces;
-};
-
-const normalizeFailurePolicy = (requestFailurePolicy, optionArgs) => {
-  if (requestFailurePolicy !== null && requestFailurePolicy !== undefined) {
-    if (!FAILURE_POLICIES.has(requestFailurePolicy)) {
-      throw new Error(
-        `Unsupported failure policy "${String(requestFailurePolicy)}". Supported values: fail-fast, collect-all.`,
-      );
-    }
-    return { failurePolicy: requestFailurePolicy, passthroughOptionArgs: optionArgs };
-  }
-
-  const normalizedOptionArgs = [];
-  let failurePolicy = "fail-fast";
-
-  for (let index = 0; index < optionArgs.length; index += 1) {
-    const arg = optionArgs[index];
-    if (arg === "--bail") {
-      const nextValue = optionArgs[index + 1] ?? "";
-      if (nextValue === "0") {
-        failurePolicy = "collect-all";
-        index += 1;
-        continue;
-      }
-      throw new Error(
-        `Unsupported wrapper-level --bail value: ${String(nextValue || "<missing>")}. Use --bail=0, --collect-failures, or --failure-policy=collect-all.`,
-      );
-    }
-    if (arg.startsWith("--bail=")) {
-      const value = arg.slice("--bail=".length);
-      if (value === "0") {
-        failurePolicy = "collect-all";
-        continue;
-      }
-      throw new Error(
-        `Unsupported wrapper-level --bail value: ${String(value || "<missing>")}. Use --bail=0, --collect-failures, or --failure-policy=collect-all.`,
-      );
-    }
-    normalizedOptionArgs.push(arg);
-  }
-
-  return { failurePolicy, passthroughOptionArgs: normalizedOptionArgs };
-};
-
-const createPlannerContext = (request, options = {}) => {
-  const env = options.env ?? process.env;
-  const runtime = resolveRuntimeCapabilities(env, {
-    mode: request.mode ?? null,
-    profile: request.profile ?? null,
-    cpuCount: options.cpuCount,
-    totalMemoryBytes: options.totalMemoryBytes,
-    platform: options.platform,
-    loadAverage: options.loadAverage,
-    nodeVersion: options.nodeVersion,
-  });
-  const executionBudget = resolveExecutionBudget(runtime);
-  const catalog = options.catalog ?? loadTestCatalog();
-  const unitTimingManifest = loadUnitTimingManifest();
-  const channelTimingManifest = loadChannelTimingManifest();
-  const extensionTimingManifest = loadExtensionTimingManifest();
-  const extensionMemoryHotspotManifest = loadExtensionMemoryHotspotManifest();
-  const unitMemoryHotspotManifest = loadUnitMemoryHotspotManifest();
-  return {
-    env,
-    runtime,
-    executionBudget,
-    catalog,
-    unitTimingManifest,
-    channelTimingManifest,
-    extensionTimingManifest,
-    extensionMemoryHotspotManifest,
-    unitMemoryHotspotManifest,
-  };
-};
-
-const resolveCIManifestScope = (scope = {}, env = process.env) => ({
-  eventName: scope.eventName ?? env.GITHUB_EVENT_NAME ?? "pull_request",
-  docsOnly: parseBooleanLike(scope.docsOnly ?? env.OPENCLAW_CI_DOCS_ONLY, false),
-  docsChanged: parseBooleanLike(scope.docsChanged ?? env.OPENCLAW_CI_DOCS_CHANGED, false),
-  runNode: parseBooleanLike(scope.runNode ?? env.OPENCLAW_CI_RUN_NODE, true),
-  runMacos: parseBooleanLike(scope.runMacos ?? env.OPENCLAW_CI_RUN_MACOS, true),
-  runAndroid: parseBooleanLike(scope.runAndroid ?? env.OPENCLAW_CI_RUN_ANDROID, true),
-  runWindows: parseBooleanLike(scope.runWindows ?? env.OPENCLAW_CI_RUN_WINDOWS, true),
-  runSkillsPython: parseBooleanLike(
-    scope.runSkillsPython ?? env.OPENCLAW_CI_RUN_SKILLS_PYTHON,
-    true,
-  ),
-  hasChangedExtensions: parseBooleanLike(
-    scope.hasChangedExtensions ?? env.OPENCLAW_CI_HAS_CHANGED_EXTENSIONS,
-    false,
-  ),
-  changedExtensionsMatrix: parseChangedExtensionsMatrix(
-    scope.changedExtensionsMatrix ?? env.OPENCLAW_CI_CHANGED_EXTENSIONS_MATRIX,
-  ),
-  runChangedSmoke: parseBooleanLike(
-    scope.runChangedSmoke ?? env.OPENCLAW_CI_RUN_CHANGED_SMOKE,
-    true,
-  ),
-});
-
-const estimateEntryFilesDurationMs = (entry, files, context) => {
-  const estimateDurationMs = resolveEntryTimingEstimator(entry, context);
-  if (!estimateDurationMs) {
-    return files.length * 1_000;
-  }
-  return files.reduce((totalMs, file) => totalMs + estimateDurationMs(file), 0);
-};
-
-const resolveEntryTimingEstimator = (entry, context) => {
-  const configIndex = entry.args.findIndex((arg) => arg === "--config");
-  const config = configIndex >= 0 ? (entry.args[configIndex + 1] ?? "") : "";
-  if (config === "vitest.unit.config.ts") {
-    return (file) =>
-      context.unitTimingManifest.files[file]?.durationMs ??
-      context.unitTimingManifest.defaultDurationMs;
-  }
-  if (config === "vitest.boundary.config.ts") {
-    return (file) =>
-      context.unitTimingManifest.files[file]?.durationMs ??
-      context.unitTimingManifest.defaultDurationMs;
-  }
-  if (config === "vitest.bundled.config.ts") {
-    return (file) =>
-      context.unitTimingManifest.files[file]?.durationMs ??
-      context.unitTimingManifest.defaultDurationMs;
-  }
-  if (config === "vitest.channels.config.ts") {
-    return (file) =>
-      context.channelTimingManifest.files[file]?.durationMs ??
-      context.channelTimingManifest.defaultDurationMs;
-  }
-  if (config === "vitest.extensions.config.ts") {
-    return (file) =>
-      context.extensionTimingManifest.files[file]?.durationMs ??
-      context.extensionTimingManifest.defaultDurationMs;
-  }
-  return null;
-};
-
-const splitFilesByDurationBudget = (files, targetDurationMs, estimateDurationMs) => {
-  if (!Number.isFinite(targetDurationMs) || targetDurationMs <= 0 || files.length <= 1) {
-    return [files];
-  }
-
-  const batches = [];
-  let currentBatch = [];
-  let currentDurationMs = 0;
-
-  for (const file of files) {
-    const durationMs = estimateDurationMs(file);
-    if (currentBatch.length > 0 && currentDurationMs + durationMs > targetDurationMs) {
-      batches.push(currentBatch);
-      currentBatch = [];
-      currentDurationMs = 0;
-    }
-    currentBatch.push(file);
-    currentDurationMs += durationMs;
-  }
-
-  if (currentBatch.length > 0) {
-    batches.push(currentBatch);
-  }
-
-  return batches;
-};
-
-const splitFilesByBalancedDurationBudget = (files, targetDurationMs, estimateDurationMs) => {
-  if (!Number.isFinite(targetDurationMs) || targetDurationMs <= 0 || files.length <= 1) {
-    return [files];
-  }
-  const totalDurationMs = files.reduce((sum, file) => sum + estimateDurationMs(file), 0);
-  const batchCount = clamp(Math.ceil(totalDurationMs / targetDurationMs), 1, files.length);
-  const originalOrder = new Map(files.map((file, index) => [file, index]));
-  return packFilesByDuration(files, batchCount, estimateDurationMs).map((batch) =>
-    [...batch].toSorted(
-      (left, right) => (originalOrder.get(left) ?? 0) - (originalOrder.get(right) ?? 0),
-    ),
-  );
-};
-
-const resolveUnitFastBatchTargetMs = ({ context, selectedSurfaceSet, unitOnlyRun }) => {
-  const defaultTargetMs = context.executionBudget.unitFastBatchTargetMs;
-  if (
-    !unitOnlyRun &&
-    selectedSurfaceSet.size > 1 &&
-    !context.runtime.isCI &&
-    context.runtime.memoryBand === "high"
-  ) {
-    return Math.max(defaultTargetMs, 75_000);
-  }
-  return defaultTargetMs;
-};
-
-const resolveMaxWorkersForUnit = (unit, context) => {
-  const overrideWorkers = Number.parseInt(context.env.OPENCLAW_TEST_WORKERS ?? "", 10);
-  const resolvedOverride =
-    Number.isFinite(overrideWorkers) && overrideWorkers > 0 ? overrideWorkers : null;
-  if (resolvedOverride) {
-    return resolvedOverride;
-  }
-  const budget = context.executionBudget;
-  if (unit.isolate) {
-    return budget.unitIsolatedWorkers;
-  }
-  if (unit.id.startsWith("unit-heavy-")) {
-    return budget.unitHeavyWorkers;
-  }
-  if (unit.surface === "extensions") {
-    return budget.extensionWorkers;
-  }
-  if (unit.surface === "bundled") {
-    return budget.unitSharedWorkers;
-  }
-  if (unit.surface === "channels") {
-    return budget.channelSharedWorkers ?? budget.unitSharedWorkers;
-  }
-  if (unit.surface === "contracts") {
-    return budget.unitSharedWorkers;
-  }
-  if (unit.surface === "gateway") {
-    return budget.gatewayWorkers;
-  }
-  return budget.unitSharedWorkers;
-};
-
-const formatPerFileEntryName = (owner, file) => {
-  const baseName = path
-    .basename(file)
-    .replace(/\.live\.test\.ts$/u, "")
-    .replace(/\.e2e\.test\.ts$/u, "")
-    .replace(/\.test\.ts$/u, "");
-  return `${owner}-${baseName}`;
-};
-
-const createExecutionUnit = (context, config) => {
-  const unit = {
-    id: config.id,
-    surface: config.surface,
-    isolate: Boolean(config.isolate),
-    pool: config.pool ?? "forks",
-    args: config.args,
-    env: config.env,
-    includeFiles: config.includeFiles,
-    serialPhase: config.serialPhase,
-    fixedShardIndex: config.fixedShardIndex,
-    estimatedDurationMs: config.estimatedDurationMs,
-    timeoutMs: config.timeoutMs,
-    reasons: config.reasons ?? [],
-  };
-  unit.maxWorkers = resolveMaxWorkersForUnit(unit, context);
-  return unit;
-};
-
-const withIncludeFileEnv = (context, unitId, files) => ({
-  OPENCLAW_VITEST_INCLUDE_FILE: context.writeTempJsonArtifact(unitId, files),
-});
-
-const withBundledPluginsDisabled = (unitEnv) => ({
-  ...unitEnv,
-  OPENCLAW_DISABLE_BUNDLED_PLUGINS: "1",
-});
-
-const resolveUnitHeavyFileGroups = (context) => {
-  const { env, runtime, executionBudget, catalog, unitTimingManifest, unitMemoryHotspotManifest } =
-    context;
-  const heavyUnitFileLimit = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_HEAVY_UNIT_FILE_LIMIT",
-    runtime.intentProfile === "max"
-      ? Math.max(executionBudget.heavyUnitFileLimit, 90)
-      : executionBudget.heavyUnitFileLimit,
-  );
-  const heavyUnitLaneCount = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_HEAVY_UNIT_LANES",
-    runtime.intentProfile === "max"
-      ? Math.max(executionBudget.heavyUnitLaneCount, 6)
-      : executionBudget.heavyUnitLaneCount,
-  );
-  const heavyUnitMinDurationMs = parseEnvNumber(env, "OPENCLAW_TEST_HEAVY_UNIT_MIN_MS", 1200);
-  const memoryHeavyUnitFileLimit = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_MEMORY_HEAVY_UNIT_FILE_LIMIT",
-    executionBudget.memoryHeavyUnitFileLimit,
-  );
-  const memoryHeavyUnitMinDeltaKb = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_MEMORY_HEAVY_UNIT_MIN_KB",
-    unitMemoryHotspotManifest.defaultMinDeltaKb,
-  );
-  return {
-    heavyUnitLaneCount,
-    ...selectUnitHeavyFileGroups({
-      candidates: catalog.allKnownUnitFiles,
-      behaviorOverrides: catalog.unitBehaviorOverrideSet,
-      timedLimit: heavyUnitFileLimit,
-      timedMinDurationMs: heavyUnitMinDurationMs,
-      memoryLimit: memoryHeavyUnitFileLimit,
-      memoryMinDeltaKb: memoryHeavyUnitMinDeltaKb,
-      timings: unitTimingManifest,
-      hotspots: unitMemoryHotspotManifest,
-    }),
-  };
-};
-
-const resolveExtensionHeavyFileGroups = (context) => {
-  const { env, runtime, catalog, extensionTimingManifest, extensionMemoryHotspotManifest } =
-    context;
-  const extensionCandidates = catalog.allKnownTestFiles.filter(
-    (file) =>
-      file.startsWith(BUNDLED_PLUGIN_PATH_PREFIX) &&
-      !catalog.extensionForkIsolatedFileSet.has(file),
-  );
-  const memoryHeavyFiles = selectMemoryHeavyFiles({
-    candidates: extensionCandidates,
-    limit: parseEnvNumber(
-      env,
-      "OPENCLAW_TEST_MEMORY_HEAVY_EXTENSION_FILE_LIMIT",
-      runtime.isCI ? 12 : 6,
-    ),
-    minDeltaKb: parseEnvNumber(
-      env,
-      "OPENCLAW_TEST_MEMORY_HEAVY_EXTENSION_MIN_KB",
-      extensionMemoryHotspotManifest.defaultMinDeltaKb,
-    ),
-    exclude: catalog.extensionForkIsolatedFileSet,
-    hotspots: extensionMemoryHotspotManifest,
-  });
-  const timedHeavyFiles = selectTimedHeavyFiles({
-    candidates: extensionCandidates,
-    limit: parseEnvNumber(env, "OPENCLAW_TEST_HEAVY_EXTENSION_FILE_LIMIT", runtime.isCI ? 16 : 8),
-    minDurationMs: parseEnvNumber(
-      env,
-      "OPENCLAW_TEST_HEAVY_EXTENSION_MIN_MS",
-      runtime.isCI ? 9_000 : 12_000,
-    ),
-    exclude: new Set([...catalog.extensionForkIsolatedFiles, ...memoryHeavyFiles]),
-    timings: extensionTimingManifest,
-  });
-  return { memoryHeavyFiles, timedHeavyFiles };
-};
-
-const resolveChannelTimedHeavyFiles = (context) => {
-  const { env, runtime, catalog, channelTimingManifest } = context;
-  const timedHeavyChannelFileLimit = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_HEAVY_CHANNEL_FILE_LIMIT",
-    runtime.isCI ? 10 : 6,
-  );
-  const timedHeavyChannelMinDurationMs = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_HEAVY_CHANNEL_MIN_MS",
-    runtime.isCI ? 12_000 : 18_000,
-  );
-  return selectTimedHeavyFiles({
-    candidates: catalog.allKnownTestFiles.filter(
-      (file) =>
-        catalog.channelTestPrefixes.some((prefix) => file.startsWith(prefix)) &&
-        !catalog.channelIsolatedFileSet.has(file),
-    ),
-    limit: timedHeavyChannelFileLimit,
-    minDurationMs: timedHeavyChannelMinDurationMs,
-    timings: channelTimingManifest,
-  });
-};
-
-const buildDefaultUnits = (context, request) => {
-  const {
-    env,
-    executionBudget,
-    catalog,
-    unitTimingManifest,
-    channelTimingManifest,
-    extensionTimingManifest,
-  } = context;
-  const noIsolateArgs = context.noIsolateArgs;
-  const selectedSurfaces = buildRequestedSurfaces(request, env);
-  const selectedSurfaceSet = new Set(selectedSurfaces);
-  const unitOnlyRun = selectedSurfaceSet.size === 1 && selectedSurfaceSet.has("unit");
-  const bundledOnlyRun = selectedSurfaceSet.size === 1 && selectedSurfaceSet.has("bundled");
-  const channelsOnlyRun = selectedSurfaceSet.size === 1 && selectedSurfaceSet.has("channels");
-  const contractsOnlyRun = selectedSurfaceSet.size === 1 && selectedSurfaceSet.has("contracts");
-  const extensionsOnlyRun = selectedSurfaceSet.size === 1 && selectedSurfaceSet.has("extensions");
-
-  const {
-    heavyUnitLaneCount,
-    memoryHeavyFiles: memoryHeavyUnitFiles,
-    timedHeavyFiles: timedHeavyUnitFiles,
-  } = resolveUnitHeavyFileGroups(context);
-  const unitMemoryIsolatedFiles = [...memoryHeavyUnitFiles].filter(
-    (file) => !catalog.unitBehaviorOverrideSet.has(file),
-  );
-  const { memoryHeavyFiles: extensionMemoryHeavyFiles, timedHeavyFiles: extensionTimedHeavyFiles } =
-    resolveExtensionHeavyFileGroups(context);
-  const extensionMemoryIsolatedFiles = [...extensionMemoryHeavyFiles].filter(
-    (file) => !catalog.extensionForkIsolatedFileSet.has(file),
-  );
-  const channelTimedHeavyFiles = resolveChannelTimedHeavyFiles(context);
-  const unitSchedulingOverrideSet = new Set([
-    ...catalog.unitBehaviorOverrideSet,
-    ...memoryHeavyUnitFiles,
-  ]);
-  const extensionSchedulingOverrideSet = new Set([
-    ...catalog.extensionForkIsolatedFiles,
-    ...extensionMemoryHeavyFiles,
-    ...extensionTimedHeavyFiles,
-  ]);
-  const channelSchedulingOverrideSet = new Set([
-    ...catalog.channelIsolatedFiles,
-    ...channelTimedHeavyFiles,
-  ]);
-  const unitFastExcludedFiles = [
-    ...new Set([
-      ...unitSchedulingOverrideSet,
-      ...timedHeavyUnitFiles,
-      ...boundaryTestFiles,
-      ...catalog.channelIsolatedFiles,
-    ]),
-  ];
-  const estimateUnitDurationMs = (file) =>
-    unitTimingManifest.files[file]?.durationMs ?? unitTimingManifest.defaultDurationMs;
-  const estimateChannelDurationMs = (file) =>
-    channelTimingManifest.files[file]?.durationMs ?? channelTimingManifest.defaultDurationMs;
-  const estimateExtensionDurationMs = (file) =>
-    extensionTimingManifest.files[file]?.durationMs ?? extensionTimingManifest.defaultDurationMs;
-  const unitFastCandidateFiles = catalog.allKnownUnitFiles.filter(
-    (file) => !new Set(unitFastExcludedFiles).has(file),
-  );
-  const shouldPhaseUnitFastBatches =
-    !unitOnlyRun ||
-    catalog.unitForkIsolatedFiles.length > 0 ||
-    unitMemoryIsolatedFiles.length > 0 ||
-    timedHeavyUnitFiles.length > 0 ||
-    catalog.unitThreadPinnedFiles.length > 0;
-  const extensionSharedCandidateFiles = catalog.allKnownTestFiles.filter(
-    (file) =>
-      file.startsWith(BUNDLED_PLUGIN_PATH_PREFIX) && !extensionSchedulingOverrideSet.has(file),
-  );
-  const channelSharedCandidateFiles = catalog.allKnownTestFiles.filter(
-    (file) =>
-      catalog.channelTestPrefixes.some((prefix) => file.startsWith(prefix)) &&
-      !channelSchedulingOverrideSet.has(file),
-  );
-  const defaultExtensionsBatchTargetMs = executionBudget.extensionsBatchTargetMs;
-  const extensionsBatchTargetMs = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_EXTENSIONS_BATCH_TARGET_MS",
-    defaultExtensionsBatchTargetMs,
-  );
-  const defaultUnitFastLaneCount = executionBudget.unitFastLaneCount;
-  const unitFastLaneCount = Math.max(
-    1,
-    parseEnvNumber(env, "OPENCLAW_TEST_UNIT_FAST_LANES", defaultUnitFastLaneCount),
-  );
-  const defaultUnitFastBatchTargetMs = resolveUnitFastBatchTargetMs({
-    context,
-    selectedSurfaceSet,
-    unitOnlyRun,
-  });
-  const unitFastBatchTargetMs = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_UNIT_FAST_BATCH_TARGET_MS",
-    defaultUnitFastBatchTargetMs,
-  );
-  const defaultChannelsBatchTargetMs = executionBudget.channelsBatchTargetMs;
-  const channelsBatchTargetMs = parseEnvNumber(
-    env,
-    "OPENCLAW_TEST_CHANNELS_BATCH_TARGET_MS",
-    defaultChannelsBatchTargetMs,
-  );
-  const unitFastBuckets =
-    unitFastLaneCount > 1
-      ? packFilesByDuration(unitFastCandidateFiles, unitFastLaneCount, estimateUnitDurationMs)
-      : [unitFastCandidateFiles];
-  const units = [];
-
-  if (selectedSurfaceSet.has("unit")) {
-    if (boundaryTestFiles.length > 0) {
-      units.push(
-        createExecutionUnit(context, {
-          id: "unit-boundary",
-          surface: "unit",
-          isolate: false,
-          serialPhase: unitOnlyRun ? undefined : "unit-fast",
-          includeFiles: boundaryTestFiles,
-          estimatedDurationMs: estimateEntryFilesDurationMs(
-            { args: ["vitest", "run", "--config", "vitest.boundary.config.ts"] },
-            boundaryTestFiles,
-            context,
-          ),
-          env: withBundledPluginsDisabled(
-            withIncludeFileEnv(context, "vitest-boundary-include", boundaryTestFiles),
-          ),
-          args: [
-            "vitest",
-            "run",
-            "--config",
-            "vitest.boundary.config.ts",
-            "--pool=forks",
-            ...noIsolateArgs,
-          ],
-          reasons: ["unit-boundary-shared"],
-        }),
-      );
-    }
-
-    for (const [laneIndex, files] of unitFastBuckets.entries()) {
-      const laneName =
-        unitFastBuckets.length === 1 ? "unit-fast" : `unit-fast-${String(laneIndex + 1)}`;
-      const recycledBatches = splitFilesByDurationBudget(
-        files,
-        unitFastBatchTargetMs,
-        estimateUnitDurationMs,
-      );
-      for (const [batchIndex, batch] of recycledBatches.entries()) {
-        if (batch.length === 0) {
-          continue;
-        }
-        const unitId =
-          recycledBatches.length === 1 ? laneName : `${laneName}-batch-${String(batchIndex + 1)}`;
-        units.push(
-          createExecutionUnit(context, {
-            id: unitId,
-            surface: "unit",
-            isolate: false,
-            serialPhase: shouldPhaseUnitFastBatches ? "unit-fast" : undefined,
-            includeFiles: batch,
-            estimatedDurationMs: estimateEntryFilesDurationMs(
-              { args: ["vitest", "run", "--config", "vitest.unit.config.ts"] },
-              batch,
-              context,
-            ),
-            env: withBundledPluginsDisabled(
-              withIncludeFileEnv(
-                context,
-                `vitest-unit-fast-include-${String(laneIndex + 1)}-${String(batchIndex + 1)}`,
-                batch,
-              ),
-            ),
-            args: [
-              "vitest",
-              "run",
-              "--config",
-              "vitest.unit.config.ts",
-              "--pool=forks",
-              ...noIsolateArgs,
-            ],
-            reasons: ["unit-fast-shared"],
-          }),
-        );
-      }
-    }
-
-    for (const file of catalog.unitForkIsolatedFiles) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `unit-${path.basename(file, ".test.ts")}-isolated`,
-          surface: "unit",
-          isolate: true,
-          estimatedDurationMs: estimateUnitDurationMs(file),
-          env: withBundledPluginsDisabled(),
-          args: [
-            "vitest",
-            "run",
-            "--config",
-            "vitest.unit.config.ts",
-            "--pool=forks",
-            ...noIsolateArgs,
-            file,
-          ],
-          reasons: ["unit-isolated-manifest"],
-        }),
-      );
-    }
-
-    const heavyUnitBuckets = packFilesByDuration(
-      timedHeavyUnitFiles,
-      heavyUnitLaneCount,
-      estimateUnitDurationMs,
-    );
-    for (const [index, files] of heavyUnitBuckets.entries()) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `unit-heavy-${String(index + 1)}`,
-          surface: "unit",
-          isolate: false,
-          estimatedDurationMs: files.reduce((sum, file) => sum + estimateUnitDurationMs(file), 0),
-          env: withBundledPluginsDisabled(),
-          args: [
-            "vitest",
-            "run",
-            "--config",
-            "vitest.unit.config.ts",
-            "--pool=forks",
-            ...noIsolateArgs,
-            ...files,
-          ],
-          reasons: ["unit-timed-heavy"],
-        }),
-      );
-    }
-
-    for (const file of unitMemoryIsolatedFiles) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `unit-${path.basename(file, ".test.ts")}-memory-isolated`,
-          surface: "unit",
-          isolate: true,
-          estimatedDurationMs: estimateUnitDurationMs(file),
-          env: withBundledPluginsDisabled(),
-          args: [
-            "vitest",
-            "run",
-            "--config",
-            "vitest.unit.config.ts",
-            "--pool=forks",
-            ...noIsolateArgs,
-            file,
-          ],
-          reasons: ["unit-memory-isolated"],
-        }),
-      );
-    }
-
-    if (catalog.unitThreadPinnedFiles.length > 0) {
-      units.push(
-        createExecutionUnit(context, {
-          id: "unit-pinned",
-          surface: "unit",
-          isolate: false,
-          env: withBundledPluginsDisabled(),
-          args: [
-            "vitest",
-            "run",
-            "--config",
-            "vitest.unit.config.ts",
-            "--pool=forks",
-            ...noIsolateArgs,
-            ...catalog.unitThreadPinnedFiles,
-          ],
-          reasons: ["unit-pinned-manifest"],
-        }),
-      );
-    }
-  }
-
-  if (selectedSurfaceSet.has("bundled")) {
-    units.push(
-      createExecutionUnit(context, {
-        id: "bundled",
-        surface: "bundled",
-        isolate: false,
-        serialPhase: bundledOnlyRun ? undefined : "bundled",
-        estimatedDurationMs: bundledPluginDependentUnitTestFiles.reduce(
-          (sum, file) => sum + estimateUnitDurationMs(file),
-          0,
-        ),
-        args: ["vitest", "run", "--config", "vitest.bundled.config.ts", ...noIsolateArgs],
-        reasons: ["bundled-surface"],
-      }),
-    );
-  }
-
-  if (selectedSurfaceSet.has("channels")) {
-    for (const file of catalog.channelIsolatedFiles) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `${path.basename(file, ".test.ts")}-channels-isolated`,
-          surface: "channels",
-          isolate: true,
-          estimatedDurationMs: estimateChannelDurationMs(file),
-          args: [
-            "vitest",
-            "run",
-            "--config",
-            "vitest.channels.config.ts",
-            "--pool=forks",
-            ...noIsolateArgs,
-            file,
-          ],
-          reasons: ["channels-isolated-rule"],
-        }),
-      );
-    }
-    for (const file of channelTimedHeavyFiles) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `channels-${path.basename(file, ".test.ts")}-isolated`,
-          surface: "channels",
-          isolate: true,
-          estimatedDurationMs: estimateChannelDurationMs(file),
-          args: [
-            "vitest",
-            "run",
-            "--config",
-            "vitest.channels.config.ts",
-            "--pool=forks",
-            ...noIsolateArgs,
-            file,
-          ],
-          reasons: ["channels-timed-heavy"],
-        }),
-      );
-    }
-  }
-
-  if (selectedSurfaceSet.has("contracts")) {
-    units.push(
-      createExecutionUnit(context, {
-        id: "contracts",
-        surface: "contracts",
-        isolate: false,
-        serialPhase: contractsOnlyRun ? undefined : "contracts",
-        args: ["vitest", "run", "--config", "vitest.contracts.config.ts", ...noIsolateArgs],
-        reasons: ["contracts-shared"],
-      }),
-    );
-  }
-
-  if (selectedSurfaceSet.has("extensions")) {
-    for (const file of catalog.extensionForkIsolatedFiles) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `extensions-${path.basename(file, ".test.ts")}-isolated`,
-          surface: "extensions",
-          isolate: true,
-          estimatedDurationMs: estimateExtensionDurationMs(file),
-          args: ["vitest", "run", "--config", "vitest.extensions.config.ts", "--pool=forks", file],
-          reasons: ["extensions-isolated-manifest"],
-        }),
-      );
-    }
-    for (const file of extensionMemoryIsolatedFiles) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `extensions-${path.basename(file, ".test.ts")}-memory-isolated`,
-          surface: "extensions",
-          isolate: true,
-          estimatedDurationMs: estimateExtensionDurationMs(file),
-          args: ["vitest", "run", "--config", "vitest.extensions.config.ts", "--pool=forks", file],
-          reasons: ["extensions-memory-heavy"],
-        }),
-      );
-    }
-    for (const file of extensionTimedHeavyFiles) {
-      units.push(
-        createExecutionUnit(context, {
-          id: `extensions-${path.basename(file, ".test.ts")}-isolated`,
-          surface: "extensions",
-          isolate: true,
-          estimatedDurationMs: estimateExtensionDurationMs(file),
-          args: ["vitest", "run", "--config", "vitest.extensions.config.ts", "--pool=forks", file],
-          reasons: ["extensions-timed-heavy"],
-        }),
-      );
-    }
-    const extensionBatches = splitFilesByBalancedDurationBudget(
-      extensionSharedCandidateFiles,
-      extensionsBatchTargetMs,
-      estimateExtensionDurationMs,
-    );
-    for (const [batchIndex, batch] of extensionBatches.entries()) {
-      if (batch.length === 0) {
-        continue;
-      }
-      const unitId =
-        extensionBatches.length === 1 ? "extensions" : `extensions-batch-${String(batchIndex + 1)}`;
-      units.push(
-        createExecutionUnit(context, {
-          id: unitId,
-          surface: "extensions",
-          isolate: false,
-          serialPhase: extensionsOnlyRun ? undefined : "extensions",
-          includeFiles: batch,
-          estimatedDurationMs: estimateEntryFilesDurationMs(
-            { args: ["vitest", "run", "--config", "vitest.extensions.config.ts"] },
-            batch,
-            context,
-          ),
-          env: withIncludeFileEnv(
-            context,
-            `vitest-extensions-include-${String(batchIndex + 1)}`,
-            batch,
-          ),
-          args: ["vitest", "run", "--config", "vitest.extensions.config.ts", ...noIsolateArgs],
-          reasons: ["extensions-shared"],
-        }),
-      );
-    }
-  }
-
-  if (selectedSurfaceSet.has("channels")) {
-    const channelBatches = splitFilesByDurationBudget(
-      channelSharedCandidateFiles,
-      channelsBatchTargetMs,
-      estimateChannelDurationMs,
-    );
-    for (const [batchIndex, batch] of channelBatches.entries()) {
-      if (batch.length === 0) {
-        continue;
-      }
-      const unitId =
-        channelBatches.length === 1 ? "channels" : `channels-batch-${String(batchIndex + 1)}`;
-      units.push(
-        createExecutionUnit(context, {
-          id: unitId,
-          surface: "channels",
-          isolate: false,
-          serialPhase: channelsOnlyRun ? undefined : "channels",
-          includeFiles: batch,
-          estimatedDurationMs: estimateEntryFilesDurationMs(
-            { args: ["vitest", "run", "--config", "vitest.channels.config.ts"] },
-            batch,
-            context,
-          ),
-          env: withIncludeFileEnv(
-            context,
-            `vitest-channels-include-${String(batchIndex + 1)}`,
-            batch,
-          ),
-          args: ["vitest", "run", "--config", "vitest.channels.config.ts", ...noIsolateArgs],
-          reasons: ["channels-shared"],
-        }),
-      );
-    }
-  }
-
-  if (selectedSurfaceSet.has("gateway")) {
-    units.push(
-      createExecutionUnit(context, {
-        id: "gateway",
-        surface: "gateway",
-        isolate: false,
-        args: [
-          "vitest",
-          "run",
-          "--config",
-          "vitest.gateway.config.ts",
-          "--pool=forks",
-          ...noIsolateArgs,
-        ],
-        reasons: ["gateway-surface"],
-      }),
-    );
-  }
-
-  return {
-    units,
-    unitMemoryIsolatedFiles,
-    extensionMemoryIsolatedFiles,
-    extensionTimedHeavyFiles,
-    channelTimedHeavyFiles,
-  };
-};
-
-const createTargetedUnit = (context, classification, filters) => {
-  const owner = classification.legacyBasePinned ? "base-pinned" : classification.surface;
-  const unitId =
-    filters.length === 1 && (classification.isolated || owner === "base-pinned")
-      ? `${formatPerFileEntryName(owner, filters[0])}${classification.isolated ? "-isolated" : ""}`
-      : classification.isolated
-        ? `${owner}-isolated`
-        : owner;
-  const args = (() => {
-    if (owner === "unit") {
-      const config = filters.every((file) => isBoundaryTestFile(file))
-        ? "vitest.boundary.config.ts"
-        : "vitest.unit.config.ts";
-      return [
-        "vitest",
-        "run",
-        "--config",
-        config,
-        "--pool=forks",
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "bundled") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.bundled.config.ts",
-        ...(classification.isolated ? ["--pool=forks"] : []),
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "base-pinned") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.config.ts",
-        "--pool=forks",
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "extensions") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.extensions.config.ts",
-        ...(classification.isolated ? ["--pool=forks"] : []),
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "gateway") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.gateway.config.ts",
-        "--pool=forks",
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "channels") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.channels.config.ts",
-        ...(classification.isolated ? ["--pool=forks"] : []),
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "contracts") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.contracts.config.ts",
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "live") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.live.config.ts",
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    if (owner === "e2e") {
-      return [
-        "vitest",
-        "run",
-        "--config",
-        "vitest.e2e.config.ts",
-        ...context.noIsolateArgs,
-        ...filters,
-      ];
-    }
-    return [
-      "vitest",
-      "run",
-      "--config",
-      "vitest.config.ts",
-      ...context.noIsolateArgs,
-      ...(classification.isolated ? ["--pool=forks"] : []),
-      ...filters,
-    ];
-  })();
-  return createExecutionUnit(context, {
-    id: unitId,
-    surface: classification.legacyBasePinned ? "base" : classification.surface,
-    isolate: classification.isolated || owner === "base-pinned",
-    args,
-    env: owner === "unit" ? withBundledPluginsDisabled() : undefined,
-    reasons: classification.reasons,
-  });
-};
-
-const buildTargetedUnits = (context, request) => {
-  if (request.fileFilters.length === 0) {
-    return [];
-  }
-  const unitMemoryIsolatedFiles = request.unitMemoryIsolatedFiles ?? [];
-  const extensionMemoryIsolatedFiles = request.extensionMemoryIsolatedFiles ?? [];
-  const extensionTimedIsolatedFiles = request.extensionTimedIsolatedFiles ?? [];
-  const channelTimedIsolatedFiles = request.channelTimedIsolatedFiles ?? [];
-  const estimateUnitDurationMs = (file) =>
-    context.unitTimingManifest.files[file]?.durationMs ??
-    context.unitTimingManifest.defaultDurationMs;
-  const estimateChannelDurationMs = (file) =>
-    context.channelTimingManifest.files[file]?.durationMs ??
-    context.channelTimingManifest.defaultDurationMs;
-  const defaultTargetedUnitBatchTargetMs = 12_000;
-  const targetedUnitBatchTargetMs = parseEnvNumber(
-    context.env,
-    "OPENCLAW_TEST_TARGETED_UNIT_BATCH_TARGET_MS",
-    defaultTargetedUnitBatchTargetMs,
-  );
-  const defaultTargetedChannelsBatchTargetMs = 11_000;
-  const targetedChannelsBatchTargetMs = parseEnvNumber(
-    context.env,
-    "OPENCLAW_TEST_TARGETED_CHANNELS_BATCH_TARGET_MS",
-    defaultTargetedChannelsBatchTargetMs,
-  );
-  const groups = request.fileFilters.reduce((acc, fileFilter) => {
-    const matchedFiles = context.catalog.resolveFilterMatches(fileFilter);
-    if (matchedFiles.length === 0) {
-      const classification = context.catalog.classifyTestFile(normalizeRepoPath(fileFilter), {
-        unitMemoryIsolatedFiles,
-        extensionMemoryIsolatedFiles,
-        extensionTimedIsolatedFiles,
-        channelTimedIsolatedFiles,
-      });
-      const key = `${classification.legacyBasePinned ? "base-pinned" : classification.surface}:${
-        classification.isolated ? "isolated" : "default"
-      }`;
-      const files = acc.get(key) ?? { classification, files: [] };
-      files.files.push(normalizeRepoPath(fileFilter));
-      acc.set(key, files);
-      return acc;
-    }
-    for (const matchedFile of matchedFiles) {
-      const classification = context.catalog.classifyTestFile(matchedFile, {
-        unitMemoryIsolatedFiles,
-        extensionMemoryIsolatedFiles,
-        extensionTimedIsolatedFiles,
-        channelTimedIsolatedFiles,
-      });
-      const key = `${classification.legacyBasePinned ? "base-pinned" : classification.surface}:${
-        classification.isolated ? "isolated" : "default"
-      }`;
-      const files = acc.get(key) ?? { classification, files: [] };
-      files.files.push(matchedFile);
-      acc.set(key, files);
-    }
-    return acc;
-  }, new Map());
-  return Array.from(groups.values()).flatMap(({ classification, files }) => {
-    const uniqueFilters = [...new Set(files)];
-    if (classification.isolated || classification.legacyBasePinned) {
-      return uniqueFilters.map((file) =>
-        createTargetedUnit(
-          context,
-          context.catalog.classifyTestFile(file, {
-            unitMemoryIsolatedFiles,
-            extensionMemoryIsolatedFiles,
-            extensionTimedIsolatedFiles,
-            channelTimedIsolatedFiles,
-          }),
-          [file],
-        ),
-      );
-    }
-    if (
-      classification.surface === "unit" &&
-      uniqueFilters.length > 4 &&
-      targetedUnitBatchTargetMs > 0
-    ) {
-      const estimatedTotalDurationMs = uniqueFilters.reduce(
-        (totalMs, file) => totalMs + estimateUnitDurationMs(file),
-        0,
-      );
-      if (estimatedTotalDurationMs > targetedUnitBatchTargetMs) {
-        return splitFilesByBalancedDurationBudget(
-          uniqueFilters,
-          targetedUnitBatchTargetMs,
-          estimateUnitDurationMs,
-        ).map((batch, batchIndex) =>
-          createExecutionUnit(context, {
-            ...createTargetedUnit(context, classification, batch),
-            id: `unit-batch-${String(batchIndex + 1)}`,
-          }),
-        );
-      }
-    }
-    if (
-      classification.surface === "channels" &&
-      uniqueFilters.length > 4 &&
-      targetedChannelsBatchTargetMs > 0
-    ) {
-      const estimatedTotalDurationMs = uniqueFilters.reduce(
-        (totalMs, file) => totalMs + estimateChannelDurationMs(file),
-        0,
-      );
-      if (estimatedTotalDurationMs > targetedChannelsBatchTargetMs) {
-        return splitFilesByBalancedDurationBudget(
-          uniqueFilters,
-          targetedChannelsBatchTargetMs,
-          estimateChannelDurationMs,
-        ).map((batch, batchIndex) =>
-          createExecutionUnit(context, {
-            ...createTargetedUnit(context, classification, batch),
-            id: `channels-batch-${String(batchIndex + 1)}`,
-          }),
-        );
-      }
-    }
-    return [createTargetedUnit(context, classification, uniqueFilters)];
-  });
-};
-
-const rebuildEntryArgsWithFilters = (entryArgs, filters) => {
-  const baseArgs = entryArgs.slice(0, 2);
-  const { optionArgs } = parsePassthroughArgs(entryArgs.slice(2));
-  return [...baseArgs, ...optionArgs, ...filters];
-};
-
-const createPinnedShardUnit = (context, unit, files, fixedShardIndex) => {
-  const nextUnit = createExecutionUnit(context, {
-    ...unit,
-    id: `${unit.id}-shard-${String(fixedShardIndex)}`,
-    fixedShardIndex,
-    estimatedDurationMs: estimateEntryFilesDurationMs(unit, files, context),
-    includeFiles:
-      Array.isArray(unit.includeFiles) && unit.includeFiles.length > 0 ? files : undefined,
-    env:
-      Array.isArray(unit.includeFiles) && unit.includeFiles.length > 0
-        ? {
-            ...unit.env,
-            OPENCLAW_VITEST_INCLUDE_FILE: context.writeTempJsonArtifact(
-              `${unit.id}-shard-${String(fixedShardIndex)}-include`,
-              files,
-            ),
-          }
-        : unit.env,
-    args:
-      Array.isArray(unit.includeFiles) && unit.includeFiles.length > 0
-        ? rebuildEntryArgsWithFilters(unit.args, [])
-        : rebuildEntryArgsWithFilters(unit.args, files),
-  });
-  nextUnit.fixedShardIndex = fixedShardIndex;
-  return nextUnit;
-};
-
-const expandUnitsAcrossTopLevelShards = (context, units) => {
-  if (context.configuredShardCount === null || context.shardCount <= 1) {
-    return units;
-  }
-  return units.flatMap((unit) => {
-    const estimateDurationMs = resolveEntryTimingEstimator(unit, context);
-    if (!estimateDurationMs || unit.fixedShardIndex !== undefined) {
-      return [unit];
-    }
-    const candidateFiles =
-      Array.isArray(unit.includeFiles) && unit.includeFiles.length > 0
-        ? unit.includeFiles
-        : getExplicitEntryFilters(unit.args);
-    if (candidateFiles.length <= 1) {
-      return [unit];
-    }
-    const effectiveShardCount = Math.min(
-      context.shardCount,
-      Math.max(1, candidateFiles.length - 1),
-    );
-    if (effectiveShardCount <= 1) {
-      return [unit];
-    }
-    const buckets = packFilesByDurationWithBaseLoads(
-      candidateFiles,
-      effectiveShardCount,
-      estimateDurationMs,
-    );
-    return buckets.flatMap((files, bucketIndex) =>
-      files.length > 0 ? [createPinnedShardUnit(context, unit, files, bucketIndex + 1)] : [],
-    );
-  });
-};
-
-const estimateTopLevelEntryDurationMs = (unit, context) => {
-  if (Number.isFinite(unit.estimatedDurationMs) && unit.estimatedDurationMs > 0) {
-    return unit.estimatedDurationMs;
-  }
-  const filters = getExplicitEntryFilters(unit.args);
-  if (filters.length === 0) {
-    return context.unitTimingManifest.defaultDurationMs;
-  }
-  return filters.reduce((totalMs, file) => {
-    if (isUnitConfigTestFile(file)) {
-      return (
-        totalMs +
-        (context.unitTimingManifest.files[file]?.durationMs ??
-          context.unitTimingManifest.defaultDurationMs)
-      );
-    }
-    if (isBundledPluginDependentUnitTestFile(file)) {
-      return (
-        totalMs +
-        (context.unitTimingManifest.files[file]?.durationMs ??
-          context.unitTimingManifest.defaultDurationMs)
-      );
-    }
-    if (context.catalog.channelTestPrefixes.some((prefix) => file.startsWith(prefix))) {
-      return (
-        totalMs +
-        (context.channelTimingManifest.files[file]?.durationMs ??
-          context.channelTimingManifest.defaultDurationMs)
-      );
-    }
-    if (file.startsWith(BUNDLED_PLUGIN_PATH_PREFIX)) {
-      return (
-        totalMs +
-        (context.extensionTimingManifest.files[file]?.durationMs ??
-          context.extensionTimingManifest.defaultDurationMs)
-      );
-    }
-    return totalMs + 1_000;
-  }, 0);
-};
-
-const buildTopLevelSingleShardAssignments = (context, units) => {
-  if (context.shardIndexOverride === null || context.shardCount <= 1) {
-    return new WeakMap();
-  }
-
-  const entriesNeedingAssignment = units.filter((unit) => {
-    if (unit.fixedShardIndex !== undefined) {
-      return false;
-    }
-    const explicitFilterCount = countUnitEntryFilters(unit);
-    if (explicitFilterCount === null) {
-      return false;
-    }
-    const effectiveShardCount = Math.min(context.shardCount, Math.max(1, explicitFilterCount - 1));
-    return effectiveShardCount <= 1;
-  });
-
-  const assignmentMap = new WeakMap();
-  const pinnedShardLoadsMs = Array.from({ length: context.shardCount }, () => 0);
-  for (const unit of units) {
-    if (unit.fixedShardIndex === undefined) {
-      continue;
-    }
-    const shardArrayIndex = unit.fixedShardIndex - 1;
-    if (shardArrayIndex < 0 || shardArrayIndex >= pinnedShardLoadsMs.length) {
-      continue;
-    }
-    pinnedShardLoadsMs[shardArrayIndex] += estimateTopLevelEntryDurationMs(unit, context);
-  }
-  const buckets = packFilesByDurationWithBaseLoads(
-    entriesNeedingAssignment,
-    context.shardCount,
-    (unit) => estimateTopLevelEntryDurationMs(unit, context),
-    pinnedShardLoadsMs,
-  );
-  for (const [bucketIndex, bucket] of buckets.entries()) {
-    for (const unit of bucket) {
-      assignmentMap.set(unit, bucketIndex + 1);
-    }
-  }
-  return assignmentMap;
-};
-
-export function buildCIExecutionManifest(scopeInput = {}, options = {}) {
-  const env = options.env ?? process.env;
-  const scope = resolveCIManifestScope(scopeInput, env);
-  const context = createPlannerContext({ mode: "ci", profile: null }, { ...options, env });
-  const isPullRequest = scope.eventName === "pull_request";
-  const isPush = scope.eventName === "push";
-  const nodeEligible = !scope.docsOnly && scope.runNode;
-  const macosEligible = !scope.docsOnly && isPullRequest && scope.runMacos;
-  const windowsEligible = !scope.docsOnly && scope.runWindows;
-  const androidEligible = !scope.docsOnly && scope.runAndroid;
-  const docsEligible = scope.docsChanged;
-  const skillsPythonEligible = !scope.docsOnly && (isPush || scope.runSkillsPython);
-  const extensionFastEligible = nodeEligible && scope.hasChangedExtensions;
-
-  const channelCandidateFiles = context.catalog.allKnownTestFiles.filter((file) =>
-    context.catalog.channelTestPrefixes.some((prefix) => file.startsWith(prefix)),
-  );
-  const extensionCandidateFiles = context.catalog.allKnownTestFiles.filter((file) =>
-    file.startsWith(BUNDLED_PLUGIN_PATH_PREFIX),
-  );
-  const unitShardCount = resolveDynamicShardCount({
-    estimatedDurationMs: sumKnownManifestDurationsMs(context.unitTimingManifest),
-    fileCount: context.catalog.allKnownUnitFiles.length,
-    targetDurationMs: 30_000,
-    targetFilesPerShard: 80,
-    minShards: 1,
-    maxShards: 4,
-  });
-  const channelShardCount = resolveDynamicShardCount({
-    estimatedDurationMs: sumKnownManifestDurationsMs(context.channelTimingManifest),
-    fileCount: channelCandidateFiles.length,
-    targetDurationMs: 90_000,
-    targetFilesPerShard: 150,
-    minShards: 1,
-    maxShards: 4,
-  });
-  const windowsShardCount = resolveDynamicShardCount({
-    estimatedDurationMs: sumKnownManifestDurationsMs(context.unitTimingManifest),
-    fileCount: context.catalog.allKnownUnitFiles.length,
-    targetDurationMs: 12_000,
-    targetFilesPerShard: 30,
-    minShards: 1,
-    maxShards: 6,
-  });
-  const macosNodeShardCount = resolveDynamicShardCount({
-    estimatedDurationMs: sumKnownManifestDurationsMs(context.unitTimingManifest),
-    fileCount: context.catalog.allKnownUnitFiles.length,
-    targetDurationMs: 12_000,
-    targetFilesPerShard: 30,
-    minShards: 1,
-    maxShards: 9,
-  });
-  const extensionFastShardCount = resolveDynamicShardCount({
-    estimatedDurationMs: sumKnownManifestDurationsMs(context.extensionTimingManifest),
-    fileCount: extensionCandidateFiles.length,
-    targetDurationMs: 120_000,
-    targetFilesPerShard: 140,
-    minShards: 4,
-    maxShards: 6,
-  });
-
-  const checksFastInclude = nodeEligible
-    ? [
-        {
-          check_name: "checks-fast-bundled",
-          runtime: "node",
-          task: "bundled",
-          command: "pnpm test:bundled",
-        },
-        ...createShardMatrixEntries({
-          checkNamePrefix: "checks-fast-extensions",
-          runtime: "node",
-          task: "extensions",
-          command: "pnpm test:extensions",
-          shardCount: extensionFastShardCount,
-        }),
-        {
-          check_name: "checks-fast-contracts-protocol",
-          runtime: "node",
-          task: "contracts-protocol",
-          command: "pnpm test:contracts\npnpm protocol:check",
-        },
-      ]
-    : [];
-  const checksInclude = nodeEligible
-    ? [
-        ...createShardMatrixEntries({
-          checkNamePrefix: "checks-node-test",
-          runtime: "node",
-          task: "test",
-          command: "pnpm test:planner",
-          shardCount: unitShardCount,
-        }),
-        ...createShardMatrixEntries({
-          checkNamePrefix: "checks-node-channels",
-          runtime: "node",
-          task: "channels",
-          command: "pnpm test:channels",
-          shardCount: channelShardCount,
-        }),
-        ...(isPush
-          ? [
-              {
-                check_name: "checks-node-compat-node22",
-                runtime: "node",
-                task: "compat-node22",
-                node_version: "22.x",
-                cache_key_suffix: "node22",
-                command: [
-                  "pnpm build",
-                  "pnpm ui:build",
-                  "node openclaw.mjs --help",
-                  "node openclaw.mjs status --json --timeout 1",
-                  "pnpm test:build:singleton",
-                ].join("\n"),
-              },
-            ]
-          : []),
-      ]
-    : [];
-  const checksWindowsInclude = windowsEligible
-    ? createShardMatrixEntries({
-        checkNamePrefix: "checks-windows-node-test",
-        runtime: "node",
-        task: "test",
-        command: "pnpm test:planner",
-        shardCount: windowsShardCount,
-      })
-    : [];
-  const macosNodeInclude = macosEligible
-    ? createShardMatrixEntries({
-        checkNamePrefix: "macos-node",
-        runtime: "node",
-        task: "test",
-        command: "pnpm test:planner",
-        shardCount: macosNodeShardCount,
-      })
-    : [];
-  const androidInclude = androidEligible
-    ? [
-        {
-          check_name: "android-test-play",
-          task: "test-play",
-          command: "./gradlew --no-daemon :app:testPlayDebugUnitTest",
-        },
-        {
-          check_name: "android-test-third-party",
-          task: "test-third-party",
-          command: "./gradlew --no-daemon :app:testThirdPartyDebugUnitTest",
-        },
-        {
-          check_name: "android-build-play",
-          task: "build-play",
-          command: "./gradlew --no-daemon :app:assemblePlayDebug",
-        },
-        {
-          check_name: "android-build-third-party",
-          task: "build-third-party",
-          command: "./gradlew --no-daemon :app:assembleThirdPartyDebug",
-        },
-      ]
-    : [];
-  const extensionFastInclude = extensionFastEligible
-    ? scope.changedExtensionsMatrix.include.map((entry) => ({
-        check_name: `extension-fast-${entry.extension}`,
-        extension: entry.extension,
-      }))
-    : [];
-
-  const jobs = {
-    buildArtifacts: { enabled: nodeEligible, needsDistArtifacts: false },
-    checksFast: { enabled: checksFastInclude.length > 0, matrix: { include: checksFastInclude } },
-    checks: { enabled: checksInclude.length > 0, matrix: { include: checksInclude } },
-    extensionFast: {
-      enabled: extensionFastInclude.length > 0,
-      matrix: { include: extensionFastInclude },
-    },
-    check: { enabled: !scope.docsOnly },
-    checkAdditional: { enabled: !scope.docsOnly },
-    buildSmoke: { enabled: nodeEligible },
-    checkDocs: { enabled: docsEligible },
-    skillsPython: { enabled: skillsPythonEligible },
-    checksWindows: {
-      enabled: checksWindowsInclude.length > 0,
-      matrix: { include: checksWindowsInclude },
-    },
-    macosNode: { enabled: macosNodeInclude.length > 0, matrix: { include: macosNodeInclude } },
-    macosSwift: { enabled: macosEligible },
-    android: { enabled: androidInclude.length > 0, matrix: { include: androidInclude } },
-    installSmoke: { enabled: !scope.docsOnly && scope.runChangedSmoke },
-  };
-
-  return {
-    runtimeProfile: context.runtime.runtimeProfileName,
-    scope,
-    shardCounts: {
-      unit: unitShardCount,
-      channels: channelShardCount,
-      extensionFast: extensionFastShardCount,
-      windows: windowsShardCount,
-      macosNode: macosNodeShardCount,
-    },
-    jobs,
-    requiredCheckNames: [
-      ...checksFastInclude.map((entry) => entry.check_name),
-      ...checksInclude.map((entry) => entry.check_name),
-      ...checksWindowsInclude.map((entry) => entry.check_name),
-      ...macosNodeInclude.map((entry) => entry.check_name),
-      ...(macosEligible ? ["macos-swift"] : []),
-      ...androidInclude.map((entry) => entry.check_name),
-      ...extensionFastInclude.map((entry) => entry.check_name),
-      "check",
-      "check-additional",
-      "build-smoke",
-      ...(docsEligible ? ["check-docs"] : []),
-      ...(skillsPythonEligible ? ["skills-python"] : []),
-      ...(nodeEligible ? ["build-artifacts"] : []),
-    ],
-  };
-}
-
-export const formatExecutionUnitSummary = (unit) =>
-  `${unit.id} filters=${String(countUnitEntryFilters(unit) || "all")} maxWorkers=${String(
-    unit.maxWorkers ?? "default",
-  )} surface=${unit.surface} isolate=${unit.isolate ? "yes" : "no"} pool=${unit.pool}`;
-
-function resolveSurfaceAwareTopLevelParallelLimit(context, units, defaultLimit) {
-  const sharedUnitBatches = units.filter(
-    (unit) => unit.surface === "unit" && !unit.isolate && unit.id.startsWith("unit-fast"),
-  );
-  const onlyUnitSurface = units.length > 0 && units.every((unit) => unit.surface === "unit");
-
-  if (!context.runtime.isCI && context.noIsolateArgs.length > 0) {
-    if (onlyUnitSurface && sharedUnitBatches.length >= 4) {
-      return Math.min(defaultLimit, 3);
-    }
-  }
-
-  if (
-    !context.runtime.isCI &&
-    context.runtime.loadBand === "saturated" &&
-    context.noIsolateArgs.length > 0
-  ) {
-    if (sharedUnitBatches.length >= 4) {
-      // Saturated local hosts regress when every unit-fast batch fans out at once.
-      // Keep the shared unit phase to a smaller burst and let later isolated lanes
-      // make forward progress instead of waiting behind a thundering herd.
-      return Math.min(defaultLimit, 3);
-    }
-  }
-
-  if (!context.runtime.isCI || context.noIsolateArgs.length === 0) {
-    return defaultLimit;
-  }
-
-  const sharedExtensionUnits = units.filter(
-    (unit) => unit.surface === "extensions" && !unit.isolate,
-  );
-  if (sharedExtensionUnits.length <= 1) {
-    return defaultLimit;
-  }
-
-  // Shared extension batches can each retain multiple GiB in CI, but capping
-  // them at two lanes stretches the extensions phase into double-digit minutes.
-  // Keep one slot in reserve versus the base CI budget while still allowing
-  // enough overlap to amortize startup and import overhead.
-  return Math.min(defaultLimit, 3);
-}
-
-export function explainExecutionTarget(request, options = {}) {
-  const context = createPlannerContext(request, options);
-  context.noIsolateArgs =
-    context.env.OPENCLAW_TEST_ISOLATE === "1" || context.env.OPENCLAW_TEST_ISOLATE === "true"
-      ? []
-      : context.env.OPENCLAW_TEST_NO_ISOLATE !== "0" &&
-          context.env.OPENCLAW_TEST_NO_ISOLATE !== "false"
-        ? ["--isolate=false"]
-        : [];
-  const [target] = request.fileFilters;
-  const matchedFiles = context.catalog.resolveFilterMatches(target);
-  const normalizedTarget = matchedFiles[0] ?? normalizeRepoPath(target);
-  const { memoryHeavyFiles } = resolveUnitHeavyFileGroups(context);
-  const unitMemoryIsolatedFiles = [...memoryHeavyFiles].filter(
-    (file) => !context.catalog.unitBehaviorOverrideSet.has(file),
-  );
-  const {
-    memoryHeavyFiles: extensionMemoryHeavyFiles,
-    timedHeavyFiles: extensionTimedIsolatedFiles,
-  } = resolveExtensionHeavyFileGroups(context);
-  const extensionMemoryIsolatedFiles = [...extensionMemoryHeavyFiles].filter(
-    (file) => !context.catalog.extensionForkIsolatedFileSet.has(file),
-  );
-  const channelTimedIsolatedFiles = resolveChannelTimedHeavyFiles(context);
-  const classification = context.catalog.classifyTestFile(normalizedTarget, {
-    unitMemoryIsolatedFiles,
-    extensionMemoryIsolatedFiles,
-    extensionTimedIsolatedFiles,
-    channelTimedIsolatedFiles,
-  });
-  const targetedUnit = createTargetedUnit(context, classification, [normalizedTarget]);
-  return {
-    runtimeProfile: context.runtime.runtimeProfileName,
-    intentProfile: context.runtime.intentProfile,
-    memoryBand: context.runtime.memoryBand,
-    loadBand: context.runtime.loadBand,
-    file: classification.file,
-    surface: classification.legacyBasePinned ? "base" : classification.surface,
-    isolate: targetedUnit.isolate,
-    pool: targetedUnit.pool,
-    maxWorkers: targetedUnit.maxWorkers,
-    reasons: classification.reasons,
-    args: targetedUnit.args,
-  };
-}
-
-export function buildExecutionPlan(request, options = {}) {
-  const env = options.env ?? process.env;
-  const explicitFileFilters = (request.fileFilters ?? []).map((value) => normalizeRepoPath(value));
-  const { fileFilters: passthroughFileFilters, optionArgs } = parsePassthroughArgs(
-    request.passthroughArgs ?? [],
-  );
-  const normalizedFailurePolicy = normalizeFailurePolicy(request.failurePolicy ?? null, optionArgs);
-  const fileFilters = [...explicitFileFilters, ...passthroughFileFilters];
-  const passthroughMetadataFlags = new Set(["-h", "--help", "--listTags", "--clearCache"]);
-  const passthroughMetadataOnly =
-    (request.passthroughArgs ?? []).length > 0 &&
-    fileFilters.length === 0 &&
-    optionArgs.every((arg) => {
-      if (!arg.startsWith("-")) {
-        return false;
-      }
-      const [flag] = arg.split("=", 1);
-      return passthroughMetadataFlags.has(flag);
-    });
-  const passthroughRequiresSingleRun = normalizedFailurePolicy.passthroughOptionArgs.some((arg) => {
-    if (!arg.startsWith("-")) {
-      return false;
-    }
-    const [flag] = arg.split("=", 1);
-    return SINGLE_RUN_ONLY_FLAGS.has(flag);
-  });
-  const context = createPlannerContext(
-    {
-      ...request,
-      fileFilters,
-      passthroughOptionArgs: normalizedFailurePolicy.passthroughOptionArgs,
-    },
-    options,
-  );
-  context.noIsolateArgs =
-    env.OPENCLAW_TEST_ISOLATE === "1" || env.OPENCLAW_TEST_ISOLATE === "true"
-      ? []
-      : env.OPENCLAW_TEST_NO_ISOLATE !== "0" && env.OPENCLAW_TEST_NO_ISOLATE !== "false"
-        ? ["--isolate=false"]
-        : [];
-  context.writeTempJsonArtifact =
-    options.writeTempJsonArtifact ??
-    (() => {
-      throw new Error("buildExecutionPlan requires writeTempJsonArtifact for include-file units");
-    });
-
-  const shardOverride = Number.parseInt(env.OPENCLAW_TEST_SHARDS ?? "", 10);
-  context.configuredShardCount =
-    Number.isFinite(shardOverride) && shardOverride > 1 ? shardOverride : null;
-  context.shardCount = context.configuredShardCount ?? (context.runtime.isWindowsCi ? 2 : 1);
-  const shardIndexOverride = Number.parseInt(env.OPENCLAW_TEST_SHARD_INDEX ?? "", 10);
-  context.shardIndexOverride =
-    Number.isFinite(shardIndexOverride) && shardIndexOverride > 0 ? shardIndexOverride : null;
-
-  if (context.shardIndexOverride !== null && context.shardCount <= 1) {
-    throw new Error(
-      `OPENCLAW_TEST_SHARD_INDEX=${String(context.shardIndexOverride)} requires OPENCLAW_TEST_SHARDS>1.`,
-    );
-  }
-  if (context.shardIndexOverride !== null && context.shardIndexOverride > context.shardCount) {
-    throw new Error(
-      `OPENCLAW_TEST_SHARD_INDEX=${String(context.shardIndexOverride)} exceeds OPENCLAW_TEST_SHARDS=${String(context.shardCount)}.`,
-    );
-  }
-
-  const defaultPlanning = buildDefaultUnits(context, { ...request, fileFilters });
-  let units = defaultPlanning.units;
-  const targetedUnits = buildTargetedUnits(context, {
-    ...request,
-    fileFilters,
-    unitMemoryIsolatedFiles: defaultPlanning.unitMemoryIsolatedFiles,
-    extensionMemoryIsolatedFiles: defaultPlanning.extensionMemoryIsolatedFiles,
-    extensionTimedIsolatedFiles: defaultPlanning.extensionTimedHeavyFiles,
-    channelTimedIsolatedFiles: defaultPlanning.channelTimedHeavyFiles,
-  });
-  if (context.configuredShardCount !== null && context.shardCount > 1) {
-    units = expandUnitsAcrossTopLevelShards(context, units);
-  }
-  const selectedUnits = targetedUnits.length > 0 ? targetedUnits : units;
-  const topLevelSingleShardAssignments = buildTopLevelSingleShardAssignments(context, units);
-  const parallelGatewayEnabled =
-    env.OPENCLAW_TEST_PARALLEL_GATEWAY === "1" ||
-    (!context.runtime.isCI && context.executionBudget.gatewayWorkers > 1);
-  const keepGatewaySerial =
-    context.runtime.isWindowsCi ||
-    env.OPENCLAW_TEST_SERIAL_GATEWAY === "1" ||
-    context.runtime.intentProfile === "serial" ||
-    !parallelGatewayEnabled;
-  const parallelUnits = keepGatewaySerial
-    ? selectedUnits.filter((unit) => unit.surface !== "gateway")
-    : selectedUnits;
-  const serialUnits = keepGatewaySerial
-    ? selectedUnits.filter((unit) => unit.surface === "gateway")
-    : [];
-  const serialPrefixUnits = parallelUnits.filter((unit) => unit.serialPhase);
-  const deferredParallelUnits = parallelUnits.filter((unit) => !unit.serialPhase);
-  const topLevelParallelEnabled = context.executionBudget.topLevelParallelEnabled;
-  const baseTopLevelParallelLimit =
-    context.noIsolateArgs.length > 0
-      ? context.executionBudget.topLevelParallelLimitNoIsolate
-      : context.executionBudget.topLevelParallelLimitIsolated;
-  const defaultTopLevelParallelLimit = resolveSurfaceAwareTopLevelParallelLimit(
-    context,
-    selectedUnits,
-    baseTopLevelParallelLimit,
-  );
-  const topLevelParallelLimit = Math.max(
-    1,
-    parseEnvNumber(env, "OPENCLAW_TEST_TOP_LEVEL_CONCURRENCY", defaultTopLevelParallelLimit),
-  );
-  const deferredRunConcurrency = context.executionBudget.deferredRunConcurrency;
-
-  return {
-    runtimeCapabilities: context.runtime,
-    executionBudget: context.executionBudget,
-    failurePolicy: normalizedFailurePolicy.failurePolicy,
-    passthroughOptionArgs: normalizedFailurePolicy.passthroughOptionArgs,
-    passthroughRequiresSingleRun,
-    passthroughMetadataOnly,
-    fileFilters,
-    allUnits: units,
-    selectedUnits,
-    targetedUnits,
-    parallelUnits,
-    serialUnits,
-    serialPrefixUnits,
-    deferredParallelUnits,
-    topLevelParallelEnabled,
-    topLevelParallelLimit,
-    deferredRunConcurrency,
-    keepGatewaySerial,
-    shardCount: context.shardCount,
-    shardIndexOverride: context.shardIndexOverride,
-    topLevelSingleShardAssignments,
-  };
-}
diff --git a/scripts/test-planner/runtime-profile.mjs b/scripts/test-planner/runtime-profile.mjs
deleted file mode 100644
index 79c5814efae7..000000000000
--- a/scripts/test-planner/runtime-profile.mjs
+++ /dev/null
@@ -1,382 +0,0 @@
-import os from "node:os";
-
-export const TEST_PROFILES = new Set(["normal", "serial", "max"]);
-
-export const parsePositiveInt = (value) => {
-  const parsed = Number.parseInt(value ?? "", 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
-};
-
-export const resolveVitestMode = (env = process.env, explicitMode = null) => {
-  if (explicitMode === "ci" || explicitMode === "local") {
-    return explicitMode;
-  }
-  return env.CI === "true" || env.GITHUB_ACTIONS === "true" ? "ci" : "local";
-};
-
-const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
-
-const parseProfile = (rawProfile) => {
-  if (!rawProfile) {
-    return "normal";
-  }
-  const normalized = rawProfile.trim().toLowerCase();
-  if (normalized === "low") {
-    return "serial";
-  }
-  if (!TEST_PROFILES.has(normalized)) {
-    throw new Error(
-      `Unsupported test profile "${normalized}". Supported profiles: normal, serial, max.`,
-    );
-  }
-  return normalized;
-};
-
-const resolveLoadRatio = (env, cpuCount, platform, loadAverage) => {
-  const loadAwareDisabledRaw = env.OPENCLAW_TEST_LOAD_AWARE?.trim().toLowerCase();
-  const loadAwareDisabled = loadAwareDisabledRaw === "0" || loadAwareDisabledRaw === "false";
-  if (loadAwareDisabled || platform === "win32" || cpuCount <= 0) {
-    return 0;
-  }
-  const source = Array.isArray(loadAverage) ? loadAverage : os.loadavg();
-  return source.length > 0 ? source[0] / cpuCount : 0;
-};
-
-const resolveMemoryBand = (memoryGiB) => {
-  if (memoryGiB < 24) {
-    return "constrained";
-  }
-  if (memoryGiB < 48) {
-    return "moderate";
-  }
-  if (memoryGiB < 96) {
-    return "mid";
-  }
-  return "high";
-};
-
-const resolveLoadBand = (isLoadAware, loadRatio) => {
-  if (!isLoadAware) {
-    return "normal";
-  }
-  if (loadRatio < 0.5) {
-    return "idle";
-  }
-  if (loadRatio < 0.9) {
-    return "normal";
-  }
-  if (loadRatio < 1.1) {
-    return "busy";
-  }
-  return "saturated";
-};
-
-const scaleForLoad = (value, loadBand) => {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  const scale = loadBand === "busy" ? 0.75 : loadBand === "saturated" ? 0.5 : 1;
-  return Math.max(1, Math.floor(value * scale));
-};
-
-const scaleConcurrencyForLoad = (value, loadBand) => {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  const scale = loadBand === "busy" ? 0.8 : loadBand === "saturated" ? 0.5 : 1;
-  return Math.max(1, Math.floor(value * scale));
-};
-
-const scaleBatchTargetForLoad = (value, loadBand) => {
-  if (value === null || value === undefined || value <= 0) {
-    return value;
-  }
-  const scale = loadBand === "busy" ? 0.75 : loadBand === "saturated" ? 0.5 : 1;
-  return Math.max(5_000, Math.floor(value * scale));
-};
-
-const LOCAL_MEMORY_BUDGETS = {
-  constrained: {
-    vitestCap: 2,
-    unitShared: 2,
-    channelsShared: 2,
-    unitIsolated: 1,
-    unitHeavy: 1,
-    extensions: 1,
-    gateway: 1,
-    topLevelNoIsolate: 4,
-    topLevelIsolated: 2,
-    deferred: 1,
-    heavyFileLimit: 36,
-    heavyLaneCount: 3,
-    memoryHeavyFileLimit: 8,
-    unitFastBatchTargetMs: 10_000,
-    channelsBatchTargetMs: 0,
-    extensionsBatchTargetMs: 60_000,
-  },
-  moderate: {
-    vitestCap: 3,
-    unitShared: 3,
-    channelsShared: 3,
-    unitIsolated: 1,
-    unitHeavy: 1,
-    extensions: 2,
-    gateway: 1,
-    topLevelNoIsolate: 6,
-    topLevelIsolated: 2,
-    deferred: 1,
-    heavyFileLimit: 48,
-    heavyLaneCount: 4,
-    memoryHeavyFileLimit: 12,
-    unitFastBatchTargetMs: 15_000,
-    channelsBatchTargetMs: 0,
-    extensionsBatchTargetMs: 120_000,
-  },
-  mid: {
-    vitestCap: 4,
-    unitShared: 4,
-    channelsShared: 4,
-    unitIsolated: 1,
-    unitHeavy: 1,
-    extensions: 3,
-    gateway: 1,
-    topLevelNoIsolate: 8,
-    topLevelIsolated: 3,
-    deferred: 2,
-    heavyFileLimit: 60,
-    heavyLaneCount: 4,
-    memoryHeavyFileLimit: 16,
-    unitFastBatchTargetMs: 0,
-    channelsBatchTargetMs: 0,
-    extensionsBatchTargetMs: 180_000,
-  },
-  high: {
-    vitestCap: 6,
-    unitShared: 6,
-    channelsShared: 5,
-    unitIsolated: 2,
-    unitHeavy: 2,
-    extensions: 5,
-    gateway: 3,
-    topLevelNoIsolate: 14,
-    topLevelIsolated: 4,
-    deferred: 8,
-    heavyFileLimit: 80,
-    heavyLaneCount: 5,
-    memoryHeavyFileLimit: 16,
-    unitFastBatchTargetMs: 45_000,
-    channelsBatchTargetMs: 30_000,
-    extensionsBatchTargetMs: 300_000,
-  },
-};
-
-const withIntentBudgetAdjustments = (budget, intentProfile, cpuCount) => {
-  if (intentProfile === "serial") {
-    return {
-      ...budget,
-      vitestMaxWorkers: 1,
-      unitSharedWorkers: 1,
-      channelSharedWorkers: 1,
-      unitIsolatedWorkers: 1,
-      unitHeavyWorkers: 1,
-      extensionWorkers: 1,
-      gatewayWorkers: 1,
-      topLevelParallelEnabled: false,
-      topLevelParallelLimit: 1,
-      topLevelParallelLimitNoIsolate: 1,
-      topLevelParallelLimitIsolated: 1,
-      deferredRunConcurrency: 1,
-    };
-  }
-
-  if (intentProfile === "max") {
-    const maxTopLevelParallelLimit = clamp(
-      Math.max(budget.topLevelParallelLimitNoIsolate ?? budget.topLevelParallelLimit ?? 1, 5),
-      1,
-      8,
-    );
-    return {
-      ...budget,
-      vitestMaxWorkers: clamp(Math.max(budget.vitestMaxWorkers, Math.min(8, cpuCount)), 1, 16),
-      unitSharedWorkers: clamp(Math.max(budget.unitSharedWorkers, Math.min(8, cpuCount)), 1, 16),
-      channelSharedWorkers: clamp(
-        Math.max(budget.channelSharedWorkers ?? budget.unitSharedWorkers, Math.min(6, cpuCount)),
-        1,
-        16,
-      ),
-      unitIsolatedWorkers: clamp(Math.max(budget.unitIsolatedWorkers, Math.min(4, cpuCount)), 1, 4),
-      unitHeavyWorkers: clamp(Math.max(budget.unitHeavyWorkers, Math.min(4, cpuCount)), 1, 4),
-      extensionWorkers: clamp(Math.max(budget.extensionWorkers, Math.min(6, cpuCount)), 1, 6),
-      gatewayWorkers: clamp(Math.max(budget.gatewayWorkers, Math.min(2, cpuCount)), 1, 6),
-      topLevelParallelEnabled: true,
-      topLevelParallelLimit: maxTopLevelParallelLimit,
-      topLevelParallelLimitNoIsolate: maxTopLevelParallelLimit,
-      topLevelParallelLimitIsolated: clamp(
-        Math.max(budget.topLevelParallelLimitIsolated ?? budget.topLevelParallelLimit ?? 1, 4),
-        1,
-        8,
-      ),
-      deferredRunConcurrency: Math.max(budget.deferredRunConcurrency ?? 1, 3),
-    };
-  }
-
-  return budget;
-};
-
-export function resolveRuntimeCapabilities(env = process.env, options = {}) {
-  const mode = resolveVitestMode(env, options.mode ?? null);
-  const isCI = mode === "ci";
-  const platform = options.platform ?? process.platform;
-  const runnerOs = env.RUNNER_OS ?? "";
-  const isMacOS = platform === "darwin" || runnerOs === "macOS";
-  const isWindows = platform === "win32" || runnerOs === "Windows";
-  const isWindowsCi = isCI && isWindows;
-  const hostCpuCount =
-    parsePositiveInt(env.OPENCLAW_TEST_HOST_CPU_COUNT) ?? options.cpuCount ?? os.cpus().length;
-  const totalMemoryBytes = options.totalMemoryBytes ?? os.totalmem();
-  const hostMemoryGiB =
-    parsePositiveInt(env.OPENCLAW_TEST_HOST_MEMORY_GIB) ?? Math.floor(totalMemoryBytes / 1024 ** 3);
-  const nodeMajor = Number.parseInt(
-    (options.nodeVersion ?? process.versions.node).split(".")[0] ?? "",
-    10,
-  );
-  const intentProfile = parseProfile(options.profile ?? env.OPENCLAW_TEST_PROFILE ?? "normal");
-  const loadRatio = !isCI ? resolveLoadRatio(env, hostCpuCount, platform, options.loadAverage) : 0;
-  const loadAware = !isCI && platform !== "win32";
-  const memoryBand = resolveMemoryBand(hostMemoryGiB);
-  const loadBand = resolveLoadBand(loadAware, loadRatio);
-  const runtimeProfileName = isCI
-    ? isWindows
-      ? "ci-windows"
-      : isMacOS
-        ? "ci-macos"
-        : "ci-linux"
-    : isWindows
-      ? "local-windows"
-      : isMacOS
-        ? "local-darwin"
-        : "local-linux";
-
-  return {
-    mode,
-    runtimeProfileName,
-    isCI,
-    isMacOS,
-    isWindows,
-    isWindowsCi,
-    platform,
-    hostCpuCount,
-    hostMemoryGiB,
-    nodeMajor,
-    intentProfile,
-    memoryBand,
-    loadAware,
-    loadRatio,
-    loadBand,
-  };
-}
-
-export function resolveExecutionBudget(runtimeCapabilities) {
-  const runtime = runtimeCapabilities;
-  const cpuCount = clamp(runtime.hostCpuCount, 1, 16);
-
-  if (runtime.isCI) {
-    const macCiWorkers = runtime.isMacOS ? 1 : null;
-    return {
-      vitestMaxWorkers: runtime.isWindows ? 2 : runtime.isMacOS ? 1 : 3,
-      unitSharedWorkers: macCiWorkers,
-      channelSharedWorkers: macCiWorkers,
-      unitIsolatedWorkers: macCiWorkers,
-      unitHeavyWorkers: macCiWorkers,
-      extensionWorkers: macCiWorkers,
-      gatewayWorkers: macCiWorkers,
-      topLevelParallelEnabled: runtime.intentProfile !== "serial" && !runtime.isWindows,
-      topLevelParallelLimit: runtime.isWindows ? 2 : 4,
-      topLevelParallelLimitNoIsolate: runtime.isWindows ? 2 : 4,
-      topLevelParallelLimitIsolated: runtime.isWindows ? 2 : 4,
-      deferredRunConcurrency: null,
-      heavyUnitFileLimit: 64,
-      heavyUnitLaneCount: 4,
-      memoryHeavyUnitFileLimit: 64,
-      unitFastLaneCount: runtime.isWindows ? 1 : 3,
-      unitFastBatchTargetMs: runtime.isWindows ? 0 : 45_000,
-      channelsBatchTargetMs: runtime.isWindows ? 0 : 30_000,
-      extensionsBatchTargetMs: runtime.isWindows ? 0 : 30_000,
-    };
-  }
-
-  const bandBudget = LOCAL_MEMORY_BUDGETS[runtime.memoryBand];
-  const baseBudget = {
-    vitestMaxWorkers: Math.min(cpuCount, bandBudget.vitestCap),
-    unitSharedWorkers: Math.min(cpuCount, bandBudget.unitShared),
-    channelSharedWorkers: Math.min(cpuCount, bandBudget.channelsShared ?? bandBudget.unitShared),
-    unitIsolatedWorkers: Math.min(cpuCount, bandBudget.unitIsolated),
-    unitHeavyWorkers: Math.min(cpuCount, bandBudget.unitHeavy),
-    extensionWorkers: Math.min(cpuCount, bandBudget.extensions),
-    gatewayWorkers: Math.min(cpuCount, bandBudget.gateway),
-    topLevelParallelEnabled: !runtime.isWindows,
-    topLevelParallelLimit: Math.min(cpuCount, bandBudget.topLevelIsolated),
-    topLevelParallelLimitNoIsolate: Math.min(cpuCount, bandBudget.topLevelNoIsolate),
-    topLevelParallelLimitIsolated: Math.min(cpuCount, bandBudget.topLevelIsolated),
-    deferredRunConcurrency: bandBudget.deferred,
-    heavyUnitFileLimit: bandBudget.heavyFileLimit,
-    heavyUnitLaneCount: bandBudget.heavyLaneCount,
-    memoryHeavyUnitFileLimit: bandBudget.memoryHeavyFileLimit,
-    unitFastLaneCount: 1,
-    unitFastBatchTargetMs: bandBudget.unitFastBatchTargetMs,
-    channelsBatchTargetMs: bandBudget.channelsBatchTargetMs ?? 0,
-    extensionsBatchTargetMs: bandBudget.extensionsBatchTargetMs ?? 300_000,
-  };
-
-  const loadAdjustedBudget = {
-    ...baseBudget,
-    vitestMaxWorkers: scaleForLoad(baseBudget.vitestMaxWorkers, runtime.loadBand),
-    unitSharedWorkers: scaleForLoad(baseBudget.unitSharedWorkers, runtime.loadBand),
-    channelSharedWorkers: scaleForLoad(baseBudget.channelSharedWorkers, runtime.loadBand),
-    unitIsolatedWorkers: scaleForLoad(baseBudget.unitIsolatedWorkers, runtime.loadBand),
-    unitHeavyWorkers: scaleForLoad(baseBudget.unitHeavyWorkers, runtime.loadBand),
-    extensionWorkers: scaleForLoad(baseBudget.extensionWorkers, runtime.loadBand),
-    gatewayWorkers: scaleForLoad(baseBudget.gatewayWorkers, runtime.loadBand),
-    topLevelParallelLimit: scaleConcurrencyForLoad(
-      baseBudget.topLevelParallelLimit,
-      runtime.loadBand,
-    ),
-    topLevelParallelLimitNoIsolate: scaleConcurrencyForLoad(
-      baseBudget.topLevelParallelLimitNoIsolate,
-      runtime.loadBand,
-    ),
-    topLevelParallelLimitIsolated: scaleConcurrencyForLoad(
-      baseBudget.topLevelParallelLimitIsolated,
-      runtime.loadBand,
-    ),
-    unitFastBatchTargetMs: scaleBatchTargetForLoad(
-      baseBudget.unitFastBatchTargetMs,
-      runtime.loadBand,
-    ),
-    deferredRunConcurrency:
-      runtime.loadBand === "busy"
-        ? Math.max(1, (baseBudget.deferredRunConcurrency ?? 1) - 1)
-        : runtime.loadBand === "saturated"
-          ? 1
-          : baseBudget.deferredRunConcurrency,
-  };
-
-  return withIntentBudgetAdjustments(loadAdjustedBudget, runtime.intentProfile, cpuCount);
-}
-
-export function resolveLocalVitestMaxWorkers(env = process.env, options = {}) {
-  const explicit = parsePositiveInt(env.OPENCLAW_VITEST_MAX_WORKERS);
-  if (explicit !== null) {
-    return explicit;
-  }
-
-  const runtimeCapabilities = resolveRuntimeCapabilities(env, {
-    cpuCount: options.cpuCount,
-    totalMemoryBytes: options.totalMemoryBytes,
-    platform: options.platform,
-    mode: "local",
-    loadAverage: options.loadAverage,
-    profile: options.profile,
-  });
-  return resolveExecutionBudget(runtimeCapabilities).vitestMaxWorkers;
-}
diff --git a/scripts/test-runner-manifest.mjs b/scripts/test-runner-manifest.mjs
deleted file mode 100644
index 8dfb92a273e6..000000000000
--- a/scripts/test-runner-manifest.mjs
+++ /dev/null
@@ -1,353 +0,0 @@
-import { normalizeTrackedRepoPath, tryReadJsonFile } from "./test-report-utils.mjs";
-
-export const behaviorManifestPath = "test/fixtures/test-parallel.behavior.json";
-export const cliStartupBenchManifestPath = "test/fixtures/cli-startup-bench.json";
-export const unitTimingManifestPath = "test/fixtures/test-timings.unit.json";
-export const channelTimingManifestPath = "test/fixtures/test-timings.channels.json";
-export const extensionTimingManifestPath = "test/fixtures/test-timings.extensions.json";
-export const unitMemoryHotspotManifestPath = "test/fixtures/test-memory-hotspots.unit.json";
-export const extensionMemoryHotspotManifestPath =
-  "test/fixtures/test-memory-hotspots.extensions.json";
-
-const defaultTimingManifest = {
-  config: "vitest.unit.config.ts",
-  defaultDurationMs: 250,
-  files: {},
-};
-const defaultChannelTimingManifest = {
-  config: "vitest.channels.config.ts",
-  defaultDurationMs: 3000,
-  files: {},
-};
-const defaultExtensionTimingManifest = {
-  config: "vitest.extensions.config.ts",
-  defaultDurationMs: 1000,
-  files: {},
-};
-const defaultMemoryHotspotManifest = {
-  config: "vitest.unit.config.ts",
-  defaultMinDeltaKb: 256 * 1024,
-  files: {},
-};
-const defaultExtensionMemoryHotspotManifest = {
-  config: "vitest.extensions.config.ts",
-  defaultMinDeltaKb: 1024 * 1024,
-  files: {},
-};
-
-const normalizeManifestEntries = (entries) =>
-  entries
-    .map((entry) =>
-      typeof entry === "string"
-        ? { file: normalizeTrackedRepoPath(entry), reason: "" }
-        : {
-            file: normalizeTrackedRepoPath(String(entry?.file ?? "")),
-            reason: typeof entry?.reason === "string" ? entry.reason : "",
-          },
-    )
-    .filter((entry) => entry.file.length > 0);
-
-const mergeManifestEntries = (section, keys) => {
-  const merged = [];
-  const seenFiles = new Set();
-  for (const key of keys) {
-    const normalizedEntries = normalizeManifestEntries(section?.[key] ?? []);
-    for (const entry of normalizedEntries) {
-      if (seenFiles.has(entry.file)) {
-        continue;
-      }
-      seenFiles.add(entry.file);
-      merged.push(entry);
-    }
-  }
-  return merged;
-};
-
-const mergeManifestStrings = (section, keys) => {
-  const merged = [];
-  const seen = new Set();
-  for (const key of keys) {
-    const values = Array.isArray(section?.[key]) ? section[key] : [];
-    for (const value of values) {
-      if (typeof value !== "string") {
-        continue;
-      }
-      const normalizedValue = normalizeTrackedRepoPath(value);
-      if (normalizedValue.length === 0 || seen.has(normalizedValue)) {
-        continue;
-      }
-      seen.add(normalizedValue);
-      merged.push(normalizedValue);
-    }
-  }
-  return merged;
-};
-
-export function loadTestRunnerBehavior() {
-  const raw = tryReadJsonFile(behaviorManifestPath, {});
-  const unit = raw.unit ?? {};
-  const base = raw.base ?? {};
-  const channels = raw.channels ?? {};
-  const extensions = raw.extensions ?? {};
-  return {
-    base: {
-      threadPinned: mergeManifestEntries(base, ["threadPinned", "threadSingleton"]),
-    },
-    channels: {
-      isolated: mergeManifestEntries(channels, ["isolated"]),
-      isolatedPrefixes: mergeManifestStrings(channels, ["isolatedPrefixes"]),
-    },
-    extensions: {
-      isolated: mergeManifestEntries(extensions, ["isolated"]),
-    },
-    unit: {
-      isolated: mergeManifestEntries(unit, ["isolated"]),
-      threadPinned: mergeManifestEntries(unit, ["threadPinned", "threadSingleton"]),
-    },
-  };
-}
-
-const loadTimingManifest = (manifestPath, fallbackManifest) => {
-  const raw = tryReadJsonFile(manifestPath, fallbackManifest);
-  const defaultDurationMs =
-    Number.isFinite(raw.defaultDurationMs) && raw.defaultDurationMs > 0
-      ? raw.defaultDurationMs
-      : fallbackManifest.defaultDurationMs;
-  const files = Object.fromEntries(
-    Object.entries(raw.files ?? {})
-      .map(([file, value]) => {
-        const normalizedFile = normalizeTrackedRepoPath(file);
-        const durationMs =
-          Number.isFinite(value?.durationMs) && value.durationMs >= 0 ? value.durationMs : null;
-        const testCount =
-          Number.isFinite(value?.testCount) && value.testCount >= 0 ? value.testCount : null;
-        if (!durationMs) {
-          return [normalizedFile, null];
-        }
-        return [
-          normalizedFile,
-          {
-            durationMs,
-            ...(testCount !== null ? { testCount } : {}),
-          },
-        ];
-      })
-      .filter(([, value]) => value !== null),
-  );
-
-  return {
-    config: typeof raw.config === "string" && raw.config ? raw.config : fallbackManifest.config,
-    generatedAt: typeof raw.generatedAt === "string" ? raw.generatedAt : "",
-    defaultDurationMs,
-    files,
-  };
-};
-
-export function loadUnitTimingManifest() {
-  return loadTimingManifest(unitTimingManifestPath, defaultTimingManifest);
-}
-
-export function loadChannelTimingManifest() {
-  return loadTimingManifest(channelTimingManifestPath, defaultChannelTimingManifest);
-}
-
-export function loadExtensionTimingManifest() {
-  return loadTimingManifest(extensionTimingManifestPath, defaultExtensionTimingManifest);
-}
-
-const loadMemoryHotspotManifest = (manifestPath, fallbackManifest) => {
-  const raw = tryReadJsonFile(manifestPath, fallbackManifest);
-  const defaultMinDeltaKb =
-    Number.isFinite(raw.defaultMinDeltaKb) && raw.defaultMinDeltaKb > 0
-      ? raw.defaultMinDeltaKb
-      : fallbackManifest.defaultMinDeltaKb;
-  const files = Object.fromEntries(
-    Object.entries(raw.files ?? {})
-      .map(([file, value]) => {
-        const normalizedFile = normalizeTrackedRepoPath(file);
-        const deltaKb =
-          Number.isFinite(value?.deltaKb) && value.deltaKb > 0 ? Math.round(value.deltaKb) : null;
-        const sources = Array.isArray(value?.sources)
-          ? value.sources.filter((source) => typeof source === "string" && source.length > 0)
-          : [];
-        if (deltaKb === null) {
-          return [normalizedFile, null];
-        }
-        return [
-          normalizedFile,
-          {
-            deltaKb,
-            ...(sources.length > 0 ? { sources } : {}),
-          },
-        ];
-      })
-      .filter(([, value]) => value !== null),
-  );
-
-  return {
-    config: typeof raw.config === "string" && raw.config ? raw.config : fallbackManifest.config,
-    generatedAt: typeof raw.generatedAt === "string" ? raw.generatedAt : "",
-    defaultMinDeltaKb,
-    files,
-  };
-};
-
-export function loadUnitMemoryHotspotManifest() {
-  return loadMemoryHotspotManifest(unitMemoryHotspotManifestPath, defaultMemoryHotspotManifest);
-}
-
-export function loadExtensionMemoryHotspotManifest() {
-  return loadMemoryHotspotManifest(
-    extensionMemoryHotspotManifestPath,
-    defaultExtensionMemoryHotspotManifest,
-  );
-}
-
-export function selectTimedHeavyFiles({
-  candidates,
-  limit,
-  minDurationMs,
-  exclude = new Set(),
-  timings,
-}) {
-  return candidates
-    .filter((file) => !exclude.has(file))
-    .map((file) => ({
-      file,
-      durationMs: timings.files[file]?.durationMs ?? timings.defaultDurationMs,
-      known: Boolean(timings.files[file]),
-    }))
-    .filter((entry) => entry.known && entry.durationMs >= minDurationMs)
-    .toSorted((a, b) => b.durationMs - a.durationMs)
-    .slice(0, limit)
-    .map((entry) => entry.file);
-}
-
-export function selectMemoryHeavyFiles({
-  candidates,
-  limit,
-  minDeltaKb,
-  exclude = new Set(),
-  hotspots,
-}) {
-  return candidates
-    .filter((file) => !exclude.has(file))
-    .map((file) => ({
-      file,
-      deltaKb: hotspots.files[file]?.deltaKb ?? 0,
-      known: Boolean(hotspots.files[file]),
-    }))
-    .filter((entry) => entry.known && entry.deltaKb >= minDeltaKb)
-    .toSorted((a, b) => b.deltaKb - a.deltaKb)
-    .slice(0, limit)
-    .map((entry) => entry.file);
-}
-
-export function selectUnitHeavyFileGroups({
-  candidates,
-  behaviorOverrides = new Set(),
-  timedLimit,
-  timedMinDurationMs,
-  memoryLimit,
-  memoryMinDeltaKb,
-  timings,
-  hotspots,
-}) {
-  const memoryHeavyFiles =
-    memoryLimit > 0
-      ? selectMemoryHeavyFiles({
-          candidates,
-          limit: memoryLimit,
-          minDeltaKb: memoryMinDeltaKb,
-          exclude: behaviorOverrides,
-          hotspots,
-        })
-      : [];
-  const schedulingOverrides = new Set([...behaviorOverrides, ...memoryHeavyFiles]);
-  const timedHeavyFiles =
-    timedLimit > 0
-      ? selectTimedHeavyFiles({
-          candidates,
-          limit: timedLimit,
-          minDurationMs: timedMinDurationMs,
-          exclude: schedulingOverrides,
-          timings,
-        })
-      : [];
-
-  return {
-    memoryHeavyFiles,
-    timedHeavyFiles,
-  };
-}
-
-export function packFilesByDuration(files, bucketCount, estimateDurationMs) {
-  const normalizedBucketCount = Math.max(0, Math.floor(bucketCount));
-  if (normalizedBucketCount <= 0 || files.length === 0) {
-    return [];
-  }
-
-  return packFilesIntoDurationBuckets(
-    files,
-    Array.from({ length: Math.min(normalizedBucketCount, files.length) }, () => ({
-      totalMs: 0,
-      files: [],
-    })),
-    estimateDurationMs,
-  ).filter((bucket) => bucket.length > 0);
-}
-
-export function packFilesByDurationWithBaseLoads(
-  files,
-  bucketCount,
-  estimateDurationMs,
-  baseLoadsMs = [],
-) {
-  const normalizedBucketCount = Math.max(0, Math.floor(bucketCount));
-  if (normalizedBucketCount <= 0) {
-    return [];
-  }
-
-  return packFilesIntoDurationBuckets(
-    files,
-    Array.from({ length: normalizedBucketCount }, (_, index) => ({
-      totalMs:
-        Number.isFinite(baseLoadsMs[index]) && baseLoadsMs[index] >= 0
-          ? Math.round(baseLoadsMs[index])
-          : 0,
-      files: [],
-    })),
-    estimateDurationMs,
-  );
-}
-
-function packFilesIntoDurationBuckets(files, buckets, estimateDurationMs) {
-  const sortedFiles = [...files].toSorted((left, right) => {
-    return estimateDurationMs(right) - estimateDurationMs(left);
-  });
-
-  for (const file of sortedFiles) {
-    const bucket = buckets.reduce((lightest, current) =>
-      current.totalMs < lightest.totalMs ? current : lightest,
-    );
-    bucket.files.push(file);
-    bucket.totalMs += estimateDurationMs(file);
-  }
-
-  return buckets.map((bucket) => bucket.files);
-}
-
-export function dedupeFilesPreserveOrder(files, exclude = new Set()) {
-  const result = [];
-  const seen = new Set();
-
-  for (const file of files) {
-    if (exclude.has(file) || seen.has(file)) {
-      continue;
-    }
-    seen.add(file);
-    result.push(file);
-  }
-
-  return result;
-}
diff --git a/scripts/test-update-cli-startup-bench.mjs b/scripts/test-update-cli-startup-bench.mjs
index c8909bf94797..560343179db3 100644
--- a/scripts/test-update-cli-startup-bench.mjs
+++ b/scripts/test-update-cli-startup-bench.mjs
@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { parseFlagArgs, stringFlag, intFlag } from "./lib/arg-utils.mjs";
-import { cliStartupBenchManifestPath } from "./test-runner-manifest.mjs";
+
+const CLI_STARTUP_BENCH_FIXTURE_PATH = "test/fixtures/cli-startup-bench.json";
 
 if (process.argv.slice(2).includes("--help")) {
   console.log(
@@ -28,7 +29,7 @@ if (process.argv.slice(2).includes("--help")) {
 const opts = parseFlagArgs(
   process.argv.slice(2),
   {
-    out: cliStartupBenchManifestPath,
+    out: CLI_STARTUP_BENCH_FIXTURE_PATH,
     entry: "openclaw.mjs",
     preset: "all",
     runs: 5,
diff --git a/scripts/test-update-memory-hotspots-sources.mjs b/scripts/test-update-memory-hotspots-sources.mjs
deleted file mode 100644
index 01cd52da0a26..000000000000
--- a/scripts/test-update-memory-hotspots-sources.mjs
+++ /dev/null
@@ -1,89 +0,0 @@
-import { execFileSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-
-export function loadHotspotInputTexts({
-  logPaths = [],
-  ghJobs = [],
-  ghRuns = [],
-  ghRunJobMatches = [],
-  readFileSyncImpl = fs.readFileSync,
-  execFileSyncImpl = execFileSync,
-}) {
-  const inputs = [];
-  for (const logPath of logPaths) {
-    inputs.push({
-      sourceName: path.basename(logPath, path.extname(logPath)),
-      text: readFileSyncImpl(logPath, "utf8"),
-    });
-  }
-  const normalizedRunJobMatches = ghRunJobMatches
-    .map((match) => (typeof match === "string" ? match.trim() : String(match ?? "").trim()))
-    .filter((match) => match.length > 0)
-    .map((match) => match.toLowerCase());
-  const shouldIncludeRunJob = (jobName) => {
-    if (normalizedRunJobMatches.length === 0) {
-      return true;
-    }
-    if (typeof jobName !== "string") {
-      return false;
-    }
-    const normalizedName = jobName.toLowerCase();
-    return normalizedRunJobMatches.some((match) => normalizedName.includes(match));
-  };
-  // Deduplicate explicit and run-derived job ids so repeated inputs do not refetch the same log.
-  const ghJobIds = new Set(
-    ghJobs
-      .map((jobId) => (typeof jobId === "string" ? jobId.trim() : String(jobId ?? "").trim()))
-      .filter((jobId) => jobId.length > 0),
-  );
-  for (const ghRunId of ghRuns) {
-    const normalizedRunId =
-      typeof ghRunId === "string" ? ghRunId.trim() : String(ghRunId ?? "").trim();
-    if (normalizedRunId.length === 0) {
-      continue;
-    }
-    let rawJobs;
-    try {
-      rawJobs = execFileSyncImpl("gh", ["run", "view", normalizedRunId, "--json", "jobs"], {
-        encoding: "utf8",
-        maxBuffer: 8 * 1024 * 1024,
-      });
-    } catch (error) {
-      throw new Error(
-        `[test-update-memory-hotspots] failed to fetch gh run ${normalizedRunId} jobs`,
-        { cause: error },
-      );
-    }
-    let jobs = [];
-    try {
-      const parsed = JSON.parse(rawJobs);
-      jobs = Array.isArray(parsed?.jobs) ? parsed.jobs : [];
-    } catch (error) {
-      throw new Error(
-        `[test-update-memory-hotspots] failed to parse gh run ${normalizedRunId} jobs json`,
-        { cause: error },
-      );
-    }
-    for (const job of jobs) {
-      if (!shouldIncludeRunJob(job?.name)) {
-        continue;
-      }
-      const jobId = job?.databaseId;
-      if (!Number.isFinite(jobId)) {
-        continue;
-      }
-      ghJobIds.add(String(jobId));
-    }
-  }
-  for (const ghJobId of ghJobIds) {
-    inputs.push({
-      sourceName: `gh-job-${String(ghJobId)}`,
-      text: execFileSyncImpl("gh", ["run", "view", "--job", String(ghJobId), "--log"], {
-        encoding: "utf8",
-        maxBuffer: 64 * 1024 * 1024,
-      }),
-    });
-  }
-  return inputs;
-}
diff --git a/scripts/test-update-memory-hotspots-utils.mjs b/scripts/test-update-memory-hotspots-utils.mjs
deleted file mode 100644
index 7e05b1ccf877..000000000000
--- a/scripts/test-update-memory-hotspots-utils.mjs
+++ /dev/null
@@ -1,6 +0,0 @@
-export function matchesHotspotSummaryLane(lane, targetLane, lanePrefixes = []) {
-  if (lane === targetLane) {
-    return true;
-  }
-  return lanePrefixes.some((prefix) => prefix.length > 0 && lane.startsWith(prefix));
-}
diff --git a/scripts/test-update-memory-hotspots.mjs b/scripts/test-update-memory-hotspots.mjs
deleted file mode 100644
index 72920008e64b..000000000000
--- a/scripts/test-update-memory-hotspots.mjs
+++ /dev/null
@@ -1,169 +0,0 @@
-import { intFlag, parseFlagArgs, stringFlag, stringListFlag } from "./lib/arg-utils.mjs";
-import { parseMemoryTraceSummaryLines } from "./test-parallel-memory.mjs";
-import { normalizeTrackedRepoPath, tryReadJsonFile, writeJsonFile } from "./test-report-utils.mjs";
-import { unitMemoryHotspotManifestPath } from "./test-runner-manifest.mjs";
-import { loadHotspotInputTexts } from "./test-update-memory-hotspots-sources.mjs";
-import { matchesHotspotSummaryLane } from "./test-update-memory-hotspots-utils.mjs";
-
-if (process.argv.slice(2).includes("--help")) {
-  console.log(
-    [
-      "Usage: node scripts/test-update-memory-hotspots.mjs [options]",
-      "",
-      "Generate or refresh the unit memory-hotspot manifest from test-parallel memory logs.",
-      "",
-      "Options:",
-      "  --config <path>            Vitest config label stored in the output manifest",
-      "  --out <path>               Output manifest path (default: test/fixtures/test-memory-hotspots.unit.json)",
-      "  --lane <name>              Primary lane name to match (default: unit-fast)",
-      "  --lane-prefix <prefix>     Additional lane prefixes to include (repeatable)",
-      "  --log <path>               Memory trace log to ingest (repeatable, required)",
-      "  --gh-job <id>              GitHub Actions job id to ingest via gh (repeatable)",
-      "  --gh-run <id>              GitHub Actions run id to ingest via gh (repeatable)",
-      "  --gh-run-job-match <text>  Filter gh-run jobs by name substring (repeatable)",
-      "  --min-delta-kb <kb>        Minimum RSS delta to retain (default: 262144)",
-      "  --limit <count>            Max hotspot entries to retain (default: 64)",
-      "  --help                     Show this help text",
-      "",
-      "Examples:",
-      "  node scripts/test-update-memory-hotspots.mjs --log /tmp/unit-fast.log",
-      "  node scripts/test-update-memory-hotspots.mjs --log a.log --log b.log --lane-prefix unit-fast-batch-",
-      "  node scripts/test-update-memory-hotspots.mjs --gh-job 69804189668 --gh-job 69804189672",
-      "  node scripts/test-update-memory-hotspots.mjs --gh-run 23933168654 --gh-run-job-match extensions",
-    ].join("\n"),
-  );
-  process.exit(0);
-}
-
-function parseArgs(argv) {
-  return parseFlagArgs(
-    argv,
-    {
-      config: "vitest.unit.config.ts",
-      out: unitMemoryHotspotManifestPath,
-      lane: "unit-fast",
-      lanePrefixes: [],
-      logs: [],
-      ghJobs: [],
-      ghRuns: [],
-      ghRunJobMatches: [],
-      minDeltaKb: 256 * 1024,
-      limit: 64,
-    },
-    [
-      stringFlag("--config", "config"),
-      stringFlag("--out", "out"),
-      stringFlag("--lane", "lane"),
-      stringListFlag("--lane-prefix", "lanePrefixes"),
-      stringListFlag("--log", "logs"),
-      stringListFlag("--gh-job", "ghJobs"),
-      stringListFlag("--gh-run", "ghRuns"),
-      stringListFlag("--gh-run-job-match", "ghRunJobMatches"),
-      intFlag("--min-delta-kb", "minDeltaKb", { min: 1 }),
-      intFlag("--limit", "limit", { min: 1 }),
-    ],
-  );
-}
-
-function mergeHotspotEntry(aggregated, file, value) {
-  if (!(Number.isFinite(value?.deltaKb) && value.deltaKb > 0)) {
-    return;
-  }
-  const normalizedFile = normalizeTrackedRepoPath(file);
-  const normalizeSourceLabel = (source) => {
-    const separator = source.lastIndexOf(":");
-    if (separator === -1) {
-      return source.endsWith(".log") ? source.slice(0, -4) : source;
-    }
-    const name = source.slice(0, separator);
-    const lane = source.slice(separator + 1);
-    return `${name.endsWith(".log") ? name.slice(0, -4) : name}:${lane}`;
-  };
-  const nextSources = Array.isArray(value?.sources)
-    ? value.sources
-        .filter((source) => typeof source === "string" && source.length > 0)
-        .map(normalizeSourceLabel)
-    : [];
-  const previous = aggregated.get(normalizedFile);
-  if (!previous) {
-    aggregated.set(normalizedFile, {
-      deltaKb: Math.round(value.deltaKb),
-      sources: [...new Set(nextSources)],
-    });
-    return;
-  }
-  previous.deltaKb = Math.max(previous.deltaKb, Math.round(value.deltaKb));
-  for (const source of nextSources) {
-    if (!previous.sources.includes(source)) {
-      previous.sources.push(source);
-    }
-  }
-}
-
-const opts = parseArgs(process.argv.slice(2));
-
-if (opts.logs.length === 0 && opts.ghJobs.length === 0 && opts.ghRuns.length === 0) {
-  console.error(
-    "[test-update-memory-hotspots] pass at least one --log <path>, --gh-job <id>, or --gh-run <id>.",
-  );
-  process.exit(2);
-}
-
-const aggregated = new Map();
-const existing = tryReadJsonFile(opts.out, null);
-if (existing) {
-  for (const [file, value] of Object.entries(existing.files ?? {})) {
-    mergeHotspotEntry(aggregated, file, value);
-  }
-}
-for (const input of loadHotspotInputTexts({
-  logPaths: opts.logs,
-  ghJobs: opts.ghJobs,
-  ghRuns: opts.ghRuns,
-  ghRunJobMatches: opts.ghRunJobMatches,
-})) {
-  const text = input.text;
-  const summaries = parseMemoryTraceSummaryLines(text).filter((summary) =>
-    matchesHotspotSummaryLane(summary.lane, opts.lane, opts.lanePrefixes),
-  );
-  for (const summary of summaries) {
-    for (const record of summary.top) {
-      if (record.deltaKb < opts.minDeltaKb) {
-        continue;
-      }
-      mergeHotspotEntry(aggregated, record.file, {
-        deltaKb: record.deltaKb,
-        sources: [`${input.sourceName}:${summary.lane}`],
-      });
-    }
-  }
-}
-
-const files = Object.fromEntries(
-  [...aggregated.entries()]
-    .toSorted((left, right) => right[1].deltaKb - left[1].deltaKb)
-    .slice(0, opts.limit)
-    .map(([file, value]) => [
-      file,
-      {
-        deltaKb: value.deltaKb,
-        sources: value.sources.toSorted(),
-      },
-    ]),
-);
-
-const output = {
-  config: opts.config,
-  generatedAt: new Date().toISOString(),
-  defaultMinDeltaKb: opts.minDeltaKb,
-  lane:
-    opts.lanePrefixes.length === 0
-      ? opts.lane
-      : [opts.lane, ...opts.lanePrefixes.map((prefix) => String(prefix).concat("*"))].join(", "),
-  files,
-};
-
-writeJsonFile(opts.out, output);
-console.log(
-  `[test-update-memory-hotspots] wrote ${String(Object.keys(files).length)} hotspots to ${opts.out}`,
-);
diff --git a/scripts/test-update-timings.mjs b/scripts/test-update-timings.mjs
deleted file mode 100644
index 5aca9a3fd93c..000000000000
--- a/scripts/test-update-timings.mjs
+++ /dev/null
@@ -1,105 +0,0 @@
-import { intFlag, parseFlagArgs, stringFlag } from "./lib/arg-utils.mjs";
-import { loadVitestReportFromArgs } from "./lib/vitest-report-cli-utils.mjs";
-import {
-  collectVitestFileDurations,
-  normalizeTrackedRepoPath,
-  writeJsonFile,
-} from "./test-report-utils.mjs";
-import { extensionTimingManifestPath, unitTimingManifestPath } from "./test-runner-manifest.mjs";
-
-const resolveDefaultManifestSettings = (config) => {
-  if (config === "vitest.extensions.config.ts") {
-    return {
-      out: extensionTimingManifestPath,
-      defaultDurationMs: 1000,
-      description: "extension",
-    };
-  }
-  return {
-    out: unitTimingManifestPath,
-    defaultDurationMs: 250,
-    description: "unit",
-  };
-};
-
-if (process.argv.slice(2).includes("--help")) {
-  console.log(
-    [
-      "Usage: node scripts/test-update-timings.mjs [options]",
-      "",
-      "Generate or refresh a test timing manifest from a Vitest JSON report.",
-      "",
-      "Options:",
-      "  --config <path>                Vitest config to run when no report is supplied",
-      "  --report <path>                Reuse an existing Vitest JSON report",
-      "  --out <path>                   Output manifest path (default follows --config)",
-      "  --limit <count>                Max number of file timings to retain (default: 256)",
-      "  --default-duration-ms <ms>     Fallback duration for unknown files (default follows --config)",
-      "  --help                         Show this help text",
-      "",
-      "Examples:",
-      "  node scripts/test-update-timings.mjs",
-      "  node scripts/test-update-timings.mjs --config vitest.unit.config.ts --limit 128",
-      "  node scripts/test-update-timings.mjs --config vitest.extensions.config.ts",
-      "  node scripts/test-update-timings.mjs --report /tmp/vitest-report.json --out /tmp/timings.json",
-    ].join("\n"),
-  );
-  process.exit(0);
-}
-
-function parseArgs(argv) {
-  const parsed = parseFlagArgs(
-    argv,
-    {
-      config: "vitest.unit.config.ts",
-      limit: 256,
-      reportPath: "",
-      out: "",
-      defaultDurationMs: 0,
-    },
-    [
-      stringFlag("--config", "config"),
-      intFlag("--limit", "limit", { min: 1 }),
-      stringFlag("--report", "reportPath"),
-      stringFlag("--out", "out"),
-      intFlag("--default-duration-ms", "defaultDurationMs", { min: 1 }),
-    ],
-  );
-  const defaults = resolveDefaultManifestSettings(parsed.config);
-  return {
-    ...parsed,
-    out: parsed.out || defaults.out,
-    defaultDurationMs:
-      Number.isFinite(parsed.defaultDurationMs) && parsed.defaultDurationMs > 0
-        ? parsed.defaultDurationMs
-        : defaults.defaultDurationMs,
-    description: defaults.description,
-  };
-}
-
-const opts = parseArgs(process.argv.slice(2));
-const report = loadVitestReportFromArgs(opts, "openclaw-vitest-timings");
-const files = Object.fromEntries(
-  collectVitestFileDurations(report, normalizeTrackedRepoPath)
-    .toSorted((a, b) => b.durationMs - a.durationMs)
-    .slice(0, opts.limit)
-    .map((entry) => [
-      entry.file,
-      {
-        durationMs: entry.durationMs,
-        testCount: entry.testCount,
-      },
-    ]),
-);
-
-const output = {
-  config: opts.config,
-  generatedAt: new Date().toISOString(),
-  defaultDurationMs: opts.defaultDurationMs,
-  files,
-};
-
-writeJsonFile(opts.out, output);
-console.log(
-  `[test-update-timings] wrote ${String(Object.keys(files).length)} ${opts.description} timings to ${opts.out}`,
-);
diff --git a/vitest.config.ts b/vitest.config.ts
index 00d73fcf0dc0..33283b243b17 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -1,3 +1,4 @@
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { defineConfig } from "vitest/config";
@@ -6,15 +7,37 @@ import {
   BUNDLED_PLUGIN_TEST_GLOB,
 } from "./scripts/lib/bundled-plugin-paths.mjs";
 import { pluginSdkSubpaths } from "./scripts/lib/plugin-sdk-entries.mjs";
-import { resolveLocalVitestMaxWorkers } from "./scripts/test-planner/runtime-profile.mjs";
-import {
-  behaviorManifestPath,
-  unitMemoryHotspotManifestPath,
-  unitTimingManifestPath,
-} from "./scripts/test-runner-manifest.mjs";
 import { loadVitestExperimentalConfig } from "./vitest.performance-config.ts";
 
-export { resolveLocalVitestMaxWorkers };
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+function parsePositiveInt(value) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+export function resolveLocalVitestMaxWorkers(
+  env = process.env,
+  system = {
+    cpuCount: os.cpus().length || 1,
+    totalMemoryBytes: os.totalmem(),
+  },
+) {
+  const override = parsePositiveInt(env.OPENCLAW_VITEST_MAX_WORKERS ?? env.OPENCLAW_TEST_WORKERS);
+  if (override !== null) {
+    return clamp(override, 1, 16);
+  }
+
+  const cpuCount = Math.max(1, system.cpuCount || 1);
+  const memoryGiB = (system.totalMemoryBytes || 0) / 1024 ** 3;
+  let workers = cpuCount >= 16 ? 6 : cpuCount >= 10 ? 4 : cpuCount >= 6 ? 3 : 2;
+  if (memoryGiB < 24) {
+    workers = Math.min(workers, 2);
+  } else if (memoryGiB < 48) {
+    workers = Math.min(workers, 3);
+  }
+  return clamp(workers, 1, 16);
+}
 
 const repoRoot = path.dirname(fileURLToPath(import.meta.url));
 const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
@@ -55,12 +78,9 @@ export default defineConfig({
       "test/setup.ts",
       "test/setup.shared.ts",
       "test/setup.extensions.ts",
-      "scripts/test-parallel.mjs",
-      "scripts/test-planner/catalog.mjs",
-      "scripts/test-planner/executor.mjs",
-      "scripts/test-planner/planner.mjs",
-      "scripts/test-planner/runtime-profile.mjs",
-      "scripts/test-runner-manifest.mjs",
+      "scripts/test-projects.mjs",
+      "scripts/test-projects-lib.mjs",
+      "scripts/ci-write-manifest-outputs.mjs",
       "vitest.channel-paths.mjs",
       "vitest.channels.config.ts",
       "vitest.bundled.config.ts",
@@ -71,12 +91,10 @@ export default defineConfig({
       "vitest.gateway.config.ts",
       "vitest.live.config.ts",
       "vitest.performance-config.ts",
+      "vitest.projects.config.ts",
       "vitest.scoped-config.ts",
       "vitest.unit.config.ts",
       "vitest.unit-paths.mjs",
-      behaviorManifestPath,
-      unitTimingManifestPath,
-      unitMemoryHotspotManifestPath,
     ],
     include: [
       "src/**/*.test.ts",