fix(test): skip backslash-normalization test on non-Windows

CI on ubuntu-latest failed because the F-SCRIPTS-010 normalization test
constructed a backslash path and passed it to hash-file.mjs, expecting
the OS to resolve it to the same file. On Linux/macOS, backslashes are
literal filename characters — the file doesn't exist at the backslash
path, so hash-file errors with ENOENT before any normalization happens.

The behavior being tested (POSIX-normalize the emitted `path` field
when the input contains backslashes) is genuinely a Windows-only
concern; on POSIX the input would never contain backslashes in the
first place. Skipping on non-Windows preserves the test's intent
without fighting OS path semantics.

Pre-fix CI: ubuntu × node 20+22 — 88/89, 1 fail (this test)
Post-fix expected: ubuntu × node 20+22 — 88/89, 1 skipped (passes)
                   windows × node 20+22 — 89/89, 0 skipped

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mcp-tool-shop

test/hash-file.test.mjs

@@ -76,34 +76,44 @@ describe("hash-file.mjs — known-vector + path-normalization + empty-file", ()
     assert.equal(out.bytes, 0, `expected 0 bytes; got ${out.bytes}`);
   });
 
-  it("normalizes Windows backslashes to POSIX forward slashes in the emitted path", () => {
-    // Create a nested file so the relative path actually contains a separator.
-    const dir = makeTempDir("posix-norm");
-    const subdir = join(dir, "sub");
-    mkdirSync(subdir, { recursive: true });
-    const filePath = join(subdir, "f.txt");
-    writeFileSync(filePath, "x", "utf-8");
+  it(
+    "normalizes Windows backslashes to POSIX forward slashes in the emitted path",
+    {
+      skip:
+        process.platform !== "win32"
+          ? "Windows-only — backslash path resolution is OS-level"
+          : false,
+    },
+    () => {
+      // Create a nested file so the relative path actually contains a separator.
+      const dir = makeTempDir("posix-norm");
+      const subdir = join(dir, "sub");
+      mkdirSync(subdir, { recursive: true });
+      const filePath = join(subdir, "f.txt");
+      writeFileSync(filePath, "x", "utf-8");
 
-    // Build a path with explicit backslashes regardless of platform — this is
-    // the surface the F-SCRIPTS-010 fix protects. The normalization must run
-    // even on POSIX so the test is meaningful cross-platform.
-    const backslashPath = filePath.replace(/[/\\]/g, "\\");
-    const result = runHash(backslashPath);
-    assert.equal(
-      result.status,
-      0,
-      `hash-file should exit 0; got ${result.status}.\nstderr: ${result.stderr}`,
-    );
-    const out = JSON.parse(result.stdout);
-    assert.ok(
-      !out.path.includes("\\"),
-      `emitted path must not contain backslashes (POSIX-normalized); got ${JSON.stringify(out.path)}`,
-    );
-    assert.ok(
-      out.path.includes("/"),
-      `emitted path should use forward slashes for nested files; got ${JSON.stringify(out.path)}`,
-    );
-  });
+      // On Windows, both backslash and forward-slash paths resolve to the same
+      // file. We pass the backslash form to assert that the F-SCRIPTS-010 fix
+      // POSIX-normalizes the emitted `path` field. POSIX hosts cannot run this
+      // test because Linux/macOS treat backslashes as literal filename chars.
+      const backslashPath = filePath.replace(/[/\\]/g, "\\");
+      const result = runHash(backslashPath);
+      assert.equal(
+        result.status,
+        0,
+        `hash-file should exit 0; got ${result.status}.\nstderr: ${result.stderr}`,
+      );
+      const out = JSON.parse(result.stdout);
+      assert.ok(
+        !out.path.includes("\\"),
+        `emitted path must not contain backslashes (POSIX-normalized); got ${JSON.stringify(out.path)}`,
+      );
+      assert.ok(
+        out.path.includes("/"),
+        `emitted path should use forward slashes for nested files; got ${JSON.stringify(out.path)}`,
+      );
+    },
+  );
 
   it("exits non-zero with a usage message when called with no argument", () => {
     const result = runHash();