@@ -1,7 +1,7 @@
 name: desktop-e2e
 
 # Smoke coverage of the real Electron shell on desktop changes. Three isolated runners
-# partition the complete suite by Playwright test-file groups; workers remain serial per runner.
+# partition complete test files by measured duration; workers remain serial per runner.
 # The weekly
 # advisory canary against electron@latest so Chromium-cadence breakage surfaces
 # before an upgrade is attempted.
@@ -47,6 +47,8 @@ on:
       - 'packages/utils/**'
       - 'bun.lock'
       - 'package.json'
+      - 'scripts/desktop-e2e.ts'
+      - 'scripts/duration-shards.ts'
   schedule:
     - cron: '23 9 * * 1'
   workflow_dispatch:
@@ -108,7 +110,7 @@ jobs:
 
       - name: Run Playwright _electron smoke suite
         working-directory: apps/desktop
-        run: bunx playwright test --shard=${{ matrix.shard }}/3 --reporter=line,json
+        run: bun run ../../scripts/desktop-e2e.ts ${{ matrix.shard }}/3
         env:
           PLAYWRIGHT_JSON_OUTPUT_FILE: test-results/desktop-smoke.json
           BACKGROUND_EXECUTOR_REPORT_PATH: test-results/background-executor-report.json
@@ -127,7 +129,10 @@ jobs:
         uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: desktop-smoke-reports-${{ matrix.shard }}
-          path: apps/desktop/test-results/desktop-smoke.json
+          path: |
+            apps/desktop/test-results/desktop-smoke.json
+            apps/desktop/test-results/desktop-shard-plan.json
+            apps/desktop/test-results/desktop-discovery.json
           if-no-files-found: ignore
           retention-days: 7
 
 
@@ -0,0 +1,20 @@
+{
+  "background-executor.spec.ts": 131.12,
+  "browser-chrome.spec.ts": 15.28,
+  "browser-focus.spec.ts": 6.53,
+  "browser-page-dialogs.spec.ts": 11.81,
+  "browser-tools.spec.ts": 94.66,
+  "chat-panel.spec.ts": 31.08,
+  "check-report.spec.ts": 3.78,
+  "computer-use.spec.ts": 2.07,
+  "desktop-tools-live-sim.spec.ts": 0.0,
+  "local-files.spec.ts": 27.68,
+  "packaged-smoke.spec.ts": 0.0,
+  "password-autofill.spec.ts": 46.56,
+  "session-cookies.spec.ts": 11.45,
+  "smoke.spec.ts": 25.56,
+  "source-connect.spec.ts": 41.49,
+  "terminal-cancel.spec.ts": 199.76,
+  "update-notification.spec.ts": 19.55,
+  "updater.spec.ts": 2.48
+}
@@ -0,0 +1,70 @@
+import { spawnSync } from 'node:child_process'
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { createLogger } from '@sim/logger'
+import { escapeRegExp } from '@sim/utils/string'
+import { partitionFiles } from './duration-shards'
+
+interface Suite {
+  specs?: { file: string }[]
+  suites?: Suite[]
+}
+
+interface DiscoveryReport {
+  config: { rootDir: string }
+  suites: Suite[]
+  errors: unknown[]
+}
+
+const logger = createLogger('DesktopE2E')
+const match = /^(\d+)\/(\d+)$/.exec(process.argv[2] ?? '')
+if (!match) throw new Error('Usage: bun run ../../scripts/desktop-e2e.ts <shard>/<total>')
+const index = Number(match[1])
+const count = Number(match[2])
+if (!Number.isSafeInteger(index) || !Number.isSafeInteger(count) || index < 1 || index > count) {
+  throw new Error('Invalid desktop shard index or count')
+}
+
+mkdirSync('test-results', { recursive: true })
+const discoveryPath = resolve('test-results/desktop-discovery.json')
+const discovery = spawnSync('bunx', ['playwright', 'test', '--list', '--reporter=json'], {
+  stdio: 'inherit',
+  env: { ...process.env, PLAYWRIGHT_JSON_OUTPUT_FILE: discoveryPath },
+})
+if (discovery.error) throw discovery.error
+if (discovery.status !== 0) process.exit(discovery.status ?? 1)
+const discoveryJson = readFileSync(discoveryPath, 'utf8')
+const report = JSON.parse(discoveryJson) as DiscoveryReport
+if (report.errors.length > 0) throw new Error('Playwright discovery reported errors')
+const files = new Set<string>()
+function visit(suite: Suite): void {
+  for (const spec of suite.specs ?? []) files.add(spec.file)
+  for (const child of suite.suites ?? []) visit(child)
+}
+for (const suite of report.suites) visit(suite)
+if (count > files.size) throw new Error('More desktop shards than discovered test files')
+const durations = JSON.parse(
+  readFileSync(new URL('../apps/desktop/e2e-durations.json', import.meta.url), 'utf8')
+) as Record<string, number>
+const shards = partitionFiles([...files], durations, count)
+const selected = shards[index - 1]
+if (selected.length === 0) throw new Error('Desktop shard selected no test files')
+logger.info(`Running desktop shard ${index}/${count}: ${selected.join(', ')}`)
+const run = spawnSync(
+  'bunx',
+  [
+    'playwright',
+    'test',
+    ...selected.map((file) => `^${escapeRegExp(resolve(report.config.rootDir, file))}$`),
+    '--reporter=line,json',
+  ],
+  { stdio: 'inherit', env: process.env }
+)
+mkdirSync('test-results', { recursive: true })
+writeFileSync(discoveryPath, discoveryJson)
+writeFileSync(
+  'test-results/desktop-shard-plan.json',
+  `${JSON.stringify({ index, count, discoveredFiles: files.size, shards }, null, 2)}\n`
+)
+if (run.error) throw run.error
+process.exit(run.status ?? 1)
@@ -0,0 +1,41 @@
+import { partitionFiles } from '@scripts/duration-shards'
+import { describe, expect, it } from 'vitest'
+
+describe('duration-balanced file partitions', () => {
+  it('keeps whole files and assigns every discovered file exactly once, including unmeasured files', () => {
+    const files = ['a.spec.ts', 'b.spec.ts', 'new/nested.test.ts', 'unmeasured.spec.ts']
+    const shards = partitionFiles(
+      files,
+      { 'a.spec.ts': 100, 'b.spec.ts': 1, 'deleted.spec.ts': 999 },
+      3
+    )
+    expect(shards.flat().sort()).toEqual([...files].sort())
+    expect(shards.every((shard) => shard.length > 0)).toBe(true)
+  })
+
+  it('separates long files instead of packing them into the same shard', () => {
+    const weights = { a: 100, b: 90, c: 80, d: 20, e: 10 }
+    const shards = partitionFiles(Object.keys(weights), weights, 3)
+    const loads = shards.map((files) =>
+      files.reduce((sum, file) => sum + weights[file as keyof typeof weights], 0)
+    )
+    expect(Math.max(...loads)).toBe(100)
+  })
+
+  it('gives all runners the same partition regardless of discovery order and equal weights', () => {
+    const files = ['z', 'b', 'a', 'nested/c', 'x']
+    expect(partitionFiles(files, {}, 3)).toEqual(partitionFiles([...files].reverse(), {}, 3))
+  })
+
+  it('preserves zero-duration files without placing every skipped file in one empty shard', () => {
+    const shards = partitionFiles(['a', 'b', 'c'], { a: 0, b: 0, c: 0 }, 3)
+    expect(shards.map((files) => files.length)).toEqual([1, 1, 1])
+  })
+
+  it.each([0, -1, 1.5, Number.NaN, Number.POSITIVE_INFINITY])(
+    'rejects invalid shard count %s',
+    (count) => {
+      expect(() => partitionFiles(['a'], {}, count)).toThrow('shard count')
+    }
+  )
+})
@@ -0,0 +1,28 @@
+import { compareStrings } from '@sim/utils/string'
+
+/** Partitions discovered files without splitting their serial fixtures or omitting unmeasured files. */
+export function partitionFiles(
+  files: readonly string[],
+  durations: Record<string, number>,
+  count: number
+): string[][] {
+  if (!Number.isSafeInteger(count) || count < 1) throw new Error('Invalid shard count')
+  const measured = files
+    .map((file) => durations[file])
+    .filter((duration) => Number.isFinite(duration) && duration > 0)
+    .sort((a, b) => a - b)
+  const fallback = measured[Math.floor(measured.length / 2)] ?? 1
+  const weight = (file: string) =>
+    Number.isFinite(durations[file]) && durations[file] >= 0
+      ? Math.max(1, durations[file])
+      : fallback
+  const shards = Array.from({ length: count }, () => ({ files: [] as string[], seconds: 0 }))
+  for (const file of [...files].sort((a, b) => weight(b) - weight(a) || compareStrings(a, b))) {
+    const target = shards.reduce((smallest, shard) =>
+      shard.seconds < smallest.seconds ? shard : smallest
+    )
+    target.files.push(file)
+    target.seconds += weight(file)
+  }
+  return shards.map((shard) => shard.files.sort(compareStrings))
+}