@@ -14,6 +14,8 @@ import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
 import * as Schema from "effect/Schema";
 import * as HttpClient from "effect/http/HttpClient";
 import * as HttpClientResponse from "effect/http/HttpClientResponse";
@@ -823,6 +825,90 @@ describe("AcpRegistrySupport", () => {
     );
   });
 
+  it.effect("prepares an x64 ZIP fallback on Windows ARM when PATH tar cannot read ZIP", () => {
+    const downloadUrl = "https://registry.test/agent-windows-x64.zip";
+    const agent = makeAgent({
+      binary: { "windows-x86_64": { archive: downloadUrl, cmd: "./agent.exe" } },
+      npx: { package: "@example/[email protected]" },
+    });
+    return Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const cacheDir = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-acp-arm-zip-" });
+      const commands: Array<string> = [];
+      const spawner = ChildProcessSpawner.make((command) =>
+        Effect.gen(function* () {
+          if (command._tag !== "StandardCommand") return yield* Effect.die("Unexpected pipeline");
+          commands.push(command.command);
+          // Simulate Git's GNU tar rejecting ZIP and System32 bsdtar listing/extracting it.
+          const supportsZip = command.command === "C:\\Windows\\System32\\tar.exe";
+          if (supportsZip && command.args[0] === "-xf") {
+            const outputDirectory = command.args[3];
+            if (!outputDirectory) return yield* Effect.die("Missing extraction directory");
+            yield* fileSystem.writeFileString(path.join(outputDirectory, "agent.exe"), "fixture");
+          }
+          return ChildProcessSpawner.makeHandle({
+            pid: ChildProcessSpawner.ProcessId(1),
+            exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(supportsZip ? 0 : 1)),
+            isRunning: Effect.succeed(false),
+            kill: () => Effect.void,
+            unref: Effect.succeed(Effect.void),
+            stdin: Sink.drain,
+            stdout: Stream.make(new TextEncoder().encode(supportsZip ? "agent.exe\r\n" : "")),
+            stderr: Stream.make(
+              new TextEncoder().encode(supportsZip ? "" : "GNU tar cannot read ZIP"),
+            ),
+            all: Stream.empty,
+            getInputFd: () => Sink.drain,
+            getOutputFd: () => Stream.empty,
+          });
+        }).pipe(Effect.orDie),
+      );
+      const resolver = yield* AcpRegistrySupport.makeAcpRegistryCatalog({
+        cacheDir,
+        toolsDir: path.join(cacheDir, "tools"),
+        registryUrl,
+      }).pipe(
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        Effect.provideService(HostProcess.Platform, "win32"),
+        Effect.provideService(HostProcess.Architecture, "arm64"),
+        Effect.provideService(HostProcess.Environment, {
+          SystemRoot: "C:\\Windows",
+          PATH: "C:\\Program Files\\Git\\usr\\bin;C:\\Windows\\System32",
+        }),
+        Effect.provideService(SpawnExecutableResolution, (command) =>
+          command === "tar" ? "C:\\Program Files\\Git\\usr\\bin\\tar.exe" : command,
+        ),
+      );
+      yield* resolver.prepare({ agentId: agent.id });
+      const resolved = yield* resolver.resolve(settings(), "/workspace", {});
+      expect(resolved.spawn.command).toBe(
+        yield* fileSystem.realPath(
+          path.join(cacheDir, "tools", agent.id, agent.version, "windows-x86_64", "agent.exe"),
+        ),
+      );
+      expect(yield* fileSystem.readFileString(resolved.spawn.command)).toBe("fixture");
+      expect(commands).toEqual([
+        "C:\\Windows\\System32\\tar.exe",
+        "C:\\Windows\\System32\\tar.exe",
+      ]);
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(
+        layerResolver((request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              request.url === registryUrl
+                ? new Response(makeRegistry(agent))
+                : new Response("ZIP fixture"),
+            ),
+          ),
+        ),
+      ),
+    );
+  });
+
   it.effect("searches compatible agents with deterministic ranking and bounded metadata", () => {
     const exact = {
       ...makeAgent({ npx: { package: "@example/[email protected]" } }),
 
@@ -12,6 +12,7 @@ import {
 } from "@t3tools/contracts";
 import type { AcpRegistryDistributionPreference } from "../settings.ts";
 import type { AcpRegistrySettings } from "../settings.ts";
+import { cliArchiveTarCommand } from "@t3tools/shared/cliRelease";
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import {
   mergePathEntries,
@@ -1363,6 +1364,7 @@ export const makeAcpRegistryCatalog = Effect.fn("AcpRegistryCatalog.make")(funct
     return {
       commandSegments,
       installRoot,
+      platformTarget: matchedPlatformTarget,
       executablePath: path.join(installRoot, ...commandSegments),
     };
   };
@@ -1509,6 +1511,14 @@ export const makeAcpRegistryCatalog = Effect.fn("AcpRegistryCatalog.make")(funct
         yield* fileSystem.makeDirectory(path.dirname(targetPath), { recursive: true });
         yield* fileSystem.rename(archivePath, targetPath);
       } else {
+        // The new Windows ARM fallback must extract x64 ZIPs even when Git's GNU tar wins PATH.
+        // Keep archive selection for existing native distributions unchanged in this PR.
+        const tarCommand =
+          platformTarget === "windows-aarch64" &&
+          paths.platformTarget === "windows-x86_64" &&
+          kind === "zip"
+            ? cliArchiveTarCommand(platform, hostEnvironment)
+            : "tar";
         const listArgs =
           kind === "tar_gz"
             ? ["-tzf", archivePath]
@@ -1520,7 +1530,7 @@ export const makeAcpRegistryCatalog = Effect.fn("AcpRegistryCatalog.make")(funct
         const entries =
           listArgs === undefined
             ? yield* runCommand("unzip", ["-Z1", archivePath])
-            : yield* runCommand("tar", listArgs);
+            : yield* runCommand(tarCommand, listArgs);
         if (!validateArchiveEntries(entries)) {
           return yield* new AcpRegistryError({
             reason: "archive_invalid",
@@ -1531,7 +1541,7 @@ export const makeAcpRegistryCatalog = Effect.fn("AcpRegistryCatalog.make")(funct
           yield* runCommand("unzip", ["-q", archivePath, "-d", extractionRoot]);
         } else {
           const extractFlag = kind === "tar_gz" ? "-xzf" : kind === "tar_bz2" ? "-xjf" : "-xf";
-          yield* runCommand("tar", [extractFlag, archivePath, "-C", extractionRoot]);
+          yield* runCommand(tarCommand, [extractFlag, archivePath, "-C", extractionRoot]);
         }
       }