@aefree/pi-unity 0.10.0 → 0.12.0

package/index.ts

@@ -1,7 +1,7 @@
 import { keyHint, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
-import { mkdir, readdir, stat, unlink } from "node:fs/promises";
+import { mkdir, readFile, readdir, stat, unlink } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { getKeybindings, Text, truncateToWidth } from "@earendil-works/pi-tui";
@@ -20,13 +20,15 @@ import {
   type UnityParsedTestResults,
 } from "./src/unity-batchmode";
 import { formatPathForUser, hasUnityCommandLineFlag } from "./src/unity-core";
-import { createUnityCliBatchmodeReportArgs, createUnityCliEditorExitCommand, createUnityCliRunCommand, dispatchUnityPlanningInspection, haveSameKnownProcessIds, inspectUnityCliProjectCapabilities, listRunningUnityCliEditorsForProject, resolveUnityCliCommand, UNITY_PLANNING_READ_COMMANDS, type UnityCliProjectCapabilities } from "./src/unity-cli";
-import { createUnityBatchmodeCommand, launchUnityCliOpenDetached, launchUnityEditorDetached, resolveUnityEditorPath } from "./src/unity-launch";
+import { createUnityCliBatchmodeReportArgs, createUnityCliEditorExitCommand, createUnityCliRunCommand, createUnityCliTestCommand, dispatchUnityPlanningInspection, haveSameKnownProcessIds, inspectUnityCliProjectCapabilities, listRunningUnityCliEditorsForProject, resolveUnityCliCommand, UNITY_PLANNING_READ_COMMANDS, type UnityCliProjectCapabilities } from "./src/unity-cli";
+import { launchUnityCliOpenDetached } from "./src/unity-launch";
+import { createUnityBatchmodeCommand, launchUnityEditorDetached, resolveUnityEditorPath } from "./src/unity-editor-fallback";
 import { loadPiUnitySettings, type PiUnitySettings } from "./src/pi-unity-settings";
 import { dedupeRunningUnityProcesses, listRunningUnityProcessesForProject, redactUnityProcessCommandLine, terminateRunningUnityProcesses, verifyUnityProcessIdentity, type RunningUnityProcess } from "./src/unity-processes";
 import { assertUnityProjectNotBusy, evaluateUnityLaunchSafety, getUnityNativeLockfilePath, inspectUnityProjectBusyState, withUnityProjectLaunchMutex } from "./src/unity-project-lock";
-import { resolveUnityProjectCandidates, type UnityProjectCandidate } from "./src/unity-projects";
+import { readUnityVersion, resolveUnityProjectCandidates, type UnityProjectCandidate } from "./src/unity-projects";
 import { createUnityTestBatchPlan, type UnityTestBatchPlan, type UnityTestPlatform } from "./src/unity-test-batch";
+import { applyUnityCliRetrySummary, compactUnityTestSummary, defaultUnityTestReportFormats, deriveUnityCliEffectiveReportPath, determineUnityTestOutcome, getUnityTestRouteRequirements, normalizeUnityRunTestsRequest, parseUnityCliRetrySummary, resolveUnityCliBackendReportPaths, writeNormalizedUnityTestArtifact, type NormalizedUnityTestResult, type UnityRunTestsRequest } from "./src/unity-tests";
 import { auditUnityGuidance, type UnityGuidanceAuditResult } from "./src/unity-guidance-audit";
 import { runUnityPipelineRecompile, runUnityPipelineTests, type UnityPipelineOperationDetails } from "./src/unity-pipeline";
 import {
@@ -66,7 +68,7 @@ const GUI_WARNING = "This launches the full Unity Editor GUI and is not the same
 const SINGLE_PROCESS_WARNING = "Unity allows only one process per project folder. GUI Editor and batchmode/headless both count as that one process.";
 
 type UnityToolDetails = {
-  mode: "gui" | "batchmode" | "status" | "artifacts" | "pipeline_inspection" | "pipeline_eval" | "pipeline";
+  mode: "gui" | "batchmode" | "status" | "artifacts" | "pipeline_inspection" | "pipeline_eval" | "pipeline" | "tests";
   projectRoot: string;
   unityVersion: string;
   editorPath: string;
@@ -102,32 +104,38 @@ type UnityLauncherPreference = "auto" | "unity-cli" | "editor-executable";
 
 const OPEN_EDITOR_PARAMS = Type.Object({
   path: Type.Optional(Type.String({ description: "Unity project path, workspace copy root, or folder containing project copies." })),
-  unityEditorPath: Type.Optional(Type.String({ description: "Optional explicit Unity executable path override." })),
   automated: Type.Optional(Type.Boolean({ default: false, description: "Pass Unity Editor's -automated flag when opening the project. Defaults to false." })),
   launcher: LAUNCHER_SCHEMA,
-});
+}, { additionalProperties: false });
 
 const LAUNCH_BATCHMODE_PARAMS = Type.Object({
   path: Type.Optional(Type.String({ description: "Unity project path, workspace copy root, or folder containing project copies." })),
-  unityEditorPath: Type.Optional(Type.String({ description: "Optional explicit Unity executable path override." })),
+
   args: Type.Optional(Type.Array(Type.String(), { description: "Additional Unity command-line arguments appended after -batchmode -projectPath <project> for direct editor launch, or forwarded after `unity run <project> --` for Unity CLI launch. pi-unity adds -nographics by default unless useGraphics=true." })),
   useGraphics: Type.Optional(Type.Boolean({ default: false, description: "Set true only when the requested Unity batchmode work requires an active graphics device, such as screenshots, rendering, or visual PlayMode tests. Defaults to false, which adds -nographics." })),
   timeoutSeconds: Type.Optional(Type.Integer({ minimum: 1, maximum: 14400, default: 3600, description: "Timeout in seconds for the batchmode process." })),
   launcher: LAUNCHER_SCHEMA,
   closeBlockingUnityProcess: Type.Optional(Type.Boolean({ default: false, description: "When true, pi-unity may close a running Unity process for the resolved project before launch, but only if piUnity.allowCloseRunningUnityProcess is enabled in Pi settings. The process is selected by project matching, not by model-supplied PID." })),
-});
+}, { additionalProperties: false });
 
-const RUN_TEST_BATCH_PARAMS = Type.Object({
+const RUN_TESTS_PARAMS = Type.Object({
   path: Type.Optional(Type.String({ description: "Unity project path, workspace copy root, or folder containing project copies." })),
-  unityEditorPath: Type.Optional(Type.String({ description: "Optional explicit Unity executable path override." })),
-  testPlatform: StringEnum(["EditMode", "PlayMode"] as const, { description: "Unity Test Framework platform. One batch runs exactly one test platform." }),
-  testFilters: Type.Optional(Type.Array(Type.String(), { maxItems: 50, description: "Full test names or regex filters. Values are normalized into one semicolon-separated -testFilter argument." })),
-  testCategories: Type.Optional(Type.Array(Type.String(), { maxItems: 50, description: "Categories or category regex/negations. Values are normalized into one semicolon-separated -testCategory argument." })),
-  useGraphics: Type.Optional(Type.Boolean({ default: false, description: "Set true only for graphics-dependent PlayMode tests or visual capture. Defaults to headless -nographics." })),
+  testPlatform: StringEnum(["EditMode", "PlayMode"] as const),
+  testFilters: Type.Optional(Type.Array(Type.String(), { maxItems: 50 })),
+  testCategories: Type.Optional(Type.Array(Type.String(), { maxItems: 50 })),
+  execution: Type.Optional(StringEnum(["auto", "connected", "isolated"] as const, { default: "auto" })),
+  isolatedLauncher: Type.Optional(StringEnum(["auto", "unity-cli", "editor-executable"] as const, { default: "auto" })),
+  retries: Type.Optional(Type.Integer({ minimum: 0, maximum: 20, default: 0 })),
+  rerunFailed: Type.Optional(Type.Boolean({ default: false })),
+  shard: Type.Optional(Type.String({ maxLength: 500 })),
+  shardInventoryPath: Type.Optional(Type.String({ maxLength: 1000 })),
+  reportFormats: Type.Optional(Type.Array(StringEnum(["json", "nunit", "junit"] as const), { maxItems: 3 })),
+  coverage: Type.Optional(Type.Boolean({ default: false })),
+  coverageOptions: Type.Optional(Type.String({ maxLength: 1000 })),
+  useGraphics: Type.Optional(Type.Boolean({ default: false })),
   timeoutSeconds: Type.Optional(Type.Integer({ minimum: 1, maximum: 14400, default: 3600 })),
-  launcher: LAUNCHER_SCHEMA,
-  closeBlockingUnityProcess: Type.Optional(Type.Boolean({ default: false, description: "Use guarded same-project Unity process closure only when piUnity.allowCloseRunningUnityProcess is enabled." })),
-});
+  closeBlockingUnityProcess: Type.Optional(Type.Boolean({ default: false })),
+}, { additionalProperties: false });
 
 const PROJECT_STATUS_PARAMS = Type.Object({
   path: Type.Optional(Type.String({ description: "Unity project path, workspace copy root, or folder containing project copies." })),
@@ -168,6 +176,7 @@ const GUIDANCE_AUDIT_PARAMS = Type.Object({
 const INSPECT_ARTIFACTS_PARAMS = Type.Object({
   path: Type.Optional(Type.String({ description: "Unity project path, workspace copy root, or folder containing project copies." })),
   testResultsPath: Type.Optional(Type.String({ description: "Unity Test Framework XML results path. Relative paths are resolved against cwd and the Unity project root." })),
+  normalizedResultPath: Type.Optional(Type.String({ description: "pi-unity normalized JSON test artifact path." })),
   logFilePath: Type.Optional(Type.String({ description: "Unity log file path. Relative paths are resolved against cwd and the Unity project root." })),
   latestFromLogs: Type.Optional(Type.Boolean({ default: true, description: "When paths are omitted, inspect the newest .xml and .log files under the project's Logs folder." })),
   maxLines: Type.Optional(Type.Integer({ minimum: 1, maximum: 500, default: 60, description: "Maximum log/output lines to include." })),
@@ -175,7 +184,7 @@ const INSPECT_ARTIFACTS_PARAMS = Type.Object({
 });
 
 function buildProjectChoiceLabel(cwd: string, candidate: UnityProjectCandidate): string {
-  return `${candidate.projectName} (${candidate.unityVersion}) — ${formatPathForUser(cwd, candidate.projectRoot)}`;
+  return `${candidate.projectName} — ${formatPathForUser(cwd, candidate.projectRoot)}`;
 }
 
 async function chooseProjectCandidateWithWrappingNavigation(
@@ -246,7 +255,7 @@ async function chooseProjectCandidateWithWrappingNavigation(
 
 function formatCandidateList(cwd: string, candidates: UnityProjectCandidate[]): string {
   return candidates
-    .map((candidate) => `- ${candidate.projectName} (${candidate.unityVersion}) — ${formatPathForUser(cwd, candidate.projectRoot)}`)
+    .map((candidate) => `- ${candidate.projectName} — ${formatPathForUser(cwd, candidate.projectRoot)}`)
     .join("\n");
 }
 
@@ -310,6 +319,13 @@ async function resolveProjectCandidate(
   return { candidate, discoveryWarning };
 }
 
+async function requireManualUnityVersion(candidate: UnityProjectCandidate): Promise<string> {
+  if (candidate.unityVersion) return candidate.unityVersion;
+  const unityVersion = await readUnityVersion(candidate.projectRoot);
+  candidate.unityVersion = unityVersion;
+  return unityVersion;
+}
+
 function joinWarnings(...warnings: Array<string | undefined>): string | undefined {
   const present = warnings.filter((warning): warning is string => Boolean(warning && warning.trim().length > 0));
   return present.length > 0 ? present.join("\n") : undefined;
@@ -425,11 +441,12 @@ async function closeBlockingUnityProcessesForBatchmode(
     );
   }
 
-  const cliCapabilities = await inspectUnityCliProjectCapabilities(candidate.projectRoot, candidate.unityVersion, { signal });
+  const unityVersion = await requireManualUnityVersion(candidate);
+  const cliCapabilities = await inspectUnityCliProjectCapabilities(candidate.projectRoot, unityVersion, { signal });
   const canRequestGracefulExit = cliCapabilities.commandDiscoverySucceeded && cliCapabilities.advertisedCommands.includes("eval");
   if (canRequestGracefulExit) {
     const refreshedRunning = await listBlockingUnityProcesses(candidate.projectRoot);
-    const refreshedCapabilities = await inspectUnityCliProjectCapabilities(candidate.projectRoot, candidate.unityVersion, { signal });
+    const refreshedCapabilities = await inspectUnityCliProjectCapabilities(candidate.projectRoot, unityVersion, { signal });
     const samePids = haveSameKnownProcessIds(running.processes, refreshedRunning.processes);
     const samePipelinePids = haveSameKnownProcessIds(cliCapabilities.matchingInstances, refreshedCapabilities.matchingInstances);
     if (refreshedRunning.warning || !samePids || !samePipelinePids || !refreshedCapabilities.advertisedCommands.includes("eval")) {
@@ -578,7 +595,8 @@ async function buildProjectStatusReport(
   const lockState = await inspectUnityProjectBusyState(candidate.projectRoot);
   const cliStatus = await listRunningUnityCliEditorsForProject(candidate.projectRoot);
   const processStatus = await listRunningUnityProcessesForProject(candidate.projectRoot);
-  const cliCapabilities = await inspectUnityCliProjectCapabilities(candidate.projectRoot, candidate.unityVersion, { signal });
+  const unityVersion = await requireManualUnityVersion(candidate);
+  const cliCapabilities = await inspectUnityCliProjectCapabilities(candidate.projectRoot, unityVersion, { signal });
   const runningProcesses = dedupeRunningUnityProcesses([...cliStatus.processes, ...processStatus.processes]);
   const isBusy = runningProcesses.length > 0 || cliCapabilities.matchingInstances.length > 0;
   const staleLockSuspected = lockState.nativeLockfileExists && !isBusy && !processStatus.warning;
@@ -586,7 +604,7 @@ async function buildProjectStatusReport(
   const piUnitySettings = await loadPiUnitySettings(ctx);
 
   const lines = [
-    `Unity project status for ${formatPathForUser(ctx.cwd, candidate.projectRoot)} using Unity ${candidate.unityVersion}.`,
+    `Unity project status for ${formatPathForUser(ctx.cwd, candidate.projectRoot)} using declared Unity ${unityVersion}.`,
     `- Native lockfile: ${lockState.nativeLockfileExists ? "present" : "absent"}`,
     `- Lockfile path: ${lockState.nativeLockfilePath}`,
     `- Running Unity processes targeting project: ${runningProcesses.length}`,
@@ -635,7 +653,7 @@ async function buildProjectStatusReport(
     details: {
       mode: "status",
       projectRoot: candidate.projectRoot,
-      unityVersion: candidate.unityVersion,
+      unityVersion: await requireManualUnityVersion(candidate),
       editorPath: "",
       warning: combinedWarning,
       status: "passed",
@@ -685,7 +703,7 @@ function compactUnityArtifacts(artifacts: UnityBatchmodeArtifacts): UnityBatchmo
 async function buildArtifactInspectionReport(
   ctx: ExtensionContext,
   candidate: UnityProjectCandidate,
-  params: { testResultsPath?: string; logFilePath?: string; latestFromLogs?: boolean; maxLines?: number; maxChars?: number },
+  params: { testResultsPath?: string; normalizedResultPath?: string; logFilePath?: string; latestFromLogs?: boolean; maxLines?: number; maxChars?: number },
 ): Promise<{ text: string; details: UnityToolDetails }> {
   const useLatest = params.latestFromLogs !== false;
   const logsRoot = join(candidate.projectRoot, "Logs");
@@ -693,6 +711,15 @@ async function buildArtifactInspectionReport(
     ?? (useLatest ? await findNewestFile(logsRoot, [".xml"]) : undefined);
   const logFilePath = resolveArtifactPath(ctx.cwd, candidate.projectRoot, params.logFilePath)
     ?? (useLatest ? await findNewestFile(logsRoot, [".log", ".txt"]) : undefined);
+  const normalizedResultPath = resolveArtifactPath(ctx.cwd, candidate.projectRoot, params.normalizedResultPath)
+    ?? (useLatest ? await findNewestFile(logsRoot, [".json"]) : undefined);
+  let normalizedSummary: string | undefined;
+  if (normalizedResultPath) {
+    try {
+      const normalized = JSON.parse(await readFile(normalizedResultPath, "utf8")) as Partial<NormalizedUnityTestResult>;
+      if (normalized.schemaVersion === 1 && typeof normalized.outcome === "string") normalizedSummary = `Normalized test result: ${normalized.platform ?? "Unity"} ${normalized.outcome}; ${normalized.summary?.total ?? "unknown"} total.`;
+    } catch { normalizedSummary = `Normalized test result JSON could not be parsed: ${normalizedResultPath}`; }
+  }
   const invocation: UnityBatchmodeInvocation = {
     isTestRun: Boolean(testResultsPath),
     usesNoGraphics: false,
@@ -707,9 +734,11 @@ async function buildArtifactInspectionReport(
   const hasLoadedArtifacts = Boolean(artifacts.testResultsPath || artifacts.logFilePath);
   const status = deriveUnityArtifactInspectionStatus(hasLoadedArtifacts, invocation, parsedTestResults);
   const lines = [
-    `Unity artifacts inspected for ${formatPathForUser(ctx.cwd, candidate.projectRoot)} using Unity ${candidate.unityVersion}.`,
+    `Unity artifacts inspected for ${formatPathForUser(ctx.cwd, candidate.projectRoot)}; Unity CLI selects the project's declared Editor version when launching.`,
     testResultsPath ? `Requested test results: ${testResultsPath}` : "Requested test results: (none found)",
     logFilePath ? `Requested log file: ${logFilePath}` : "Requested log file: (none found)",
+    normalizedResultPath ? `Requested normalized result: ${normalizedResultPath}` : "Requested normalized result: (none found)",
+    ...(normalizedSummary ? [normalizedSummary] : []),
   ];
 
   if (parsedTestResults) {
@@ -732,7 +761,7 @@ async function buildArtifactInspectionReport(
     details: {
       mode: "artifacts",
       projectRoot: candidate.projectRoot,
-      unityVersion: candidate.unityVersion,
+      unityVersion: await requireManualUnityVersion(candidate),
       editorPath: "",
       invocation,
       artifacts: compactUnityArtifacts(artifacts),
@@ -750,7 +779,9 @@ function buildEditorLaunchSummary(
   launcher: "unity-cli" | "editor-executable" = "editor-executable",
 ): string {
   return [
-    `Launched Unity Editor GUI for ${formatPathForUser(cwd, candidate.projectRoot)} using Unity ${candidate.unityVersion}.`,
+    launcher === "unity-cli"
+      ? `Launched Unity Editor GUI for ${formatPathForUser(cwd, candidate.projectRoot)} with the project-declared Editor version selected by Unity CLI.`
+      : `Launched Unity Editor GUI for ${formatPathForUser(cwd, candidate.projectRoot)} using the project's declared Unity version through the direct Editor fallback.`,
     launcher === "unity-cli" ? `Launcher: unity open (${editorPath})` : `Editor: ${editorPath}`,
     GUI_WARNING,
     SINGLE_PROCESS_WARNING,
@@ -777,7 +808,7 @@ async function buildBatchmodeReport(
   const status = deriveUnityBatchmodeStatus(result.code, Boolean(result.killed), invocation, parsedTestResults);
   const text = buildUnityBatchmodeAgentText({
     displayProjectPath: formatPathForUser(ctx.cwd, candidate.projectRoot),
-    unityVersion: candidate.unityVersion,
+    unityVersion: await requireManualUnityVersion(candidate),
     editorPath,
     exitCode: result.code,
     killed: Boolean(result.killed),
@@ -795,7 +826,7 @@ async function buildBatchmodeReport(
     details: {
       mode: "batchmode",
       projectRoot: candidate.projectRoot,
-      unityVersion: candidate.unityVersion,
+      unityVersion: await requireManualUnityVersion(candidate),
       editorPath,
       command: editorPath,
       args,
@@ -904,16 +935,42 @@ function throwIfAborted(signal?: AbortSignal): void {
   }
 }
 
-async function canUseUnityCli(pi: ExtensionAPI, signal?: AbortSignal): Promise<boolean> {
+const UNITY_CLI_WARNING_SYMBOL = Symbol.for("@aefree/pi-unity/unity-cli-warning/v1");
+const unityCliRuntimeState = globalThis as Record<PropertyKey, unknown>;
+const UNITY_CLI_WARNING = "pi-unity capability warning: Unity CLI is unavailable or UNITY_CLI_PATH is invalid. Install Unity CLI, then restart or reload Pi to restore pi-unity's primary project-launch workflow.";
+
+async function warnWhenUnityCliUnavailable(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  if (!ctx.hasUI || unityCliRuntimeState[UNITY_CLI_WARNING_SYMBOL] === true) return;
+  try {
+    const result = await pi.exec(resolveUnityCliCommand(), ["--version"], { timeout: 5000 });
+    // Timeouts are uncertain and must neither warn nor select another backend.
+    if (result.killed || result.code === 0 || unityCliRuntimeState[UNITY_CLI_WARNING_SYMBOL] === true) return;
+    unityCliRuntimeState[UNITY_CLI_WARNING_SYMBOL] = true;
+    ctx.ui.notify(UNITY_CLI_WARNING, "warning");
+  } catch (error) {
+    if ((error instanceof Error && error.name === "AbortError") || isUnityCliProbeTimeout(error)) return;
+    if (unityCliRuntimeState[UNITY_CLI_WARNING_SYMBOL] === true) return;
+    unityCliRuntimeState[UNITY_CLI_WARNING_SYMBOL] = true;
+    ctx.ui.notify(UNITY_CLI_WARNING, "warning");
+  }
+}
+type UnityCliAvailability = "available" | "unavailable" | "uncertain";
+
+function isUnityCliProbeTimeout(error: unknown): boolean {
+  return Boolean(error && typeof error === "object" && "code" in error && (error as { code?: unknown }).code === "ETIMEDOUT");
+}
+
+async function getUnityCliAvailability(pi: ExtensionAPI, signal?: AbortSignal): Promise<UnityCliAvailability> {
   try {
     throwIfAborted(signal);
     const command = resolveUnityCliCommand();
     const result = await pi.exec(command, ["--version"], { signal, timeout: 5000 });
     throwIfAborted(signal);
-    return !result.killed && result.code === 0;
+    if (result.killed) return "uncertain";
+    return result.code === 0 ? "available" : "unavailable";
   } catch (error) {
     if (signal?.aborted || (error instanceof Error && error.name === "AbortError")) throw error;
-    return false;
+    return isUnityCliProbeTimeout(error) ? "uncertain" : "unavailable";
   }
 }
 
@@ -963,16 +1020,18 @@ async function shouldUseUnityCli(
     return false;
   }
 
-  const available = await canUseUnityCli(pi, signal);
-  if (preference === "unity-cli" && !available) {
+  const availability = await getUnityCliAvailability(pi, signal);
+  if (availability === "uncertain") {
+    throw new Error("Unity CLI availability could not be confirmed because its bounded probe timed out. Retry the request; pi-unity will not select the direct Editor fallback after an uncertain Unity CLI probe.");
+  }
+  if (preference === "unity-cli" && availability === "unavailable") {
     throw new Error("Unity CLI launcher was requested, but the `unity` command is not available. Set UNITY_CLI_PATH or use launcher='editor-executable'.");
   }
 
-  return available;
+  return availability === "available";
 }
 
 type GuardedBatchmodeParams = {
-  unityEditorPath?: string;
   args?: string[];
   useGraphics?: boolean;
   timeoutSeconds?: number;
@@ -1004,17 +1063,14 @@ async function runGuardedUnityBatchmode(
       const invocation = parseUnityBatchmodeInvocation(createUnityCliBatchmodeReportArgs(candidate.projectRoot, extraArgs, { useGraphics }));
       const useUnityCli = await shouldUseUnityCli(pi, params.launcher, signal);
       throwIfAborted(signal);
-      const editorPath = useUnityCli
-        ? await resolveUnityEditorPath(candidate.unityVersion, { overridePath: params.unityEditorPath }).catch(() => "Unity CLI resolved editor")
-        : await resolveUnityEditorPath(candidate.unityVersion, { overridePath: params.unityEditorPath });
-      const command = useUnityCli
-        ? createUnityCliRunCommand(candidate.projectRoot, extraArgs, {
-          editorVersion: candidate.unityVersion,
-          editorPath: params.unityEditorPath,
-          timeoutSeconds,
-          useGraphics,
-        })
-        : createUnityBatchmodeCommand(editorPath, candidate.projectRoot, extraArgs, { useGraphics });
+      let editorPath = "Unity CLI";
+      let command: { command: string; args: string[] };
+      if (useUnityCli) {
+        command = createUnityCliRunCommand(candidate.projectRoot, extraArgs, { timeoutSeconds, useGraphics });
+      } else {
+        editorPath = await resolveUnityEditorPath(await requireManualUnityVersion(candidate));
+        command = createUnityBatchmodeCommand(editorPath, candidate.projectRoot, extraArgs, { useGraphics });
+      }
       const closeReport = await closeBlockingUnityProcessesForBatchmode(
         pi,
         ctx,
@@ -1079,6 +1135,96 @@ async function runGuardedUnityBatchmode(
   );
 }
 
+async function runUnifiedUnityTests(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  candidate: UnityProjectCandidate,
+  discoveryWarning: string | undefined,
+  raw: UnityRunTestsRequest,
+  signal: AbortSignal | undefined,
+  onUpdate?: (update: { content: Array<{ type: "text"; text: string }> }) => void,
+  allowAutonomousExitPlayMode = true,
+): Promise<{ content: Array<{ type: "text"; text: string }>; details: UnityToolDetails & { testResult: NormalizedUnityTestResult; artifactPath: string; route: "connected" | "isolated" } }> {
+  const request = normalizeUnityRunTestsRequest(raw);
+  const requirements = getUnityTestRouteRequirements(request);
+  const capabilities = await inspectUnityCliProjectCapabilities(candidate.projectRoot, await requireManualUnityVersion(candidate), { signal, execute: createPipelineUnityCliExecutor(pi) });
+  const reachable = capabilities.matchingInstances.some(instance => instance.reachable === true);
+  const busy = (await listBlockingUnityProcesses(candidate.projectRoot)).processes.length > 0 || capabilities.matchingInstances.length > 0;
+  let route: "connected" | "isolated";
+  if (request.execution === "connected") {
+    if (requirements.requiresIsolation) throw new Error(`Connected execution cannot honor this request: ${requirements.reasons.join("; ")}.`);
+    if (!reachable) throw new Error("Connected execution requires an already-open exact-copy reachable Pipeline Editor; no Unity was launched.");
+    route = "connected";
+  } else if (request.execution === "isolated") {
+    if (reachable && !request.closeBlockingUnityProcess) throw new Error("Isolated execution will not close a reachable Pipeline Editor automatically. Close it first or use the explicitly guarded close option.");
+    route = "isolated";
+  } else if (reachable) {
+    if (requirements.requiresIsolation) throw new Error(`This request requires isolated execution (${requirements.reasons.join("; ")}), but the exact project copy is open in reachable Pipeline. pi-unity will not close it automatically.`);
+    route = "connected";
+  } else {
+    if (capabilities.pipelineDiscovery === "timeout" || (capabilities.projectSupportsPipeline && capabilities.pipelineDiscovery !== "absent" && capabilities.pipelineDiscovery !== "available")) throw new Error("Pipeline discovery is uncertain for this exact project copy; refusing to start an isolated Editor until project state is known.");
+    if (busy) throw new Error("A Unity process is already open for this exact project copy without reachable Pipeline; refusing to launch a second process.");
+    route = "isolated";
+  }
+  const formats = request.reportFormats ?? defaultUnityTestReportFormats(route);
+  if (route === "connected") {
+    const result = await runUnityPipelineTests({ projectRoot: candidate.projectRoot, unityVersion: await requireManualUnityVersion(candidate), testPlatform: request.testPlatform, testFilter: request.testFilters[0], testCategory: request.testCategories[0], timeoutSeconds: request.timeoutSeconds, allowAutonomousExitPlayMode }, createPipelineDependencies(pi), { signal, onUpdate: message => onUpdate?.({ content: [{ type: "text", text: message }] }) });
+    const counts = result.details.counts!;
+    const normalized: NormalizedUnityTestResult = {
+      schemaVersion: 1, source: "pipeline", platform: request.testPlatform,
+      selection: { testFilters: request.testFilters, testCategories: request.testCategories },
+      durationSeconds: result.details.elapsedSeconds, outcome: determineUnityTestOutcome(counts), summary: counts, tests: result.testRecords ?? [],
+    };
+    const artifactPath = await writeNormalizedUnityTestArtifact(candidate.projectRoot, normalized);
+    const text = `${compactUnityTestSummary(normalized)}\nRoute: connected Pipeline. Normalized artifact: ${artifactPath}`;
+    return { content: [{ type: "text", text }], details: { mode: "tests", projectRoot: candidate.projectRoot, unityVersion: await requireManualUnityVersion(candidate), editorPath: "", status: normalized.outcome === "passed" ? "passed" : "failed", pipeline: result.details, testResult: { ...normalized, tests: [] }, artifactPath, route } };
+  }
+  if (request.isolatedLauncher === "editor-executable" && (request.retries || request.rerunFailed || request.shard || request.coverage || formats.includes("junit"))) throw new Error("The direct Editor fallback cannot honor CLI-only retry, rerun, shard, coverage, or JUnit options.");
+  const plan = createUnityTestBatchPlan({ projectRoot: candidate.projectRoot, testPlatform: request.testPlatform, testFilters: request.testFilters, testCategories: request.testCategories });
+  const cliAvailable = await shouldUseUnityCli(pi, request.isolatedLauncher, signal);
+  if (!cliAvailable && request.isolatedLauncher === "unity-cli") throw new Error("Unity CLI was requested but is unavailable.");
+  if (!cliAvailable && (request.retries || request.rerunFailed || request.shard || request.coverage || formats.includes("junit"))) throw new Error("Unity CLI is unavailable and the requested options have no direct Editor fallback.");
+  if (!cliAvailable) {
+    const fallback = await runGuardedUnityBatchmode(pi, ctx, candidate, discoveryWarning, { args: plan.args, useGraphics: request.useGraphics, timeoutSeconds: request.timeoutSeconds, launcher: "editor-executable", closeBlockingUnityProcess: request.closeBlockingUnityProcess }, signal, "unity_run_test_batch");
+    const parsed = fallback.details.parsedTestResults;
+    const summary = { total: parsed?.total, passed: parsed?.passed, failed: parsed?.failed, skipped: parsed?.skipped };
+    const normalized: NormalizedUnityTestResult = { schemaVersion: 1, source: "editor-executable", platform: request.testPlatform, selection: { testFilters: request.testFilters, testCategories: request.testCategories }, outcome: determineUnityTestOutcome(summary), summary, tests: parsed?.tests ?? [] };
+    const artifactPath = await writeNormalizedUnityTestArtifact(candidate.projectRoot, normalized);
+    return { content: [{ type: "text", text: `${compactUnityTestSummary(normalized)}\nRoute: isolated direct Editor. Normalized artifact: ${artifactPath}` }], details: { ...fallback.details, mode: "tests", testResult: { ...normalized, tests: [] }, artifactPath, route } };
+  }
+  return await withUnityProjectLaunchMutex(candidate.projectRoot, { mode: "batchmode", toolName: "unity_run_tests" }, async () => {
+    const invocation = parseUnityBatchmodeInvocation(plan.args);
+    const closeReport = await closeBlockingUnityProcessesForBatchmode(pi, ctx, candidate, invocation, request.closeBlockingUnityProcess, signal);
+    await removeStaleLockfileAfterGuardedClose(candidate, closeReport);
+    await enforceLaunchRouteSafety(candidate.projectRoot, "unity-cli");
+    const command = createUnityCliTestCommand(candidate.projectRoot, { testPlatform: request.testPlatform, testFilters: request.testFilters, testCategories: request.testCategories, retries: request.retries, rerunFailed: request.rerunFailed, shard: request.shard, shardInventoryPath: request.shardInventoryPath, reportPaths: resolveUnityCliBackendReportPaths({ nunit: plan.testResultsPath, junit: plan.junitResultsPath, log: plan.logFilePath }, formats), coverage: request.coverage, coverageOptions: request.coverageOptions, useGraphics: request.useGraphics, timeoutSeconds: request.timeoutSeconds });
+    const execution = await pi.exec(command.command, command.args, { signal, timeout: (request.timeoutSeconds ?? 3600) * 1000 + 30_000 });
+    const effectiveResultsPath = deriveUnityCliEffectiveReportPath(plan.testResultsPath, { rerunFailed: request.rerunFailed, shard: request.shard });
+    let effectiveResultsXml: string | undefined;
+    try { effectiveResultsXml = await readFile(effectiveResultsPath, "utf8"); } catch { /* Missing current-run evidence is handled below. */ }
+    const parsed = effectiveResultsXml ? parseUnityTestResultsXml(effectiveResultsXml) : null;
+    const summary = { total: parsed?.total, passed: parsed?.passed, failed: parsed?.failed, skipped: parsed?.skipped };
+    const outcome = execution.killed ? "timed_out" : execution.code === 8 ? "tests_failed" : execution.code === 6 ? "run_error" : determineUnityTestOutcome(summary);
+    let normalized: NormalizedUnityTestResult = { schemaVersion: 1, source: "unity-cli", platform: request.testPlatform, selection: { testFilters: request.testFilters, testCategories: request.testCategories }, outcome: (request.rerunFailed || request.shard) && execution.code === 0 && !parsed ? "empty_selection" : outcome, summary, tests: parsed?.tests ?? [], backendArtifacts: { ...(parsed && formats.includes("nunit") ? { nunit: `Logs/${effectiveResultsPath.split(/[\\/]/).pop()}` } : {}), ...(parsed && formats.includes("junit") ? { junit: `Logs/${deriveUnityCliEffectiveReportPath(plan.junitResultsPath, { rerunFailed: request.rerunFailed, shard: request.shard }).split(/[\\/]/).pop()}` } : {}), log: `Logs/${plan.logFilePath.split(/[\\/]/).pop()}` } };
+    if (request.retries > 0 && formats.includes("nunit")) {
+      const retryPath = effectiveResultsPath.replace(/\.[^.\\/]+$/, ".retries.json");
+      try {
+        const retry = parseUnityCliRetrySummary(JSON.parse(await readFile(retryPath, "utf8")));
+        if (!retry) normalized = { ...normalized, outcome: "uncertain" };
+        else {
+          normalized = applyUnityCliRetrySummary(normalized, retry);
+          normalized.backendArtifacts = { ...normalized.backendArtifacts, retrySummary: `Logs/${retryPath.split(/[\\/]/).pop()}` };
+        }
+      } catch {
+        normalized = { ...normalized, outcome: "uncertain" };
+      }
+    }
+    const artifactPath = await writeNormalizedUnityTestArtifact(candidate.projectRoot, normalized);
+    const text = `${compactUnityTestSummary(normalized)}\nRoute: isolated Unity CLI. Normalized artifact: ${artifactPath}`;
+    return { content: [{ type: "text", text }], details: { mode: "tests", projectRoot: candidate.projectRoot, unityVersion: await requireManualUnityVersion(candidate), editorPath: "Unity CLI", status: outcome === "passed" || outcome === "passed_with_flakes" || outcome === "empty_selection" ? "passed" : "failed", command: command.command, cliArgs: command.args, testBatch: plan, testResult: { ...normalized, tests: [] }, artifactPath, route } };
+  });
+}
+
 function renderUnityPipelineResult(result: any, options: { expanded: boolean; isPartial: boolean }, theme: any, context: { lastComponent?: unknown }): Text {
   const details = result.details as UnityToolDetails | undefined;
   const primaryText = getToolTextContent(result);
@@ -1216,6 +1362,7 @@ export default function freeUnityPi(pi: ExtensionAPI) {
 
   pi.on("session_start", async (_event, ctx) => {
     restoreSessionSettings(ctx);
+    await warnWhenUnityCliUnavailable(pi, ctx);
     const scope = ctx.sessionManager;
     unregisterScope(registrations.get(scope));
     // Optional package integrations resolve independently. The Unity extension and
@@ -1293,14 +1440,14 @@ export default function freeUnityPi(pi: ExtensionAPI) {
         await withUnityProjectLaunchMutex(candidate.projectRoot, { mode: "gui", toolName: "unity-open" }, async () => {
           await enforceSingleProcessRule(candidate.projectRoot);
         let launcher: "unity-cli" | "editor-executable" = "editor-executable";
-        let editorPath = await resolveUnityEditorPath(candidate.unityVersion).catch(() => "Unity CLI resolved editor");
+        let editorPath = "Unity CLI";
         let launch: { pid: number | undefined; args: string[]; command: string };
-        if (await canUseUnityCli(pi)) {
+        if (await shouldUseUnityCli(pi, undefined)) {
           launcher = "unity-cli";
-          launch = launchUnityCliOpenDetached(candidate.projectRoot, { editorVersion: candidate.unityVersion });
+          launch = launchUnityCliOpenDetached(candidate.projectRoot);
         } else {
           await assertUnityProjectNotBusy(candidate.projectRoot);
-          editorPath = await resolveUnityEditorPath(candidate.unityVersion);
+          editorPath = await resolveUnityEditorPath(await requireManualUnityVersion(candidate));
           launch = launchUnityEditorDetached(editorPath, candidate.projectRoot);
         }
         const summary = buildEditorLaunchSummary(ctx.cwd, candidate, editorPath, discoveryWarning, launcher);
@@ -1392,6 +1539,27 @@ export default function freeUnityPi(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "unity_run_tests",
+    label: "Unity Run Tests",
+    description: "Run Unity Test Framework tests through one intent-oriented workflow. It reuses a reachable exact-copy Pipeline Editor when compatible, otherwise uses isolated `unity test` execution.",
+    promptSnippet: "Run Unity EditMode or PlayMode tests through one safe routed workflow with durable normalized evidence.",
+    promptGuidelines: [
+      "Use unity_run_tests for ordinary Unity Test Framework runs. It selects connected Pipeline only for compatible requests and isolated unity test only when the exact project copy is closed.",
+      "Do not use unity_launch_batchmode for ordinary tests; raw test flags there are an unsupported escape hatch.",
+      "A reachable Editor is never closed merely to obtain isolated-only options. Requests needing retries, sharding, reruns, coverage, multiple selectors, or XML reports are rejected before dispatch when it is open.",
+      "Timeout, malformed evidence, cancellation, or missing artifacts never cause a backend fallback or relaunch.",
+    ],
+    parameters: RUN_TESTS_PARAMS,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      throwIfAborted(signal);
+      const { candidate, discoveryWarning } = await resolveProjectCandidate(ctx, params.path);
+      return await runUnifiedUnityTests(pi, ctx, candidate, discoveryWarning, params as UnityRunTestsRequest, signal, onUpdate, sessionAllowsAutonomousPlayModeExit(ctx));
+    },
+    renderCall(args, theme, context) { return renderUnityToolCall("unity_run_tests", args, theme, "tests", `${args.testPlatform ?? "Unity"} • ${compactUnityRendererValue(args.testFilters?.[0] ?? args.testFilter ?? args.execution ?? "auto", 100)}`, context); },
+    renderResult(result, { expanded }, theme) { return renderUnityToolResult(result, expanded, theme); },
+  });
+
   pi.registerTool({
     name: "unity_pipeline_recompile",
     label: "Unity Pipeline Recompile",
@@ -1406,47 +1574,19 @@ export default function freeUnityPi(pi: ExtensionAPI) {
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       throwIfAborted(signal);
       const { candidate } = await resolveProjectCandidate(ctx, params.path);
-      const result = await runUnityPipelineRecompile({ projectRoot: candidate.projectRoot, unityVersion: candidate.unityVersion, timeoutSeconds: params.timeoutSeconds, allowAutonomousExitPlayMode: sessionAllowsAutonomousPlayModeExit(ctx) }, createPipelineDependencies(pi), {
+      const result = await runUnityPipelineRecompile({ projectRoot: candidate.projectRoot, unityVersion: await requireManualUnityVersion(candidate), timeoutSeconds: params.timeoutSeconds, allowAutonomousExitPlayMode: sessionAllowsAutonomousPlayModeExit(ctx) }, createPipelineDependencies(pi), {
         signal,
         onUpdate: message => onUpdate?.({ content: [{ type: "text", text: message }] }),
       });
       return {
         content: [{ type: "text", text: result.text }],
-        details: { mode: "pipeline", projectRoot: result.details.projectRoot, unityVersion: candidate.unityVersion, editorPath: "", status: "passed", pipeline: result.details } satisfies UnityToolDetails,
+        details: { mode: "pipeline", projectRoot: result.details.projectRoot, unityVersion: await requireManualUnityVersion(candidate), editorPath: "", status: "passed", pipeline: result.details } satisfies UnityToolDetails,
       };
     },
     renderCall(args, theme, context) { return renderUnityPipelineCall("unity_pipeline_recompile", args, theme, context); },
     renderResult(result, options, theme, context) { return renderUnityPipelineResult(result, options, theme, context); },
   });
 
-  pi.registerTool({
-    name: "unity_pipeline_run_tests",
-    label: "Unity Pipeline Run Tests",
-    description: "Run one focused EditMode or PlayMode test selection through an already-open exact Unity Pipeline Editor, with internal bounded polling and aggregate output.",
-    promptSnippet: "Run focused connected Unity EditMode or PlayMode tests in one bounded call without shell polling; aggregate passing results stay compact.",
-    promptGuidelines: [
-      "Use unity_pipeline_run_tests for one focused connected Unity test platform when the exact Editor is already open and reachable.",
-      "unity_pipeline_run_tests may exit Play Mode through advertised editor_stop when needed, then verifies Edit Mode before dispatching tests.",
-      "Use unity_run_test_batch instead of unity_pipeline_run_tests for closed projects, isolation, complex filters/categories, or required NUnit XML/log evidence.",
-      "unity_pipeline_run_tests does not cancel uncertain work or switch to batchmode after timeout; report that the connected run may still be running.",
-    ],
-    parameters: PIPELINE_TEST_PARAMS,
-    async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      throwIfAborted(signal);
-      const { candidate } = await resolveProjectCandidate(ctx, params.path);
-      const result = await runUnityPipelineTests({ projectRoot: candidate.projectRoot, unityVersion: candidate.unityVersion, testPlatform: params.testPlatform, testFilter: params.testFilter, timeoutSeconds: params.timeoutSeconds, allowAutonomousExitPlayMode: sessionAllowsAutonomousPlayModeExit(ctx) }, createPipelineDependencies(pi), {
-        signal,
-        onUpdate: message => onUpdate?.({ content: [{ type: "text", text: message }] }),
-      });
-      return {
-        content: [{ type: "text", text: result.text }],
-        details: { mode: "pipeline", projectRoot: result.details.projectRoot, unityVersion: candidate.unityVersion, editorPath: "", status: "passed", pipeline: result.details } satisfies UnityToolDetails,
-      };
-    },
-    renderCall(args, theme, context) { return renderUnityPipelineCall("unity_pipeline_run_tests", args, theme, context); },
-    renderResult(result, options, theme, context) { return renderUnityPipelineResult(result, options, theme, context); },
-  });
-
   pi.registerTool({
     name: "unity_pipeline_eval",
     label: "Unity Pipeline Eval",
@@ -1465,7 +1605,7 @@ export default function freeUnityPi(pi: ExtensionAPI) {
       throwIfAborted(signal);
       const result = await dispatchUnityPlanningInspection({
         projectRoot: candidate.projectRoot,
-        unityVersion: candidate.unityVersion,
+        unityVersion: await requireManualUnityVersion(candidate),
         command: "eval",
         evalSnippet: params.code,
       }, {
@@ -1482,7 +1622,7 @@ export default function freeUnityPi(pi: ExtensionAPI) {
         details: {
           mode: "pipeline_eval",
           projectRoot: candidate.projectRoot,
-          unityVersion: candidate.unityVersion,
+          unityVersion: await requireManualUnityVersion(candidate),
           editorPath: "",
           status: result.outcome === "dispatched" ? "passed" : "failed",
           pipelineEval: result,
@@ -1514,7 +1654,7 @@ export default function freeUnityPi(pi: ExtensionAPI) {
       throwIfAborted(signal);
       const result = await dispatchUnityPlanningInspection({
         projectRoot: candidate.projectRoot,
-        unityVersion: candidate.unityVersion,
+        unityVersion: await requireManualUnityVersion(candidate),
         command: params.command,
         args: params.args,
       }, {
@@ -1531,7 +1671,7 @@ export default function freeUnityPi(pi: ExtensionAPI) {
         details: {
           mode: "pipeline_inspection",
           projectRoot: candidate.projectRoot,
-          unityVersion: candidate.unityVersion,
+          unityVersion: await requireManualUnityVersion(candidate),
           editorPath: "",
           status: result.outcome === "dispatched" ? "passed" : "failed",
           pipelineInspection: result,
@@ -1600,18 +1740,14 @@ export default function freeUnityPi(pi: ExtensionAPI) {
       const useUnityCli = await shouldUseUnityCli(pi, params.launcher as UnityLauncherPreference | undefined, signal);
       throwIfAborted(signal);
       let launcher: "unity-cli" | "editor-executable" = "editor-executable";
-      let editorPath = await resolveUnityEditorPath(candidate.unityVersion, { overridePath: params.unityEditorPath }).catch(() => "Unity CLI resolved editor");
+      let editorPath = "Unity CLI";
       let launch: { pid: number | undefined; args: string[]; command: string };
       if (useUnityCli) {
         launcher = "unity-cli";
-        launch = launchUnityCliOpenDetached(candidate.projectRoot, {
-          editorVersion: candidate.unityVersion,
-          editorPath: params.unityEditorPath,
-          automated: params.automated,
-        });
+        launch = launchUnityCliOpenDetached(candidate.projectRoot, { automated: params.automated });
       } else {
         await assertUnityProjectNotBusy(candidate.projectRoot);
-        editorPath = await resolveUnityEditorPath(candidate.unityVersion, { overridePath: params.unityEditorPath });
+        editorPath = await resolveUnityEditorPath(await requireManualUnityVersion(candidate));
         launch = launchUnityEditorDetached(editorPath, candidate.projectRoot, { automated: params.automated });
       }
       const text = buildEditorLaunchSummary(ctx.cwd, candidate, editorPath, discoveryWarning, launcher);
@@ -1621,7 +1757,7 @@ export default function freeUnityPi(pi: ExtensionAPI) {
         details: {
           mode: "gui",
           projectRoot: candidate.projectRoot,
-          unityVersion: candidate.unityVersion,
+          unityVersion: await requireManualUnityVersion(candidate),
           editorPath,
           pid: launch.pid,
           command: launch.command,
@@ -1640,52 +1776,6 @@ export default function freeUnityPi(pi: ExtensionAPI) {
     },
   });
 
-  pi.registerTool({
-    name: "unity_run_test_batch",
-    label: "Unity Test Batch",
-    description: "Run one bundled Unity Test Framework platform with normalized filters/categories and generated absolute XML/log paths under the project Logs directory.",
-    promptSnippet: "Run a bundled Unity EditMode or PlayMode test batch with safe generated artifact paths",
-    promptGuidelines: [
-      "Before choosing a test route, call unity_project_status for the exact project copy. If it is already open with reachable Pipeline run_tests/test_status commands, use the connected workflow without closing the Editor.",
-      "Prefer unity_run_test_batch over unity_launch_batchmode only for isolated or report-producing Unity Test Framework runs: closed projects, unavailable/unsupported connected testing, intentional CI isolation, unsupported filters, or required NUnit XML/log artifacts.",
-      "Do not set closeBlockingUnityProcess merely to switch a reachable Pipeline Editor into batchmode; use it only after isolated execution is deliberately required and the guarded setting is enabled.",
-      "Pass unity_run_test_batch exactly one testPlatform. Multiple test platforms require separate user-authorized launches.",
-      "An empty unity_run_test_batch testFilters/testCategories selection runs all tests for that testPlatform; use narrow arrays when focused evidence is sufficient.",
-      "Do not call unity_run_test_batch for PlayMode when user/project guidance says to skip PlayMode tests.",
-      "Use unity_run_test_batch useGraphics=true only for graphics-dependent PlayMode tests or visual capture; ordinary EditMode and non-visual PlayMode remain headless.",
-      "After unity_run_test_batch infrastructure failure, inspect the exact generated paths reported by the failed call once and do not repeat an unchanged launch.",
-    ],
-    parameters: RUN_TEST_BATCH_PARAMS,
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      throwIfAborted(signal);
-      const { candidate, discoveryWarning } = await resolveProjectCandidate(ctx, params.path);
-      const plan = createUnityTestBatchPlan({
-        projectRoot: candidate.projectRoot,
-        testPlatform: params.testPlatform as UnityTestPlatform,
-        testFilters: params.testFilters,
-        testCategories: params.testCategories,
-      });
-      await mkdir(dirname(plan.testResultsPath), { recursive: true });
-      throwIfAborted(signal);
-      const result = await runGuardedUnityBatchmode(pi, ctx, candidate, discoveryWarning, {
-        unityEditorPath: params.unityEditorPath,
-        args: plan.args,
-        useGraphics: params.useGraphics,
-        timeoutSeconds: params.timeoutSeconds,
-        launcher: params.launcher as UnityLauncherPreference | undefined,
-        closeBlockingUnityProcess: params.closeBlockingUnityProcess,
-      }, signal, "unity_run_test_batch");
-      result.details = { ...result.details, testBatch: plan };
-      return result;
-    },
-    renderCall(args, theme) {
-      return renderUnityToolCall("unity_run_test_batch", args, theme, "batchmode", `${args.testPlatform} test batch`);
-    },
-    renderResult(result, { expanded }, theme) {
-      return renderUnityToolResult(result, expanded, theme);
-    },
-  });
-
   pi.registerTool({
     name: "unity_launch_batchmode",
     label: "Unity CLI",