fix(#205): retire tautological host/embedded parity check

--backend host on the CLI/wasmtime harness tests/parity/ used can never
diverge from --backend embedded: hasHostImport() is gated on
builtin.target.cpu.arch == .wasm32 and root.is_embedded_engine, true only
for the engine embedding targets, never the CLI. The CLI also never
registers native_host_call_fn, so nativeCallRaw always returns
.unsupported and every native call falls back to embedded regardless of
the flag. The check was verifying embedded output equals embedded
output; expanding its corpus as #205 originally asked would have reported
false backend-divergence coverage rather than real signal.

Removed: tests/parity/, test_runner.zig's runParity, the build.zig parity
step, the redundant parity-test CI job, and stale references in
CONTRIBUTING.md/Makefile/dev-docs. test remains the one real correctness
gate. The actual gap this leaves — no test registers a genuine alternate
implementation of the 8 CAP_* host-override capabilities and diffs it
against embedded — is written up in dev-docs/roadmap.md for future work.

Author: ganehag

.githooks/pre-push

@@ -26,7 +26,6 @@ run git diff --check
 
 run zig build -Dpreset=1m fuzz-native
 run zig build -Dpreset=1m test
-run zig build -Dpreset=1m parity
 run zig build -Dpreset=1m bench
 run zig build -Dpreset=1m native-cap
 run zig build -Dpreset=1m chaos

.github/workflows/ci.yml

@@ -198,34 +198,3 @@ jobs:
           echo "$PWD/binaryen-${BINARYEN_VERSION}/bin" >> "$GITHUB_PATH"
       - name: Run tests with heap paranoia (assert no live regions overwritten)
         run: zig build -Dpreset=dev -Dheap_paranoia=true test
-
-  parity-test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: mlugg/setup-zig@v2
-        with:
-          version: 0.16.0
-      - name: Install wasmtime
-        run: |
-          set -euo pipefail
-          TARBALL="wasmtime-${WASMTIME_VERSION}-x86_64-linux.tar.xz"
-          URL="https://github.com/bytecodealliance/wasmtime/releases/download/${WASMTIME_VERSION}/${TARBALL}"
-          for attempt in 1 2 3; do
-            curl -fsSL --retry 3 --retry-delay 5 "$URL" -o "/tmp/${TARBALL}" && break
-            [ "$attempt" -lt 3 ] && sleep 15 || exit 1
-          done
-          echo "${WASMTIME_SHA256}  /tmp/${TARBALL}" | sha256sum --check --strict
-          tar -xJf "/tmp/${TARBALL}" -C /tmp
-          mkdir -p "$HOME/.wasmtime/bin"
-          mv "/tmp/wasmtime-${WASMTIME_VERSION}-x86_64-linux/wasmtime" "$HOME/.wasmtime/bin/"
-          echo "$HOME/.wasmtime/bin" >> "$GITHUB_PATH"
-      - name: Install wasm-opt
-        run: |
-          TARBALL="binaryen-${BINARYEN_VERSION}-x86_64-linux.tar.gz"
-          curl -fsSL "https://github.com/WebAssembly/binaryen/releases/download/${BINARYEN_VERSION}/${TARBALL}" -o "/tmp/${TARBALL}"
-          echo "${BINARYEN_SHA256}  /tmp/${TARBALL}" | sha256sum --check --strict
-          tar -xzf "/tmp/${TARBALL}"
-          echo "$PWD/binaryen-${BINARYEN_VERSION}/bin" >> "$GITHUB_PATH"
-      - name: Run host/embedded backend parity tests
-        run: zig build -Dpreset=dev parity

CONTRIBUTING.md

@@ -49,11 +49,8 @@ If relevant, also run:
 
 ```bash
 make bench
-make parity
 ```
 
-`parity` checks that the native and WASM backends produce the same output. Run it when touching the VM or compiler.
-
 ## Profiling
 
 Build the timing binary and profile with DWARF call graphs:

Makefile

@@ -77,7 +77,3 @@ bench-release-stress:
 .PHONY: bench-recursion-stress
 bench-recursion-stress:
 	GENGO_BENCH_INCLUDE_STRESS=1 GENGO_BENCH_FILTER='005_fib_recursive_35_stress.gengo' $(ZIG) build -Dpreset=stress -Dwasmtime=$(WASMTIME) bench-release
-
-.PHONY: parity
-parity:
-	$(ZIG) build -Dpreset=$(PRESET) -Dwasmtime=$(WASMTIME) parity

build.zig

@@ -488,14 +488,6 @@ pub fn build(b: *std.Build) void {
     const fuzz_gc_stress_step = b.step("fuzz-gc-stress", "Run fuzz tests under gc_stress (GC on every allocation)");
     fuzz_gc_stress_step.dependOn(&run_fuzz_gc_stress.step);
 
-    const run_parity = b.addRunArtifact(test_runner_exe);
-    run_parity.step.dependOn(&install_test.step);
-    run_parity.addArg("parity");
-    run_parity.addArg(wasmtime_opt);
-    run_parity.addArg("build/test/gengo-cli.wasm");
-    const parity_step = b.step("parity", "Run host/embedded parity tests");
-    parity_step.dependOn(&run_parity.step);
-
     // ── Native CLI ────────────────────────────────────────────────────────────
 
     const native_mod = b.createModule(.{

dev-docs/index.md

@@ -4,7 +4,7 @@ This directory holds contributor and project-internal documentation rather than
 
 Contents:
 
-- `testing.md` — conformance, parity, and benchmark harnesses
+- `testing.md` — conformance and benchmark harnesses
 - `roadmap.md` — current open items and exit criteria
 - `opcodes.md` — VM opcode reference (fused-op internals; not public language semantics)
 - `design/compiler-architecture.md` — compiler conceptual reference: single-pass Pratt parser, expression/statement/declaration compilation, type system, scope/upvalues, module resolution

dev-docs/roadmap.md

@@ -24,7 +24,19 @@ This becomes more relevant once the module system is used heavily. At that point
 
 ---
 
-## 3. Exit Criteria
+## 3. Host-backend override parity has no real test coverage
+
+**Status:** gap identified 2026-07-21, not scheduled.
+
+The VM's `native_backend` policy (`--backend embedded`/`--backend host`) lets a host override built-in natives (`std.core.len`/`append`/`bytelen`, `std.conv.*`, `std.io.println` — the 8 `CAP_*` capabilities in `src/runtime/host_abi.zig`) with its own implementation, dispatched through `gengo_native_call`. No test ever registers a *real* alternate implementation and diffs its output against the embedded one.
+
+`tests/parity/` (removed, see #205) ran the plain CLI/WASM binary under `wasmtime run` with `--backend host` — but `hasHostImport()` is gated on `builtin.target.cpu.arch == .wasm32 and root.is_embedded_engine`, true only for the `gengo-engine.wasm`/`libgengo-engine.so` embedding targets, never for the CLI. The CLI never registers `native_host_call_fn` either, so `nativeCallRaw` always returns `.unsupported` and every call falls back to the embedded path — `--backend host` on the CLI is architecturally a no-op, for any input, always. `engine_runner.zig`'s existing host-module tests only check that calling an *unregistered* host function produces the correct error; they don't register real implementations of the 8 override capabilities either.
+
+Real coverage would need a native (or WASM component-model) test harness that registers a genuine `native_host_call_fn` implementing those 8 capabilities, runs scripts with `--backend host` against it, and diffs the result against both golden output and the embedded-backend result. That's new test infrastructure, not a corpus expansion.
+
+---
+
+## 4. Exit Criteria
 
 1. All core capabilities are `done` and covered by conformance cases.
 2. Conformance suite runs in CI on every PR.

dev-docs/testing.md

@@ -26,18 +26,6 @@ Notes:
 - Pass cases are in `tests/spec/*.gengo` with matching `.out` files.
 - Fail cases are in `tests/spec/fail/*.gengo` with matching `.err` token files.
 
-## Parity Harness
-
-Run embedded vs host-backend parity checks:
-
-```bash
-zig build -Dpreset=1m parity
-```
-
-Notes:
-- Parity cases live in `tests/parity/*.gengo`.
-- Host backend gracefully falls back to VM-local implementations when host import is unavailable.
-
 ## Bench Harness
 
 Run benchmarks:

tools/test_runner.zig

@@ -20,7 +20,7 @@ pub fn main(init: std.process.Init.Minimal) !void {
     const args = argv_storage[0..arg_count];
 
     if (args.len < 2) {
-        std.debug.print("usage: test-runner <conformance|bench|parity> [wasmtime] [wasm] [--filter <pattern>]\n", .{});
+        std.debug.print("usage: test-runner <conformance|bench> [wasmtime] [wasm] [--filter <pattern>]\n", .{});
         std.debug.print("   or: test-runner <native-cap|chaos> [gengo] [--filter <pattern>]\n", .{});
         std.process.exit(1);
     }
@@ -69,8 +69,6 @@ pub fn main(init: std.process.Init.Minimal) !void {
         try runConformance(alloc, wasmtime, wasm_path);
     } else if (std.mem.eql(u8, mode, "bench")) {
         try runBench(alloc, wasmtime, wasm_path);
-    } else if (std.mem.eql(u8, mode, "parity")) {
-        try runParity(alloc, wasmtime, wasm_path);
     } else {
         std.debug.print("unknown mode: {s}\n", .{mode});
         std.process.exit(1);
@@ -303,74 +301,6 @@ fn runBench(alloc: std.mem.Allocator, wasmtime: []const u8, wasm_path: []const u
     std.debug.print("Bench OK: {d} cases\n", .{pass_count});
 }
 
-// ── Parity ─────────────────────────────────────────────────────────────────
-
-fn runParity(alloc: std.mem.Allocator, wasmtime: []const u8, wasm_path: []const u8) !void {
-    const parity_dir = "tests/parity";
-
-    var cases_buf: [MaxCases][]const u8 = undefined;
-    const case_count = collectGengoFiles(alloc, parity_dir, &cases_buf) catch |err| {
-        std.debug.print("cannot scan parity dir: {s}\n", .{@errorName(err)});
-        std.process.exit(1);
-    };
-
-    var pass_count: usize = 0;
-    var errors: usize = 0;
-
-    for (cases_buf[0..case_count]) |path| {
-        defer alloc.free(path);
-        const base = path[0 .. path.len - 6];
-        const got_emb_path = try std.fmt.allocPrint(alloc, "{s}.embedded.got", .{base});
-        defer alloc.free(got_emb_path);
-        const got_host_path = try std.fmt.allocPrint(alloc, "{s}.host.got", .{base});
-        defer alloc.free(got_host_path);
-
-        std.debug.print("[PARITY] {s}\n", .{path});
-
-        // Embedded backend
-        const emb_extra = try std.fmt.allocPrint(alloc, "--backend embedded {s}", .{path});
-        defer alloc.free(emb_extra);
-        const emb_result = runWasmtimeExtra(alloc, wasmtime, wasm_path, emb_extra);
-        const emb_data = emb_result[0];
-        const emb_failed = emb_result[1];
-        defer alloc.free(emb_data);
-
-        if (emb_failed) {
-            std.debug.print("embedded backend failed: {s}\n", .{path});
-            errors += 1;
-            continue;
-        }
-
-        // Host backend
-        const host_extra = try std.fmt.allocPrint(alloc, "--backend host {s}", .{path});
-        defer alloc.free(host_extra);
-        const host_result = runWasmtimeExtra(alloc, wasmtime, wasm_path, host_extra);
-        const host_data = host_result[0];
-        const host_failed = host_result[1];
-        defer alloc.free(host_data);
-
-        if (host_failed) {
-            std.debug.print("host backend failed: {s}\n", .{path});
-            errors += 1;
-            continue;
-        }
-
-        if (!std.mem.eql(u8, emb_data, host_data)) {
-            std.debug.print("backend output mismatch: {s}\n", .{path});
-            errors += 1;
-            continue;
-        }
-
-        pass_count += 1;
-    }
-
-    if (errors != 0) {
-        std.debug.print("Host parity FAILED: {d} pass, {d} errors\n", .{ pass_count, errors });
-        std.process.exit(1);
-    }
-    std.debug.print("Host parity OK: {d} cases\n", .{pass_count});
-}
-
 // ── Native capability lane ────────────────────────────────────────────────
 
 fn runNativeCap(alloc: std.mem.Allocator, gengo: []const u8, filter: ?[]const u8) !void {