fix(provider-acp-registry): prepared binary agents stay ready when the registry advances

packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts

@@ -622,6 +622,70 @@ describe("AcpRegistrySupport", () => {
     );
   });
 
+  it.effect("keeps a prepared binary ready after the registry advances its version", () => {
+    const makeBinaryAgent = (version: string) => ({
+      ...makeAgent({
+        binary: {
+          "linux-x86_64": {
+            archive: `https://registry.test/example-agent-${version}.bin`,
+            cmd: "./bin/example-agent",
+          },
+        },
+      }),
+      version,
+    });
+    let agent = makeBinaryAgent("1.2.3");
+    return Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const cacheDir = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3-acp-registry-advance-",
+      });
+      const resolver = yield* AcpRegistrySupport.makeAcpRegistryCatalog({
+        cacheDir,
+        toolsDir: `${cacheDir}/tools`,
+        registryUrl,
+      });
+      yield* resolver.prepare({ agentId: agent.id });
+
+      agent = makeBinaryAgent("1.2.4");
+      yield* TestClock.adjust("6 minutes");
+      yield* resolver.search({ query: "example" });
+
+      expect(yield* resolver.inspect(settings())).toMatchObject({
+        status: "ready",
+        distribution: "binary",
+      });
+      const resolved = yield* resolver.resolve(settings(), "/workspace", {});
+      expect(resolved.spawn.command).toContain(
+        "/tools/example-agent/1.2.4/linux-x86_64/bin/example-agent",
+      );
+      expect(yield* fileSystem.readFileString(resolved.spawn.command)).toBe(
+        "#!/bin/sh\necho 1.2.4\n",
+      );
+
+      expect(yield* resolver.uninstallManagedBinary({ agentId: agent.id })).toMatchObject({
+        removed: true,
+      });
+      expect(yield* resolver.inspect(settings())).toMatchObject({ status: "unprepared" });
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(
+        layerResolver((request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              new Response(
+                request.url === registryUrl
+                  ? makeRegistry(agent)
+                  : `#!/bin/sh\necho ${agent.version}\n`,
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+  });
+
   it.effect(
     "prepares the registry version despite an older PATH binary and permits explicit overrides",
     () => {

packages/provider-acp-registry/src/server/AcpRegistrySupport.ts

@@ -1393,6 +1393,27 @@ export const makeAcpRegistryCatalog = Effect.fn("AcpRegistryCatalog.make")(funct
     };
   };
 
+  const hasInstalledBinaryVersion = Effect.fn("AcpRegistryCatalog.hasInstalledBinaryVersion")(
+    function* (agentId: string) {
+      const agentRoot = path.join(installsDirectory, agentId);
+      const versions = yield* fileSystem
+        .readDirectory(agentRoot)
+        .pipe(Effect.orElseSucceed((): Array<string> => []));
+      for (const version of versions) {
+        for (const candidateTarget of resolveAcpRegistryPlatformTargetCandidates(platformTarget)) {
+          if (
+            yield* fileSystem
+              .exists(path.join(agentRoot, version, candidateTarget))
+              .pipe(Effect.orElseSucceed(() => false))
+          ) {
+            return true;
+          }
+        }
+      }
+      return false;
+    },
+  );
+
   const installBinary = Effect.fn("AcpRegistryCatalog.installBinary")(function* (
     agent: AcpRegistryAgent,
     target: typeof AcpRegistryBinaryTarget.Type,
@@ -1773,25 +1794,28 @@ export const makeAcpRegistryCatalog = Effect.fn("AcpRegistryCatalog.make")(funct
             const exists = yield* fileSystem
               .exists(paths.executablePath)
               .pipe(Effect.orElseSucceed(() => false));
-            if (!exists) {
+            // Any prepared version keeps the agent ready; resolve installs the current one on demand.
+            if (!exists && !(yield* hasInstalledBinaryVersion(agent.id))) {
               return {
                 status: "unprepared",
                 agentId,
                 version: agent.version,
                 distribution: "binary",
               } as const;
             }
-            yield* assertExecutableInRoot(paths.installRoot, paths.executablePath).pipe(
-              Effect.mapError((cause) =>
-                isAcpRegistryError(cause)
-                  ? cause
-                  : new AcpRegistryError({
-                      reason: "install_failed",
-                      detail: `Could not validate cached ACP Registry agent ${agent.id}.`,
-                      cause,
-                    }),
-              ),
-            );
+            if (exists) {
+              yield* assertExecutableInRoot(paths.installRoot, paths.executablePath).pipe(
+                Effect.mapError((cause) =>
+                  isAcpRegistryError(cause)
+                    ? cause
+                    : new AcpRegistryError({
+                        reason: "install_failed",
+                        detail: `Could not validate cached ACP Registry agent ${agent.id}.`,
+                        cause,
+                      }),
+                ),
+              );
+            }
             return {
               status: "ready",
               agentId,