@aefree/pi-unity 0.11.0 → 0.12.1

package/index.ts

@@ -7,9 +7,9 @@ import { setTimeout as delay } from "node:timers/promises";
 import { getKeybindings, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import {
   buildUnityBatchmodeAgentText,
-  deriveUnityArtifactInspectionStatus,
   deriveUnityBatchmodeStatus,
   hasKnownPositiveExecutedTestCount,
+  hasConflictingUnityXmlTestEvidence,
   loadUnityBatchmodeArtifacts,
   parseUnityBatchmodeInvocation,
   parseUnityTestResultsXml,
@@ -21,13 +21,16 @@ import {
 } from "./src/unity-batchmode";
 import { formatPathForUser, hasUnityCommandLineFlag } from "./src/unity-core";
 import { createUnityCliBatchmodeReportArgs, createUnityCliEditorExitCommand, createUnityCliRunCommand, createUnityCliTestCommand, 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 { 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, writeNormalizedUnityTestArtifact, type NormalizedUnityTestResult, type UnityRunTestsRequest } from "./src/unity-tests";
+import { applyUnityCliRetrySummary, compactUnityTestSummary, defaultUnityTestReportFormats, deriveUnityCliEffectiveReportPath, determineUnityTestOutcome, getUnityTestRouteRequirements, normalizeUnityRunTestsRequest, parseUnityCliRetrySummary, resolveUnityCliBackendReportPaths, writeNormalizedUnityTestArtifact, type NormalizedUnityTestResult, type UnityRunTestsRequest } from "./src/unity-tests";
+import { validateNormalizedUnityTestArtifact } from "./src/unity-artifact-inspection";
+import { UNITY_TEST_MAX_ARTIFACT_BYTES } from "./src/unity-tests";
 import { auditUnityGuidance, type UnityGuidanceAuditResult } from "./src/unity-guidance-audit";
 import { runUnityPipelineRecompile, runUnityPipelineTests, type UnityPipelineOperationDetails } from "./src/unity-pipeline";
 import {
@@ -82,6 +85,10 @@ type UnityToolDetails = {
   invocation?: UnityBatchmodeInvocation;
   artifacts?: UnityBatchmodeArtifacts;
   parsedTestResults?: UnityParsedTestResults | null;
+  testOutcome?: NormalizedUnityTestResult["outcome"];
+  normalizedResultPath?: string;
+  normalizedResult?: Pick<NormalizedUnityTestResult, "source" | "platform" | "outcome" | "summary"> & { testRecordCount: number };
+  evidenceWarnings?: string[];
   status?: "passed" | "failed" | "killed";
   launcher?: "unity-cli" | "editor-executable";
   cliArgs?: string[];
@@ -103,26 +110,27 @@ 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 CONNECTED_TEST_SELECTOR_GUIDANCE = 'unity_run_tests connected execution supports one testFilters entry OR one testCategories entry per call. For independent, non-overlapping selections, use separate execution: "connected" calls with the same explicit path and platform; await and inspect each passing result before issuing the next. Stop the remaining sequence on failure or uncertainty; never retry, broaden the selection, close the Editor, or switch routes automatically. Do not split a mixed filter/category intersection into separate runs.';
 
 const RUN_TESTS_PARAMS = Type.Object({
   path: Type.Optional(Type.String({ description: "Unity project path, workspace copy root, or folder containing project copies." })),
   testPlatform: StringEnum(["EditMode", "PlayMode"] as const),
-  testFilters: Type.Optional(Type.Array(Type.String(), { maxItems: 50 })),
-  testCategories: Type.Optional(Type.Array(Type.String(), { maxItems: 50 })),
+  testFilters: Type.Optional(Type.Array(Type.String(), { maxItems: 50, description: "Connected: one test-name selector only; omit testCategories. For two independent fixtures, issue serial single-selector calls, inspecting each result first. No semicolon lists. Omitted/empty selectors select all tests, not a repair for rejected filters." })),
+  testCategories: Type.Optional(Type.Array(Type.String(), { maxItems: 50, description: "Connected: one category only; omit testFilters. Multiple categories require separate non-overlapping selections or deliberate isolated execution; never split a filter/category intersection into separate runs." })),
   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 })),
@@ -137,18 +145,6 @@ const RUN_TESTS_PARAMS = Type.Object({
   closeBlockingUnityProcess: Type.Optional(Type.Boolean({ default: false })),
 }, { additionalProperties: false });
 
-const RUN_TEST_BATCH_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." })),
-  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." })),
-});
-
 const PROJECT_STATUS_PARAMS = Type.Object({
   path: Type.Optional(Type.String({ description: "Unity project path, workspace copy root, or folder containing project copies." })),
 });
@@ -190,13 +186,13 @@ const INSPECT_ARTIFACTS_PARAMS = Type.Object({
   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." })),
+  latestFromLogs: Type.Optional(Type.Boolean({ default: true, description: "Only when all artifact paths are omitted, inspect the newest .json, .xml and .log files under Logs. Latest files are not proof of a shared run." })),
   maxLines: Type.Optional(Type.Integer({ minimum: 1, maximum: 500, default: 60, description: "Maximum log/output lines to include." })),
   maxChars: Type.Optional(Type.Integer({ minimum: 500, maximum: 20000, default: 6000, description: "Maximum log/output characters to include." })),
 });
 
 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(
@@ -267,7 +263,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");
 }
 
@@ -331,6 +327,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;
@@ -446,11 +449,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")) {
@@ -599,7 +603,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;
@@ -607,7 +612,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}`,
@@ -656,7 +661,7 @@ async function buildProjectStatusReport(
     details: {
       mode: "status",
       projectRoot: candidate.projectRoot,
-      unityVersion: candidate.unityVersion,
+      unityVersion: await requireManualUnityVersion(candidate),
       editorPath: "",
       warning: combinedWarning,
       status: "passed",
@@ -708,7 +713,8 @@ async function buildArtifactInspectionReport(
   candidate: UnityProjectCandidate,
   params: { testResultsPath?: string; normalizedResultPath?: string; logFilePath?: string; latestFromLogs?: boolean; maxLines?: number; maxChars?: number },
 ): Promise<{ text: string; details: UnityToolDetails }> {
-  const useLatest = params.latestFromLogs !== false;
+  // An exact artifact request must not silently recruit unrelated latest evidence.
+  const useLatest = params.latestFromLogs !== false && ![params.testResultsPath, params.logFilePath, params.normalizedResultPath].some(value => value?.trim());
   const logsRoot = join(candidate.projectRoot, "Logs");
   const testResultsPath = resolveArtifactPath(ctx.cwd, candidate.projectRoot, params.testResultsPath)
     ?? (useLatest ? await findNewestFile(logsRoot, [".xml"]) : undefined);
@@ -716,12 +722,16 @@ async function buildArtifactInspectionReport(
     ?? (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;
+  let normalized: NormalizedUnityTestResult | undefined;
+  const evidenceErrors: string[] = [];
+  const evidenceWarnings: string[] = [];
   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}`; }
+      if ((await stat(normalizedResultPath)).size > UNITY_TEST_MAX_ARTIFACT_BYTES) throw new Error("Normalized artifact exceeds its size limit.");
+      normalized = validateNormalizedUnityTestArtifact(JSON.parse(await readFile(normalizedResultPath, "utf8")));
+    } catch (error) {
+      evidenceErrors.push(`Normalized test result could not be loaded/validated: ${normalizedResultPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
   const invocation: UnityBatchmodeInvocation = {
     isTestRun: Boolean(testResultsPath),
@@ -734,16 +744,51 @@ async function buildArtifactInspectionReport(
   if (testResultsPath && artifacts.testResultsXml && !parsedTestResults) {
     artifacts.warnings.push(`Unity test results XML could not be parsed: ${artifacts.testResultsPath ?? testResultsPath}`);
   }
-  const hasLoadedArtifacts = Boolean(artifacts.testResultsPath || artifacts.logFilePath);
-  const status = deriveUnityArtifactInspectionStatus(hasLoadedArtifacts, invocation, parsedTestResults);
+  if (testResultsPath && !parsedTestResults) evidenceErrors.push(`Requested XML evidence is missing or malformed: ${testResultsPath}`);
+  if (parsedTestResults && hasConflictingUnityXmlTestEvidence(parsedTestResults)) {
+    evidenceErrors.push("Conflicting XML evidence: invalid or inconsistent counts/records.");
+  }
+  if (logFilePath && artifacts.logText === undefined) evidenceErrors.push(`Requested log evidence is missing: ${logFilePath}`);
+  const hasLoadedArtifacts = Boolean(normalized || parsedTestResults || artifacts.logText !== undefined);
+  if (!hasLoadedArtifacts) evidenceErrors.push("No valid Unity artifacts were loaded.");
+  let testOutcome = normalized?.outcome ?? (parsedTestResults ? determineUnityTestOutcome({ ...parsedTestResults, failed: parsedTestResults.failedTests.length > 0 ? Math.max(1, parsedTestResults.failed ?? 0) : parsedTestResults.failed }) : undefined);
+  if (normalized && parsedTestResults) {
+    if (hasConflictingUnityXmlTestEvidence(parsedTestResults, normalized.summary)) evidenceErrors.push("Conflicting normalized/XML evidence: combined counts/records disagree.");
+    for (const key of ["total", "passed", "failed", "skipped", "inconclusive"] as const) {
+      if (normalized.summary[key] !== undefined && parsedTestResults[key] !== undefined && normalized.summary[key] !== parsedTestResults[key]) evidenceErrors.push(`Conflicting normalized/XML evidence: ${key} differs.`);
+    }
+    if ((normalized.outcome === "passed" || normalized.outcome === "passed_with_flakes") && parsedTestResults.failedTests.length > 0) evidenceErrors.push("Conflicting normalized/XML evidence: XML contains failed tests.");
+    const linkedXml = normalized.backendArtifacts?.nunit;
+    if (linkedXml && resolve(candidate.projectRoot, linkedXml) !== resolve(testResultsPath!)) evidenceErrors.push("Conflicting artifact identity: selected XML is not the normalized artifact's nunit path.");
+    if (!linkedXml) {
+      evidenceWarnings.push("Normalized JSON and XML have no shared run identity; matching counts alone do not correlate these files.");
+      testOutcome = "uncertain";
+    }
+  }
+  if (parsedTestResults?.testRecordCounts?.other && (testOutcome === "passed" || testOutcome === "passed_with_flakes")) {
+    evidenceWarnings.push("XML contains test records with unknown outcomes; these are not passing evidence.");
+    testOutcome = "uncertain";
+  }
+  if (useLatest) evidenceWarnings.push("Latest artifact selection does not establish current-run identity; use exact paths for a particular run.");
+  if (evidenceErrors.length) testOutcome = "uncertain";
+  // Inspection succeeded even when valid evidence reports test failure or uncertainty.
+  const status = evidenceErrors.length ? "failed" : "passed";
   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] : []),
+    `Inspection: ${status}. Test outcome: ${testOutcome ?? "not established (log only)"}.`,
+    ...(normalized ? [compactUnityTestSummary(normalized), `Normalized source: ${normalized.source}; selection (bounded): ${summarizeTextForAgent(JSON.stringify(normalized.selection), 1, 2000)}; ${normalized.tests.length} retained test record(s).`] : []),
+    ...evidenceErrors,
+    ...evidenceWarnings,
   ];
 
+  if (normalized) {
+    for (const test of normalized.tests.filter(test => !["passed", "success"].includes(test.status.toLowerCase())).slice(0, 8)) {
+      lines.push(`- ${test.name.slice(0, 1000)}: ${test.status.slice(0, 100)}${test.message ? ` — ${test.message.slice(0, 1000)}` : ""}`);
+    }
+  }
   if (parsedTestResults) {
     lines.push(...formatParsedTestResultsForAgent(parsedTestResults));
   }
@@ -764,12 +809,16 @@ async function buildArtifactInspectionReport(
     details: {
       mode: "artifacts",
       projectRoot: candidate.projectRoot,
-      unityVersion: candidate.unityVersion,
+      unityVersion: await requireManualUnityVersion(candidate),
       editorPath: "",
       invocation,
       artifacts: compactUnityArtifacts(artifacts),
       parsedTestResults,
       status,
+      testOutcome,
+      normalizedResultPath,
+      normalizedResult: normalized ? { source: normalized.source, platform: normalized.platform, outcome: normalized.outcome, summary: { total: normalized.summary.total, passed: normalized.summary.passed, failed: normalized.summary.failed, skipped: normalized.summary.skipped, inconclusive: normalized.summary.inconclusive }, testRecordCount: normalized.tests.length } : undefined,
+      evidenceWarnings,
     },
   };
 }
@@ -782,7 +831,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,
@@ -809,7 +860,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),
@@ -827,7 +878,7 @@ async function buildBatchmodeReport(
     details: {
       mode: "batchmode",
       projectRoot: candidate.projectRoot,
-      unityVersion: candidate.unityVersion,
+      unityVersion: await requireManualUnityVersion(candidate),
       editorPath,
       command: editorPath,
       args,
@@ -936,16 +987,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";
   }
 }
 
@@ -995,16 +1072,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;
@@ -1036,17 +1115,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,
@@ -1123,19 +1199,19 @@ async function runUnifiedUnityTests(
 ): 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, candidate.unityVersion, { signal, execute: createPipelineUnityCliExecutor(pi) });
+  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 (requirements.requiresIsolation) throw new Error(`Connected execution cannot honor this request: ${requirements.reasons.join("; ")}. No tests were dispatched. ${CONNECTED_TEST_SELECTOR_GUIDANCE} Other isolated-only options still require a deliberate isolated-execution decision.`);
     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.`);
+    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. No tests were dispatched. ${CONNECTED_TEST_SELECTOR_GUIDANCE} Other isolated-only options still require a deliberate isolated-execution decision.`);
     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.");
@@ -1144,7 +1220,7 @@ async function runUnifiedUnityTests(
   }
   const formats = request.reportFormats ?? defaultUnityTestReportFormats(route);
   if (route === "connected") {
-    const result = await runUnityPipelineTests({ projectRoot: candidate.projectRoot, unityVersion: candidate.unityVersion, 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 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,
@@ -1153,11 +1229,11 @@ async function runUnifiedUnityTests(
     };
     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: candidate.unityVersion, editorPath: "", status: normalized.outcome === "passed" ? "passed" : "failed", pipeline: result.details, testResult: { ...normalized, tests: [] }, artifactPath, route } };
+    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 = request.isolatedLauncher !== "editor-executable" && await canUseUnityCli(pi, signal);
+  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) {
@@ -1173,7 +1249,7 @@ async function runUnifiedUnityTests(
     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: { nunit: formats.includes("nunit") ? plan.testResultsPath : undefined, junit: formats.includes("junit") ? plan.junitResultsPath : undefined, log: plan.logFilePath }, coverage: request.coverage, coverageOptions: request.coverageOptions, useGraphics: request.useGraphics, timeoutSeconds: request.timeoutSeconds, editorVersion: candidate.unityVersion });
+    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;
@@ -1197,7 +1273,7 @@ async function runUnifiedUnityTests(
     }
     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: candidate.unityVersion, 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 } };
+    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 } };
   });
 }
 
@@ -1309,6 +1385,17 @@ function formatUnityGuidanceAudit(result: UnityGuidanceAuditResult): string {
 }
 
 export default function freeUnityPi(pi: ExtensionAPI) {
+  // Pi's documented tool_result patch marks native failure without discarding the
+  // structured rejection details (throwing from execute retains only error text).
+  // A top-level isError property returned from execute is NOT a native error.
+  pi.on("tool_result", (event) => {
+    const details = event.details as UnityToolDetails | undefined;
+    if ((event.toolName === "unity_pipeline_eval" && details?.mode === "pipeline_eval" && details.pipelineEval?.outcome === "rejected")
+      || (event.toolName === "unity_pipeline_inspect" && details?.mode === "pipeline_inspection" && details.pipelineInspection?.outcome === "rejected")) {
+      return { isError: true };
+    }
+  });
+
   type ScopeRegistrations = Readonly<{
     artifactProfile?: Readonly<{ registry: ScopedRegistryV1; token: RegistrationToken }>;
     fileDiscoveryFilter?: Readonly<{ registry: ScopedRegistryV1; token: RegistrationToken }>;
@@ -1338,6 +1425,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
@@ -1415,14 +1503,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);
@@ -1521,6 +1609,7 @@ export default function freeUnityPi(pi: ExtensionAPI) {
     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.",
+      CONNECTED_TEST_SELECTOR_GUIDANCE,
       "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.",
@@ -1549,13 +1638,13 @@ 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); },
@@ -1580,7 +1669,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,
       }, {
@@ -1597,7 +1686,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,
@@ -1629,7 +1718,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,
       }, {
@@ -1646,7 +1735,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,
@@ -1664,13 +1753,13 @@ export default function freeUnityPi(pi: ExtensionAPI) {
   pi.registerTool({
     name: "unity_inspect_artifacts",
     label: "Unity Inspect Artifacts",
-    description: "Summarize existing Unity log files and Unity Test Framework XML results without launching Unity.",
-    promptSnippet: "Inspect existing Unity logs or test result XML files without launching Unity.",
+    description: "Inspect existing Unity normalized JSON, Test Framework XML and logs without launching Unity. Inspection success is separate from test outcome.",
+    promptSnippet: "Inspect existing Unity normalized test evidence, XML or logs without launching Unity.",
     promptGuidelines: [
       "Use unity_inspect_artifacts after Unity failures when existing -testResults or -logFile artifacts need concise parsing without another Unity launch.",
       "Prefer unity_inspect_artifacts over ad hoc bash parsing of Unity XML/log files when paths are known or Logs/ contains recent artifacts.",
       "unity_inspect_artifacts does not launch Unity and is safe to use even when the Unity project is busy.",
-      "Treat selected test XML as passing evidence only when it is well formed, reports a known positive executed-test count, and reports no failures.",
+      "Inspect details.testOutcome, not inspection status, for test success. Passing evidence needs consistent positive passing counts; missing explicit paths and conflicting artifacts fail inspection. Latest files are not current-run identity.",
     ],
     parameters: INSPECT_ARTIFACTS_PARAMS,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -1715,18 +1804,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);
@@ -1736,7 +1821,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,