diff --git a/.github/workflows/integration-mobile-test-qvac-lib-infer-parakeet.yml b/.github/workflows/integration-mobile-test-qvac-lib-infer-parakeet.yml
index 3d549200cd..f8c8d2b880 100644
--- a/.github/workflows/integration-mobile-test-qvac-lib-infer-parakeet.yml
+++ b/.github/workflows/integration-mobile-test-qvac-lib-infer-parakeet.yml
@@ -18,6 +18,17 @@ on:
         default: "packages/qvac-lib-infer-parakeet"
   workflow_dispatch:
     inputs:
+      # TODO(QVAC-17801): the `default: main` here is a footgun. `gh workflow
+      # run --ref=<branch>` only selects which branch's workflow YAML to run —
+      # it does NOT populate `inputs.ref`. So a developer dispatching against a
+      # feature branch silently gets `inputs.ref="main"`, the addon checkout
+      # pulls main, and the test bundle on the device runs main's source code
+      # instead of their branch (see run #49 — pulled main, no perf markers
+      # emitted; run #50 with explicit `-f ref=<branch>` worked as expected).
+      # Fix: change default to `''` so `${{ inputs.ref || github.ref }}` falls
+      # back to the dispatched branch, matching what every other Github Action
+      # in this repo expects. Apply the same change to the sibling
+      # integration-mobile-test-*.yml workflows that copy this same pattern.
       ref:
         description: "Git ref (branch/tag/SHA) to test"
         type: string
@@ -1498,6 +1509,119 @@ jobs:
           retention-days: 30
           if-no-files-found: ignore
 
+      # ─── Mobile performance report (additive) ───
+      # Scrapes [PERF_REPORT_START]...[PERF_REPORT_END] markers (or chunked
+      # [PERF_CHUNK] sequences) from the downloaded Device Farm logs into a
+      # canonical perf-report.json that scripts/perf-report/aggregate.js
+      # already understands. Same shape as the OCR mobile pipeline so the
+      # weekly Performance Report workflow can pick parakeet up automatically.
+      - name: Extract performance report from mobile logs
+        if: always() && steps.schedule_run.outputs.run_arn_1
+        run: |
+          ARTIFACT_DIR="${GITHUB_WORKSPACE}/devicefarm-logs/${{ matrix.platform }}"
+          CONSOLE_DIR="${GITHUB_WORKSPACE}/console-logs/${{ matrix.platform }}"
+          OUTPUT_DIR="${GITHUB_WORKSPACE}/perf-results/${{ matrix.platform }}"
+          mkdir -p "$OUTPUT_DIR"
+
+          SEARCH_DIR=""
+          if [ -d "$CONSOLE_DIR" ] && [ -n "$(ls -A "$CONSOLE_DIR" 2>/dev/null)" ]; then
+            SEARCH_DIR="$CONSOLE_DIR"
+          elif [ -d "$ARTIFACT_DIR" ] && [ -n "$(ls -A "$ARTIFACT_DIR" 2>/dev/null)" ]; then
+            SEARCH_DIR="$ARTIFACT_DIR"
+          fi
+
+          if [ -z "$SEARCH_DIR" ]; then
+            echo "No console-logs/ or devicefarm-logs/ available — skipping perf extraction"
+            exit 0
+          fi
+
+          echo "Scanning $SEARCH_DIR for [PERF_REPORT_START] / [PERF_CHUNK] markers..."
+          node "${GITHUB_WORKSPACE}/addon/scripts/perf-report/extract-from-log.js" \
+            "$SEARCH_DIR" \
+            "$OUTPUT_DIR/performance-report.json" \
+            --run-number "${{ github.run_number }}" || true
+
+          if find "$OUTPUT_DIR" -name "performance-report.json" -type f -size +0 | head -1 | grep -q .; then
+            echo "Perf report extracted; rendering markdown + HTML..."
+            node "${GITHUB_WORKSPACE}/addon/scripts/perf-report/aggregate.js" \
+              --dir "$OUTPUT_DIR" \
+              --output "$OUTPUT_DIR/performance-report.md" \
+              --output-html "$OUTPUT_DIR/performance-report.html" \
+              --output-json "$OUTPUT_DIR/performance-summary.json" || true
+          else
+            echo "No perf-report.json produced — markers were not present in this run's logs."
+            echo "(This is expected on the first run if no integration test has been wired"
+            echo " yet to call recordParakeetStats(); failing soft so the job keeps green.)"
+          fi
+
+      # Render the rich Step Summary table (Test | EP | RTF | Wall | Tokens/sec
+      # | Encoder | Decoder | Audio) using render-step-summary.js, which honors
+      # METRIC_COLUMNS.parakeet from scripts/test-utils/performance-reporter.js.
+      # aggregate.js's Markdown renderer only emits a single "Mean Total Time"
+      # column and was producing an unhelpful summary even though the extracted
+      # performance-report.json contains every metric we need (run #50 proved
+      # this — RTF/Wall/Encoder/Decoder were all in the JSON artifact, just
+      # not in the rendered Markdown). This matches the NMT mobile pattern.
+      - name: Append performance summary to job step summary
+        if: always() && steps.schedule_run.outputs.run_arn_1
+        run: |
+          OUTPUT_DIR="${GITHUB_WORKSPACE}/perf-results/${{ matrix.platform }}"
+          RENDERER="${GITHUB_WORKSPACE}/addon/scripts/perf-report/render-step-summary.js"
+
+          if [ ! -f "$RENDERER" ]; then
+            echo "::warning::$RENDERER not found; falling back to aggregator markdown"
+            REPORT_MD="$OUTPUT_DIR/performance-report.md"
+            if [ -s "$REPORT_MD" ]; then
+              echo "## Mobile Performance — Parakeet (${{ matrix.platform }})" >> "$GITHUB_STEP_SUMMARY"
+              echo "" >> "$GITHUB_STEP_SUMMARY"
+              cat "$REPORT_MD" >> "$GITHUB_STEP_SUMMARY"
+            else
+              echo "No mobile performance report rendered for parakeet on ${{ matrix.platform }}." >> "$GITHUB_STEP_SUMMARY"
+            fi
+            exit 0
+          fi
+
+          # Single-device layout: extract-from-log.js writes the JSON at the
+          # platform root when there's one device in the matrix.
+          if [ -f "$OUTPUT_DIR/performance-report.json" ]; then
+            node "$RENDERER" \
+              "$OUTPUT_DIR/performance-report.json" \
+              "$GITHUB_STEP_SUMMARY" \
+              --title "Mobile Performance: parakeet (${{ matrix.platform }})"
+            exit 0
+          fi
+
+          # Multi-device layout: per-device subdirectories. Render one block
+          # per device so each device's CPU vs GPU rows show up cleanly.
+          RENDERED=0
+          for DEV_DIR in "$OUTPUT_DIR"/*/; do
+            DEV_REPORT="$DEV_DIR/performance-report.json"
+            [ -f "$DEV_REPORT" ] || continue
+            DEV_NAME=$(basename "$DEV_DIR" | tr '_' ' ')
+            node "$RENDERER" \
+              "$DEV_REPORT" \
+              "$GITHUB_STEP_SUMMARY" \
+              --title "Mobile Performance: parakeet (${{ matrix.platform }} · ${DEV_NAME})"
+            RENDERED=$((RENDERED + 1))
+          done
+
+          if [ "$RENDERED" = "0" ]; then
+            echo "No mobile performance report rendered for parakeet on ${{ matrix.platform }}." >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+      - name: Upload mobile performance report
+        if: always() && steps.schedule_run.outputs.run_arn_1
+        uses: actions/upload-artifact@v4
+        with:
+          name: perf-report-parakeet-${{ matrix.platform }}-${{ github.run_number }}
+          path: |
+            perf-results/${{ matrix.platform }}/**/performance-report.json
+            perf-results/${{ matrix.platform }}/performance-report.html
+            perf-results/${{ matrix.platform }}/performance-report.md
+            perf-results/${{ matrix.platform }}/performance-summary.json
+          retention-days: 90
+          if-no-files-found: ignore
+
       - name: Upload Full Device Farm Logs
         if: always() && steps.schedule_run.outputs.run_arn_1
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/on-pr-qvac-lib-infer-parakeet.yml b/.github/workflows/on-pr-qvac-lib-infer-parakeet.yml
index 709ef7e11b..61cee026cf 100644
--- a/.github/workflows/on-pr-qvac-lib-infer-parakeet.yml
+++ b/.github/workflows/on-pr-qvac-lib-infer-parakeet.yml
@@ -202,11 +202,65 @@ jobs:
       repository: ${{ needs.context.outputs.repository }}
       ref: ${{ needs.context.outputs.ref }}
 
+  combine-unified-performance-report:
+    needs: [context, run-integration-tests, run-mobile-integration-tests]
+    if: always() && (needs.context.outputs.run_verify == 'true' || github.event_name == 'workflow_dispatch')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      actions: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # 6.0.2
+        with:
+          repository: ${{ github.repository }}
+          ref: ${{ github.event_name == 'pull_request_target' && needs.context.outputs.base_sha || github.sha }}
+          token: ${{ secrets.PAT_TOKEN }}
+
+      - name: Download desktop RTF artifacts
+        continue-on-error: true
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # 8.0.1
+        with:
+          pattern: rtf-results-*
+          path: benchmark-artifacts/desktop
+          merge-multiple: true
+
+      - name: Download mobile performance artifacts
+        continue-on-error: true
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # 8.0.1
+        with:
+          pattern: perf-report-parakeet-*
+          path: benchmark-artifacts/mobile
+          merge-multiple: false
+
+      - name: Generate unified Parakeet performance report
+        run: |
+          node scripts/perf-report/aggregate-parakeet-rtf.js \
+            --dir benchmark-artifacts \
+            --manual-dir packages/qvac-lib-infer-parakeet/benchmarks/manual-results \
+            --output benchmark-artifacts/parakeet-unified-performance-report.md \
+            --output-json benchmark-artifacts/parakeet-unified-performance-report.json \
+            --output-html benchmark-artifacts/parakeet-unified-performance-report.html
+
+      - name: Add unified performance summary
+        run: |
+          node -e "process.stdout.write(require('fs').readFileSync('benchmark-artifacts/parakeet-unified-performance-report.md', 'utf8'))" >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Upload unified Parakeet performance report
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # 7.0.0
+        with:
+          name: parakeet-unified-performance-report
+          path: |
+            benchmark-artifacts/parakeet-unified-performance-report.md
+            benchmark-artifacts/parakeet-unified-performance-report.json
+            benchmark-artifacts/parakeet-unified-performance-report.html
+          retention-days: 30
+
   merge-guard:
-    needs: [authorize, sanity-checks, cpp-lint, cpp-tests-coverage, prebuild, run-integration-tests, run-mobile-integration-tests]
+    needs: [authorize, sanity-checks, cpp-lint, cpp-tests-coverage, prebuild, run-integration-tests, run-mobile-integration-tests, combine-unified-performance-report]
     if: always()
     uses: ./.github/workflows/public-pr.yml
     with:
       sanity-checks-status: ${{ needs.sanity-checks.result == 'success' && (needs.cpp-lint.result == 'success' || needs.cpp-lint.result == 'skipped') && (needs.cpp-tests-coverage.result == 'success' || needs.cpp-tests-coverage.result == 'skipped') }}
       build-status: ${{ needs.prebuild.result == 'success' || needs.prebuild.result == 'skipped' }}
-      integration-tests-status: ${{ (needs.run-integration-tests.result == 'success' || needs.run-integration-tests.result == 'skipped') && (needs.run-mobile-integration-tests.result == 'success' || needs.run-mobile-integration-tests.result == 'skipped') }}
+      integration-tests-status: ${{ (needs.run-integration-tests.result == 'success' || needs.run-integration-tests.result == 'skipped') && (needs.run-mobile-integration-tests.result == 'success' || needs.run-mobile-integration-tests.result == 'skipped') && (needs.combine-unified-performance-report.result == 'success' || needs.combine-unified-performance-report.result == 'skipped') }}
diff --git a/.github/workflows/perf-report.yml b/.github/workflows/perf-report.yml
index 979a1dca32..ccc73ddc67 100644
--- a/.github/workflows/perf-report.yml
+++ b/.github/workflows/perf-report.yml
@@ -14,6 +14,7 @@ on:
           - nmtcpp
           - llamacpp-llm
           - onnx-tts
+          - parakeet
       workflow_name:
         description: "Integration test workflow name to query"
         type: choice
@@ -24,6 +25,7 @@ on:
           - "Integration Tests (NMTCPP)"
           - "Integration Tests (LLM)"
           - "Integration Tests (TTS)"
+          - "Mobile Integration Tests (Parakeet)"
       runs:
         description: "Number of recent runs to aggregate"
         type: number
@@ -120,6 +122,15 @@ jobs:
             --output-json reports/onnx-tts-performance.json \
             --output-html reports/onnx-tts-performance.html || true
 
+          echo "=== Parakeet (Mobile) ==="
+          node scripts/perf-report/aggregate.js \
+            --addon parakeet \
+            --workflow "Mobile Integration Tests (Parakeet)" \
+            --runs 6 \
+            --output reports/parakeet-mobile-performance.md \
+            --output-json reports/parakeet-mobile-performance.json \
+            --output-html reports/parakeet-mobile-performance.html || true
+
       # ─── Phase B: COMET quality scoring for NMT (weekly aggregate only) ───
       # Runs only on the Monday scheduled trigger, or on workflow_dispatch
       # when inputs.addon == 'nmtcpp'. Intentionally NOT wired into per-PR
diff --git a/packages/qvac-lib-infer-parakeet/scripts/generate-mobile-integration-tests.js b/packages/qvac-lib-infer-parakeet/scripts/generate-mobile-integration-tests.js
index e902216fa9..b82c8ece26 100644
--- a/packages/qvac-lib-infer-parakeet/scripts/generate-mobile-integration-tests.js
+++ b/packages/qvac-lib-infer-parakeet/scripts/generate-mobile-integration-tests.js
@@ -28,6 +28,7 @@ function toFunctionName (fileName) {
 
 function buildFileContents (files) {
   const lines = []
+  const functionNames = files.map(toFunctionName)
   lines.push("'use strict'")
   lines.push("require('./integration-runtime.cjs')")
   lines.push('')
@@ -39,7 +40,7 @@ function buildFileContents (files) {
 
   for (let i = 0; i < files.length; i++) {
     const file = files[i]
-    const fnName = toFunctionName(file)
+    const fnName = functionNames[i]
     const relativePath = `../integration/${file}`
     lines.push(`async function ${fnName} (options = {}) { // eslint-disable-line no-unused-vars`)
     lines.push(`  return runIntegrationModule('${relativePath}', options)`)
@@ -49,6 +50,14 @@ function buildFileContents (files) {
     }
   }
 
+  lines.push('')
+  lines.push('module.exports = {')
+  for (let i = 0; i < functionNames.length; i++) {
+    const suffix = i < functionNames.length - 1 ? ',' : ''
+    lines.push(`  ${functionNames[i]}${suffix}`)
+  }
+  lines.push('}')
+
   return `${lines.join('\n')}\n`
 }
 
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/helpers.js b/packages/qvac-lib-infer-parakeet/test/integration/helpers.js
index 9629f93ec5..6c7bb379e5 100644
--- a/packages/qvac-lib-infer-parakeet/test/integration/helpers.js
+++ b/packages/qvac-lib-infer-parakeet/test/integration/helpers.js
@@ -10,6 +10,179 @@ const platform = os.platform()
 const arch = os.arch()
 const isMobile = platform === 'ios' || platform === 'android'
 
+// ---------------------------------------------------------------------------
+// Performance reporter — captures Parakeet integration-test stats and emits
+// them through the shared QVAC perf-report pipeline (desktop) or via console
+// markers extractable from Device Farm logs (mobile).
+//
+// On desktop we require the shared scripts/test-utils/performance-reporter
+// directly. On mobile that path lives outside the addon package and bare-pack
+// can't bundle it, so we fall back to an inline lightweight reporter that
+// chunks JSON into [PERF_REPORT_START]/[PERF_CHUNK] markers — the exact
+// format scripts/perf-report/extract-from-log.js already understands.
+// ---------------------------------------------------------------------------
+let createPerformanceReporter
+const _scriptBase = path.join('..', '..', '..', '..', 'scripts', 'test-utils')
+try {
+  const perfReporterMod = require(path.join(_scriptBase, 'performance-reporter'))
+  perfReporterMod.configure({ fs, path, process, os })
+  createPerformanceReporter = perfReporterMod.createPerformanceReporter
+} catch (_) {
+  createPerformanceReporter = function (opts) {
+    const _results = []
+    const _startedAt = new Date().toISOString()
+    const _addon = (opts && opts.addon) || 'parakeet'
+    const _addonType = (opts && opts.addonType) || 'parakeet'
+    const _device = {
+      name: platform,
+      platform,
+      os_version: '',
+      arch: os.arch ? os.arch() : '',
+      runner: 'device-farm'
+    }
+
+    return {
+      record (testName, metrics, extra) {
+        const entry = {
+          test: testName,
+          execution_provider: (extra && extra.execution_provider) || null,
+          metrics: Object.assign({
+            real_time_factor: null,
+            wall_time_ms: null,
+            tps: null,
+            encoder_time_ms: null,
+            decoder_time_ms: null,
+            audio_duration_ms: null,
+            total_time_ms: null
+          }, metrics),
+          input: (extra && extra.input) || null,
+          output: (extra && extra.output) || null
+        }
+        _results.push(entry)
+      },
+      toJSON () {
+        return {
+          schema_version: '1.0',
+          addon: _addon,
+          addon_type: _addonType,
+          timestamp: _startedAt,
+          device: _device,
+          results: _results
+        }
+      },
+      writeReport () {
+        const json = JSON.stringify(this.toJSON())
+        const dirs = []
+        if (global.testDir) dirs.push(global.testDir)
+        if (platform === 'android') {
+          dirs.push('/sdcard/Android/data/io.tether.test.qvac/files')
+          dirs.push('/storage/emulated/0/Android/data/io.tether.test.qvac/files')
+          dirs.push('/data/local/tmp')
+        }
+        dirs.push('/tmp')
+        for (let di = 0; di < dirs.length; di++) {
+          try {
+            try { fs.mkdirSync(dirs[di], { recursive: true }) } catch (_) {}
+            const p = path.join(dirs[di], 'perf-report.json')
+            fs.writeFileSync(p, json)
+            console.log('[PERF_REPORT_PATH]' + p)
+          } catch (e) {
+            console.log('[perf-reporter] write to ' + dirs[di] + ' failed: ' + e.message)
+          }
+        }
+      },
+      writeStepSummary () {},
+      writeToConsole () {
+        try {
+          const json = JSON.stringify(this.toJSON())
+          const CHUNK = 800
+          if (json.length <= CHUNK) {
+            console.log('[PERF_REPORT_START]' + json + '[PERF_REPORT_END]')
+          } else {
+            const id = Date.now().toString(36)
+            const n = Math.ceil(json.length / CHUNK)
+            for (let i = 0; i < n; i++) {
+              console.log('[PERF_CHUNK:' + id + ':' + i + ':' + n + ']' + json.substring(i * CHUNK, (i + 1) * CHUNK))
+            }
+          }
+        } catch (err) {
+          console.log('[perf-reporter] mobile console write failed: ' + err.message)
+        }
+      },
+      get length () { return _results.length }
+    }
+  }
+}
+
+const _perfReporter = createPerformanceReporter({
+  addon: 'parakeet',
+  addonType: 'parakeet'
+})
+
+const _reportPath = path.resolve('.', 'test/results/performance-report.json')
+let _reportScheduled = false
+
+function _flushPerfReport () {
+  if (_perfReporter.length === 0) return
+  try { _perfReporter.writeReport(_reportPath) } catch (_) {}
+  try { _perfReporter.writeToConsole() } catch (_) {}
+}
+
+function _scheduleReportWrite () {
+  if (_reportScheduled) return
+  _reportScheduled = true
+  process.on('exit', _flushPerfReport)
+}
+
+/**
+ * Record a parakeet inference stats row through the shared perf reporter.
+ *
+ * @param {string} label - Test label, e.g. '[CPU] multiple-transcriptions run 1'.
+ *                         The execution-provider is auto-detected from the
+ *                         label when it contains [CPU] or [GPU].
+ * @param {Object} stats - Stats object from the JobEnded event:
+ *                         { realTimeFactor, totalTime, audioDurationMs,
+ *                           tokensPerSecond, encoderMs, decoderMs,
+ *                           totalWallMs, ... }
+ * @param {Object} [extra] - Optional { wallMs, output, executionProvider }
+ *                            overrides.
+ */
+function recordParakeetStats (label, stats, extra) {
+  if (!stats || typeof stats !== 'object') return
+  const epOverride = extra && extra.executionProvider
+  const ep = epOverride || (/\[gpu\]/i.test(label) ? 'gpu' : /\[cpu\]/i.test(label) ? 'cpu' : null)
+
+  const rtf = typeof stats.realTimeFactor === 'number' ? stats.realTimeFactor : null
+  const totalTimeSec = typeof stats.totalTime === 'number' ? stats.totalTime : null
+  const totalTimeMs = totalTimeSec !== null ? Math.round(totalTimeSec * 1000) : null
+  const wallMs = (extra && typeof extra.wallMs === 'number')
+    ? Math.round(extra.wallMs)
+    : (typeof stats.totalWallMs === 'number' ? Math.round(stats.totalWallMs) : totalTimeMs)
+  const tps = typeof stats.tokensPerSecond === 'number' ? stats.tokensPerSecond : null
+  const encoderMs = typeof stats.encoderMs === 'number' ? Math.round(stats.encoderMs) : null
+  const decoderMs = typeof stats.decoderMs === 'number' ? Math.round(stats.decoderMs) : null
+  const audioMs = typeof stats.audioDurationMs === 'number' ? Math.round(stats.audioDurationMs) : null
+
+  _perfReporter.record(label, {
+    real_time_factor: rtf,
+    wall_time_ms: wallMs,
+    tps,
+    encoder_time_ms: encoderMs,
+    decoder_time_ms: decoderMs,
+    audio_duration_ms: audioMs,
+    total_time_ms: totalTimeMs
+  }, {
+    execution_provider: ep,
+    output: extra && extra.output ? String(extra.output) : null
+  })
+  _scheduleReportWrite()
+
+  if (isMobile) {
+    try { _perfReporter.writeReport() } catch (_) {}
+    try { _perfReporter.writeToConsole() } catch (_) {}
+  }
+}
+
 // Mobile paths use static string literals so bare-pack can trace them into
 // the bundle.  Desktop paths use variables so bare-pack skips them — the
 // relative ../../ paths don't exist in the mobile test-framework layout.
@@ -744,5 +917,7 @@ module.exports = {
   isMobile,
   platform,
   arch,
-  MODEL_CONFIGS
+  MODEL_CONFIGS,
+  recordParakeetStats,
+  flushParakeetPerfReport: _flushPerfReport
 }
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-ctc-cpu.test.js b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-ctc-cpu.test.js
new file mode 100644
index 0000000000..fc9ee191b8
--- /dev/null
+++ b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-ctc-cpu.test.js
@@ -0,0 +1,11 @@
+'use strict'
+
+const test = require('brittle')
+const { runMobilePerfCase } = require('./mobile-perf-runner.js')
+
+test('Mobile perf CTC CPU', { timeout: 600000 }, async (t) => {
+  await runMobilePerfCase(t, {
+    modelType: 'ctc',
+    useGPU: false
+  })
+})
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-ctc-gpu.test.js b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-ctc-gpu.test.js
new file mode 100644
index 0000000000..3167814019
--- /dev/null
+++ b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-ctc-gpu.test.js
@@ -0,0 +1,11 @@
+'use strict'
+
+const test = require('brittle')
+const { runMobilePerfCase } = require('./mobile-perf-runner.js')
+
+test('Mobile perf CTC GPU', { timeout: 600000 }, async (t) => {
+  await runMobilePerfCase(t, {
+    modelType: 'ctc',
+    useGPU: true
+  })
+})
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-eou-cpu.test.js b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-eou-cpu.test.js
new file mode 100644
index 0000000000..769303d2bc
--- /dev/null
+++ b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-eou-cpu.test.js
@@ -0,0 +1,11 @@
+'use strict'
+
+const test = require('brittle')
+const { runMobilePerfCase } = require('./mobile-perf-runner.js')
+
+test('Mobile perf EOU CPU', { timeout: 600000 }, async (t) => {
+  await runMobilePerfCase(t, {
+    modelType: 'eou',
+    useGPU: false
+  })
+})
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-eou-gpu.test.js b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-eou-gpu.test.js
new file mode 100644
index 0000000000..96eee08cc3
--- /dev/null
+++ b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-eou-gpu.test.js
@@ -0,0 +1,11 @@
+'use strict'
+
+const test = require('brittle')
+const { runMobilePerfCase } = require('./mobile-perf-runner.js')
+
+test('Mobile perf EOU GPU', { timeout: 600000 }, async (t) => {
+  await runMobilePerfCase(t, {
+    modelType: 'eou',
+    useGPU: true
+  })
+})
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-runner.js b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-runner.js
new file mode 100644
index 0000000000..912819d824
--- /dev/null
+++ b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-runner.js
@@ -0,0 +1,174 @@
+'use strict'
+
+const fs = require('bare-fs')
+const path = require('bare-path')
+const {
+  binding,
+  ParakeetInterface,
+  detectPlatform,
+  setupJsLogger,
+  getTestPaths,
+  ensureModelForType,
+  getNamedPathsConfig,
+  isMobile,
+  recordParakeetStats
+} = require('./helpers.js')
+
+const platform = detectPlatform()
+const { samplesDir } = getTestPaths()
+const NUM_TRANSCRIPTIONS = 3
+
+function loadSampleAudio () {
+  const samplePath = path.join(samplesDir, 'sample.raw')
+  if (!fs.existsSync(samplePath)) return null
+
+  const rawBuffer = fs.readFileSync(samplePath)
+  const pcmData = new Int16Array(rawBuffer.buffer, rawBuffer.byteOffset, rawBuffer.length / 2)
+  const audioData = new Float32Array(pcmData.length)
+  for (let i = 0; i < pcmData.length; i++) {
+    audioData[i] = pcmData[i] / 32768.0
+  }
+  return audioData
+}
+
+async function runMobilePerfCase (t, opts) {
+  const modelType = opts.modelType
+  const useGPU = opts.useGPU
+  const epLabel = useGPU ? '[GPU]' : '[CPU]'
+  const modelLabel = `[${modelType}]`
+
+  if (!isMobile) {
+    t.pass(`${modelLabel} ${epLabel} mobile perf case skipped on desktop`)
+    return
+  }
+
+  const loggerBinding = setupJsLogger(binding)
+  let parakeet = null
+  let outputResolve = null
+  const allResults = []
+  const receivedStats = []
+
+  function finishCurrentRun () {
+    if (outputResolve) {
+      outputResolve()
+      outputResolve = null
+    }
+  }
+
+  try {
+    console.log('\n' + '='.repeat(60))
+    console.log(`MOBILE PERF CASE ${modelLabel} ${epLabel}`)
+    console.log('='.repeat(60))
+    console.log(` Platform: ${platform}`)
+    console.log(` Model type: ${modelType}`)
+    console.log(` Number of transcriptions: ${NUM_TRANSCRIPTIONS}`)
+    console.log(` useGPU: ${useGPU}`)
+    console.log('='.repeat(60) + '\n')
+
+    const modelPath = await ensureModelForType(modelType)
+    if (!modelPath) {
+      t.fail(`Unable to resolve model for type: ${modelType}`)
+      return
+    }
+    console.log(` Model path: ${modelPath}`)
+
+    const audioData = loadSampleAudio()
+    if (!audioData) {
+      t.pass('Test skipped - sample audio not found')
+      return
+    }
+    console.log(`   Audio duration: ${(audioData.length / 16000).toFixed(2)}s\n`)
+
+    const config = {
+      modelPath,
+      modelType,
+      maxThreads: 4,
+      useGPU,
+      sampleRate: 16000,
+      channels: 1,
+      ...getNamedPathsConfig(modelType, modelPath)
+    }
+
+    function outputCallback (handle, event, id, output, error) {
+      if (event === 'Output' && Array.isArray(output)) {
+        for (const segment of output) {
+          if (segment && segment.text) {
+            allResults.push({ jobId: id, segment })
+          }
+        }
+      } else if (event === 'JobEnded' && output) {
+        receivedStats.push({ jobId: id, stats: output })
+        finishCurrentRun()
+      } else if (event === 'Error' || error) {
+        finishCurrentRun()
+      }
+    }
+
+    parakeet = new ParakeetInterface(binding, config, outputCallback)
+    await parakeet.activate()
+    console.log('   Model activated\n')
+
+    const timings = []
+    for (let run = 1; run <= NUM_TRANSCRIPTIONS; run++) {
+      console.log(`=== Transcription ${run}/${NUM_TRANSCRIPTIONS} ===`)
+      const runStartTime = Date.now()
+      const startResultCount = allResults.length
+      const outputPromise = new Promise(resolve => { outputResolve = resolve })
+
+      await parakeet.append({ type: 'audio', data: audioData.buffer })
+      await parakeet.append({ type: 'end of job' })
+
+      const timeout = setTimeout(finishCurrentRun, 600000)
+      await outputPromise
+      clearTimeout(timeout)
+
+      const runTime = Date.now() - runStartTime
+      timings.push(runTime)
+      const runResults = allResults.slice(startResultCount)
+      const runText = runResults.map(r => r.segment.text).join(' ').trim()
+
+      console.log(`   Time: ${runTime}ms`)
+      console.log(`   Segments: ${runResults.length}`)
+      console.log(`   Text preview: "${runText.substring(0, 80)}${runText.length > 80 ? '...' : ''}"`)
+
+      const jobStats = receivedStats.length > 0
+        ? receivedStats[receivedStats.length - 1].stats
+        : null
+      if (jobStats) {
+        recordParakeetStats(`${modelLabel} ${epLabel} mobile-perf run ${run}`, jobStats, {
+          wallMs: runTime,
+          output: runText
+        })
+        if (typeof jobStats.realTimeFactor === 'number') {
+          console.log(`   RTF: ${jobStats.realTimeFactor.toFixed(4)}`)
+        }
+      }
+      console.log('')
+    }
+
+    t.ok(receivedStats.length >= NUM_TRANSCRIPTIONS, `${modelLabel} ${epLabel} should receive JobEnded stats for every run (got ${receivedStats.length})`)
+    t.ok(timings.length === NUM_TRANSCRIPTIONS, `${modelLabel} ${epLabel} should complete ${NUM_TRANSCRIPTIONS} transcriptions (got ${timings.length})`)
+    console.log(`✅ Mobile perf case ${modelLabel} ${epLabel} completed successfully!\n`)
+  } finally {
+    console.log('=== Cleanup ===')
+    finishCurrentRun()
+    if (parakeet) {
+      try {
+        await parakeet.destroyInstance()
+        console.log('   Instance destroyed')
+      } catch (err) {
+        console.log('   Instance destroy error:', err.message)
+      }
+    }
+    try {
+      loggerBinding.releaseLogger()
+      console.log('   Logger released')
+    } catch (err) {
+      console.log('   Logger release error:', err.message)
+    }
+  }
+}
+
+module.exports = {
+  runMobilePerfCase
+}
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-sortformer-cpu.test.js b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-sortformer-cpu.test.js
new file mode 100644
index 0000000000..4b36163c15
--- /dev/null
+++ b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-sortformer-cpu.test.js
@@ -0,0 +1,11 @@
+'use strict'
+
+const test = require('brittle')
+const { runMobilePerfCase } = require('./mobile-perf-runner.js')
+
+test('Mobile perf Sortformer CPU', { timeout: 600000 }, async (t) => {
+  await runMobilePerfCase(t, {
+    modelType: 'sortformer',
+    useGPU: false
+  })
+})
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-sortformer-gpu.test.js b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-sortformer-gpu.test.js
new file mode 100644
index 0000000000..462a019369
--- /dev/null
+++ b/packages/qvac-lib-infer-parakeet/test/integration/mobile-perf-sortformer-gpu.test.js
@@ -0,0 +1,17 @@
+'use strict'
+
+const test = require('brittle')
+const { detectPlatform } = require('./helpers.js')
+const { runMobilePerfCase } = require('./mobile-perf-runner.js')
+
+test('Mobile perf Sortformer GPU', { timeout: 600000 }, async (t) => {
+  if (detectPlatform().startsWith('ios')) {
+    t.pass('Sortformer GPU is quarantined on iOS pending CoreML/resource investigation')
+    return
+  }
+
+  await runMobilePerfCase(t, {
+    modelType: 'sortformer',
+    useGPU: true
+  })
+})
diff --git a/packages/qvac-lib-infer-parakeet/test/integration/multiple-transcriptions.test.js b/packages/qvac-lib-infer-parakeet/test/integration/multiple-transcriptions.test.js
index 3baf4bffcb..56f75c24e1 100644
--- a/packages/qvac-lib-infer-parakeet/test/integration/multiple-transcriptions.test.js
+++ b/packages/qvac-lib-infer-parakeet/test/integration/multiple-transcriptions.test.js
@@ -10,13 +10,44 @@ const {
   setupJsLogger,
   getTestPaths,
   ensureModel,
+  ensureModelForType,
   getNamedPathsConfig,
-  isMobile
+  isMobile,
+  recordParakeetStats
 } = require('./helpers.js')
 
 const platform = detectPlatform()
 const { modelPath, samplesDir } = getTestPaths()
 
+// Device configurations for the perf-report sweep.
+// Mobile runs both CPU + GPU so the step-summary table shows the comparison
+// the team uses to spot regressions (CoreML on iOS, NNAPI on Android).
+// Desktop runs CPU only — the GPU EP isn't built into our prebuilt onnx
+// runtime for darwin/linux desktops, so a `useGPU: true` run there would
+// silently fall back to CPU and pollute the comparison.
+const ALL_DEVICE_CONFIGS = [
+  { id: 'gpu', useGPU: true },
+  { id: 'cpu', useGPU: false }
+]
+const DEVICE_CONFIGS = isMobile
+  ? ALL_DEVICE_CONFIGS
+  : ALL_DEVICE_CONFIGS.filter(c => c.id === 'cpu')
+// Keep the legacy mobile multiple-transcriptions path scoped to TDT. Non-TDT
+// mobile perf coverage lives in dedicated model/backend files so Device Farm
+// can report the exact failing case instead of one combined failure.
+const MOBILE_PERF_MODEL_TYPES = ['tdt']
+const PERF_MODEL_TYPES = isMobile ? MOBILE_PERF_MODEL_TYPES : ['tdt']
+
+async function resolvePerfModelPath (modelType) {
+  if (modelType === 'tdt') {
+    await ensureModel(modelPath)
+    return modelPath
+  }
+  const resolved = await ensureModelForType(modelType)
+  if (!resolved) throw new Error(`Unable to resolve model for type: ${modelType}`)
+  return resolved
+}
+
 /**
  * Test that multiple consecutive transcriptions work without errors.
  * This verifies:
@@ -24,168 +55,227 @@ const { modelPath, samplesDir } = getTestPaths()
  * - No memory leaks or state corruption between runs
  * - Job IDs increment correctly
  */
-test('Multiple consecutive transcriptions should work without errors', { timeout: 600000 }, async (t) => {
-  const NUM_TRANSCRIPTIONS = 3
-  const loggerBinding = setupJsLogger(binding)
-
-  console.log('\n' + '='.repeat(60))
-  console.log('MULTIPLE CONSECUTIVE TRANSCRIPTIONS TEST')
-  console.log('='.repeat(60))
-  console.log(` Platform: ${platform}`)
-  console.log(` Model path: ${modelPath}`)
-  console.log(` Number of transcriptions: ${NUM_TRANSCRIPTIONS}`)
-  console.log(` Mobile: ${isMobile}`)
-  console.log('='.repeat(60) + '\n')
-
-  // Ensure model is downloaded
-  await ensureModel(modelPath)
-
-  // Check sample audio exists
-  const samplePath = path.join(samplesDir, 'sample.raw')
-  if (!fs.existsSync(samplePath)) {
-    loggerBinding.releaseLogger()
-    t.pass('Test skipped - sample audio not found')
-    return
-  }
-
-  // Configuration
-  const config = {
-    modelPath,
-    modelType: 'tdt',
-    maxThreads: 4,
-    useGPU: false,
-    sampleRate: 16000,
-    channels: 1,
-    ...getNamedPathsConfig('tdt', modelPath)
-  }
-
-  let parakeet = null
-  const allResults = []
-
-  try {
-    console.log('=== Creating instance and loading model ===')
-
-    // Output callback to track all transcriptions
-    function outputCallback (handle, event, id, output, error) {
-      if (event === 'Output' && Array.isArray(output)) {
-        for (const segment of output) {
-          if (segment && segment.text) {
-            allResults.push({ jobId: id, segment })
-          }
-        }
+for (const modelType of PERF_MODEL_TYPES) {
+  for (const deviceConfig of DEVICE_CONFIGS) {
+    const epLabel = `[${deviceConfig.id.toUpperCase()}]`
+    const modelLabel = isMobile ? `[${modelType}]` : ''
+    const testLabel = modelLabel ? `${modelLabel} ${epLabel}` : epLabel
+    const perfLabelPrefix = modelLabel ? `${modelLabel} ${epLabel}` : epLabel
+
+    test(`Multiple consecutive transcriptions ${testLabel} should work without errors`, { timeout: 600000 }, async (t) => {
+      const NUM_TRANSCRIPTIONS = 3
+      const loggerBinding = setupJsLogger(binding)
+
+      console.log('\n' + '='.repeat(60))
+      console.log(`MULTIPLE CONSECUTIVE TRANSCRIPTIONS TEST ${testLabel}`)
+      console.log('='.repeat(60))
+      console.log(` Platform: ${platform}`)
+      if (isMobile) console.log(` Model type: ${modelType}`)
+      console.log(` Number of transcriptions: ${NUM_TRANSCRIPTIONS}`)
+      console.log(` Mobile: ${isMobile}`)
+      console.log(` useGPU: ${deviceConfig.useGPU}`)
+      console.log('='.repeat(60) + '\n')
+
+      const perfModelPath = await resolvePerfModelPath(modelType)
+      console.log(` Model path: ${perfModelPath}`)
+
+      // Check sample audio exists
+      const samplePath = path.join(samplesDir, 'sample.raw')
+      if (!fs.existsSync(samplePath)) {
+        loggerBinding.releaseLogger()
+        t.pass('Test skipped - sample audio not found')
+        return
       }
-    }
-
-    parakeet = new ParakeetInterface(binding, config, outputCallback)
-
-    await parakeet.activate()
-    console.log('   Model activated\n')
-
-    // Load audio once (read into memory)
-    const rawBuffer = fs.readFileSync(samplePath)
-    const pcmData = new Int16Array(rawBuffer.buffer, rawBuffer.byteOffset, rawBuffer.length / 2)
-    const audioData = new Float32Array(pcmData.length)
-    for (let i = 0; i < pcmData.length; i++) {
-      audioData[i] = pcmData[i] / 32768.0
-    }
-    console.log(`   Audio duration: ${(audioData.length / 16000).toFixed(2)}s\n`)
-
-    // Run multiple transcriptions
-    const timings = []
 
-    for (let run = 1; run <= NUM_TRANSCRIPTIONS; run++) {
-      console.log(`=== Transcription ${run}/${NUM_TRANSCRIPTIONS} ===`)
-      const runStartTime = Date.now()
-
-      // Clear results for this run
-      const startResultCount = allResults.length
+      // Configuration
+      const config = {
+        modelPath: perfModelPath,
+        modelType,
+        maxThreads: 4,
+        useGPU: deviceConfig.useGPU,
+        sampleRate: 16000,
+        channels: 1,
+        ...getNamedPathsConfig(modelType, perfModelPath)
+      }
 
-      // Track when this run completes
+      let parakeet = null
+      const allResults = []
+      // JobEnded payloads carry the C++ runtime stats (RTF, encoder/decoder ms,
+      // tokens/sec, audio duration). We collect them per run so the shared perf
+      // reporter can emit one row per transcription.
+      const receivedStats = []
       let outputResolve = null
-      const outputPromise = new Promise(resolve => { outputResolve = resolve })
 
-      // Watch for output from this run
-      const checkInterval = setInterval(() => {
-        if (allResults.length > startResultCount) {
-          clearInterval(checkInterval)
+      function finishCurrentRun () {
+        if (outputResolve) {
           outputResolve()
+          outputResolve = null
         }
-      }, 100)
-
-      // Transcribe
-      await parakeet.append({ type: 'audio', data: audioData.buffer })
-      await parakeet.append({ type: 'end of job' })
-
-      // Wait for output with timeout
-      const timeout = setTimeout(() => {
-        clearInterval(checkInterval)
-        outputResolve()
-      }, 600000)
+      }
 
-      await outputPromise
-      clearTimeout(timeout)
+      try {
+        console.log('=== Creating instance and loading model ===')
+
+        function outputCallback (handle, event, id, output, error) {
+          if (event === 'Output' && Array.isArray(output)) {
+            for (const segment of output) {
+              if (segment && segment.text) {
+                allResults.push({ jobId: id, segment })
+              }
+            }
+          } else if (event === 'JobEnded' && output) {
+            receivedStats.push({ jobId: id, stats: output })
+            finishCurrentRun()
+          } else if (event === 'Error' || error) {
+            finishCurrentRun()
+          }
+        }
 
-      const runTime = Date.now() - runStartTime
-      timings.push(runTime)
+        parakeet = new ParakeetInterface(binding, config, outputCallback)
 
-      // Get results for this run
-      const runResults = allResults.slice(startResultCount)
-      const runText = runResults.map(r => r.segment.text).join(' ').trim()
+        await parakeet.activate()
+        console.log('   Model activated\n')
 
-      console.log(`   Time: ${runTime}ms`)
-      console.log(`   Segments: ${runResults.length}`)
-      console.log(`   Text preview: "${runText.substring(0, 80)}${runText.length > 80 ? '...' : ''}"`)
-      console.log('')
+        // Load audio once (read into memory)
+        const rawBuffer = fs.readFileSync(samplePath)
+        const pcmData = new Int16Array(rawBuffer.buffer, rawBuffer.byteOffset, rawBuffer.length / 2)
+        const audioData = new Float32Array(pcmData.length)
+        for (let i = 0; i < pcmData.length; i++) {
+          audioData[i] = pcmData[i] / 32768.0
+        }
+        console.log(`   Audio duration: ${(audioData.length / 16000).toFixed(2)}s\n`)
+
+        // Run multiple transcriptions
+        const timings = []
+
+        for (let run = 1; run <= NUM_TRANSCRIPTIONS; run++) {
+          console.log(`=== Transcription ${run}/${NUM_TRANSCRIPTIONS} ===`)
+          const runStartTime = Date.now()
+
+          // Clear results for this run
+          const startResultCount = allResults.length
+
+          // Track when this run completes. Mobile waits for JobEnded so the
+          // perf row has native runtime stats; desktop keeps the previous
+          // output-based behavior.
+          const outputPromise = new Promise(resolve => { outputResolve = resolve })
+          let checkInterval = null
+          if (!isMobile) {
+            checkInterval = setInterval(() => {
+              if (allResults.length > startResultCount) {
+                clearInterval(checkInterval)
+                finishCurrentRun()
+              }
+            }, 100)
+          }
 
-      // Small delay between runs (helps with memory cleanup)
-      if (run < NUM_TRANSCRIPTIONS) {
-        await new Promise(resolve => setTimeout(resolve, 200))
-      }
-    }
+          // Transcribe
+          await parakeet.append({ type: 'audio', data: audioData.buffer })
+          await parakeet.append({ type: 'end of job' })
+
+          const timeout = setTimeout(() => {
+            if (checkInterval) clearInterval(checkInterval)
+            finishCurrentRun()
+          }, 600000)
+
+          await outputPromise
+          if (checkInterval) clearInterval(checkInterval)
+          clearTimeout(timeout)
+
+          const runTime = Date.now() - runStartTime
+          timings.push(runTime)
+
+          // Get results for this run
+          const runResults = allResults.slice(startResultCount)
+          const runText = runResults.map(r => r.segment.text).join(' ').trim()
+
+          console.log(`   Time: ${runTime}ms`)
+          console.log(`   Segments: ${runResults.length}`)
+          console.log(`   Text preview: "${runText.substring(0, 80)}${runText.length > 80 ? '...' : ''}"`)
+
+          // Capture this run's JobEnded stats (most recent one belongs to us
+          // because the output callback observes events in order). Wire into
+          // the shared perf reporter so the CI step summary surfaces RTF,
+          // encoder/decoder timing, tokens-per-second per device.
+          const jobStats = receivedStats.length > 0
+            ? receivedStats[receivedStats.length - 1].stats
+            : null
+          if (jobStats) {
+            try {
+              recordParakeetStats(`${perfLabelPrefix} multi-transcribe run ${run}`, jobStats, {
+                wallMs: runTime,
+                output: runText
+              })
+            } catch (err) {
+              console.log(`   [perf] recordParakeetStats failed: ${err.message}`)
+            }
+            if (typeof jobStats.realTimeFactor === 'number') {
+              console.log(`   RTF: ${jobStats.realTimeFactor.toFixed(4)}`)
+            }
+          }
+          console.log('')
 
-    // Summary and assertions
-    console.log('='.repeat(60))
-    console.log('TEST SUMMARY')
-    console.log('='.repeat(60))
+          if (run < NUM_TRANSCRIPTIONS) {
+            await new Promise(resolve => setTimeout(resolve, 200))
+          }
+        }
 
-    console.log('\n  Timing per run:')
-    timings.forEach((time, i) => {
-      console.log(`    Run ${i + 1}: ${time}ms`)
-    })
+        // Summary and assertions
+        console.log('='.repeat(60))
+        console.log(`TEST SUMMARY ${testLabel}`)
+        console.log('='.repeat(60))
 
-    const avgTime = timings.reduce((a, b) => a + b, 0) / timings.length
-    console.log(`\n  Average time: ${avgTime.toFixed(0)}ms`)
-    console.log(`  Total segments: ${allResults.length}`)
-    console.log('='.repeat(60) + '\n')
+        console.log('\n  Timing per run:')
+        timings.forEach((time, i) => {
+          console.log(`    Run ${i + 1}: ${time}ms`)
+        })
 
-    // Assertions
-    t.ok(allResults.length > 0, `Should produce segments across all runs (got ${allResults.length})`)
-    t.ok(timings.length === NUM_TRANSCRIPTIONS, `Should complete ${NUM_TRANSCRIPTIONS} transcriptions (got ${timings.length})`)
+        const avgTime = timings.reduce((a, b) => a + b, 0) / timings.length
+        console.log(`\n  Average time: ${avgTime.toFixed(0)}ms`)
+        console.log(`  Total segments: ${allResults.length}`)
+        console.log('='.repeat(60) + '\n')
 
-    // Verify each run produced output
-    const runsWithOutput = new Set(allResults.map(r => r.jobId)).size
-    t.ok(runsWithOutput === NUM_TRANSCRIPTIONS, `Multiple runs should produce output for every job (got ${runsWithOutput}/${NUM_TRANSCRIPTIONS} unique job IDs)`)
+        // Assertions
+        if (isMobile) {
+          t.ok(receivedStats.length >= NUM_TRANSCRIPTIONS, `${testLabel} Should receive JobEnded stats for every run (got ${receivedStats.length})`)
+        }
+        t.ok(timings.length === NUM_TRANSCRIPTIONS, `${testLabel} Should complete ${NUM_TRANSCRIPTIONS} transcriptions (got ${timings.length})`)
+
+        // Verify each run produced output when the model emits textual segments.
+        const runsWithOutput = new Set(allResults.map(r => r.jobId)).size
+        if (allResults.length > 0) {
+          if (isMobile) {
+            t.ok(runsWithOutput <= NUM_TRANSCRIPTIONS, `${testLabel} Output job IDs are bounded by run count`)
+          } else {
+            t.ok(runsWithOutput === NUM_TRANSCRIPTIONS, `${epLabel} Multiple runs should produce output for every job (got ${runsWithOutput}/${NUM_TRANSCRIPTIONS} unique job IDs)`)
+          }
+        } else {
+          console.log(`   ${testLabel} produced runtime stats without textual output`)
+        }
 
-    console.log('✅ Multiple transcriptions test completed successfully!\n')
-  } finally {
-    // Cleanup
-    console.log('=== Cleanup ===')
-    if (parakeet) {
-      try {
-        await parakeet.destroyInstance()
-        console.log('   Instance destroyed')
-      } catch (e) {
-        console.log('   Instance destroy error:', e.message)
+        console.log(`✅ Multiple transcriptions test ${testLabel} completed successfully!\n`)
+      } finally {
+        // Cleanup
+        console.log('=== Cleanup ===')
+        finishCurrentRun()
+        if (parakeet) {
+          try {
+            await parakeet.destroyInstance()
+            console.log('   Instance destroyed')
+          } catch (e) {
+            console.log('   Instance destroy error:', e.message)
+          }
+        }
+        try {
+          loggerBinding.releaseLogger()
+          console.log('   Logger released')
+        } catch (e) {
+          console.log('   Logger release error:', e.message)
+        }
       }
-    }
-    try {
-      loggerBinding.releaseLogger()
-      console.log('   Logger released')
-    } catch (e) {
-      console.log('   Logger release error:', e.message)
-    }
+    })
   }
-})
+}
 
 /**
  * Test that creating fresh model instances for each transcription works correctly.
diff --git a/packages/qvac-lib-infer-parakeet/test/mobile/integration.auto.cjs b/packages/qvac-lib-infer-parakeet/test/mobile/integration.auto.cjs
index a78de7b566..efa9211762 100644
--- a/packages/qvac-lib-infer-parakeet/test/mobile/integration.auto.cjs
+++ b/packages/qvac-lib-infer-parakeet/test/mobile/integration.auto.cjs
@@ -26,6 +26,10 @@ async function runCorruptedModelTest (options = {}) { // eslint-disable-line no-
   return runIntegrationModule('../integration/corrupted-model.test.js', options)
 }
 
+async function runExternalDataStagingTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/external-data-staging.test.js', options)
+}
+
 async function runIndividualFilePathsTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/individual-file-paths.test.js', options)
 }
@@ -34,6 +38,30 @@ async function runLiveStreamSimulationTest (options = {}) { // eslint-disable-li
   return runIntegrationModule('../integration/live-stream-simulation.test.js', options)
 }
 
+async function runMobilePerfCtcCpuTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/mobile-perf-ctc-cpu.test.js', options)
+}
+
+async function runMobilePerfCtcGpuTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/mobile-perf-ctc-gpu.test.js', options)
+}
+
+async function runMobilePerfEouCpuTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/mobile-perf-eou-cpu.test.js', options)
+}
+
+async function runMobilePerfEouGpuTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/mobile-perf-eou-gpu.test.js', options)
+}
+
+async function runMobilePerfSortformerCpuTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/mobile-perf-sortformer-cpu.test.js', options)
+}
+
+async function runMobilePerfSortformerGpuTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/mobile-perf-sortformer-gpu.test.js', options)
+}
+
 async function runModelFileValidationTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/model-file-validation.test.js', options)
 }
@@ -49,3 +77,24 @@ async function runNamedPathsAllModelsTest (options = {}) { // eslint-disable-lin
 async function runNamedPathsReloadTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/named-paths-reload.test.js', options)
 }
+
+module.exports = {
+  runAccuracyMultilangTest,
+  runAddonMultimodelTest,
+  runAddonTest,
+  runColdStartTimingTest,
+  runCorruptedModelTest,
+  runExternalDataStagingTest,
+  runIndividualFilePathsTest,
+  runLiveStreamSimulationTest,
+  runMobilePerfCtcCpuTest,
+  runMobilePerfCtcGpuTest,
+  runMobilePerfEouCpuTest,
+  runMobilePerfEouGpuTest,
+  runMobilePerfSortformerCpuTest,
+  runMobilePerfSortformerGpuTest,
+  runModelFileValidationTest,
+  runMultipleTranscriptionsTest,
+  runNamedPathsAllModelsTest,
+  runNamedPathsReloadTest
+}
diff --git a/scripts/perf-report/aggregate-parakeet-rtf.js b/scripts/perf-report/aggregate-parakeet-rtf.js
index e5fe8004a6..e422ff4422 100644
--- a/scripts/perf-report/aggregate-parakeet-rtf.js
+++ b/scripts/perf-report/aggregate-parakeet-rtf.js
@@ -75,6 +75,12 @@ function formatMaybeInteger (value) {
   return String(Math.round(Number(value)))
 }
 
+function mean (values) {
+  const nums = values.filter(value => Number.isFinite(value))
+  if (nums.length === 0) return NaN
+  return nums.reduce((sum, value) => sum + value, 0) / nums.length
+}
+
 function normalizeBackend (platformName, useGPU, backendHint) {
   const hint = String(backendHint || '').toLowerCase()
   if (hint && hint !== 'mobile-accelerated') return hint
@@ -162,6 +168,88 @@ function normalizeManualRecord (record, sourceFile) {
   }
 }
 
+function percentile (values, p) {
+  const nums = values
+    .filter(value => Number.isFinite(value))
+    .slice()
+    .sort((a, b) => a - b)
+  if (nums.length === 0) return NaN
+  const idx = Math.min(nums.length - 1, Math.max(0, Math.ceil((p / 100) * nums.length) - 1))
+  return nums[idx]
+}
+
+function isMobilePerformanceReport (report) {
+  return Boolean(
+    report &&
+    report.addon === 'parakeet' &&
+    report.addon_type === 'parakeet' &&
+    report.device &&
+    Array.isArray(report.results)
+  )
+}
+
+function mobileExecutionProvider (result) {
+  const explicit = String(result.execution_provider || '').toLowerCase()
+  if (explicit === 'gpu' || explicit === 'cpu') return explicit
+
+  const testName = String(result.test || '').toLowerCase()
+  if (testName.includes('[gpu]')) return 'gpu'
+  if (testName.includes('[cpu]')) return 'cpu'
+  return 'cpu'
+}
+
+function mobileModelType (result) {
+  const testName = String(result.test || '').toLowerCase()
+  const match = testName.match(/\[(tdt|ctc|eou|sortformer)\]/)
+  return match ? match[1] : 'tdt'
+}
+
+function normalizeMobileRecords (report, sourceFile) {
+  const byModelAndProvider = new Map()
+  const device = report.device || {}
+  const platformFamily = String(device.platform || '').toLowerCase()
+  const notes = path.basename(path.dirname(sourceFile))
+
+  for (const result of report.results || []) {
+    const provider = mobileExecutionProvider(result)
+    const modelType = mobileModelType(result)
+    const metrics = result.metrics || {}
+    const key = `${modelType}|${provider}`
+    if (!byModelAndProvider.has(key)) {
+      byModelAndProvider.set(key, {
+        modelType,
+        provider,
+        rtf: [],
+        wallMs: []
+      })
+    }
+    const group = byModelAndProvider.get(key)
+    if (typeof metrics.real_time_factor === 'number') group.rtf.push(metrics.real_time_factor)
+    if (typeof metrics.wall_time_ms === 'number') group.wallMs.push(metrics.wall_time_ms)
+  }
+
+  const records = []
+  for (const values of byModelAndProvider.values()) {
+    const useGPU = values.provider === 'gpu'
+    records.push({
+      source: 'mobile-ci',
+      device: device.name || humanizeSourceFile(sourceFile),
+      platform: device.platform || 'unknown',
+      platformFamily: platformFamily || 'unknown',
+      model: values.modelType,
+      gpu: values.provider,
+      backend: normalizeBackend(platformFamily, useGPU),
+      meanRtf: mean(values.rtf),
+      p50: percentile(values.rtf, 50),
+      p95: percentile(values.rtf, 95),
+      wallMs: mean(values.wallMs),
+      notes
+    })
+  }
+
+  return records
+}
+
 function loadArtifactRecords (inputDir) {
   const records = []
   const files = walkFiles(inputDir).filter(file => /^rtf-benchmark-.*\.json$/.test(path.basename(file)))
@@ -174,6 +262,18 @@ function loadArtifactRecords (inputDir) {
   return records
 }
 
+function loadMobilePerformanceRecords (inputDir) {
+  const records = []
+  const files = walkFiles(inputDir).filter(file => path.basename(file) === 'performance-report.json')
+  for (const file of files) {
+    const report = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (isMobilePerformanceReport(report)) {
+      records.push(...normalizeMobileRecords(report, file))
+    }
+  }
+  return records
+}
+
 function loadManualRecords (manualDir) {
   const records = []
   if (!fs.existsSync(manualDir)) return records
@@ -367,8 +467,9 @@ function main () {
   const manualDir = path.resolve(args.manualDir)
 
   const desktopRecords = loadArtifactRecords(inputDir)
+  const mobileRecords = loadMobilePerformanceRecords(inputDir)
   const manualRecords = loadManualRecords(manualDir)
-  const records = sortRecords(dedupeRecords(desktopRecords.concat(manualRecords)))
+  const records = sortRecords(dedupeRecords(desktopRecords.concat(mobileRecords, manualRecords)))
   const markdown = renderMarkdown(records)
   const html = renderHtml(records)
 
diff --git a/scripts/perf-report/utils.js b/scripts/perf-report/utils.js
index 7485eb767a..949c7ca0e6 100644
--- a/scripts/perf-report/utils.js
+++ b/scripts/perf-report/utils.js
@@ -53,7 +53,11 @@ const METRIC_LABELS = {
   text_regions: 'Text regions',
   real_time_factor: 'RTF',
   sample_count: 'Samples',
-  duration_ms: 'Duration'
+  duration_ms: 'Duration',
+  wall_time_ms: 'Wall time',
+  encoder_time_ms: 'Encoder time',
+  decoder_time_ms: 'Decoder time',
+  audio_duration_ms: 'Audio duration'
 }
 
 function metricLabel (key) {
diff --git a/scripts/test-utils/performance-reporter.js b/scripts/test-utils/performance-reporter.js
index 5c66bd710e..aebe11961e 100644
--- a/scripts/test-utils/performance-reporter.js
+++ b/scripts/test-utils/performance-reporter.js
@@ -135,6 +135,14 @@ const METRIC_COLUMNS = {
     { key: 'real_time_factor', label: 'RTF' },
     { key: 'sample_count', label: 'Samples' }
   ],
+  parakeet: [
+    { key: 'real_time_factor', label: 'RTF' },
+    { key: 'wall_time_ms', label: 'Wall (ms)' },
+    { key: 'tps', label: 'Tokens/sec' },
+    { key: 'encoder_time_ms', label: 'Encoder (ms)' },
+    { key: 'decoder_time_ms', label: 'Decoder (ms)' },
+    { key: 'audio_duration_ms', label: 'Audio (ms)' }
+  ],
   generic: [
     { key: 'total_time_ms', label: 'Total Time (ms)' },
     { key: 'tps', label: 'TPS' }