@@ -128,14 +128,15 @@ jobs:
           fi
 
   persistence:
-    needs: changes
+    needs: [changes, mobile_web_bundle]
     concurrency:
       group: node-server-persistence-${{ matrix.os }}-${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' && github.ref || github.run_id }}
       cancel-in-progress: ${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' }}
     # Missing/failed detection runs the full matrix; scheduled and manual runs stay unconditional.
     # Drafts re-trigger at readiness; inherited caller events must not depend on PR fields.
     if: >-
       ${{ !cancelled() && needs.changes.outputs.should_run != 'false' &&
+      (needs.changes.outputs.qualification == 'false' || needs.mobile_web_bundle.result == 'success') &&
       (github.event_name != 'pull_request' || github.event.pull_request.draft != true) }}
     strategy:
       fail-fast: false
@@ -154,7 +155,8 @@ jobs:
         id: dependencies
         with:
           native-runtime: ${{ runner.os == 'Windows' && 'node' || 'none' }}
-          cache-pnpm-store: ${{ runner.os != 'Windows' }}
+          # Template qualification must not wait for large download-cache uploads.
+          cache-pnpm-store: ${{ !inputs.build_template && runner.os != 'Windows' }}
           cache-pnpm-store-lookup-only: 'true'
       # Design D7 upgrade and rollback: the last Bun orcad, built from a main commit that shipped
       # it, using the current Bun pin beside this checkout's Node slot; hand-over skips once PROTOCOL_VERSION
@@ -191,7 +193,14 @@ jobs:
         if: runner.os == 'Windows'
         with:
           arches: ${{ (inputs.build_template && matrix.os == 'windows-2022') && 'x64 arm64' || (runner.arch == 'ARM64' && 'arm64' || 'x64') }}
+      - uses: actions/download-artifact@v8
+        if: needs.changes.outputs.qualification != 'false'
+        with:
+          name: orcad-mobile-web-bundle
+          path: out/mobile-web
+      # Narrow test-only runs skip the shared producer but still need a page.
       - uses: ./.github/actions/build-mobile-web-bundle
+        if: needs.changes.outputs.qualification == 'false'
       - run: pnpm build:orcad
         env:
           ORCA_REUSE_PREPARED_WINDOWS_SECURITY: ${{ github.event_name == 'pull_request' && runner.os == 'Windows' && steps.dependencies.outcome == 'success' }}
@@ -298,8 +307,7 @@ jobs:
           # A rerun attempt re-uploads under the same name, which v4 otherwise refuses.
           overwrite: true
 
-  # The container lanes take the page from here: it is platform-independent, and building it needs
-  # mobile/node_modules, which those images never install.
+  # Every qualification lane tests the same platform-independent page.
   mobile_web_bundle:
     needs: changes
     if: >-
@@ -324,13 +332,13 @@ jobs:
           overwrite: true
 
   linux_glibc_floor:
-    needs: [changes, persistence, mobile_web_bundle]
+    needs: [changes, mobile_web_bundle]
     concurrency:
       group: node-server-linux_glibc_floor-${{ matrix.os }}-${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' && github.ref || github.run_id }}
       cancel-in-progress: ${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' }}
-    # A failed smoke already blocks qualification; missing scope still selects every platform.
+    # Each Linux lane owns its inputs; the template still requires every lane to pass.
     if: >-
-      ${{ !cancelled() && needs.persistence.result == 'success' &&
+      ${{ !cancelled() &&
       needs.mobile_web_bundle.result == 'success' &&
       needs.changes.outputs.should_run != 'false' &&
       needs.changes.outputs.qualification != 'false' }}
@@ -397,15 +405,15 @@ jobs:
           overwrite: true
 
   linux_glibc217_compat:
-    needs: [changes, persistence]
+    needs: changes
     concurrency:
       group: node-server-linux_glibc217_compat-${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' && github.ref || github.run_id }}
       cancel-in-progress: ${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' }}
-    # A failed smoke already blocks qualification; missing scope still selects every platform.
     if: >-
-      ${{ !cancelled() && needs.persistence.result == 'success' &&
+      ${{ !cancelled() &&
       needs.changes.outputs.should_run != 'false' &&
       needs.changes.outputs.qualification != 'false' &&
+      (github.event_name != 'pull_request' || github.event.pull_request.draft != true) &&
       (github.event_name != 'pull_request' || inputs.build_template || inputs.ref != '' ||
       needs.changes.outputs.native_compatibility != 'false') }}
     runs-on: ubuntu-22.04
@@ -454,13 +462,12 @@ jobs:
           overwrite: true
 
   linux_musl:
-    needs: [changes, persistence, mobile_web_bundle]
+    needs: [changes, mobile_web_bundle]
     concurrency:
       group: node-server-linux_musl-${{ matrix.os }}-${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' && github.ref || github.run_id }}
       cancel-in-progress: ${{ github.event_name == 'push' && !inputs.build_template && inputs.ref == '' }}
-    # A failed smoke already blocks qualification; missing scope still selects every platform.
     if: >-
-      ${{ !cancelled() && needs.persistence.result == 'success' &&
+      ${{ !cancelled() &&
       needs.mobile_web_bundle.result == 'success' &&
       needs.changes.outputs.should_run != 'false' &&
       needs.changes.outputs.qualification != 'false' }}
 
@@ -290,7 +290,9 @@ describe('CI dependency download caches', () => {
     ).jobs
     const warmer = platformJobs['warm-windows'].steps.find((step) => step.uses === installer)
     expect(action.inputs['cache-pnpm-store'].default).toBe('true')
-    expect(persistence.with['cache-pnpm-store']).toBe("${{ runner.os != 'Windows' }}")
+    expect(persistence.with['cache-pnpm-store']).toBe(
+      "${{ !inputs.build_template && runner.os != 'Windows' }}"
+    )
     expect(ssh.with['cache-pnpm-store']).toBe('false')
     expect(warmer.with['cache-pnpm-store']).toBe('false')
     expect(warmer.with['native-runtime']).toBe('node')
 
@@ -571,11 +571,11 @@ it('keeps every platform job and runs them when detection is skipped or fails',
   expect(workflow.jobs.persistence.strategy.matrix.os).toContain('needs.changes.outputs.runners')
   for (const jobName of ['linux_glibc_floor', 'linux_musl']) {
     const job = workflow.jobs[jobName]
-    expect(job.needs).toEqual(['changes', 'persistence', 'mobile_web_bundle'])
+    expect(job.needs).toEqual(['changes', 'mobile_web_bundle'])
     // The containers never install mobile/, and orcad refuses to build without the page.
     expect(job.steps.some((step) => step.with?.name === 'orcad-mobile-web-bundle')).toBe(true)
     expect(job.if).toContain("needs.mobile_web_bundle.result == 'success'")
-    expect(job.if).toContain("needs.persistence.result == 'success'")
+    expect(job.if).not.toContain('needs.persistence')
     expect(job.if).toContain("needs.changes.outputs.qualification != 'false'")
     expect(job.if).toContain("needs.changes.outputs.should_run != 'false'")
     expect(job.strategy.matrix.os).toEqual(['ubuntu-22.04', 'ubuntu-24.04-arm'])
 
@@ -327,7 +327,7 @@ it('builds server glibc slots on glibc 2.28 and the compat slot on glibc 2.17 (d
   expect(floor.env).toMatchObject({ CC: 'gcc', CXX: 'g++' })
 
   const compat = workflow.jobs.linux_glibc217_compat
-  expect(compat.needs).toEqual(['changes', 'persistence'])
+  expect(compat.needs).toBe('changes')
   // Only the floor builds orcad, so only it waits for the page.
   expect(compat.if).toContain(
     floor.if.slice(0, -3).replace(" && needs.mobile_web_bundle.result == 'success'", '')
@@ -366,15 +366,19 @@ it.each([
   { expected: true, native: 'false', event: 'workflow_dispatch' },
   { expected: true, native: 'false', template: true },
   { expected: true, native: 'false', ref: 'other-commit' },
-  { expected: false, native: 'true', persistence: 'failure' },
-  { expected: false, native: 'true', persistence: 'cancelled' },
-  { expected: false, native: 'true', persistence: 'skipped' },
+  { expected: true, native: 'true', persistence: 'failure' },
+  { expected: true, native: 'true', persistence: 'cancelled' },
+  { expected: true, native: 'true', persistence: 'skipped' },
+  { expected: false, native: 'true', draft: true },
   { expected: false, native: 'true', qualification: 'false' },
   { expected: false, native: 'true', shouldRun: 'false' },
   { expected: false, native: 'true', cancelled: true }
 ])('evaluates the hosted native job guard with %j', (scenario) => {
   const context = {
-    github: { event_name: scenario.event ?? 'pull_request' },
+    github: {
+      event_name: scenario.event ?? 'pull_request',
+      event: { pull_request: { draft: scenario.draft ?? false } }
+    },
     inputs: { build_template: scenario.template ?? false, ref: scenario.ref ?? '' },
     needs: {
       persistence: { result: scenario.persistence ?? 'success' },
 
@@ -0,0 +1,113 @@
+import { readFileSync } from 'node:fs'
+import { runInNewContext } from 'node:vm'
+import { expect, it } from 'vitest'
+import { parse } from 'yaml'
+import { compileAggregateExpression } from './pr-aggregate-gate-context.mjs'
+
+const workflow = parse(readFileSync('.github/workflows/node-server-tests.yml', 'utf8'))
+const persistence = workflow.jobs.persistence
+const shouldPersist = compileAggregateExpression(persistence.if, ['needs', 'github'])
+
+function context({ qualification, producer = 'success', event = 'pull_request', draft = false }) {
+  return {
+    github: { event_name: event, event: { pull_request: { draft } } },
+    needs: {
+      changes: { outputs: { qualification } },
+      mobile_web_bundle: { result: producer }
+    }
+  }
+}
+
+it.each([
+  { qualification: 'true', producer: 'success', expected: true },
+  { qualification: '', producer: 'success', expected: true },
+  { qualification: 'true', producer: 'failure', expected: false },
+  { qualification: 'true', producer: 'cancelled', expected: false },
+  { qualification: 'true', producer: 'skipped', expected: false },
+  { qualification: '', producer: 'skipped', expected: false },
+  { qualification: 'false', producer: 'skipped', expected: true },
+  { qualification: 'false', producer: 'skipped', draft: true, expected: false },
+  { producer: 'success', event: 'workflow_dispatch', expected: true },
+  { producer: 'success', event: 'schedule', expected: true }
+])('preserves mobile producer failure and test-only behavior: %j', (scenario) => {
+  const ctx = context(scenario)
+  expect(persistence.needs).toEqual(['changes', 'mobile_web_bundle'])
+  expect(shouldPersist(ctx).coerceString()).toBe(String(scenario.expected))
+  expect(shouldPersist(ctx, true).coerceString()).toBe('false')
+})
+
+it('uses the shared page for qualification and builds locally only when its producer is skipped', () => {
+  const download = persistence.steps.find((step) => step.with?.name === 'orcad-mobile-web-bundle')
+  const build = persistence.steps.find((step) => step.uses?.includes('build-mobile-web-bundle'))
+  const serverBuild = persistence.steps.find((step) => step.run === 'pnpm build:orcad')
+  expect(download.uses).toBe('actions/download-artifact@v8')
+  expect(download.with.path).toBe('out/mobile-web')
+  expect(persistence.steps.indexOf(download)).toBeLessThan(persistence.steps.indexOf(serverBuild))
+  expect(persistence.steps.indexOf(build)).toBeLessThan(persistence.steps.indexOf(serverBuild))
+  for (const qualification of ['true', '', undefined, 'false']) {
+    const ctx = context({ qualification })
+    expect(compileAggregateExpression(download.if)(ctx).coerceString()).toBe(
+      String(qualification !== 'false')
+    )
+    expect(compileAggregateExpression(build.if)(ctx).coerceString()).toBe(
+      String(qualification === 'false')
+    )
+  }
+  expect(serverBuild['continue-on-error']).toBeUndefined()
+})
+
+it('starts independent Linux qualification without waiting for another platform', () => {
+  for (const name of ['linux_glibc_floor', 'linux_glibc217_compat', 'linux_musl']) {
+    const job = workflow.jobs[name]
+    expect([job.needs].flat()).not.toContain('persistence')
+    expect(job.if).not.toContain('needs.persistence')
+    const evaluate = compileAggregateExpression(job.if, ['needs', 'github', 'inputs'])
+    const ctx = { ...context({ qualification: 'true' }), inputs: { build_template: true } }
+    expect(evaluate(ctx).coerceString()).toBe('true')
+    expect(evaluate(ctx, true).coerceString()).toBe('false')
+    const draft = {
+      ...context({ qualification: '', draft: true, producer: 'skipped' }),
+      inputs: { build_template: false }
+    }
+    expect(evaluate(draft).coerceString()).toBe('false')
+  }
+})
+
+it('requires every platform and compatibility result before publishing a desktop template', () => {
+  const template = workflow.jobs.desktop_template
+  const required = [
+    'persistence',
+    'mobile_web_bundle',
+    'linux_glibc_floor',
+    'linux_glibc217_compat',
+    'linux_musl'
+  ]
+  expect(template.needs).toEqual(required)
+  const evaluate = compileAggregateExpression(template.if, ['needs', 'inputs'])
+  const needs = Object.fromEntries(required.map((name) => [name, { result: 'success' }]))
+  const ctx = { needs, inputs: { build_template: true } }
+  expect(evaluate(ctx).coerceString()).toBe('true')
+  expect(evaluate(ctx, true).coerceString()).toBe('false')
+  for (const name of required) {
+    for (const result of ['failure', 'cancelled', 'skipped']) {
+      expect(evaluate({ ...ctx, needs: { ...needs, [name]: { result } } }).coerceString()).toBe(
+        'false'
+      )
+    }
+  }
+})
+
+it('avoids template download-cache transfers while retaining native and verification caches', () => {
+  const install = persistence.steps.find((step) => step.id === 'dependencies')
+  expect(install.with['native-runtime']).toContain("runner.os == 'Windows' && 'node'")
+  expect(install.with['cache-pnpm-verification']).toBeUndefined()
+  expect(install.with['persist-native-cache']).toBeUndefined()
+  const source = install.with['cache-pnpm-store'].slice(3, -2)
+  for (const os of ['Linux', 'macOS', 'Windows']) {
+    for (const buildTemplate of [true, false]) {
+      expect(
+        runInNewContext(source, { inputs: { build_template: buildTemplate }, runner: { os } })
+      ).toBe(!buildTemplate && os !== 'Windows')
+    }
+  }
+})