fix(stage1): five review defects in identity, classification and PS semantics

Verified each against primary source before touching it; all five were real.

D1 — a relative OWEN_RUST_CORE was accepted by all three independent
implementations. `Path.GetFullPath` reads as "it resolves the path for me",
and it does: against whatever directory Owen happened to run in, so the same
configuration would select different binaries from different places. That is
the ambient resolution D3 exists to forbid. Now rejected up front, exit 2,
naming the requirement. The shell test accepts the absolute forms this surface
actually receives — the MSYS `/d/a/...` CI passes, `C:\...`, `C:/...`, UNC —
because a bare `/*` glob would turn a correct Windows configuration into a
usage error; it converts between none of them, as D3 ratified a locator and
not a path-translation policy. action.yml is not a fourth implementation: it
delegates, and the control proves the forwarding.

D2 — the compare verdict was inferred as `childExitCode is null && py is not
null && rs is not null ? "divergence" : "execution-failure"`. `child_exit_code`
is the D5 RUST-child carrier, so a Python-only bad exit left it null with both
outcomes present and stamped "divergence" onto evidence whose own diagnostic
beside it said "execution failure". The classification is now passed by the
call site, which is the only place that knows. The external vocabulary is
unchanged — agreement / divergence / execution-failure — because a new
serialized value is a contract the project would owe support for forever.

D3 — own-check.ps1 never mapped a spawn failure to exit 2, and its comment
asserted the opposite of D3.1 ("maps to the internal-error path"). A candidate
that never started is on the locator's side of the seam. Both engine paths now
catch it, and the comment says what the code does.

D4 — ps1 agreement replayed through `Get-Content -Raw | Write-Output`, a
decode-and-re-encode, and emitted no stderr at all. It now replays the
reference's raw bytes on both streams, as C# and own-check.sh do. Implemented
for the contract, not for today's statistics: CRLF-vs-LF makes agreement rare
on Windows now, but a replay that is wrong only when it finally runs is worse
than none.

D5 — ps1 named $cmpDir as reproduction evidence and then deleted it in
`finally`. Pointing a reader at a path and shredding it on the way out is
worse than naming nothing. The directory now survives an execution failure,
as it already did a divergence.

A SIXTH defect, found while proving D4 and fixed with it: `Start-Process
-RedirectStandardOutput` is not byte-faithful. Measured on one input, the
Python reference wrote 211 bytes and the redirected file held 210 — a blank
line silently dropped. Compare claims the engines' public BYTES are identical,
so a lossy capture of the reference can manufacture a divergence that does not
exist or hide one that does; an agreement reached over a corrupted capture is
not an agreement. ps1 now drains both pipes as byte streams, concurrently, the
way the C# launcher does. Fixing only the replay would have left the mechanism
broken underneath it.

Evidence. `tests/helpers/stage1_stub.rs` is a committed, controllable native
candidate compiled with plain `rustc` — no cargo crate, so #261's crate-edge
DAG gate is untouched. It replaces the shebang stubs, which were Unix-only and
had forced four compare controls to be declared not-applicable on Windows: that
gap is why three PowerShell defects survived a 16/16 campaign. All seventeen
shared controls now run on both platforms with zero N/A, and
`tests/test_stage1_ps1.py` adds the PowerShell surface to the adversarial set.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CYLNQy6tLXqsV1CbuNqsSb

Author: claude

.github/workflows/ci.yml

@@ -154,6 +154,14 @@ jobs:
       - name: Build the fault-injection own-cli (forced failure modes)
         working-directory: rust
         run: cargo build -p own-cli --release --features fault-injection --target-dir target-fault
+      # The controllable native candidate the compare controls need. Built
+      # with plain `rustc`, deliberately NOT as a cargo workspace member, so it
+      # cannot move the crate-edge DAG that #261's gate pins.
+      - name: Build the Stage-1 stub candidate
+        run: |
+          ext=""
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then ext=".exe"; fi
+          rustc -O tests/helpers/stage1_stub.rs -o "$RUNNER_TEMP/stage1-stub$ext"
       - name: Build the owen launcher
         run: dotnet build frontend/roslyn/OwnSharp.Cli/OwnSharp.Cli.csproj -c Release --nologo
       # The vendored Python core is a PACK-time payload, so a plain build does
@@ -164,16 +172,30 @@ jobs:
           out=frontend/roslyn/OwnSharp.Cli/bin/Release/net8.0
           mkdir -p "$out/ownlang-core/ownlang"
           cp ownlang/*.py "$out/ownlang-core/ownlang/"
-      - name: Stage-1 engine controls (all fifteen, no fail-fast)
+      - name: Stage-1 engine controls (no fail-fast)
         env:
           OWEN_STAGE1_REQUIRE: "1"
         run: |
           ext=""
           if [ "${{ matrix.os }}" = "windows-latest" ]; then ext=".exe"; fi
           export OWEN_RUST_CORE="$PWD/rust/target/release/own-cli$ext"
           export OWEN_STAGE1_RUST_FAULT="$PWD/rust/target-fault/release/own-cli$ext"
+          export OWEN_STAGE1_STUB="$RUNNER_TEMP/stage1-stub$ext"
           export OWEN_STAGE1_LAUNCHER_DLL="$PWD/frontend/roslyn/OwnSharp.Cli/bin/Release/net8.0/ownsharp.dll"
           python tests/test_stage1_engine.py
+      # The PowerShell surface's own controls. They run on BOTH legs — the
+      # logic is platform-neutral and a Linux run catches regressions early —
+      # but only the Windows leg is evidence for a PowerShell-targeted
+      # mutation, which is what the stage1-ps1-mutations job below settles.
+      - name: Stage-1 PowerShell controls
+        env:
+          OWEN_STAGE1_REQUIRE: "1"
+        run: |
+          ext=""
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then ext=".exe"; fi
+          export OWEN_RUST_CORE="$PWD/rust/target/release/own-cli$ext"
+          export OWEN_STAGE1_STUB="$RUNNER_TEMP/stage1-stub$ext"
+          python tests/test_stage1_ps1.py
       # The explicit Rust-selected run on this platform, through the shell
       # launcher, recorded as its own step so the evidence names the surface
       # and the platform rather than being inferred from a green job.
@@ -225,6 +247,75 @@ jobs:
           # require.
           exit 0
 
+  # P-022 step 8 (#262) Stage 1 — the WINDOWS-NATIVE mutation leg.
+  #
+  # A mutation whose target is scripts/own-check.ps1 is only `caught` when a
+  # Windows PowerShell catcher observes the mutant and fails. Running those
+  # mutants on Linux would execute the mutated PowerShell under a different
+  # runtime, and the Windows-specific halves — the spawn seam above all —
+  # cannot be settled there at all: a mutant that runs where its control is
+  # weakest is decorative, and proves nothing about the surface it edits.
+  #
+  # So this campaign runs here, on Windows, and this job is the gate. It fails
+  # unless every mutation is caught with its expected catcher and the
+  # honesty control survives the unmutated tree.
+  stage1-ps1-mutations:
+    name: own-check.ps1 mutation campaign (Windows-native)
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4
+        with:
+          dotnet-version: "8.0.x"
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5
+        with:
+          python-version: "3.13"
+      - uses: dtolnay/rust-toolchain@fa04a1451ff1842e2626ccb99004d0195b455a88 # master, 2026-07-10
+        with:
+          toolchain: stable
+      - name: Build the production own-cli candidate
+        working-directory: rust
+        run: cargo build -p own-cli --release
+      - name: Build the Stage-1 stub candidate
+        run: rustc -O tests/helpers/stage1_stub.rs -o "$RUNNER_TEMP/stage1-stub.exe"
+      - name: Run the PowerShell mutation campaign
+        env:
+          OWEN_STAGE1_REQUIRE: "1"
+        run: |
+          export OWEN_RUST_CORE="$PWD/rust/target/release/own-cli.exe"
+          export OWEN_STAGE1_STUB="$RUNNER_TEMP/stage1-stub.exe"
+          python scripts/mutate_campaign.py --campaign docs/evidence/p022-stage1-ps1.json --run
+      # The recorded run, printed in full so its provenance and per-mutation
+      # catchers can be read off this job rather than taken on trust — and so
+      # the committed record can be reproduced from a named CI run, the way
+      # #260's sweep record is.
+      - name: Print the recorded result
+        if: always()
+        run: cat docs/evidence/p022-stage1-ps1.result.json
+      - name: Assert every mutation was caught by a Windows catcher
+        run: |
+          python - <<'PY'
+          import json, sys
+          d = json.load(open("docs/evidence/p022-stage1-ps1.result.json", encoding="utf-8"))
+          defn = json.load(open("docs/evidence/p022-stage1-ps1.json", encoding="utf-8"))
+          exp = {m["id"]: set(m["expected_catchers"]) for m in defn["mutations"]}
+          problems = []
+          if d["control"]["outcome"] != "survived":
+              problems.append("the honesty control did not survive the unmutated tree")
+          for m in d["mutations"]:
+              if m["outcome"] != "caught":
+                  problems.append(f"{m['id']}: {m['outcome']}")
+              elif not exp[m["id"]] <= set(m["catchers"]):
+                  problems.append(f"{m['id']}: expected catchers missed ({m['catchers']})")
+              elif not any(c.startswith("ps1::") for c in m["catchers"]):
+                  problems.append(f"{m['id']}: no PowerShell catcher observed it")
+          print("\n".join(problems) if problems else "every ps1 mutation caught by a Windows catcher")
+          sys.exit(1 if problems else 0)
+          PY
+
   # P-022 step 7a (#260) — COMPARE MODE over the committed corpus: the FAST half
   # of #260's test matrix, and one leg of it. The five pinned OSS repositories,
   # the large-solution controls and the examples tree are the scheduled/manual

docs/evidence/p022-stage1-1.json

@@ -126,8 +126,8 @@
       "rule": "divergence-is-5",
       "description": "a divergence exposes the reference's result — 'Python is still the reference, so trust it' read as a licence to answer while the two engines disagree",
       "target": "frontend/roslyn/OwnSharp.Cli/CompareMode.cs",
-      "pattern": "                return Fail\\(args, rust, py, rs,\\n                    \\$\\\"engine divergence",
-      "replacement": "                await ReplayAsync(py).ConfigureAwait(false);\n                return failOnFinding ? py.Rc : (py.Rc >= 2 ? py.Rc : 0);\n#pragma warning disable CS0162\n                return Fail(args, rust, py, rs,\n                    $\"engine divergence",
+      "pattern": "                return Fail\\(args, rust, py, rs, Divergence,\\n                    \\$\\\"engine divergence",
+      "replacement": "                await ReplayAsync(py).ConfigureAwait(false);\n                return failOnFinding ? py.Rc : (py.Rc >= 2 ? py.Rc : 0);\n#pragma warning disable CS0162\n                return Fail(args, rust, py, rs, Divergence,\n                    $\"engine divergence",
       "expected_catchers": [
         "stage1::divergence-is-5",
         "stage1::compare-no-substitution"
@@ -198,6 +198,39 @@
       "expected_catchers": [
         "stage1::compare-zero-document"
       ]
+    },
+    {
+      "id": "M17",
+      "rule": "locator-must-be-absolute",
+      "description": "the launcher accepts a relative OWEN_RUST_CORE — `GetFullPath` reads as 'it resolves the path for me', which it does: against whatever directory Owen happened to run in",
+      "target": "frontend/roslyn/OwnSharp.Cli/RustCoreLocator.cs",
+      "pattern": "        if \\(!Path\\.IsPathFullyQualified\\(raw\\)\\)",
+      "replacement": "        if (false)",
+      "expected_catchers": [
+        "stage1::absolute-locator-only"
+      ]
+    },
+    {
+      "id": "M18",
+      "rule": "shell-locator-must-be-absolute",
+      "description": "the shell accepts a relative OWEN_RUST_CORE — the -f/-x tests look like they answer 'is this a usable binary', and they do, for whatever the current directory made of the path",
+      "target": "scripts/own-check.sh",
+      "pattern": "  elif \\[\\[ \\\"\\$is_absolute\\\" -eq 0 \\]\\]; then",
+      "replacement": "  elif false; then",
+      "expected_catchers": [
+        "stage1::absolute-locator-only"
+      ]
+    },
+    {
+      "id": "M19",
+      "rule": "compare-verdict-is-stated",
+      "description": "the compare verdict is inferred from the Rust-child field again — `child_exit_code is null` reads as 'no engine crashed', but it is only ever about the RUST child, so a Python-only failure is stamped 'divergence'",
+      "target": "frontend/roslyn/OwnSharp.Cli/CompareMode.cs",
+      "pattern": "                verdict: verdict, diagnostic: diagnostic, childExitCode: childExitCode\\);",
+      "replacement": "                verdict: childExitCode is null && py is not null && rs is not null\n                    ? \"divergence\"\n                    : \"execution-failure\",\n                diagnostic: diagnostic, childExitCode: childExitCode);",
+      "expected_catchers": [
+        "stage1::compare-failure-classified"
+      ]
     }
   ]
 }

docs/evidence/p022-stage1-ps1.json

@@ -0,0 +1,68 @@
+{
+  "schema": 1,
+  "comment": "GENERATED-BY-HAND definition; the RESULT beside it is recorded by scripts/mutate_campaign.py --run on a WINDOWS runner and the counts are derived from it, never typed.",
+  "campaign": "p022-stage1-ps1",
+  "description": "#262 Stage 1 — the PowerShell launcher surface. `scripts/own-check.ps1` was driven by a CI smoke step but was absent from the adversarial control set, which is why three of its engine-contract defects survived a 16/16 campaign on the other surfaces: a campaign can only prove what some control observes. Every mutation here targets own-check.ps1 itself, and every one is a plausible MISREADING rather than a syntactic accident — Test-Path answering a question D3 did not ask, a failed spawn read as the engine blowing up, `Get-Content | Write-Output` read as an echo, cleanup read as tidiness.",
+  "layers": [
+    {
+      "id": "ps1",
+      "cwd": ".",
+      "parser": "python-fail",
+      "command": [
+        "python",
+        "tests/test_stage1_ps1.py"
+      ]
+    }
+  ],
+  "layers_comment": "WINDOWS-NATIVE BY CONTRACT. A mutation whose target is scripts/own-check.ps1 is only `caught` when a Windows PowerShell catcher observes the mutant and fails; this campaign therefore runs on a windows-latest runner (.github/workflows/ci.yml, job `stage1-ps1-mutations`). Running it on Linux would execute the mutated PowerShell under a different runtime and could not settle the Windows-specific halves — the spawn seam above all — so a Linux result is not evidence for these mutants and is never recorded as one.",
+  "control": {
+    "id": "M00",
+    "description": "harness-honesty control: no mutation at all, which must report zero failing layers"
+  },
+  "mutations": [
+    {
+      "id": "P01",
+      "rule": "ps1-locator-must-be-absolute",
+      "description": "own-check.ps1 accepts a relative OWEN_RUST_CORE — Test-Path says the file is there, which is true and not the question D3 asks",
+      "target": "scripts/own-check.ps1",
+      "pattern": "    elseif \\(-not \\[System\\.IO\\.Path\\]::IsPathFullyQualified\\(\\$rustCore\\)\\) \\{",
+      "replacement": "    elseif ($false) {",
+      "expected_catchers": [
+        "ps1::ps1-absolute-locator"
+      ]
+    },
+    {
+      "id": "P02",
+      "rule": "ps1-not-started-is-configuration",
+      "description": "own-check.ps1 reports a candidate that never started as an internal failure — 'the engine blew up' read as Owen's bug rather than the caller's configuration, which is the exact side of D3.1's seam the old comment got backwards",
+      "target": "scripts/own-check.ps1",
+      "pattern": "            exit 2\n        \\}\n        # 0/1/2 are verdicts and pass through",
+      "replacement": "            exit 5\n        }\n        # 0/1/2 are verdicts and pass through",
+      "expected_catchers": [
+        "ps1::ps1-not-started-is-2"
+      ]
+    },
+    {
+      "id": "P03",
+      "rule": "ps1-agreement-replays-raw-bytes",
+      "description": "own-check.ps1 replays agreement through the object pipeline again, stdout only — `Get-Content | Write-Output` looks like an echo and is a decode-and-re-encode that also drops stderr",
+      "target": "scripts/own-check.ps1",
+      "pattern": "            \\$outBytes = \\[System\\.IO\\.File\\]::ReadAllBytes\\(\\(Join-Path \\$cmpDir \"python\\.out\"\\)\\)\n            \\$errBytes = \\[System\\.IO\\.File\\]::ReadAllBytes\\(\\(Join-Path \\$cmpDir \"python\\.err\"\\)\\)",
+      "replacement": "            Get-Content -LiteralPath (Join-Path $cmpDir \"python.out\") -Raw -ErrorAction SilentlyContinue | Write-Output\n            $outBytes = @(); $errBytes = @()",
+      "expected_catchers": [
+        "ps1::ps1-agreement-replays"
+      ]
+    },
+    {
+      "id": "P04",
+      "rule": "ps1-failure-evidence-survives",
+      "description": "own-check.ps1 deletes the reproduction directory it just named — cleanup reads as tidiness, and the message that pointed at it is left describing something that no longer exists",
+      "target": "scripts/own-check.ps1",
+      "pattern": "                # reader at a path and then deleting it on the way out is worse\n                # than not naming one at all\\.\n                \\$keep = \\$true",
+      "replacement": "                # reader at a path and then deleting it on the way out is worse\n                # than not naming one at all.\n                $keep = $false",
+      "expected_catchers": [
+        "ps1::ps1-failure-evidence"
+      ]
+    }
+  ]
+}