@@ -1001,12 +1001,14 @@ describe('downloadUpdate fallback chain', () => {
     downloadFullUpdate = mock(() => Promise.resolve()),
     addProgressListener = mock(() => ({ remove: mock(() => {}) })),
     setLocalHashInfo = mock(() => {}),
+    fetchWithTimeout = mock(() => Promise.resolve()),
   }: {
     downloadPatchFromPpk?: ReturnType<typeof mock>;
     downloadPatchFromPackage?: ReturnType<typeof mock>;
     downloadFullUpdate?: ReturnType<typeof mock>;
     addProgressListener?: ReturnType<typeof mock>;
     setLocalHashInfo?: ReturnType<typeof mock>;
+    fetchWithTimeout?: ReturnType<typeof mock>;
   } = {}) => {
     setupClientMocks({
       downloadPatchFromPpk,
@@ -1029,7 +1031,7 @@ describe('downloadUpdate fallback chain', () => {
           ? Math.min(100, Math.max(0, Math.floor((received / total) * 100)))
           : 0,
       DEFAULT_FETCH_TIMEOUT_MS: 5000,
-      fetchWithTimeout: mock(() => Promise.resolve()),
+      fetchWithTimeout,
       info: mock(() => {}),
       joinUrls: (paths: string[], fileName?: string) =>
         fileName ? paths.map((p) => `${p}/${fileName}`) : undefined,
@@ -1043,9 +1045,19 @@ describe('downloadUpdate fallback chain', () => {
       downloadPatchFromPpk,
       downloadPatchFromPackage,
       downloadFullUpdate,
+      fetchWithTimeout,
     };
   };
 
+  // The telemetry POSTs a download sent, as { type, detail } pairs.
+  const serverReports = (fetchWithTimeout: ReturnType<typeof mock>) =>
+    fetchWithTimeout.mock.calls
+      .filter(([url]: any[]) => String(url).includes('/report/'))
+      .map(([, init]: any[]): { type: string; detail?: string } => {
+        const { type, detail } = JSON.parse(String(init.body));
+        return { type, detail };
+      });
+
   const updateInfo = {
     update: true as const,
     hash: 'new-hash',
@@ -1555,6 +1567,50 @@ describe('downloadUpdate fallback chain', () => {
     );
   });
 
+  test('a download rescued after a network error is not a patch failure', async () => {
+    const timeout: any = Error('请求超时。');
+    timeout.code = 'DOWNLOAD_FAILED';
+    const { fetchWithTimeout } = setupDownloadMocks({
+      downloadPatchFromPpk: mock(() => Promise.reject(timeout)),
+    });
+    const { Pushy, sharedState } = await importFreshClient(
+      'dl-fallback-transport-report'
+    );
+    sharedState.downloadedHash = undefined;
+    const client = new Pushy({ appKey: 'demo-app', maxRetries: 0 });
+
+    expect(await client.downloadUpdate(updateInfo)).toBe('new-hash');
+
+    expect(serverReports(fetchWithTimeout)).toEqual([
+      { type: 'download_success' },
+    ]);
+  });
+
+  test('a rescued patch failure is reported once, with only the patch error', async () => {
+    const patchError: any = Error('hpatch failed');
+    patchError.code = 'PATCH_FAILED';
+    const timeout: any = Error('请求超时。');
+    timeout.code = 'DOWNLOAD_FAILED';
+    const { fetchWithTimeout } = setupDownloadMocks({
+      downloadPatchFromPpk: mock(() => Promise.reject(patchError)),
+      downloadPatchFromPackage: mock(() => Promise.reject(timeout)),
+    });
+    const { Pushy, sharedState } = await importFreshClient(
+      'dl-fallback-patch-report'
+    );
+    sharedState.downloadedHash = undefined;
+    const client = new Pushy({ appKey: 'demo-app', maxRetries: 0 });
+
+    expect(await client.downloadUpdate(updateInfo)).toBe('new-hash');
+
+    // The test i18n renders bare keys: the pdiff timeout is not in detail.
+    expect(
+      serverReports(fetchWithTimeout).filter(
+        ({ type }) => type === 'patch_fail'
+      )
+    ).toEqual([{ type: 'patch_fail', detail: 'error_diff_failed' }]);
+  });
+
   test('a `[PATCH_FAILED] ` message prefix classifies like a code property (bridge contract)', async () => {
     // Harmony's bridge cannot set `code` on a rejection and prefixes the
     // message instead; the strategy loop must treat it as the same
 
@@ -827,13 +827,11 @@ export class Pushy {
         ).catch((e: any) => {
           log('telemetry report failed:', e?.message || e);
         });
+      // A download rescued by a later strategy reports its patch-health
+      // signal through downloadFallback, which only counts patch-apply
+      // failures; downloadSuccess's data.error (any earlier failure, network
+      // errors included) stays local.
       send(serverType, message || undefined);
-      // A download that only succeeded after an incremental patch failed is
-      // still a patch_fail signal server-side (diff quality), carried in
-      // data.error alongside the downloadSuccess event.
-      if (serverType === 'download_success' && data.error) {
-        send('patch_fail', String(data.error));
-      }
     } catch (e: any) {
       log('telemetry error:', e?.message || e);
     }
@@ -1493,6 +1491,9 @@ export class Pushy {
     // downloadFallback report carries that as its code even when a later,
     // unrelated transport failure happened to be the last error seen.
     let patchFailed = false;
+    // The errors of the strategies that failed at the patch stage. A strategy
+    // that failed to apply is never retried, so these do not repeat.
+    const patchErrorMessages: string[] = [];
 
     // The ordered attempts come from decideDownload (the pure decision layer);
     // this side only executes them: probe candidate URLs, run the matching
@@ -1586,6 +1587,7 @@ export class Pushy {
             log(errorMessage);
             if (lastError.code === 'PATCH_FAILED') {
               patchFailed = true;
+              patchErrorMessages.push(errorMessage);
             }
             if (!isMirrorRetryableCode(lastError.code)) {
               // The bytes arrived but could not be applied (patch/manifest
@@ -1625,7 +1627,9 @@ export class Pushy {
           newVersion: hash,
           succeeded,
         },
-        message: errorMessages.join(';'),
+        // Only the patch failures: a mirror's timeout alongside them would
+        // otherwise be read as the cause server-side.
+        message: (patchFailed ? patchErrorMessages : errorMessages).join(';'),
       });
     }
     if (!succeeded) {