@aefree/pi-unity 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project follows semantic versioning for public package releases.
 
 ## Unreleased
 
+## 0.12.1 - 2026-09-10
+
+### Security
+
+- Update the development/test Pi baseline to 0.85.1 and refresh the lockfile to resolve patched `brace-expansion` 5.0.9 and `undici` 8.9.0. Consumer-managed Pi hosts must be updated separately; peer compatibility ranges are unchanged.
+
+### Fixed
+
+- Compare existing Windows project aliases by canonical filesystem path, preventing connected project discovery from treating short paths or junction aliases as a different closed project.
+- Preserve bounded, redacted CLI stdout/stderr on failed Pipeline inspections and evals, including actionable package-version errors; retain native failure, timeout uncertainty and single-dispatch behavior.
+- Clarify connected single-selector arguments and pre-dispatch rejection recipes; document serial independent-fixture calls with stop-on-uncertainty boundaries, backed by offline registered-tool contract tests (not model-planning or live-Editor evidence).
+- Validate normalized JSON test artifacts as standalone inspection evidence, separate inspection success from test outcome, and reject missing explicit paths or conflicting artifacts without substituting unrelated latest logs.
+- Mark rejected Pipeline eval and inspection as native Pi tool failures while retaining structured diagnostics and uncertain post-dispatch effects, without retry or fallback.
+- Reject contradictory combined XML counters and test-record evidence during artifact inspection, including self-closing failures and records beyond the display limit; keep skipped and inconclusive counters distinct and preserve valid partial records.
+
 ## 0.12.0 - 2026-08-27
 
 ### Changed

package/README.md

@@ -45,7 +45,9 @@ A timeout is uncertain: work may still be running. The tools do not silently can
 
 - `unity_open_editor` — open the Unity Editor GUI. Pass `automated: true` to add the Unity Editor `-automated` flag; this is distinct from the Unity CLI's own `--non-interactive` option.
 - `unity_launch_batchmode` — run a bounded batchmode command through Unity CLI or the direct Editor executable.
-- `unity_inspect_artifacts` — summarize existing Unity Test Framework XML and Unity logs without launching Unity.
+- `unity_inspect_artifacts` — validate existing normalized JSON test artifacts, Unity Test Framework XML and Unity logs without launching Unity. `details.status` describes inspection; `details.testOutcome` describes the tests, including failures and uncertainty. A valid failed-test artifact is a successful inspection, not a passing run.
+
+Pass `normalizedResultPath` for standalone JSON evidence. Any explicit artifact path disables implicit latest-file selection; missing requested files fail inspection. With all paths omitted, `latestFromLogs` discovers recent files but cannot establish current-run identity. Mixed JSON/XML evidence must agree; without an explicit native artifact link, matching counts alone leave correlation uncertain.
 
 Use `unity_run_tests` for all ordinary Unity Test Framework work. It writes a durable normalized JSON result under `Logs/`; isolated `unity test` runs retain requested native reports. Connected Pipeline is selected only for compatible requests. A reachable Editor is never closed automatically to obtain isolated-only features.
 
@@ -95,7 +97,7 @@ The connected compile and test tools:
 - poll internally with fixed deadlines and bounded backoff;
 - reject malformed or semantically failing nested results;
 - require a known positive test count and zero failures before reporting a pass;
-- discard passing-test records while retaining bounded failure diagnostics;
+- keep routine tool output compact while preserving connected test records in durable normalized JSON evidence;
 - detect pre-existing or clearly displaced test runs when available correlation fields permit it.
 
 Another connected client is not a project lock. When Pipeline returns stable correlation fields, conflicting status is reported as displaced and uncertain. If Pipeline omits stable run identity, a competing same-mode, same-filter run may be indistinguishable from the requested run; the tool cannot prove exclusive ownership from shared Editor status alone.
@@ -111,6 +113,8 @@ Another connected client is not a project lock. When Pipeline returns stable cor
 
 Use `unity_pipeline_inspect` when a purpose-built structured command fits. Use eval for bounded project-specific work that matches the user's intent. Prefer typed tools when they provide stronger lifecycle, polling, validation, or recovery semantics.
 
+Rejected eval and inspection results are native Pi tool failures (`isError: true`) via the documented `tool_result` middleware, with structured rejection codes and bounded diagnostics retained. Pre-dispatch rejection does not execute the command; a timeout or dispatch failure can leave effects uncertain and never triggers retry or fallback.
+
 ## Launch and process safeguards
 
 `unity_open_editor` and batchmode tools treat Unity CLI as the authoritative launcher: `unity open`, `unity run`, and `unity test` receive only the selected project and let Unity CLI read `ProjectVersion.txt`. The direct Editor executable is an exceptional compatibility fallback used only when Unity CLI is unavailable. Set `launcher` to `auto`, `unity-cli`, or `editor-executable` when explicit routing is needed.

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,
@@ -29,6 +29,8 @@ import { assertUnityProjectNotBusy, evaluateUnityLaunchSafety, getUnityNativeLoc
 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 { 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 {
@@ -83,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[];
@@ -118,11 +124,13 @@ const LAUNCH_BATCHMODE_PARAMS = Type.Object({
   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 })),
@@ -178,7 +186,7 @@ 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." })),
 });
@@ -705,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);
@@ -713,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),
@@ -731,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)}; 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));
   }
@@ -767,6 +815,10 @@ async function buildArtifactInspectionReport(
       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,
     },
   };
 }
@@ -1152,14 +1204,14 @@ async function runUnifiedUnityTests(
   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.");
@@ -1333,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 }>;
@@ -1546,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.",
@@ -1689,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aefree/pi-unity",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "type": "module",
   "exports": {
     ".": "./index.ts"
@@ -25,11 +25,11 @@
     "typebox": "1.3.8"
   },
   "peerDependencies": {
+    "@aefree/pi-file-discovery": "^0.1.0",
+    "@aefree/pi-project-artifacts": "^0.1.0",
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
-    "@aefree/pi-project-artifacts": "^0.1.0",
-    "@aefree/pi-file-discovery": "^0.1.0"
+    "@earendil-works/pi-tui": "*"
   },
   "engines": {
     "node": ">=22.19.0"
@@ -48,11 +48,11 @@
   },
   "homepage": "https://github.com/aefreedman/pi-unity#readme",
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.83.0",
-    "@earendil-works/pi-coding-agent": "0.83.0",
-    "@earendil-works/pi-tui": "0.83.0",
-    "@aefree/pi-project-artifacts": "^0.1.0",
     "@aefree/pi-file-discovery": "^0.1.0",
+    "@aefree/pi-project-artifacts": "^0.1.0",
+    "@earendil-works/pi-ai": "0.85.1",
+    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-tui": "0.85.1",
     "tsx": "^4.23.5"
   },
   "peerDependenciesMeta": {

package/skills/unity-pipeline-workflows/SKILL.md

@@ -41,12 +41,30 @@ Call `unity_run_tests` with:
 
 The tool treats `no_tests`, idle, and not-started statuses as safe inactivity, detects a pre-existing active connected test before dispatch, and stops rather than claiming or replacing active work. It captures returned mode/filter/run identity fields when available and stops as uncertain if status is clearly displaced by another run.
 
+### Two independent fixtures in an open Editor
+
+Keep the Editor open. For an authorized request for two known non-overlapping fixtures, use the same explicit exact-copy `path` and platform, one selector per call. For example, replace `./SyntheticGame` with the selected project path and issue this `unity_run_tests` call:
+
+```json
+{"path":"./SyntheticGame","testPlatform":"EditMode","execution":"connected","testFilters":["Synthetic.InventoryFixture"]}
+```
+
+Await the completed tool result and inspect its outcome and exact normalized artifact path. Only after a passing result, issue the second call (not in parallel or pre-queued in the same turn):
+
+```json
+{"path":"./SyntheticGame","testPlatform":"EditMode","execution":"connected","testFilters":["Synthetic.DialogueFixture"]}
+```
+
+Stop the remaining sequence on failure, timeout, cancellation, malformed evidence, displaced identity, or any uncertainty; report the first result and the remaining fixture as not run. Do not retry, close the Editor, switch to isolated execution, or broaden to a parent suite/category or empty selectors. Empty/omitted selectors select all tests. Keep each result's artifact separately; do not treat one fixture's evidence as covering the other.
+
+For a single category use `testCategories: ["SyntheticCategory"]` and omit `testFilters`. Never combine the two families or join selectors with semicolons. Multiple-selector rejection means no test was dispatched: use the serial recipe only for independent, non-overlapping selections without other isolated-only requirements. If overlap or intended filter/category intersection semantics are unclear, stop for clarification rather than split, duplicate, or broaden tests. Required XML, retries, coverage, or other isolated-only options still need a deliberate isolation decision, not argument stripping.
+
 ## Bounded raw CLI troubleshooting only
 
 Normally call the typed tools, not raw CLI commands. If a typed tool is unavailable in an older installed package and a user specifically authorizes troubleshooting, first use `unity_project_status` and require advertised `recompile_status` or `run_tests` and `test_status`. Use the documented asynchronous form with `--async_tests true`, one fixed deadline, and bounded backoff; parse object and stringified nested JSON. `Total: 0` with `result: running` is a valid nonterminal initiating response. Passing evidence reports successful completion, a known positive executed-test count, and zero failures; nested `success:false`, changed exact-copy identity, or polling timeout is non-passing uncertainty. Do not silently fall back to batchmode after uncertain connected dispatch. Connected work does not guarantee NUnit XML.
 
 ## When not to use connected tools
 
-Use `unity_run_tests` with `execution: "isolated"` for a closed project, intentional isolation/CI, multiple selectors, retries, sharding, coverage, or required NUnit/JUnit evidence. A single category is supported connected when Pipeline advertises the command; do not claim broader connected selector support. Do not use batchmode as an automatic fallback after an uncertain connected dispatch.
+Use `unity_run_tests` with `execution: "isolated"` for a closed project, intentional isolation/CI, multiple selectors in one run, retries, sharding, coverage, or required NUnit/JUnit evidence. Multiple independent fixtures alone do not require closing a reachable Editor: use the serial recipe above. A single category is supported connected when Pipeline advertises the command; do not claim broader connected selector support. Do not use batchmode as an automatic fallback after an uncertain connected dispatch.
 
 Use the typed compile/test tools when their polling and terminal evidence fit the task. Advertised Pipeline `eval` remains available through `unity_pipeline_eval` for bounded project-specific inspection or operations outside those typed workflows; its `timeoutSeconds` range is 1–86,400 seconds, and a timeout remains uncertain without cancellation or retry. It is an assistance surface, not a forbidden fallback or a substitute for the typed tools' completion protocol. Eval compiles arbitrary C# with Roslyn on the Editor main thread, so ordinary properties and local-variable snippets are valid; it is not expression-only or reliably statically read-only. Prefer typed tools for their stronger evidence, but let user intent and project guidance govern mutations. Lifecycle, persistent-setting, destructive, asset, scene-save, package, build, and test mutations require explicit authorization.

package/src/unity-artifact-inspection.ts

@@ -0,0 +1,59 @@
+import { isAbsolute } from "node:path";
+import { determineUnityTestOutcome, type NormalizedUnityTestResult } from "./unity-tests";
+
+const outcomes = ["passed", "passed_with_flakes", "tests_failed", "empty_selection", "run_error", "timed_out", "cancelled", "uncertain"];
+const record = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value);
+const nonnegative = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value >= 0;
+const count = (value: unknown): value is number => nonnegative(value) && Number.isSafeInteger(value);
+const strings = (value: unknown): value is string[] => Array.isArray(value) && value.every(item => typeof item === "string" && !!item.trim() && !/[\0\r\n;]/.test(item));
+const relativeId = (value: unknown): value is string => typeof value === "string" && !!value.trim()
+  && !isAbsolute(value) && !/^(?:[A-Za-z]:|[\\/])/.test(value) && !value.split(/[\\/]/).includes("..") && !/\0/.test(value);
+
+/** Read the durable schema, not a transport response. Missing optional counts remain unknown.
+ * Test records may be bounded or absent: never require tests.length === summary.total.
+ */
+export function validateNormalizedUnityTestArtifact(value: unknown): NormalizedUnityTestResult {
+  const invalid = (reason: string): never => { throw new Error(`Invalid normalized Unity test artifact: ${reason}.`); };
+  if (!record(value) || value.schemaVersion !== 1) invalid("expected schemaVersion 1 object");
+  const result = value as Record<string, unknown>;
+  if (!["pipeline", "unity-cli", "editor-executable"].includes(result.source as string)) invalid("unsupported source");
+  if (!["EditMode", "PlayMode"].includes(result.platform as string)) invalid("unsupported platform");
+  if (!outcomes.includes(result.outcome as string)) invalid("unsupported outcome");
+  if (!record(result.selection) || !strings(result.selection.testFilters) || !strings(result.selection.testCategories)) invalid("selection must contain testFilters and testCategories arrays");
+  if (!record(result.summary)) invalid("summary must be an object");
+  const summary = result.summary as Record<string, unknown>;
+  for (const key of ["total", "passed", "failed", "skipped", "inconclusive"]) {
+    if (summary[key] !== undefined && !count(summary[key])) invalid(`summary.${key} must be a non-negative integer`);
+  }
+  if (count(summary.total)) {
+    const accounted = [summary.passed, summary.failed, summary.skipped, summary.inconclusive].reduce<number>((sum, item) => sum + (count(item) ? item : 0), 0);
+    if (accounted > summary.total) invalid("summary counts exceed total");
+  }
+  if (!Array.isArray(result.tests)) invalid("tests must be an array");
+  const tests = result.tests as unknown[];
+  for (const test of tests) {
+    if (!record(test) || typeof test.name !== "string" || !test.name.trim() || typeof test.status !== "string" || !test.status.trim()) invalid("test records require name and status");
+    const item = test as Record<string, unknown>;
+    for (const key of ["message", "stackTrace"]) if (item[key] !== undefined && typeof item[key] !== "string") invalid(`test ${key} must be a string`);
+    if (item.durationSeconds !== undefined && !nonnegative(item.durationSeconds)) invalid("test durationSeconds must be non-negative");
+    if (item.attempts !== undefined && (!count(item.attempts) || item.attempts < 1)) invalid("test attempts must be positive");
+  }
+  if (count(summary.total) && tests.length > summary.total) invalid("test records exceed total");
+  const typed = result as unknown as NormalizedUnityTestResult;
+  for (const [status, key] of [["passed", "passed"], ["failed", "failed"], ["skipped", "skipped"], ["inconclusive", "inconclusive"]] as const) {
+    const observed = typed.tests.filter(test => test.status.toLowerCase() === status).length;
+    if (count(summary[key]) && observed > summary[key]) invalid(`test records conflict with summary.${key}`);
+  }
+  if (result.projectRelativeId !== undefined && !relativeId(result.projectRelativeId)) invalid("projectRelativeId must be project-relative");
+  if (result.backendArtifacts !== undefined && (!record(result.backendArtifacts) || !Object.values(result.backendArtifacts).every(relativeId))) invalid("backendArtifacts must contain project-relative paths");
+  for (const key of ["startedAt", "completedAt"]) if (result[key] !== undefined && (typeof result[key] !== "string" || !Number.isFinite(Date.parse(result[key] as string)))) invalid(`${key} must be a timestamp`);
+  if (typed.startedAt && typed.completedAt && Date.parse(typed.completedAt) < Date.parse(typed.startedAt)) invalid("completion precedes start");
+  if (result.durationSeconds !== undefined && !nonnegative(result.durationSeconds)) invalid("durationSeconds must be non-negative");
+  if (result.flakyTests !== undefined && (!Array.isArray(result.flakyTests) || !result.flakyTests.every(item => record(item) && typeof item.name === "string" && !!item.name.trim() && count(item.attempts) && item.attempts > 0))) invalid("invalid flakyTests");
+  if (result.outcome === "passed" || result.outcome === "passed_with_flakes") {
+    if (determineUnityTestOutcome(typed.summary) !== "passed" || typed.tests.some(test => !["passed", "success"].includes(test.status.toLowerCase()))) invalid("passing outcome lacks consistent positive passing counts/records");
+    if (result.outcome === "passed_with_flakes" && !typed.flakyTests?.length) invalid("passed_with_flakes requires flakyTests evidence");
+  }
+  if (result.outcome === "empty_selection" && ((typed.summary.total ?? 0) > 0 || tests.length > 0)) invalid("empty selection conflicts with executed tests");
+  return typed;
+}

package/src/unity-batchmode.ts

@@ -29,6 +29,8 @@ export type UnityParsedTestResults = {
   failedTests: UnityFailedTest[];
   /** Complete bounded per-test evidence for normalized artifacts, never routine tool output. */
   tests: UnityParsedTestCase[];
+  /** Observed XML record lower bounds, counted before record output is truncated. */
+  testRecordCounts?: { total: number; passed: number; failed: number; skipped: number; inconclusive: number; other: number };
 };
 
 export type UnityBatchmodeArtifacts = {
@@ -82,10 +84,10 @@ function decodeXmlText(value: string | undefined): string | undefined {
 
 function parseAttributes(tagSource: string): Record<string, string> {
   const attributes: Record<string, string> = {};
-  const attributeRegex = /(\w[\w:-]*)\s*=\s*"([^"]*)"/g;
+  const attributeRegex = /(\w[\w:-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
   for (const match of tagSource.matchAll(attributeRegex)) {
     const key = match[1];
-    const value = match[2] ?? "";
+    const value = match[2] ?? match[3] ?? "";
     attributes[key] = value;
   }
   return attributes;
@@ -102,6 +104,12 @@ function parseOptionalNumber(value: string | undefined): number | undefined {
   return Number.isFinite(parsed) ? parsed : undefined;
 }
 
+function parseTestCount(value: string | undefined): number | undefined {
+  // Only omission is unknown. Retain invalid supplied counters as NaN so the
+  // inspection validator rejects them instead of silently treating them as absent.
+  return value === undefined ? undefined : value.trim() ? Number(value) : Number.NaN;
+}
+
 export function parseUnityTestResultsXml(xml: string): UnityParsedTestResults | null {
   const testRunMatch = xml.match(/<test-run\b([^>]*)>/i);
   const testRunCloseIndex = xml.search(/<\/test-run\s*>/i);
@@ -112,33 +120,43 @@ export function parseUnityTestResultsXml(xml: string): UnityParsedTestResults |
   const rootAttributes = parseAttributes(testRunMatch[1] ?? "");
   const failedTests: UnityFailedTest[] = [];
   const tests: UnityParsedTestCase[] = [];
+  const testRecordCounts = { total: 0, passed: 0, failed: 0, skipped: 0, inconclusive: 0, other: 0 };
 
-  const testCaseRegex = /<test-case\b([^>]*)>([\s\S]*?)<\/test-case>/gi;
+  // Match the self-closing alternative first so it cannot consume the body of
+  // the next paired record. Both forms carry authoritative failure evidence.
+  const testCaseRegex = /<test-case\b([^>]*?)(?:\/\s*>|>([\s\S]*?)<\/test-case\s*>)/gi;
   for (const match of xml.matchAll(testCaseRegex)) {
     const attributes = parseAttributes(match[1] ?? "");
     const body = match[2] ?? "";
     const result = String(attributes.result ?? attributes.label ?? "").toLowerCase();
     const success = String(attributes.success ?? "").toLowerCase();
     const isFailure = result === "failed" || success === "false";
+    const status = isFailure ? "Failed" : attributes.result ?? attributes.label ?? "Unknown";
+    const statusKey = isFailure ? "failed" : result === "passed" || result === "success" ? "passed" : result === "skipped" ? "skipped" : result === "inconclusive" ? "inconclusive" : "other";
+    testRecordCounts.total++;
+    testRecordCounts[statusKey]++;
     const failureMessage = body.match(/<message[^>]*>([\s\S]*?)<\/message>/i);
     const stackTrace = body.match(/<stack-trace[^>]*>([\s\S]*?)<\/stack-trace>/i);
     const name = truncateEvidence(attributes.fullname ?? attributes.name ?? "(unknown test)", 1_000) ?? "(unknown test)";
-    if (tests.length < 2_000) tests.push({ name, status: attributes.result ?? attributes.label ?? "Unknown", ...(parseOptionalNumber(attributes.duration) === undefined ? {} : { durationSeconds: parseOptionalNumber(attributes.duration) }), ...(truncateEvidence(decodeXmlText(failureMessage?.[1]), 4_000) ? { message: truncateEvidence(decodeXmlText(failureMessage?.[1]), 4_000) } : {}), ...(truncateEvidence(decodeXmlText(stackTrace?.[1]), 8_000) ? { stackTrace: truncateEvidence(decodeXmlText(stackTrace?.[1]), 8_000) } : {}) });
+    if (tests.length < 2_000) tests.push({ name, status, ...(parseOptionalNumber(attributes.duration) === undefined ? {} : { durationSeconds: parseOptionalNumber(attributes.duration) }), ...(truncateEvidence(decodeXmlText(failureMessage?.[1]), 4_000) ? { message: truncateEvidence(decodeXmlText(failureMessage?.[1]), 4_000) } : {}), ...(truncateEvidence(decodeXmlText(stackTrace?.[1]), 8_000) ? { stackTrace: truncateEvidence(decodeXmlText(stackTrace?.[1]), 8_000) } : {}) });
     if (!isFailure) continue;
     if (failedTests.length < 50) failedTests.push({ name, message: truncateEvidence(decodeXmlText(failureMessage?.[1]), 1_000), stackTrace: truncateEvidence(decodeXmlText(stackTrace?.[1]), 4_000) });
   }
 
-  const skipped = parseOptionalNumber(rootAttributes.skipped) ?? parseOptionalNumber(rootAttributes.inconclusive);
+  // These are separate counters. Synthesizing skipped from inconclusive makes
+  // combined-count validation double-count one observed category.
+  const skipped = parseTestCount(rootAttributes.skipped);
 
   const parsed: UnityParsedTestResults = {
-    total: parseOptionalNumber(rootAttributes.total) ?? parseOptionalNumber(rootAttributes.testcasecount),
-    passed: parseOptionalNumber(rootAttributes.passed),
-    failed: parseOptionalNumber(rootAttributes.failed),
+    total: parseTestCount(rootAttributes.total) ?? parseTestCount(rootAttributes.testcasecount),
+    passed: parseTestCount(rootAttributes.passed),
+    failed: parseTestCount(rootAttributes.failed),
     skipped,
-    inconclusive: parseOptionalNumber(rootAttributes.inconclusive),
+    inconclusive: parseTestCount(rootAttributes.inconclusive),
     durationSeconds: parseOptionalNumber(rootAttributes.duration),
     failedTests,
     tests,
+    testRecordCounts,
   };
   if (parsed.total === undefined && parsed.passed === undefined && parsed.failed === undefined && parsed.failedTests.length === 0) {
     return null;
@@ -146,6 +164,23 @@ export function parseUnityTestResultsXml(xml: string): UnityParsedTestResults |
   return parsed;
 }
 
+/** Missing counters and omitted/bounded records are unknown, not zero executions.
+ * Supplied counters and observed record lower bounds must nevertheless agree.
+ * An optional linked summary can fill missing XML counters, not replace them.
+ */
+export function hasConflictingUnityXmlTestEvidence(
+  results: UnityParsedTestResults,
+  linkedSummary?: Pick<UnityParsedTestResults, "total" | "passed" | "failed" | "skipped" | "inconclusive">,
+): boolean {
+  const keys = ["total", "passed", "failed", "skipped", "inconclusive"] as const;
+  const counts = Object.fromEntries(keys.map(key => [key, results[key] ?? linkedSummary?.[key]])) as Pick<UnityParsedTestResults, typeof keys[number]>;
+  if (keys.some(key => counts[key] !== undefined && (!Number.isSafeInteger(counts[key]) || counts[key]! < 0))) return true;
+  const observed = results.testRecordCounts;
+  if (keys.some(key => counts[key] !== undefined && (observed?.[key] ?? 0) > counts[key]!)) return true;
+  const accounted = keys.slice(1).reduce((sum, key) => sum + Math.max(counts[key] ?? 0, observed?.[key] ?? 0), 0);
+  return counts.total !== undefined && accounted > counts.total;
+}
+
 function buildArtifactCandidates(cwd: string, projectRoot: string, rawPath: string): string[] {
   if (path.isAbsolute(rawPath)) {
     return [path.normalize(rawPath)];

package/src/unity-cli.ts

@@ -647,11 +647,11 @@ export async function dispatchUnityPlanningInspection(
     ...(isEval ? [request.evalSnippet!.trim()] : request.args ?? []),
   ];
   const execution = await options.execute(command, args, { timeout: options.timeout ?? UNITY_CLI_DISCOVERY_TIMEOUT_MS, signal: options.signal });
+  const raw = [execution.stdout, execution.stderr].filter(Boolean).join("\n");
+  const output = summarizeUnityCliText(redactUnityPlanningOutput(raw), 4_000, 40);
   if (execution.error) {
-    return { outcome: "rejected", code: isUnityCliTimeout(execution) ? "planning_command_timeout" : "planning_command_failed", message: "Connected command did not complete successfully; its effect may be uncertain." };
+    return { outcome: "rejected", code: isUnityCliTimeout(execution) ? "planning_command_timeout" : "planning_command_failed", message: `Connected command did not complete successfully; its effect may be uncertain.${output ? ` ${output}` : ""}` };
   }
-  const raw = [execution.stdout, execution.stderr].filter(Boolean).join("\n");
-  const output = redactUnityPlanningOutput(summarizeUnityCliText(raw, 4_000, 40));
   const reportedFailure = connectedCommandFailure(execution.stdout, isEval);
   if (reportedFailure) {
     return {

package/src/unity-core.ts

@@ -104,8 +104,8 @@ export function normalizeForCommandSearch(value: string, platform: SupportedPlat
   return platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
-function realpathMatchesOnDarwin(candidatePath: string, projectRoot: string, platform: SupportedPlatform): boolean | null {
-  if (platform !== "darwin" || process.platform !== "darwin") {
+function realpathMatchesOnNativePlatform(candidatePath: string, projectRoot: string, platform: SupportedPlatform): boolean | null {
+  if ((platform !== "darwin" && platform !== "win32") || process.platform !== platform) {
     return null;
   }
 
@@ -113,7 +113,7 @@ function realpathMatchesOnDarwin(candidatePath: string, projectRoot: string, pla
     return realpathSync.native(candidatePath) === realpathSync.native(projectRoot);
   } catch {
     // Only use filesystem identity when both paths can be resolved. Falling back
-    // to the case-sensitive textual comparison preserves case-sensitive APFS.
+    // to the platform-specific textual comparison preserves existing behavior.
     return null;
   }
 }
@@ -130,7 +130,7 @@ export function projectPathsMatch(candidatePath: string, projectRoot: string, pl
     return false;
   }
 
-  const realpathMatch = realpathMatchesOnDarwin(trimmedCandidatePath, trimmedProjectRoot, comparisonPlatform);
+  const realpathMatch = realpathMatchesOnNativePlatform(trimmedCandidatePath, trimmedProjectRoot, comparisonPlatform);
   if (realpathMatch !== null) {
     return realpathMatch;
   }