@@ -166,20 +166,13 @@ class OutdatedHostSocket {
 }
 
 describe("updateOutdatedHost", () => {
-  it.effect.each([false, true])("updates host, progress loss=%s", (progressDisconnect) =>
+  it.effect("updates a protocol-1 host over a bare socket, then switches it back on", () =>
     Effect.gen(function* () {
       const blocked = orchestrationProtocolCompatibilityError(descriptor(undefined, "0.0.45"));
       expect(blocked).toMatchObject({ serverUpdateRequired: true });
 
       const sockets: Array<OutdatedHostSocket> = [];
-      let served: ExecutionEnvironmentDescriptor = {
-        ...descriptor(undefined, "0.0.45"),
-        capabilities: {
-          repositoryIdentity: true,
-          serverSelfUpdate: "boot-service",
-          serverSelfUpdateProgress: progressDisconnect,
-        },
-      };
+      let served: ExecutionEnvironmentDescriptor = descriptor(undefined, "0.0.45");
       const entries = yield* SubscriptionRef.make<
         ReadonlyMap<EnvironmentId, ConnectionCatalogEntry>
       >(
@@ -227,16 +220,10 @@ describe("updateOutdatedHost", () => {
         ),
       );
 
-      const stages: Array<string> = [];
       const result = yield* updateOutdatedHost(
         TARGET.environmentId,
         { targetVersion: "0.0.46" },
-        (stage) =>
-          Effect.sync(() => {
-            stages.push(stage);
-            // Lose the transport only after the consumer has observed progress.
-            if (stage === "downloading") sockets[0]?.close();
-          }),
+        () => Effect.void,
       ).pipe(
         Effect.provide(
           Layer.mergeAll(
@@ -265,11 +252,8 @@ describe("updateOutdatedHost", () => {
 
       expect(sockets[0]?.url).not.toContain("orchestrationProtocol");
       expect(sockets[0]?.requests.map((request) => request.tag)).toEqual([
-        progressDisconnect
-          ? WS_METHODS.serverUpdateServerWithProgress
-          : WS_METHODS.serverUpdateServer,
+        WS_METHODS.serverUpdateServer,
       ]);
-      expect(stages).toEqual(progressDisconnect ? ["downloading", "resuming"] : ["resuming"]);
       expect(result.targetVersion).toBe("0.0.46");
       expect(calls).toEqual(["compatibility:clear", "enabled:true"]);
     }),
@@ -344,4 +328,111 @@ describe("updateOutdatedHost", () => {
       expect(opened).toBe(false);
     }),
   );
+
+  it.effect("resumes an outdated host update after progress transport loss", () =>
+    Effect.gen(function* () {
+      const blocked = orchestrationProtocolCompatibilityError(descriptor(undefined, "0.0.45"));
+      expect(blocked).toMatchObject({ serverUpdateRequired: true });
+
+      const sockets: Array<OutdatedHostSocket> = [];
+      let served: ExecutionEnvironmentDescriptor = {
+        ...descriptor(undefined, "0.0.45"),
+        capabilities: {
+          repositoryIdentity: true,
+          serverSelfUpdate: "boot-service",
+          serverSelfUpdateProgress: true,
+        },
+      };
+      const entries = yield* SubscriptionRef.make<
+        ReadonlyMap<EnvironmentId, ConnectionCatalogEntry>
+      >(
+        new Map([
+          [
+            TARGET.environmentId,
+            {
+              target: TARGET,
+              profile: Option.none(),
+              enabled: false,
+              unsupportedReason: blocked?.message ?? "",
+              serverUpdateRequired: true,
+            },
+          ],
+        ]),
+      );
+      const calls: Array<string> = [];
+      const registry = EnvironmentRegistry.EnvironmentRegistry.of({
+        entries,
+        setCompatibility: (_environmentId: EnvironmentId, error: unknown) =>
+          Effect.sync(() => calls.push(`compatibility:${error === null ? "clear" : "block"}`)),
+        setEnabled: (_environmentId: EnvironmentId, enabled: boolean) =>
+          Effect.sync(() => calls.push(`enabled:${enabled}`)),
+      } as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"]);
+      const resolver = ConnectionResolver.ConnectionResolver.of({
+        prepare: () => Effect.die(new Error("The update must bypass the protocol gate.")),
+        prepareForUpdate: () =>
+          Effect.sync(() => served).pipe(
+            Effect.map((current) => ({
+              descriptor: current,
+              prepared: {
+                environmentId: TARGET.environmentId,
+                label: TARGET.label,
+                httpBaseUrl: TARGET.httpBaseUrl,
+                socketUrl: "wss://build.example.test/ws?wsTicket=ticket",
+                httpAuthorization: null,
+                target: TARGET,
+              },
+            })),
+          ),
+      });
+      const httpClient = HttpClient.make((request) =>
+        Effect.sync(() =>
+          HttpClientResponse.fromWeb(request, new Response(encodeDescriptor(served))),
+        ),
+      );
+
+      const stages: Array<string> = [];
+      const result = yield* updateOutdatedHost(
+        TARGET.environmentId,
+        { targetVersion: "0.0.46" },
+        (stage) =>
+          Effect.sync(() => {
+            stages.push(stage);
+            // Lose the transport only after the consumer has observed progress.
+            if (stage === "downloading") sockets[0]?.close();
+          }),
+      ).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, registry),
+            Layer.succeed(ConnectionResolver.ConnectionResolver, resolver),
+            Layer.succeed(
+              RelayEnvironmentDiscovery.RelayEnvironmentDiscovery,
+              RelayEnvironmentDiscovery.RelayEnvironmentDiscovery.of({
+                state: yield* SubscriptionRef.make(
+                  RelayEnvironmentDiscovery.EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE,
+                ),
+                refresh: Effect.void,
+              }),
+            ),
+            Layer.succeed(HttpClient.HttpClient, httpClient),
+            Layer.succeed(Socket.WebSocketConstructor, (url) => {
+              const socket = new OutdatedHostSocket(url, () => {
+                served = descriptor(ORCHESTRATION_PROTOCOL_VERSION, "0.0.46");
+              });
+              sockets.push(socket);
+              return socket as unknown as globalThis.WebSocket;
+            }),
+          ),
+        ),
+      );
+
+      expect(sockets[0]?.url).not.toContain("orchestrationProtocol");
+      expect(sockets[0]?.requests.map((request) => request.tag)).toEqual([
+        WS_METHODS.serverUpdateServerWithProgress,
+      ]);
+      expect(stages).toEqual(["downloading", "resuming"]);
+      expect(result.targetVersion).toBe("0.0.46");
+      expect(calls).toEqual(["compatibility:clear", "enabled:true"]);
+    }),
+  );
 });