diff --git a/.github/workflows/performance.yml b/.github/workflows/performance.yml
new file mode 100644
index 000000000..1887b7ac8
--- /dev/null
+++ b/.github/workflows/performance.yml
@@ -0,0 +1,436 @@
+name: Compare ScriptAnalyzer performance
+
+on:
+  workflow_dispatch:
+    inputs:
+      repetitions:
+        description: Number of fresh-process cold/warm pairs per build
+        type: choice
+        options: ['3', '5', '10']
+        default: '3'
+
+permissions:
+  contents: read
+
+jobs:
+  workload:
+    name: Prepare shared benchmark inputs
+    runs-on: windows-latest
+    timeout-minutes: 10
+    outputs:
+      powershell: ${{ steps.revision.outputs.sha }}
+      semver: ${{ steps.semver-revision.outputs.sha }}
+      upstream: ${{ steps.analyzer-revisions.outputs.upstream }}
+      fork: ${{ steps.analyzer-revisions.outputs.fork }}
+    steps:
+      - name: Pin all analyzer revisions once
+        id: analyzer-revisions
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          foreach ($source in @(
+              @{ Name = 'upstream'; Repository = 'PowerShell/PSScriptAnalyzer'; Ref = 'main' },
+              @{ Name = 'fork'; Repository = 'jessehouwing/PSScriptAnalyzer'; Ref = 'main' }
+          )) {
+              $revision = git ls-remote "https://github.com/$($source.Repository).git" "refs/heads/$($source.Ref)"
+              if ($LASTEXITCODE -ne 0 -or $revision -notmatch '^([0-9a-f]{40})\s') {
+                  throw "Cannot resolve $($source.Repository)@$($source.Ref)."
+              }
+              "$($source.Name)=$($Matches[1])" >> $env:GITHUB_OUTPUT
+          }
+
+      - name: Checkout PowerShell source tree once for both builds
+        uses: actions/checkout@v4
+        with:
+          repository: PowerShell/PowerShell
+          ref: master
+          path: workload
+          persist-credentials: false
+
+      - name: Archive PowerShell source tree and record revision
+        id: revision
+        shell: pwsh
+        run: |
+          $revision = git -C "$env:GITHUB_WORKSPACE/workload" rev-parse HEAD
+          if ($LASTEXITCODE -ne 0) { throw 'Cannot resolve workload revision.' }
+          "sha=$revision" >> $env:GITHUB_OUTPUT
+          git -C "$env:GITHUB_WORKSPACE/workload" archive --format=zip --output="$env:GITHUB_WORKSPACE/powershell.zip" HEAD
+          if ($LASTEXITCODE -ne 0) { throw 'Cannot archive PowerShell workload.' }
+
+      - name: Share the exact PowerShell source tree
+        uses: actions/upload-artifact@v4
+        with:
+          name: performance-workload-powershell
+          path: powershell.zip
+          if-no-files-found: error
+
+      - name: Checkout actions-semver-checker
+        uses: actions/checkout@v4
+        with:
+          repository: jessehouwing/actions-semver-checker
+          ref: main
+          path: semver
+          persist-credentials: false
+
+      - name: Archive actions-semver-checker and record revision
+        id: semver-revision
+        shell: pwsh
+        run: |
+          $revision = git -C "$env:GITHUB_WORKSPACE/semver" rev-parse HEAD
+          if ($LASTEXITCODE -ne 0) { throw 'Cannot resolve semver workload revision.' }
+          "sha=$revision" >> $env:GITHUB_OUTPUT
+          git -C "$env:GITHUB_WORKSPACE/semver" archive --format=zip --output="$env:GITHUB_WORKSPACE/semver.zip" HEAD
+          if ($LASTEXITCODE -ne 0) { throw 'Cannot archive semver workload.' }
+
+      - name: Share the exact semver source tree
+        uses: actions/upload-artifact@v4
+        with:
+          name: performance-workload-semver
+          path: semver.zip
+          if-no-files-found: error
+
+  benchmark:
+    name: Benchmark ${{ matrix.source }} / ${{ matrix.workload }} / ${{ matrix.os }}
+    needs: workload
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        workload: [powershell, semver]
+        source: [upstream, fork]
+        include:
+          - source: upstream
+            repository: PowerShell/PSScriptAnalyzer
+          - source: fork
+            repository: jessehouwing/PSScriptAnalyzer
+    defaults:
+      run:
+        shell: pwsh
+    env:
+      DOTNET_NOLOGO: true
+      DOTNET_GENERATE_ASPNET_CERTIFICATE: false
+      BENCHMARK_SOURCE: ${{ matrix.source }}
+      BENCHMARK_REPOSITORY: ${{ matrix.repository }}
+      BENCHMARK_WORKLOAD: ${{ matrix.workload }}
+      WORKLOAD_REVISION: ${{ needs.workload.outputs[matrix.workload] }}
+      ANALYZER_REVISION: ${{ needs.workload.outputs[matrix.source] }}
+      BENCHMARK_REPETITIONS: ${{ inputs.repetitions }}
+    steps:
+      - name: Checkout benchmark harness
+        uses: actions/checkout@v4
+        with:
+          path: harness
+          persist-credentials: false
+
+      - name: Checkout pinned analyzer revision
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ matrix.repository }}
+          ref: ${{ needs.workload.outputs[matrix.source] }}
+          path: analyzer
+          persist-credentials: false
+
+      - name: Download shared input
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          name: performance-workload-${{ matrix.workload }}
+          path: workload
+
+      - name: Extract workload source tree
+        run: Expand-Archive -LiteralPath "$env:GITHUB_WORKSPACE/workload/$env:BENCHMARK_WORKLOAD.zip" -DestinationPath "$env:GITHUB_WORKSPACE/workload/source"
+
+      - name: Install SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          global-json-file: analyzer/global.json
+
+      - name: Install build resources
+        run: '& "$env:GITHUB_WORKSPACE/harness/tools/installPSResources.ps1"'
+
+      - name: Build (Release, PowerShell 7)
+        working-directory: analyzer
+        run: '& "$env:GITHUB_WORKSPACE/analyzer/build.ps1" -Configuration Release -PSVersion 7 -Verbose'
+
+      - name: Measure repeated cold and warm analysis in fresh shells
+        run: |
+          $ErrorActionPreference = 'Stop'
+          $workspace = $env:GITHUB_WORKSPACE
+          $resultDirectory = Join-Path $workspace 'results'
+          $null = New-Item -ItemType Directory -Path $resultDirectory -Force
+          $pwsh = (Get-Process -Id $PID).Path
+          $scriptPath = Join-Path $workspace 'workload/source/build.psm1'
+          $workloadRepository = 'PowerShell/PowerShell'
+          $analysisArguments = @()
+          if ($env:BENCHMARK_WORKLOAD -eq 'semver') {
+              $scriptPath = Join-Path $workspace 'workload/source'
+              $workloadRepository = 'jessehouwing/actions-semver-checker'
+              $analysisArguments = @('-Recurse', '-SettingsPath', (Join-Path $scriptPath 'PSScriptAnalyzerSettings.psd1'))
+          }
+          $measureScript = Join-Path $workspace 'harness/tools/Measure-ScriptAnalyzerPerformance.ps1'
+          $sourcePath = Join-Path $workspace 'analyzer'
+          $manifests = @(Get-ChildItem -Path "$sourcePath/out/PSScriptAnalyzer" -Filter PSScriptAnalyzer.psd1 -Recurse)
+          if ($manifests.Count -ne 1) {
+              throw "Expected exactly one built manifest, found $($manifests.Count)."
+          }
+          $revision = git -C $sourcePath rev-parse HEAD
+          if ($LASTEXITCODE -ne 0 -or $revision -ne $env:ANALYZER_REVISION) {
+              throw 'Analyzer checkout does not match the pinned revision.'
+          }
+          $metadata = @{
+              Source = $env:BENCHMARK_SOURCE
+              Repository = $env:BENCHMARK_REPOSITORY
+              Revision = $revision
+              Workload = $env:BENCHMARK_WORKLOAD
+              WorkloadRepository = $workloadRepository
+              WorkloadRevision = $env:WORKLOAD_REVISION
+              RunnerOS = $env:RUNNER_OS
+              RunnerImage = $env:ImageOS
+              RunnerImageVersion = $env:ImageVersion
+              ProcessorCount = [Environment]::ProcessorCount
+          }
+          for ($sample = 1; $sample -le [int]$env:BENCHMARK_REPETITIONS; $sample++) {
+              $resultPath = Join-Path $resultDirectory "$env:BENCHMARK_SOURCE-$sample.json"
+              $attempt = 0
+              # Failed upstream runs are retried in entirely fresh processes.
+              # The job timeout bounds retries if upstream never succeeds.
+              $PSNativeCommandUseErrorActionPreference = $false
+              do {
+                  $attempt++
+                  $attemptLog = Join-Path $resultDirectory "$env:BENCHMARK_SOURCE-$sample-attempt-$attempt.log"
+                  & $pwsh -NoLogo -NoProfile -NonInteractive -File $measureScript `
+                      -ModulePath $manifests[0].FullName -ScriptPath $scriptPath -ResultPath $resultPath @analysisArguments 2>&1 |
+                      Tee-Object -FilePath $attemptLog
+                  $attemptExitCode = $LASTEXITCODE
+                  if ($attemptExitCode -ne 0) {
+                      if ($env:BENCHMARK_SOURCE -ne 'upstream') {
+                          throw "Benchmark sample $sample failed (exit code $attemptExitCode)."
+                      }
+                      Write-Warning "Upstream sample $sample attempt $attempt failed (exit code $attemptExitCode); retrying in a fresh process."
+                  }
+              } while ($attemptExitCode -ne 0)
+              $result = Get-Content -LiteralPath $resultPath -Raw | ConvertFrom-Json
+              $result | Add-Member -NotePropertyMembers $metadata
+              $result | Add-Member -NotePropertyName Sample -NotePropertyValue $sample
+              $result | Add-Member -NotePropertyName Attempts -NotePropertyValue $attempt
+              $result | Add-Member -NotePropertyName Inconsistent -NotePropertyValue ($attempt -gt 1)
+              $result | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath $resultPath -Encoding utf8
+              $result | Format-List
+          }
+
+      - name: Upload raw benchmark results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: scriptanalyzer-performance-${{ matrix.os }}-${{ matrix.workload }}-${{ matrix.source }}
+          path: |
+            results/*.json
+            results/*.log
+          if-no-files-found: warn
+
+  compare:
+    name: Compare ${{ matrix.workload }} / ${{ matrix.os }}
+    needs: benchmark
+    if: ${{ !cancelled() }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    env:
+      BENCHMARK_REPETITIONS: ${{ inputs.repetitions }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        workload: [powershell, semver]
+    steps:
+      - name: Download benchmark results
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          pattern: scriptanalyzer-performance-${{ matrix.os }}-${{ matrix.workload }}-*
+          path: results
+          merge-multiple: true
+
+      - name: Validate and summarize
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          $resultDirectory = Join-Path $env:GITHUB_WORKSPACE 'results'
+          $measurements = @{}
+          foreach ($source in 'upstream', 'fork') {
+              $measurements[$source] = @(for ($sample = 1; $sample -le [int]$env:BENCHMARK_REPETITIONS; $sample++) {
+                  Get-Content -LiteralPath "$resultDirectory/$source-$sample.json" -Raw | ConvertFrom-Json
+              })
+          }
+          $baseline = $measurements.upstream[0]
+          $findingsMatch = $baseline.ColdDiagnosticCount -gt 0
+          foreach ($source in 'upstream', 'fork') {
+              foreach ($candidate in $measurements[$source]) {
+                  foreach ($property in 'InputSHA256', 'InputFileCount', 'SettingsSHA256', 'Recurse',
+                      'WorkloadRevision', 'PowerShellVersion', 'RunnerOS', 'Culture', 'UICulture') {
+                      if ($baseline.$property -cne $candidate.$property) {
+                          throw "Benchmark property '$property' differs; results are not comparable."
+                      }
+                  }
+                  if ($candidate.Revision -ne $measurements[$source][0].Revision) {
+                      throw "Analyzer revision changed between $source samples."
+                  }
+                  foreach ($run in 'Cold', 'Warm') {
+                      if ($candidate."${run}DiagnosticCount" -ne $baseline.ColdDiagnosticCount -or
+                          $candidate."${run}DiagnosticsSHA256" -cne $baseline.ColdDiagnosticsSHA256) {
+                          $findingsMatch = $false
+                      }
+                  }
+              }
+          }
+          $report = [ordered]@{
+              WorkloadRepository = $baseline.WorkloadRepository
+              WorkloadRevision = $baseline.WorkloadRevision
+              ExpectedDiagnosticCount = $baseline.ColdDiagnosticCount
+              FindingsVerified = $findingsMatch
+              UpstreamInconsistent = @($measurements.upstream | Where-Object Inconsistent).Count -gt 0
+              Measurements = @($measurements.upstream) + @($measurements.fork)
+          }
+          $report | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath "$resultDirectory/comparison.json" -Encoding utf8
+
+          function Get-Median($values) {
+              $sorted = @($values | Sort-Object)
+              $middle = [int][Math]::Floor($sorted.Count / 2)
+              if ($sorted.Count % 2) { return $sorted[$middle] }
+              return ($sorted[$middle - 1] + $sorted[$middle]) / 2
+          }
+          $medians = @{}
+          foreach ($source in 'upstream', 'fork') {
+              $medians[$source] = @{
+                  Cold = Get-Median $measurements[$source].ColdSeconds
+                  Warm = Get-Median $measurements[$source].WarmSeconds
+              }
+          }
+
+          $summary = @(
+              "## Invoke-ScriptAnalyzer performance: $($baseline.Workload) / $($baseline.RunnerOS)"
+              ''
+              'Release builds run in separate jobs with the same OS and PowerShell version and identical input bytes. No analyzer modules or sessions are shared between jobs.'
+              'The PowerShell workload analyzes only build.psm1 with default rules. The semver workload analyzes the repository recursively using its PSScriptAnalyzerSettings.psd1, without filtering findings.'
+              "Each build gets $env:BENCHMARK_REPETITIONS fresh pwsh -NoProfile processes: cold is the first analysis, warm is the immediately following analysis in each process."
+              'Shell startup, module import, checkout and build time are excluded. Cold does not mean an empty OS filesystem cache.'
+              ''
+              "| Source | Commit | Cold median (s) | Warm median (s) | Cold range (s) | Warm range (s) |"
+              "| --- | --- | ---: | ---: | --- | --- |"
+          )
+          foreach ($source in 'upstream', 'fork') {
+              $samples = $measurements[$source]
+              $reference = 'main'
+              $cold = $samples.ColdSeconds | Measure-Object -Minimum -Maximum
+              $warm = $samples.WarmSeconds | Measure-Object -Minimum -Maximum
+              $marker = if (@($samples | Where-Object Inconsistent).Count) { ' ⚠️' } else { '' }
+              $summary += "| $($samples[0].Repository)@$reference$marker | $($samples[0].Revision) | $($medians[$source].Cold.ToString('F3')) | $($medians[$source].Warm.ToString('F3')) | $($cold.Minimum.ToString('F3'))–$($cold.Maximum.ToString('F3')) | $($warm.Minimum.ToString('F3'))–$($warm.Maximum.ToString('F3')) |"
+          }
+          $summary += ''
+          if ($report.UpstreamInconsistent) {
+              $failedAttempts = ($measurements.upstream | ForEach-Object { $_.Attempts - 1 } | Measure-Object -Sum).Sum
+              $summary += "⚠️ Upstream results were inconsistent: $failedAttempts failed attempts were retried. Timings include successful attempts only and may be biased; failed-attempt logs are retained in the raw artifacts."
+              $summary += ''
+          }
+          foreach ($run in 'Cold', 'Warm') {
+              foreach ($pair in @(, @('fork', 'upstream'))) {
+                  if ($medians[$pair[1]][$run] -gt 0) {
+                      $change = 100 * ($medians[$pair[0]][$run] / $medians[$pair[1]][$run] - 1)
+                      $summary += "$run median time change ($($pair[0]) vs $($pair[1])): $($change.ToString('F2'))% (positive is slower)."
+                  }
+              }
+          }
+          $summary += @(
+              ''
+              "Input: $($baseline.WorkloadRepository) at $($baseline.WorkloadRevision)"
+              "Input SHA256: $($baseline.InputSHA256); PowerShell files: $($baseline.InputFileCount); recurse: $($baseline.Recurse)"
+              "Settings SHA256 (empty for default rules): $($baseline.SettingsSHA256)"
+              "PowerShell: $($baseline.PowerShellVersion)"
+              ''
+              'Samples run on separate hosts per build, not a controlled statistical regression test. Raw artifacts retain each measurement and full normalized diagnostics.'
+          )
+          foreach ($source in 'upstream', 'fork') {
+              $sample = $measurements[$source][0]
+              $summary += "$source runner: $($sample.RunnerImage) $($sample.RunnerImageVersion); logical processors: $($sample.ProcessorCount)"
+              $summary += "Verified $source module: $($sample.ModuleManifest); assembly: $($sample.AnalyzerAssemblyPath)"
+          }
+          if (-not $findingsMatch) {
+              $summary += '**FAILED:** Expected nonzero upstream findings and identical full diagnostic fingerprints across all samples and builds. Timing results must not be treated as a valid comparison.'
+          } else {
+              $summary += "Diagnostics verified: every sample returned the same $($baseline.ColdDiagnosticCount) findings, including locations, messages, suppression state, and corrections."
+          }
+          $summary | Add-Content -LiteralPath $env:GITHUB_STEP_SUMMARY
+          $summary | Write-Output
+          if (-not $findingsMatch) {
+              throw 'Diagnostic equivalence validation failed. See the job summary and raw benchmark results.'
+          }
+
+      - name: Upload comparison
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: scriptanalyzer-performance-${{ matrix.os }}-${{ matrix.workload }}-comparison
+          path: results/comparison.json
+          if-no-files-found: warn
+
+  summary:
+    name: All performance comparisons
+    needs: compare
+    if: ${{ !cancelled() }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Download comparisons
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          pattern: scriptanalyzer-performance-*-comparison
+          path: comparisons
+
+      - name: Summarize all combinations
+        if: ${{ !cancelled() }}
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          function Get-Median($values) {
+              $sorted = @($values | Sort-Object)
+              $middle = [int][Math]::Floor($sorted.Count / 2)
+              if ($sorted.Count % 2) { return $sorted[$middle] }
+              return ($sorted[$middle - 1] + $sorted[$middle]) / 2
+          }
+          $summary = @(
+              '## Performance across all combinations'
+              ''
+              'Times are medians of fresh-process cold/warm samples; lower is better.'
+              ''
+              '| OS | Workload | Source | Cold median (s) | Warm median (s) | Status |'
+              '| --- | --- | --- | ---: | ---: | --- |'
+          )
+          foreach ($os in 'ubuntu-latest', 'windows-latest') {
+              foreach ($workload in 'powershell', 'semver') {
+                  $path = Join-Path $env:GITHUB_WORKSPACE "comparisons/scriptanalyzer-performance-$os-$workload-comparison/comparison.json"
+                  $report = if (Test-Path -LiteralPath $path) {
+                      Get-Content -LiteralPath $path -Raw | ConvertFrom-Json
+                  } else { $null }
+                  foreach ($source in 'upstream', 'fork') {
+                      $samples = @($report.Measurements | Where-Object Source -EQ $source)
+                      if ($samples.Count -eq 0) {
+                          $summary += "| $os | $workload | $source | — | — | Missing results |"
+                          continue
+                      }
+                      $cold = (Get-Median $samples.ColdSeconds).ToString('F3', [Globalization.CultureInfo]::InvariantCulture)
+                      $warm = (Get-Median $samples.WarmSeconds).ToString('F3', [Globalization.CultureInfo]::InvariantCulture)
+                      $status = if ($report.FindingsVerified) { 'Verified' } else { 'INVALID: diagnostics differ' }
+                      if (@($samples | Where-Object Inconsistent).Count) {
+                          $status += '; ⚠️ retried samples'
+                      }
+                      $summary += "| $os | $workload | $source | $cold | $warm | $status |"
+                  }
+              }
+          }
+          $summary += @(
+              ''
+              'Sources: upstream = PowerShell/PSScriptAnalyzer@main; fork = jessehouwing/PSScriptAnalyzer@main.'
+              'Compare timings only within the same OS/workload. Invalid results must not be used for performance comparisons; retried samples may be biased.'
+              'Builds run on separate hosts, not a controlled statistical regression test. Per-combination summaries and artifacts retain revisions, ranges, diagnostics, and retry details.'
+          )
+          $summary | Add-Content -LiteralPath $env:GITHUB_STEP_SUMMARY
+          $summary | Write-Output
diff --git a/Engine/CommandInfoCache.cs b/Engine/CommandInfoCache.cs
index aa9d725f3..56d7585df 100644
--- a/Engine/CommandInfoCache.cs
+++ b/Engine/CommandInfoCache.cs
@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Management.Automation;
 using System.Linq;
 using System.Management.Automation.Runspaces;
@@ -14,9 +16,25 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
     /// </summary>
     internal class CommandInfoCache : IDisposable
     {
+        private const string GetCommandName = "Microsoft.PowerShell.Core\\Get-Command";
+
         private readonly ConcurrentDictionary<CommandLookupKey, Lazy<CommandInfo>> _commandInfoCache;
-        private readonly RunspacePool _runspacePool;
-        private bool disposed = false;
+        private readonly ConcurrentDictionary<CmdletInfo, IReadOnlyDictionary<string, CommandParameterSnapshot>> _parameterSnapshots
+            = new ConcurrentDictionary<CmdletInfo, IReadOnlyDictionary<string, CommandParameterSnapshot>>();
+        private readonly ConcurrentDictionary<CmdletInfo, IReadOnlyList<string>> _mandatoryParameters
+            = new ConcurrentDictionary<CmdletInfo, IReadOnlyList<string>>();
+
+        /// <summary>
+        /// Guards all access to <see cref="_runspace"/> so that only one thread at a time drives the
+        /// PowerShell engine. The engine is not thread safe, so concurrent lookups can fail transiently,
+        /// see https://github.com/PowerShell/PowerShell/issues/4003.
+        /// A monitor is used rather than a semaphore because it is re-entrant, which avoids a deadlock
+        /// should a lookup ever end up calling back into the cache on the same thread.
+        /// </summary>
+        private readonly object _runspaceLock = new object();
+
+        private readonly Runspace _runspace;
+        private volatile bool disposed = false;
 
         /// <summary>
         /// Create a fresh command info cache instance.
@@ -24,11 +42,13 @@ internal class CommandInfoCache : IDisposable
         public CommandInfoCache()
         {
             _commandInfoCache = new ConcurrentDictionary<CommandLookupKey, Lazy<CommandInfo>>();
-            _runspacePool = RunspaceFactory.CreateRunspacePool(1, 10);
-            _runspacePool.Open();
+            // A single runspace rather than a pool: all lookups are serialized on it, so that the
+            // PowerShell engine is never driven concurrently.
+            _runspace = RunspaceFactory.CreateRunspace();
+            _runspace.Open();
         }
 
-        /// <summary>Dispose the runspace pool</summary>
+        /// <summary>Dispose the runspace</summary>
         public void Dispose()
         {
             Dispose(true);
@@ -37,17 +57,23 @@ public void Dispose()
 
         protected virtual void Dispose(bool disposing)
         {
-            if ( disposed )
+            // Always take the lock, also on the finalizer path, so that 'disposed' is never
+            // published without the runspace being disposed along with it and so that the runspace
+            // cannot be disposed while a lookup is in flight.
+            lock (_runspaceLock)
             {
-                return;
-            }
+                if ( disposed )
+                {
+                    return;
+                }
 
-            if ( disposing )
-            {
-                _runspacePool.Dispose();
-            }
+                disposed = true;
 
-            disposed = true;
+                if ( disposing )
+                {
+                    _runspace.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -58,6 +84,19 @@ protected virtual void Dispose(bool disposing)
         /// <param name="bypassCache">When needed due to runspace affinity problems of some PowerShell objects.</param>
         /// <returns></returns>
         public CommandInfo GetCommandInfo(string commandName, CommandTypes? commandTypes = null, bool bypassCache = false)
+        {
+            try
+            {
+                return GetCachedCommandInfo(commandName, commandTypes, bypassCache);
+            }
+            catch (Exception exception) when (IsGetCommandResolutionException(exception))
+            {
+                // Failed Lazy lookups have already been evicted; never cache a lookup failure as a miss.
+                return null;
+            }
+        }
+
+        private CommandInfo GetCachedCommandInfo(string commandName, CommandTypes? commandTypes, bool bypassCache)
         {
             if (string.IsNullOrWhiteSpace(commandName))
             {
@@ -70,9 +109,35 @@ public CommandInfo GetCommandInfo(string commandName, CommandTypes? commandTypes
                 return GetCommandInfoInternal(commandName, commandTypes);
             }
             // Atomically either use PowerShell to query a command info object, or fetch it from the cache
-            return _commandInfoCache.GetOrAdd(key, new Lazy<CommandInfo>(() => GetCommandInfoInternal(commandName, commandTypes))).Value;
+            if (!_commandInfoCache.TryGetValue(key, out var lazyCommandInfo))
+            {
+                lazyCommandInfo = _commandInfoCache.GetOrAdd(key, CreateLookup(commandName, commandTypes));
+            }
+            try
+            {
+                return lazyCommandInfo.Value;
+            }
+            catch
+            {
+                // Lazy<T> caches exceptions forever, which would make every subsequent lookup of this
+                // command fail for the lifetime of the process. Evict the entry so that the next lookup
+                // can try again. Only remove the faulted instance so that a replacement that another
+                // thread may already have added is left alone.
+                RemoveLookup(key, lazyCommandInfo);
+                throw;
+            }
         }
 
+        private void RemoveLookup(CommandLookupKey key, Lazy<CommandInfo> lookup)
+        {
+            ((ICollection<KeyValuePair<CommandLookupKey, Lazy<CommandInfo>>>)_commandInfoCache)
+                .Remove(new KeyValuePair<CommandLookupKey, Lazy<CommandInfo>>(key, lookup));
+        }
+
+        private Lazy<CommandInfo> CreateLookup(string commandName, CommandTypes? commandTypes)
+        {
+            return new Lazy<CommandInfo>(() => GetCommandInfoInternal(commandName, commandTypes));
+        }
 
         /// <summary>
         /// Get a CommandInfo object of the given command name
@@ -99,29 +164,216 @@ private CommandInfo GetCommandInfoInternal(string cmdName, CommandTypes? command
             // For more details see https://github.com/PowerShell/PowerShell/issues/9308
             actualCmdName = WildcardPattern.Escape(actualCmdName);
 
-            using (var ps = System.Management.Automation.PowerShell.Create())
+            // Serialize all use of the PowerShell engine. Only cache misses reach this point;
+            // lookups that are already cached are served without taking the lock.
+            lock (_runspaceLock)
             {
-                ps.RunspacePool = _runspacePool;
+                if (disposed)
+                {
+                    return null;
+                }
+
+                using (var ps = System.Management.Automation.PowerShell.Create())
+                {
+                    ps.Runspace = _runspace;
+
+                    ps.AddCommand(GetCommandName)
+                        .AddParameter("Name", actualCmdName)
+                        .AddParameter("ErrorAction", "SilentlyContinue");
+
+                    if (commandType != null)
+                    {
+                        ps.AddParameter("CommandType", commandType);
+                    }
+
+                    if (!string.IsNullOrEmpty(moduleName))
+                    {
+                        ps.AddParameter("Module", moduleName);
+                    }
 
-                ps.AddCommand("Get-Command")
-                    .AddParameter("Name", actualCmdName)
-                    .AddParameter("ErrorAction", "SilentlyContinue");
+                    Collection<CommandInfo> result = ps.Invoke<CommandInfo>();
 
-                if (commandType != null)
+                    // 'Get-Command' is invoked with 'SilentlyContinue', so a resolution error can only
+                    // mean that the engine failed to resolve 'Get-Command' itself in the runspace.
+                    // That happened intermittently when lookups ran concurrently because the PowerShell engine
+                    // is not thread safe, see https://github.com/PowerShell/PowerShell/issues/4003 and
+                    // https://github.com/PowerShell/PSScriptAnalyzer/issues/2205
+                    // Lookups are serialized now, so this should no longer occur; if it does, the cache
+                    // entry is evicted and the lookup surfaces as a null command info.
+                    // SilentlyContinue can set HadErrors without populating the stream for an unknown name.
+                    if (ps.HadErrors && ps.Streams.Error.Count > 0 && ps.Streams.Error.All(IsGetCommandResolutionError))
+                    {
+                        throw ps.Streams.Error[0].Exception;
+                    }
+                    return result.FirstOrDefault();
+                }
+            }
+        }
+
+        private static bool IsGetCommandResolutionError(ErrorRecord errorRecord)
+        {
+            return IsGetCommandResolutionException(errorRecord?.Exception);
+        }
+
+        /// <summary>
+        /// Retrieves parameter metadata without allowing other threads to drive the command's runspace.
+        /// </summary>
+        public Dictionary<string, ParameterMetadata> GetCommandParameters(
+            string commandName, CommandTypes? commandTypes = null, bool bypassCache = false)
+        {
+            return GetCommandMetadata(commandName, commandTypes, bypassCache, command =>
+            {
+                lock (_runspaceLock)
                 {
-                    ps.AddParameter("CommandType", commandType);
+                    // Dynamic parameter getters execute PowerShell code and mutate runspace state,
+                    // even though they look like ordinary property reads.
+                    if (disposed) return null;
+                    return command.Parameters;
                 }
+            });
+        }
 
-                if (!string.IsNullOrEmpty(moduleName))
+        /// <summary>
+        /// Retrieves parameter sets under the same lock as command lookups and dynamic parameter queries.
+        /// </summary>
+        public ReadOnlyCollection<CommandParameterSetInfo> GetCommandParameterSets(string commandName)
+        {
+            return GetCommandMetadata(commandName, null, false, command =>
+            {
+                lock (_runspaceLock)
                 {
-                    ps.AddParameter("Module", moduleName);
+                    if (disposed) return null;
+                    return command.ParameterSets;
                 }
+            });
+        }
 
-                return ps.Invoke<CommandInfo>()
-                    .FirstOrDefault();
+        /// <summary>
+        /// Contains PowerShell metadata failures: the failed command object is evicted so subsequent
+        /// calls can recover, and null is returned. Unavailable metadata is never cached.
+        /// Unexpected exceptions still propagate.
+        /// </summary>
+        private T GetCommandMetadata<T>(
+            string commandName, CommandTypes? commandTypes, bool bypassCache, Func<CommandInfo, T> readMetadata)
+            where T : class
+        {
+            // Resolve Lazy values outside the runspace lock: another thread's factory may need it.
+            var command = GetCommandInfo(commandName, commandTypes, bypassCache);
+            if (disposed || command == null || command.CommandType == CommandTypes.Application) return null;
+            try
+            {
+                return readMetadata(command);
+            }
+            catch (Exception exception) when (IsMetadataException(exception))
+            {
+                var key = new CommandLookupKey(commandName, commandTypes);
+                if (_commandInfoCache.TryGetValue(key, out var lookup)
+                    && lookup.IsValueCreated && ReferenceEquals(lookup.Value, command))
+                {
+                    RemoveLookup(key, lookup);
+                }
+                return null;
             }
         }
 
+        private static bool IsRunspaceAffinityException(Exception exception)
+        {
+            // PowerShell objects can have runspace affinity, see PowerShell issue 4003 and PSSA issue 1708.
+            return exception is InvalidOperationException || exception is NullReferenceException;
+        }
+
+        private static bool IsMetadataException(Exception exception)
+        {
+            return IsRunspaceAffinityException(exception)
+                || exception is RuntimeException || exception is PSNotSupportedException;
+        }
+
+        private static CmdletInfo GetStaticCmdlet(CommandInfo command)
+        {
+            // Aliases, functions, subclasses and provider/dynamic cmdlets retain the locked,
+            // uncached path. IDynamicParameters includes implementations inherited from base types.
+            if (command == null || command.GetType() != typeof(CmdletInfo)) return null;
+            var cmdlet = (CmdletInfo)command;
+            return cmdlet.ImplementingType != null
+                && !typeof(IDynamicParameters).IsAssignableFrom(cmdlet.ImplementingType) ? cmdlet : null;
+        }
+
+        public IReadOnlyDictionary<string, CommandParameterSnapshot> GetParameterSnapshot(
+            string commandName, CommandTypes? commandTypes = null, bool bypassCache = false)
+        {
+            return GetCommandMetadata(commandName, commandTypes, bypassCache,
+                command => GetParameterSnapshot(command, bypassCache));
+        }
+
+        private IReadOnlyDictionary<string, CommandParameterSnapshot> GetParameterSnapshot(CommandInfo command, bool bypassCache)
+        {
+            var staticCmdlet = bypassCache ? null : GetStaticCmdlet(command);
+            if (disposed || command == null) return null;
+            if (staticCmdlet != null && _parameterSnapshots.TryGetValue(staticCmdlet, out var cached)) return cached;
+
+            lock (_runspaceLock)
+            {
+                if (disposed) return null;
+                if (staticCmdlet != null && _parameterSnapshots.TryGetValue(staticCmdlet, out cached)) return cached;
+                var parameters = command.Parameters;
+                if (parameters == null) return null;
+                var snapshot = new ReadOnlyDictionary<string, CommandParameterSnapshot>(
+                    parameters.ToDictionary(p => p.Key, p => new CommandParameterSnapshot(p.Value), parameters.Comparer));
+                if (staticCmdlet != null) _parameterSnapshots[staticCmdlet] = snapshot;
+                return snapshot;
+            }
+        }
+
+        public IReadOnlyList<string> GetMandatoryParameterNames(string commandName)
+        {
+            return GetCommandMetadata(commandName, null, false,
+                command => GetMandatoryParameterNames(command, bypassCache: false));
+        }
+
+        private IReadOnlyList<string> GetMandatoryParameterNames(CommandInfo command, bool bypassCache)
+        {
+            var staticCmdlet = bypassCache ? null : GetStaticCmdlet(command);
+            if (disposed || command == null) return null;
+            if (staticCmdlet != null && _mandatoryParameters.TryGetValue(staticCmdlet, out var cached)) return cached;
+
+            lock (_runspaceLock)
+            {
+                if (disposed) return null;
+                if (staticCmdlet != null && _mandatoryParameters.TryGetValue(staticCmdlet, out cached)) return cached;
+                var parameterSets = command.ParameterSets;
+                var parameters = command.Parameters;
+                if (parameterSets == null || parameters == null) return null;
+                int setCount = parameterSets.Count;
+                var mandatory = new List<string>();
+                foreach (var parameter in parameters.Values)
+                {
+                    if (parameter.Attributes.Count >= setCount
+                        && parameter.Attributes.OfType<ParameterAttribute>().Count(a => a.Mandatory) >= setCount)
+                    {
+                        mandatory.Add(parameter.Name);
+                    }
+                }
+                var snapshot = mandatory.AsReadOnly();
+                if (staticCmdlet != null) _mandatoryParameters[staticCmdlet] = snapshot;
+                return snapshot;
+            }
+        }
+
+        private static bool IsGetCommandResolutionException(Exception exception)
+        {
+            if (exception is CommandNotFoundException)
+            {
+                return true;
+            }
+
+            if (exception is ParentContainsErrorRecordException parentContainsErrorRecordException)
+            {
+                return IsGetCommandResolutionException(parentContainsErrorRecordException.InnerException);
+            }
+
+            return false;
+        }
+
         private struct CommandLookupKey : IEquatable<CommandLookupKey>
         {
             private readonly string Name;
@@ -146,7 +398,7 @@ public override int GetHashCode()
                 unchecked
                 {
                     int hash = 17;
-                    hash = hash * 31 + Name.ToUpperInvariant().GetHashCode();
+                    hash = hash * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(Name);
                     hash = hash * 31 + CommandTypes.GetHashCode();
                     return hash;
                 }
diff --git a/Engine/CommandParameterSnapshot.cs b/Engine/CommandParameterSnapshot.cs
new file mode 100644
index 000000000..75ccc3650
--- /dev/null
+++ b/Engine/CommandParameterSnapshot.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Management.Automation;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
+{
+    /// <summary>Detached parameter facts, safe to consume without driving a PowerShell runspace.</summary>
+    public sealed class CommandParameterSnapshot
+    {
+        public string Name { get; }
+        public bool SwitchParameter { get; }
+        public ReadOnlyCollection<string> Aliases { get; }
+
+        internal CommandParameterSnapshot(ParameterMetadata parameter)
+        {
+            Name = parameter.Name;
+            SwitchParameter = parameter.SwitchParameter;
+            Aliases = new ReadOnlyCollection<string>(parameter.Aliases.ToArray());
+        }
+    }
+}
diff --git a/Engine/Helper.cs b/Engine/Helper.cs
index f36d17433..a9633156f 100644
--- a/Engine/Helper.cs
+++ b/Engine/Helper.cs
@@ -330,6 +330,15 @@ public PSModuleInfo GetModuleManifest(string filePath, out IEnumerable<ErrorReco
             return psModuleInfo;
         }
 
+        /// <summary>Shares validation between built-in rules during one syntax-tree analysis only.</summary>
+        public PSModuleInfo GetModuleManifestForAnalysis(string filePath, out IEnumerable<ErrorRecord> errorRecords)
+        {
+            var cache = ModuleManifestAnalysisCache.Current;
+            return cache == null
+                ? GetModuleManifest(filePath, out errorRecords)
+                : cache.Get(this, filePath, out errorRecords);
+        }
+
         /// <summary>
         /// Checks if the error record is MissingMemberException
         /// </summary>
@@ -399,18 +408,22 @@ public HashSet<string> GetExportedFunction(Ast ast)
             List<string> exportFunctionsCmdlet = Helper.Instance.CmdletNameAndAliases("export-modulemember");
 
             // find functions exported
-            IEnumerable<Ast> cmdAsts = ast.FindAll(item => item is CommandAst
-                && exportFunctionsCmdlet.Contains((item as CommandAst).GetCommandName(), StringComparer.OrdinalIgnoreCase), true);
-
-            CommandInfo exportMM = Helper.Instance.GetCommandInfo("export-modulemember", CommandTypes.Cmdlet);
-
-            // switch parameters
-            IEnumerable<ParameterMetadata> switchParams = (exportMM != null) ? exportMM.Parameters.Values.Where<ParameterMetadata>(pm => pm.SwitchParameter) : Enumerable.Empty<ParameterMetadata>();
+            var cmdAsts = ast.FindAll(item => item is CommandAst
+                && exportFunctionsCmdlet.Contains((item as CommandAst).GetCommandName(), StringComparer.OrdinalIgnoreCase), true).ToArray();
+            if (cmdAsts.Length == 0)
+            {
+                return exportedFunctions;
+            }
 
-            if (exportMM == null)
+            // Export-ModuleMember has no dynamic parameters. Resolve names from its static
+            // metadata instead of ResolveParameter(), which re-enters the cached command's
+            // runspace and races with command lookups and metadata queries on other rule threads.
+            var parameters = GetCommandParameterSnapshot("export-modulemember", CommandTypes.Cmdlet);
+            if (parameters == null)
             {
                 return exportedFunctions;
             }
+            var switchParams = parameters.Values.Where(pm => pm.SwitchParameter);
 
             foreach (CommandAst cmdAst in cmdAsts)
             {
@@ -429,7 +442,20 @@ public HashSet<string> GetExportedFunction(Ast ast)
                     if (ceAst is CommandParameterAst)
                     {
                         var paramAst = ceAst as CommandParameterAst;
-                        var param = exportMM.ResolveParameter(paramAst.ParameterName);
+                        CommandParameterSnapshot param;
+                        if (!parameters.TryGetValue(paramAst.ParameterName, out param))
+                        {
+                            param = parameters.Values.FirstOrDefault(pm =>
+                                pm.Aliases.Contains(paramAst.ParameterName, StringComparer.OrdinalIgnoreCase));
+                            if (param == null)
+                            {
+                                var matches = parameters.Values.Where(pm =>
+                                    pm.Name.StartsWith(paramAst.ParameterName, StringComparison.OrdinalIgnoreCase)
+                                    || pm.Aliases.Any(alias => alias.StartsWith(paramAst.ParameterName, StringComparison.OrdinalIgnoreCase)))
+                                    .Take(2).ToArray();
+                                param = matches.Length == 1 ? matches[0] : null;
+                            }
+                        }
 
                         if (param == null)
                         {
@@ -671,6 +697,36 @@ public CommandInfo GetCommandInfo(string name, CommandTypes? commandType = null,
             return CommandInfoCache.GetCommandInfo(name, commandTypes: commandType, bypassCache: bypassCache);
         }
 
+        /// <summary>
+        /// Retrieves command parameters with centralized recovery; returns null when metadata is unavailable.
+        /// </summary>
+        public Dictionary<string, ParameterMetadata> GetCommandParameters(
+            string name, CommandTypes? commandType = null, bool bypassCache = false)
+        {
+            return CommandInfoCache.GetCommandParameters(name, commandType, bypassCache);
+        }
+
+        /// <summary>
+        /// Retrieves command parameter sets with centralized recovery; returns null when metadata is unavailable.
+        /// </summary>
+        public ReadOnlyCollection<CommandParameterSetInfo> GetCommandParameterSets(string name)
+        {
+            return CommandInfoCache.GetCommandParameterSets(name);
+        }
+
+        /// <summary>Gets detached parameter facts or null when unavailable; only static cmdlet metadata is cached.</summary>
+        public IReadOnlyDictionary<string, CommandParameterSnapshot> GetCommandParameterSnapshot(
+            string name, CommandTypes? commandType = null, bool bypassCache = false)
+        {
+            return CommandInfoCache.GetParameterSnapshot(name, commandType, bypassCache);
+        }
+
+        /// <summary>Gets the mandatory parameter summary under a single runspace lock, or null when unavailable.</summary>
+        public IReadOnlyList<string> GetMandatoryParameterNames(string name)
+        {
+            return CommandInfoCache.GetMandatoryParameterNames(name);
+        }
+
         /// <summary>
         /// Returns the get, set and test targetresource dsc function
         /// </summary>
diff --git a/Engine/ModuleManifestAnalysisCache.cs b/Engine/ModuleManifestAnalysisCache.cs
new file mode 100644
index 000000000..4564f88e7
--- /dev/null
+++ b/Engine/ModuleManifestAnalysisCache.cs
@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Management.Automation;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
+{
+    // Owned by one AnalyzeSyntaxTree call and explicitly installed on its rule workers.
+    // It cannot outlive that analysis or affect unrelated public GetModuleManifest callers.
+    internal sealed class ModuleManifestAnalysisCache
+    {
+        [ThreadStatic]
+        internal static ModuleManifestAnalysisCache Current;
+
+        private readonly Dictionary<string, Result> results = new Dictionary<string, Result>(StringComparer.Ordinal);
+
+        internal PSModuleInfo Get(Helper helper, string path, out IEnumerable<ErrorRecord> errors)
+        {
+            lock (results)
+            {
+                if (!results.TryGetValue(path, out var result))
+                {
+                    var module = helper.GetModuleManifest(path, out var moduleErrors);
+                    result = new Result { Module = module, Errors = moduleErrors };
+                    results.Add(path, result);
+                }
+                errors = result.Errors;
+                return result.Module;
+            }
+        }
+
+        internal Scope Enter() => new Scope(this);
+
+        internal struct Scope : IDisposable
+        {
+            private readonly ModuleManifestAnalysisCache previous;
+
+            internal Scope(ModuleManifestAnalysisCache cache)
+            {
+                previous = Current;
+                Current = cache;
+            }
+
+            public void Dispose() => Current = previous;
+        }
+
+        private sealed class Result
+        {
+            internal PSModuleInfo Module;
+            internal IEnumerable<ErrorRecord> Errors;
+        }
+    }
+}
diff --git a/Engine/ScriptAnalyzer.cs b/Engine/ScriptAnalyzer.cs
index adc81f2d3..9fed504ec 100644
--- a/Engine/ScriptAnalyzer.cs
+++ b/Engine/ScriptAnalyzer.cs
@@ -2128,6 +2128,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeSyntaxTree(
             string fileName = filePathIsNullOrWhiteSpace ? String.Empty : System.IO.Path.GetFileName(filePath);
             if (this.ScriptRules != null)
             {
+                var manifestCache = new ModuleManifestAnalysisCache();
                 var allowedRules = this.ScriptRules.Where(IsRuleAllowed);
                 if (allowedRules.Any())
                 {
@@ -2139,6 +2140,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeSyntaxTree(
 
                         // Ensure that any unhandled errors from Rules are converted to non-terminating errors
                         // We want the Engine to continue functioning even if one or more Rules throws an exception
+                        using (manifestCache.Enter())
                         try
                         {
                             if (helpRule && helpFile)
diff --git a/README.md b/README.md
index 1d2252082..bbf3750f6 100644
--- a/README.md
+++ b/README.md
@@ -137,6 +137,12 @@ To install **PSScriptAnalyzer** from source code:
   Import-Module .\out\PSScriptAnalyzer\[version]\PSScriptAnalyzer.psd1
   ```
 
+- Command metadata handling lives in `CommandInfoCache`, not individual rules. Its parameter,
+  parameter-set and snapshot APIs return null when PowerShell metadata is unavailable, while
+  unexpected exceptions still propagate. Failed lookups and command objects with failed
+  metadata are evicted so subsequent calls can recover; genuine missing commands retain
+  negative caching.
+
 To confirm installation: run `Get-ScriptAnalyzerRule` in the PowerShell console to obtain the
 built-in rules.
 
diff --git a/Rules/MissingModuleManifestField.cs b/Rules/MissingModuleManifestField.cs
index 180767766..8b7b40f7e 100644
--- a/Rules/MissingModuleManifestField.cs
+++ b/Rules/MissingModuleManifestField.cs
@@ -40,7 +40,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
             if (Helper.IsModuleManifest(fileName))
             {
                 IEnumerable<ErrorRecord> errorRecords;
-                var psModuleInfo = Helper.Instance.GetModuleManifest(fileName, out errorRecords);
+                var psModuleInfo = Helper.Instance.GetModuleManifestForAnalysis(fileName, out errorRecords);
                 if (errorRecords != null)
                 {
                     foreach (var errorRecord in errorRecords)
diff --git a/Rules/UseCmdletCorrectly.cs b/Rules/UseCmdletCorrectly.cs
index ccec27e0b..fda126a21 100644
--- a/Rules/UseCmdletCorrectly.cs
+++ b/Rules/UseCmdletCorrectly.cs
@@ -145,41 +145,9 @@ private bool MandatoryParameterExists(CommandAst cmdAst)
 
             // Gets mandatory parameters from cmdlet.
             // If cannot find any mandatory parameter, it's not necessary to do a further check for current cmdlet.
-            var mandatoryParameters = new List<ParameterMetadata>();
-            try
-            {
-                int noOfParamSets = cmdInfo.ParameterSets.Count;
-                foreach (ParameterMetadata pm in cmdInfo.Parameters.Values)
-                {
-                    int count = 0;
-
-                    if (pm.Attributes.Count < noOfParamSets)
-                    {
-                        continue;
-                    }
+            var mandatoryParameters = Helper.Instance.GetMandatoryParameterNames(cmdAst.GetCommandName());
 
-                    foreach (Attribute attr in pm.Attributes)
-                    {
-                        if (!(attr is ParameterAttribute)) continue;
-                        if (((ParameterAttribute)attr).Mandatory)
-                        {
-                            count += 1;
-                        }
-                    }
-
-                    if (count >= noOfParamSets)
-                    {
-                        mandatoryParameters.Add(pm);
-                    }
-                }
-            }
-            catch (Exception)
-            {
-                // For cases like cmd.exe. Also for runtime exception
-                return true;
-            }
-
-            if (mandatoryParameters.Count == 0)
+            if (mandatoryParameters == null || mandatoryParameters.Count == 0)
             {
                 return true;
             }
@@ -188,8 +156,8 @@ private bool MandatoryParameterExists(CommandAst cmdAst)
             foreach (CommandElementAst commandElementAst in cmdAst.CommandElements.OfType<CommandParameterAst>())
             {
                 CommandParameterAst cpAst = (CommandParameterAst)commandElementAst;
-                if (mandatoryParameters.Count<ParameterMetadata>(item =>
-                    item.Name.Equals(cpAst.ParameterName, StringComparison.OrdinalIgnoreCase)) > 0)
+                if (mandatoryParameters.Any(item =>
+                    item.Equals(cpAst.ParameterName, StringComparison.OrdinalIgnoreCase)))
                 {
                     return true;
                 }
@@ -254,6 +222,3 @@ public string GetSourceName()
     }
 }
 
-
-
-
diff --git a/Rules/UseCorrectCasing.cs b/Rules/UseCorrectCasing.cs
index f4f2c40b7..8a5ce9e12 100644
--- a/Rules/UseCorrectCasing.cs
+++ b/Rules/UseCorrectCasing.cs
@@ -119,24 +119,22 @@ public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string file
                     }
 
                     var commandParameterAsts = commandAst.FindAll(
-                        testAst => testAst is CommandParameterAst, true).Cast<CommandParameterAst>();
-                    Dictionary<string, ParameterMetadata> availableParameters;
-                    try
+                        testAst => testAst is CommandParameterAst, true).Cast<CommandParameterAst>().ToArray();
+                    if (commandParameterAsts.Length == 0)
                     {
-                        availableParameters = commandInfo.Parameters;
+                        continue;
                     }
-                    // It's a known issue that objects from PowerShell can have a runspace affinity,
-                    // therefore if that happens, we query a fresh object instead of using the cache.
-                    // https://github.com/PowerShell/PowerShell/issues/4003
-                    catch (InvalidOperationException)
+                    var availableParameters = Helper.Instance.GetCommandParameterSnapshot(commandName);
+                    if (availableParameters is null)
                     {
-                        commandInfo = Helper.Instance.GetCommandInfo(commandName, bypassCache: true);
-                        availableParameters = commandInfo.Parameters;
+                        // The parameters of this command cannot be determined reliably,
+                        // so skip the parameter casing check instead of failing the analysis.
+                        continue;
                     }
                     foreach (var commandParameterAst in commandParameterAsts)
                     {
                         var parameterName = commandParameterAst.ParameterName;
-                        if (availableParameters.TryGetValue(parameterName, out ParameterMetadata parameterMetaData))
+                        if (availableParameters.TryGetValue(parameterName, out CommandParameterSnapshot parameterMetaData))
                         {
                             var correctlyCasedParameterName = parameterMetaData.Name;
                             if (!parameterName.Equals(correctlyCasedParameterName, StringComparison.Ordinal))
diff --git a/Rules/UseToExportFieldsInManifest.cs b/Rules/UseToExportFieldsInManifest.cs
index 9bf612f83..2dcaabe31 100644
--- a/Rules/UseToExportFieldsInManifest.cs
+++ b/Rules/UseToExportFieldsInManifest.cs
@@ -51,7 +51,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
 
             // check if valid module manifest
             IEnumerable<ErrorRecord> errorRecord = null;
-            PSModuleInfo psModuleInfo = Helper.Instance.GetModuleManifest(fileName, out errorRecord);            
+            PSModuleInfo psModuleInfo = Helper.Instance.GetModuleManifestForAnalysis(fileName, out errorRecord);
             if ((errorRecord != null && errorRecord.Count() > 0) || psModuleInfo == null)
             {                
                 yield break;
diff --git a/Tests/Build/MeasureScriptAnalyzerPerformance.tests.ps1 b/Tests/Build/MeasureScriptAnalyzerPerformance.tests.ps1
new file mode 100644
index 000000000..03f512895
--- /dev/null
+++ b/Tests/Build/MeasureScriptAnalyzerPerformance.tests.ps1
@@ -0,0 +1,229 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+Describe 'Performance benchmark diagnostic normalization' -Skip:($PSVersionTable.PSVersion.Major -lt 7) {
+    BeforeAll {
+        $harnessPath = Join-Path $PSScriptRoot '../../tools/Measure-ScriptAnalyzerPerformance.ps1'
+        $tokens = $null
+        $parseErrors = $null
+        $harness = [System.Management.Automation.Language.Parser]::ParseFile(
+            $harnessPath, [ref]$tokens, [ref]$parseErrors)
+        if ($parseErrors.Count) { throw $parseErrors[0] }
+        foreach ($name in 'ConvertTo-WorkloadPath', 'ConvertTo-DiagnosticJson') {
+            $function = $harness.Find({
+                param($node)
+                $node -is [System.Management.Automation.Language.FunctionDefinitionAst] -and $node.Name -eq $name
+            }, $false)
+            . ([scriptblock]::Create($function.Extent.Text))
+        }
+
+        function Get-TestDiagnostic {
+            param([string]$Root)
+            $file = Join-Path $Root 'example.ps1'
+            [pscustomobject]@{
+                RuleName = 'PSUseCorrectCasing'
+                Severity = 'Information'
+                Message = "Incorrect casing in $Root"
+                ScriptName = 'example.ps1'
+                ScriptPath = $file
+                RuleSuppressionID = 'Get-Item'
+                IsSuppressed = $false
+                Extent = [pscustomobject]@{
+                    File = $file
+                    StartLineNumber = 1
+                    StartColumnNumber = 1
+                    EndLineNumber = 1
+                    EndColumnNumber = 9
+                    StartOffset = 0
+                    EndOffset = 8
+                    Text = 'get-item'
+                }
+                SuggestedCorrections = @([pscustomobject]@{
+                    File = $file
+                    StartLineNumber = 1
+                    StartColumnNumber = 1
+                    EndLineNumber = 1
+                    EndColumnNumber = 9
+                    Text = 'Get-Item'
+                    Description = 'Correct command casing'
+                })
+            }
+        }
+    }
+
+    It 'ignores checkout-root differences while preserving diagnostic content' {
+        $inputRoot = Join-Path $TestDrive 'first'
+        $first = ConvertTo-DiagnosticJson (Get-TestDiagnostic $inputRoot)
+        $inputRoot = Join-Path $TestDrive 'second'
+        $second = ConvertTo-DiagnosticJson (Get-TestDiagnostic $inputRoot)
+        $first | Should -BeExactly $second
+        ($first | ConvertFrom-Json).ScriptPath | Should -BeExactly 'example.ps1'
+    }
+
+    It 'detects changes in <Field> even when diagnostic counts match' -ForEach @(
+        @{ Field = 'Message' }
+        @{ Field = 'RuleName' }
+        @{ Field = 'RuleSuppressionID' }
+    ) {
+        $inputRoot = $TestDrive
+        $diagnostic = Get-TestDiagnostic $inputRoot
+        $before = ConvertTo-DiagnosticJson $diagnostic
+        $diagnostic.$Field = 'changed'
+        ConvertTo-DiagnosticJson $diagnostic | Should -Not -BeExactly $before
+    }
+
+    It 'preserves locations, suppression state and suggested corrections' {
+        $inputRoot = $TestDrive
+        $diagnostic = Get-TestDiagnostic $inputRoot
+        $before = ConvertTo-DiagnosticJson $diagnostic
+        $diagnostic.Extent.StartOffset = 1
+        ConvertTo-DiagnosticJson $diagnostic | Should -Not -BeExactly $before
+        $diagnostic.Extent.StartOffset = 0
+        $diagnostic.IsSuppressed = $true
+        ConvertTo-DiagnosticJson $diagnostic | Should -Not -BeExactly $before
+        $diagnostic.IsSuppressed = $false
+        $diagnostic.SuggestedCorrections[0].Text = 'Different-Command'
+        ConvertTo-DiagnosticJson $diagnostic | Should -Not -BeExactly $before
+    }
+
+    It 'handles missing extents and corrections' {
+        $inputRoot = $TestDrive
+        $diagnostic = Get-TestDiagnostic $inputRoot
+        $diagnostic.Extent = $null
+        $diagnostic.SuggestedCorrections = $null
+        $result = ConvertTo-DiagnosticJson $diagnostic | ConvertFrom-Json
+        $result.Extent | Should -BeNullOrEmpty
+        $result.SuggestedCorrections.Count | Should -Be 0
+    }
+}
+
+Describe 'Performance comparison validation' -Skip:($PSVersionTable.PSVersion.Major -lt 7) {
+    BeforeAll {
+        $workflow = Get-Content -LiteralPath (Join-Path $PSScriptRoot '../../.github/workflows/performance.yml') -Raw
+        $comparison = [regex]::Match($workflow, '(?ms)      - name: Validate and summarize\r?\n.*?        run: \|\r?\n(?<script>.*?)(?=      - name:)')
+        if (-not $comparison.Success) { throw 'Cannot find performance comparison script.' }
+        $comparisonScript = [scriptblock]::Create(
+            [regex]::Replace($comparison.Groups['script'].Value, '(?m)^          ', ''))
+    }
+
+    BeforeEach {
+        $savedWorkspace = $env:GITHUB_WORKSPACE
+        $savedRepetitions = $env:BENCHMARK_REPETITIONS
+        $savedSummary = $env:GITHUB_STEP_SUMMARY
+        $env:GITHUB_WORKSPACE = $TestDrive
+        $env:BENCHMARK_REPETITIONS = '1'
+        $env:GITHUB_STEP_SUMMARY = Join-Path $TestDrive 'summary.txt'
+        $resultDirectory = Join-Path $TestDrive 'results'
+        $null = New-Item -ItemType Directory -Path $resultDirectory -Force
+        foreach ($build in 'upstream', 'fork') {
+            @{
+                Revision = $build
+                ColdDiagnosticCount = 1
+                WarmDiagnosticCount = 1
+                ColdDiagnosticsSHA256 = 'identical'
+                WarmDiagnosticsSHA256 = 'identical'
+                ColdSeconds = 2.0
+                WarmSeconds = 1.0
+            } | ConvertTo-Json | Set-Content -LiteralPath (Join-Path $resultDirectory "$build-1.json")
+        }
+    }
+
+    AfterEach {
+        $env:GITHUB_WORKSPACE = $savedWorkspace
+        $env:BENCHMARK_REPETITIONS = $savedRepetitions
+        $env:GITHUB_STEP_SUMMARY = $savedSummary
+    }
+
+    It 'does not offer or enable metrics collection' {
+        $workflow | Should -Not -Match 'collect_metrics|BENCHMARK_METRICS|-CollectMetrics'
+    }
+
+    It 'compares samples from all sources' {
+        { & $comparisonScript } | Should -Not -Throw
+        $report = Get-Content -LiteralPath (Join-Path $resultDirectory 'comparison.json') -Raw | ConvertFrom-Json
+        $report.FindingsVerified | Should -BeTrue
+        $report.Measurements.Count | Should -Be 2
+    }
+}
+
+Describe 'Consolidated performance summary' -Skip:($PSVersionTable.PSVersion.Major -lt 7) {
+    BeforeAll {
+        $workflow = Get-Content -LiteralPath (Join-Path $PSScriptRoot '../../.github/workflows/performance.yml') -Raw
+        $summary = [regex]::Match($workflow, '(?ms)      - name: Summarize all combinations\r?\n.*?        run: \|\r?\n(?<script>.*)\z')
+        if (-not $summary.Success) { throw 'Cannot find consolidated summary script.' }
+        $summaryScript = [scriptblock]::Create(
+            [regex]::Replace($summary.Groups['script'].Value, '(?m)^          ', ''))
+    }
+
+    BeforeEach {
+        $savedWorkspace = $env:GITHUB_WORKSPACE
+        $savedSummary = $env:GITHUB_STEP_SUMMARY
+        $env:GITHUB_WORKSPACE = $TestDrive
+        $env:GITHUB_STEP_SUMMARY = Join-Path $TestDrive 'summary.txt'
+        Set-Content -LiteralPath $env:GITHUB_STEP_SUMMARY -Value ''
+        foreach ($os in 'ubuntu-latest', 'windows-latest') {
+            foreach ($workload in 'powershell', 'semver') {
+                $directory = Join-Path $TestDrive "comparisons/scriptanalyzer-performance-$os-$workload-comparison"
+                $null = New-Item -ItemType Directory -Path $directory -Force
+                @{
+                    FindingsVerified = $true
+                    Measurements = @(foreach ($source in 'upstream', 'fork') {
+                        foreach ($seconds in 9.0, 1.0, 2.0) {
+                            @{
+                                Source = $source
+                                ColdSeconds = $seconds
+                                WarmSeconds = $seconds / 2
+                                Inconsistent = $false
+                            }
+                        }
+                    })
+                } | ConvertTo-Json -Depth 5 | Set-Content -LiteralPath (Join-Path $directory 'comparison.json')
+            }
+        }
+        $comparisonPath = Join-Path $TestDrive 'comparisons/scriptanalyzer-performance-ubuntu-latest-powershell-comparison/comparison.json'
+    }
+
+    AfterEach {
+        $env:GITHUB_WORKSPACE = $savedWorkspace
+        $env:GITHUB_STEP_SUMMARY = $savedSummary
+    }
+
+    It 'shows all eight combinations with median rather than mean timings' {
+        & $summaryScript
+        $text = Get-Content -LiteralPath $env:GITHUB_STEP_SUMMARY -Raw
+        [regex]::Matches($text, '(?m)^\| (ubuntu|windows)-latest \|').Count | Should -Be 8
+        foreach ($os in 'ubuntu-latest', 'windows-latest') {
+            foreach ($workload in 'powershell', 'semver') {
+                foreach ($source in 'upstream', 'fork') {
+                    $text | Should -Match ([regex]::Escape("| $os | $workload | $source | 2.000 | 1.000 | Verified |"))
+                }
+            }
+        }
+    }
+
+    It 'marks missing combinations without dropping the other results' {
+        Remove-Item -LiteralPath $comparisonPath
+        & $summaryScript
+        $text = Get-Content -LiteralPath $env:GITHUB_STEP_SUMMARY -Raw
+        [regex]::Matches($text, '\| Missing results \|').Count | Should -Be 2
+        [regex]::Matches($text, '\| Verified \|').Count | Should -Be 6
+    }
+
+    It 'still produces the full table when no comparisons are available' {
+        Remove-Item -LiteralPath (Join-Path $TestDrive 'comparisons') -Recurse
+        & $summaryScript
+        $text = Get-Content -LiteralPath $env:GITHUB_STEP_SUMMARY -Raw
+        [regex]::Matches($text, '\| Missing results \|').Count | Should -Be 8
+    }
+
+    It 'marks invalid comparisons and retried samples' {
+        $report = Get-Content -LiteralPath $comparisonPath -Raw | ConvertFrom-Json
+        $report.FindingsVerified = $false
+        $report.Measurements[0].Inconsistent = $true
+        $report | ConvertTo-Json -Depth 5 | Set-Content -LiteralPath $comparisonPath
+        & $summaryScript
+        $text = Get-Content -LiteralPath $env:GITHUB_STEP_SUMMARY -Raw
+        [regex]::Matches($text, 'INVALID: diagnostics differ').Count | Should -Be 2
+        $text | Should -Match 'upstream \| 2.000 \| 1.000 \| INVALID: diagnostics differ; ⚠️ retried samples'
+    }
+}
diff --git a/Tests/Engine/AnalysisMetadata.tests.ps1 b/Tests/Engine/AnalysisMetadata.tests.ps1
new file mode 100644
index 000000000..ea4d2a615
--- /dev/null
+++ b/Tests/Engine/AnalysisMetadata.tests.ps1
@@ -0,0 +1,84 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+Describe "Analysis metadata work" {
+    BeforeAll {
+        $null = Invoke-ScriptAnalyzer -ScriptDefinition 'Write-Output example'
+        $casingSettings = @{
+            IncludeRules = @('PSUseCorrectCasing')
+            Rules = @{ PSUseCorrectCasing = @{ Enable = $true; CheckKeyword = $false; CheckOperator = $false } }
+        }
+        $manifestRules = @('PSMissingModuleManifestField', 'PSUseToExportFieldsInManifest')
+    }
+
+    It "checks static, dynamic and alias parameter casing" {
+        foreach ($iteration in 1..100) {
+            $diagnostics = @(Invoke-ScriptAnalyzer -ScriptDefinition (
+                'Write-Output -inputobject example; Get-Item -path .; gci -literalpath .'
+            ) -Settings $casingSettings -ErrorAction Stop)
+            $diagnostics.Count | Should -Be 3
+            $diagnostics.SuggestedCorrections.Text | Should -Contain 'InputObject'
+            $diagnostics.SuggestedCorrections.Text | Should -Contain 'Path'
+            $diagnostics.SuggestedCorrections.Text | Should -Contain 'LiteralPath'
+        }
+    }
+
+    It "preserves recursive casing checks for parameters nested in script blocks" {
+        $diagnostics = @(Invoke-ScriptAnalyzer -ScriptDefinition 'Get-Item { Unknown-SnapshotCommand -path value }' -Settings $casingSettings)
+        $diagnostics.Count | Should -Be 1
+        $diagnostics[0].SuggestedCorrections[0].Text | Should -BeExactly 'Path'
+    }
+
+    It "does not resolve exports when no export command matches" {
+        $ast = [System.Management.Automation.Language.Parser]::ParseInput('function Test-Example {}', [ref]$null, [ref]$null)
+        [Microsoft.Windows.PowerShell.ScriptAnalyzer.Helper]::Instance.GetExportedFunction($ast).Count | Should -Be 0
+    }
+
+    It "preserves mandatory parameter matching for <Script>" -TestCases @(
+        @{ Script = 'Write-Warning'; Count = 1 }
+        @{ Script = 'Write-Warning -Message example'; Count = 0 }
+        @{ Script = 'Write-Warning -Mes example'; Count = 1 }
+        @{ Script = 'Write-Warning example'; Count = 0 }
+        @{ Script = 'Write-Warning @parameters'; Count = 0 }
+        @{ Script = '"example" | Write-Warning'; Count = 0 }
+    ) {
+        param($Script, $Count)
+        @(Invoke-ScriptAnalyzer -ScriptDefinition $Script -IncludeRule PSUseCmdletCorrectly).Count | Should -Be $Count
+    }
+
+    It "keeps PackageManagement on its metadata-free special path" {
+        if ($null -eq [Microsoft.Windows.PowerShell.ScriptAnalyzer.Helper]::Instance.GetCommandInfo('Install-Package')) {
+            Set-ItResult -Skipped -Because 'PackageManagement is not installed'
+            return
+        }
+        @(Invoke-ScriptAnalyzer -ScriptDefinition 'Install-Package' -IncludeRule PSUseCmdletCorrectly).Count | Should -Be 1
+        @(Invoke-ScriptAnalyzer -ScriptDefinition 'Install-Package -Na example' -IncludeRule PSUseCmdletCorrectly).Count | Should -Be 0
+    }
+
+    It "shares manifest results and errors only within one analysis" {
+        $manifest = Join-Path $TestDrive 'Freshness.psd1'
+        Set-Content $manifest "@{ ModuleVersion = '1.0'; FunctionsToExport = '*' }"
+        $diagnostics = @(Invoke-ScriptAnalyzer -Path $manifest -IncludeRule $manifestRules -ErrorAction Stop)
+        $diagnostics.RuleName | Should -Contain 'PSUseToExportFieldsInManifest'
+
+        Set-Content $manifest "@{ FunctionsToExport = '*' }"
+        $diagnostics = @(Invoke-ScriptAnalyzer -Path $manifest -IncludeRule $manifestRules -ErrorAction Stop)
+        $diagnostics.Count | Should -Be 1
+        $diagnostics[0].RuleName | Should -Be 'PSMissingModuleManifestField'
+        $diagnostics[0].Message | Should -Match 'ModuleVersion'
+
+        Set-Content $manifest "@{ ModuleVersion = '2.0'; FunctionsToExport = @(); CmdletsToExport = @(); AliasesToExport = @() }"
+        @(Invoke-ScriptAnalyzer -Path $manifest -IncludeRule $manifestRules -ErrorAction Stop).Count | Should -Be 0
+    }
+
+    It "does not change public manifest lookup freshness outside an analysis" {
+        $manifest = Join-Path $TestDrive 'PublicLookup.psd1'
+        Set-Content $manifest "@{ ModuleVersion = '1.0' }"
+        $errors = $null
+        $helper = [Microsoft.Windows.PowerShell.ScriptAnalyzer.Helper]::Instance
+        $helper.GetModuleManifest($manifest, [ref]$errors).Version | Should -Be ([version]'1.0')
+        Set-Content $manifest "@{ ModuleVersion = '2.0' }"
+        $helper.GetModuleManifest($manifest, [ref]$errors).Version | Should -Be ([version]'2.0')
+        $helper.GetModuleManifestForAnalysis($manifest, [ref]$errors).Version | Should -Be ([version]'2.0')
+    }
+}
diff --git a/Tests/Engine/CommandInfoCacheConcurrency.tests.ps1 b/Tests/Engine/CommandInfoCacheConcurrency.tests.ps1
new file mode 100644
index 000000000..f7fe6e34f
--- /dev/null
+++ b/Tests/Engine/CommandInfoCacheConcurrency.tests.ps1
@@ -0,0 +1,116 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+Describe "Concurrent command lookups" {
+    BeforeAll {
+        # Run the analyzer once so that the singleton Helper is created by the cmdlet. Touching
+        # Helper.Instance before that would install a helper without a command invocation context,
+        # which breaks every later analysis in this process.
+        $null = Invoke-ScriptAnalyzer -ScriptDefinition 'Get-Item -Path .'
+
+        # The concurrency driver is written in C# so that the lookups really do run on separate
+        # threads. Invoking a PowerShell script block on a thread pool thread would introduce
+        # runspace affinity problems of its own and would not test the command info cache.
+        $analyzerAssembly = [Microsoft.Windows.PowerShell.ScriptAnalyzer.Helper].Assembly.Location
+        $references = @($analyzerAssembly, ([System.Management.Automation.PSObject].Assembly.Location))
+        if ($PSVersionTable.PSEdition -eq 'Core') {
+            $references += Join-Path $PSHOME 'ref/System.Collections.dll'
+        }
+        Add-Type -IgnoreWarnings -WarningAction SilentlyContinue -ReferencedAssemblies $references -TypeDefinition @'
+using System.Threading.Tasks;
+using System.Management.Automation.Language;
+using Microsoft.Windows.PowerShell.ScriptAnalyzer;
+
+public static class ConcurrentCommandLookup
+{
+    public static void ResolveExports()
+    {
+        Token[] tokens;
+        ParseError[] errors;
+        var ast = Parser.ParseInput("Export-ModuleMember -Function Test-Example", out tokens, out errors);
+        var helper = Helper.Instance;
+        var tasks = new Task[8];
+        for (int i = 0; i < tasks.Length; i++)
+        {
+            tasks[i] = Task.Run(() =>
+            {
+                for (int j = 0; j < 100; j++)
+                {
+                    // No null-conditional operator here: Windows PowerShell 5.1 compiles
+                    // Add-Type definitions with the C# 5 compiler.
+                    var freshInfo = helper.GetCommandInfo("Get-Command", bypassCache: true);
+                    if (freshInfo == null || freshInfo.Name != "Get-Command")
+                    {
+                        throw new System.InvalidOperationException("Get-Command was not resolved.");
+                    }
+                    var parameters = helper.GetCommandParameters("Get-Item");
+                    if (!parameters.ContainsKey("Path") || helper.GetCommandParameterSets("Get-Item").Count == 0)
+                    {
+                        throw new System.InvalidOperationException("Command parameter metadata was not resolved.");
+                    }
+                    var exports = helper.GetExportedFunction(ast);
+                    if (!exports.SetEquals(new[] { "Test-Example" }))
+                    {
+                        throw new System.InvalidOperationException("Exported function was not resolved.");
+                    }
+                }
+            });
+        }
+
+        Task.WaitAll(tasks);
+    }
+
+    public static string[] Lookup(string[] commandNames)
+    {
+        var helper = Helper.Instance;
+        var tasks = new Task<string>[commandNames.Length];
+        for (int i = 0; i < commandNames.Length; i++)
+        {
+            string name = commandNames[i];
+            tasks[i] = Task.Run(() =>
+            {
+                var commandInfo = helper.GetCommandInfo(name);
+                return commandInfo == null ? null : commandInfo.Name;
+            });
+        }
+
+        Task.WaitAll(tasks);
+
+        var results = new string[tasks.Length];
+        for (int i = 0; i < tasks.Length; i++)
+        {
+            results[i] = tasks[i].Result;
+        }
+
+        return results;
+    }
+}
+'@
+    }
+
+    It "resolves commands from several threads without failing" {
+        $commandNames = @(
+            'Get-ChildItem', 'Where-Object', 'ForEach-Object', 'Get-Content', 'Write-Output',
+            'Test-Path', 'Get-Command', 'Select-Object', 'Sort-Object', 'Measure-Object'
+        ) * 4
+
+        # A lookup that hits the thread safety problem throws, which fails the test.
+        $results = [ConcurrentCommandLookup]::Lookup($commandNames)
+
+        $results.Count | Should -Be $commandNames.Count
+        # A failed lookup returns null, so every entry must name the command that was requested.
+        for ($i = 0; $i -lt $commandNames.Count; $i++) {
+            $results[$i] | Should -BeExactly $commandNames[$i]
+        }
+
+    }
+
+    It "resolves exported functions while command lookups run concurrently" {
+        [ConcurrentCommandLookup]::ResolveExports()
+    }
+
+    It "returns null for unknown commands" {
+        [Microsoft.Windows.PowerShell.ScriptAnalyzer.Helper]::Instance.GetCommandInfo(
+            'Test-NonexistentCommandForRetryVerification', $null, $true) | Should -BeNullOrEmpty
+    }
+}
diff --git a/Tests/Engine/Helper.tests.ps1 b/Tests/Engine/Helper.tests.ps1
index 3d53e71f1..a6ccd70b2 100644
--- a/Tests/Engine/Helper.tests.ps1
+++ b/Tests/Engine/Helper.tests.ps1
@@ -39,3 +39,28 @@ Describe "Test Directed Graph" {
         }
     }
 }
+
+Describe "Exported function parameter resolution" {
+    BeforeAll {
+        $null = Invoke-ScriptAnalyzer -ScriptDefinition 'Get-Item -Path .'
+    }
+
+    It "resolves exports from <Script>" -TestCases @(
+        @{ Script = 'Export-ModuleMember -Function Test-Example' }
+        @{ Script = 'Export-ModuleMember -fUnCtIoN Test-Example' }
+        @{ Script = 'Export-ModuleMember -Fun Test-Example' }
+        @{ Script = 'Export-ModuleMember -Function:Test-Example' }
+        @{ Script = 'Export-ModuleMember Test-Example' }
+        @{ Script = 'Export-ModuleMember -Verbose Test-Example' }
+        @{ Script = 'Export-ModuleMember -vb Test-Example' }
+        @{ Script = 'Export-ModuleMember -Alias example -Function Test-Example' }
+        @{ Script = 'Export-ModuleMember -ea Stop -Fun Test-Example' }
+    ) {
+        param($Script)
+
+        $ast = [System.Management.Automation.Language.Parser]::ParseInput($Script, [ref]$null, [ref]$null)
+        $exports = [Microsoft.Windows.PowerShell.ScriptAnalyzer.Helper]::Instance.GetExportedFunction($ast)
+        $exports.Count | Should -Be 1
+        $exports | Should -Contain 'Test-Example'
+    }
+}
diff --git a/Tests/Engine/MetadataSnapshots.tests.ps1 b/Tests/Engine/MetadataSnapshots.tests.ps1
new file mode 100644
index 000000000..56d08f8d9
--- /dev/null
+++ b/Tests/Engine/MetadataSnapshots.tests.ps1
@@ -0,0 +1,322 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+Describe "Detached command metadata" {
+    BeforeAll {
+        $null = Invoke-ScriptAnalyzer -ScriptDefinition 'Write-Output example'
+        $assembly = [Microsoft.Windows.PowerShell.ScriptAnalyzer.Helper].Assembly
+        $references = @($assembly.Location, [System.Management.Automation.PSObject].Assembly.Location)
+        if ($PSVersionTable.PSEdition -eq 'Core') {
+            $references += Join-Path $PSHOME 'ref/System.Collections.dll'
+        }
+        Add-Type -IgnoreWarnings -WarningAction SilentlyContinue -ReferencedAssemblies $references -TypeDefinition @'
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Management.Automation;
+using System.Management.Automation.Runspaces;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.Windows.PowerShell.ScriptAnalyzer;
+
+[Cmdlet("Test", "SnapshotDynamic")]
+public class SnapshotDynamicCommand : PSCmdlet, IDynamicParameters
+{
+    public static string ParameterName = "First";
+
+    public object GetDynamicParameters()
+    {
+        var parameters = new RuntimeDefinedParameterDictionary();
+        parameters.Add(ParameterName, new RuntimeDefinedParameter(ParameterName, typeof(string),
+            new Collection<Attribute> { new ParameterAttribute() }));
+        return parameters;
+    }
+}
+
+[Cmdlet("Test", "SnapshotStatic")]
+public class SnapshotStaticCommand : PSCmdlet
+{
+    [Parameter(Mandatory = true)]
+    public string Example { get; set; }
+}
+
+public class FaultingMetadataInfo : CmdletInfo
+{
+    public static Exception Failure;
+    public static int FailuresRemaining;
+
+    public FaultingMetadataInfo() : base("Test-SnapshotStatic", typeof(SnapshotStaticCommand)) { }
+
+    public override Dictionary<string, ParameterMetadata> Parameters
+    {
+        get
+        {
+            if (FailuresRemaining-- > 0) throw Failure;
+            return base.Parameters;
+        }
+    }
+}
+
+public static class MetadataSnapshotTests
+{
+    private static readonly Type CacheType = typeof(Helper).Assembly.GetType(
+        "Microsoft.Windows.PowerShell.ScriptAnalyzer.CommandInfoCache");
+
+    // Block bodies instead of expression-bodied members: Windows PowerShell 5.1 compiles
+    // Add-Type definitions with the C# 5 compiler.
+    public static IDisposable Create()
+    {
+        return (IDisposable)Activator.CreateInstance(CacheType);
+    }
+
+    public static IReadOnlyDictionary<string, CommandParameterSnapshot> Parameters(
+        IDisposable cache, string name, bool bypass = false)
+    {
+        return (IReadOnlyDictionary<string, CommandParameterSnapshot>)CacheType.GetMethod("GetParameterSnapshot")
+            .Invoke(cache, new object[] { name, null, bypass });
+    }
+
+    public static object Mandatory(IDisposable cache, string name)
+    {
+        return CacheType.GetMethod("GetMandatoryParameterNames").Invoke(cache, new object[] { name });
+    }
+
+    public static object ReadMetadata(IDisposable cache, string name, string method, bool bypass = false)
+    {
+        var arguments = method == "GetCommandParameterSets" || method == "GetMandatoryParameterNames"
+            ? new object[] { name } : new object[] { name, null, bypass };
+        return CacheType.GetMethod(method).Invoke(cache, arguments);
+    }
+
+    public static void ConcurrentStatic(IDisposable cache)
+    {
+        var tasks = new Task<IReadOnlyDictionary<string, CommandParameterSnapshot>>[16];
+        for (int i = 0; i < tasks.Length; i++)
+        {
+            tasks[i] = Task.Run(() => Parameters(cache, "Export-ModuleMember"));
+        }
+        Task.WaitAll(tasks);
+        foreach (var task in tasks)
+        {
+            if (!ReferenceEquals(tasks[0].Result, task.Result) || !task.Result.ContainsKey("Function"))
+                throw new InvalidOperationException("Static metadata was not shared safely.");
+        }
+    }
+
+    public static void CheckDetached(IDisposable cache)
+    {
+        var snapshot = Parameters(cache, "Write-Output");
+        var live = (Dictionary<string, ParameterMetadata>)CacheType.GetMethod("GetCommandParameters")
+            .Invoke(cache, new object[] { "Write-Output", null, false });
+        live["InputObject"].Aliases.Add("SnapshotMustNotChange");
+        if (snapshot["InputObject"].Aliases.Contains("SnapshotMustNotChange"))
+            throw new InvalidOperationException("Snapshot retained live aliases.");
+        var dictionary = (IDictionary<string, CommandParameterSnapshot>)snapshot;
+        try { dictionary.Clear(); }
+        catch (NotSupportedException) { return; }
+        throw new InvalidOperationException("Snapshot can be modified.");
+    }
+
+    public static void Configure(IDisposable cache, string script)
+    {
+        var runspace = (Runspace)CacheType.GetField("_runspace", BindingFlags.Instance | BindingFlags.NonPublic)
+            .GetValue(cache);
+        using (var ps = PowerShell.Create())
+        {
+            ps.Runspace = runspace;
+            ps.AddScript(script);
+            ps.Invoke();
+            if (ps.HadErrors) throw new InvalidOperationException(ps.Streams.Error[0].ToString());
+        }
+    }
+}
+'@
+    }
+
+    BeforeEach {
+        $cache = [MetadataSnapshotTests]::Create()
+        $lookupCache = $cache.GetType().GetField(
+            '_commandInfoCache', [System.Reflection.BindingFlags]'NonPublic, Instance').GetValue($cache)
+    }
+
+    AfterEach {
+        $cache.Dispose()
+    }
+
+    It "publishes one immutable static snapshot to concurrent readers" {
+        [MetadataSnapshotTests]::ConcurrentStatic($cache)
+        $lookupCache.Count | Should -Be 1
+    }
+
+    It "detaches parameter facts from the live command" {
+        [MetadataSnapshotTests]::CheckDetached($cache)
+    }
+
+    It "does not cache provider dynamic metadata or aliases" {
+        foreach ($name in 'Get-Item', 'echo') {
+            $first = [MetadataSnapshotTests]::Parameters($cache, $name)
+            $second = [MetadataSnapshotTests]::Parameters($cache, $name)
+            [object]::ReferenceEquals($first, $second) | Should -BeFalse
+        }
+    }
+
+    It "does not cache function metadata" {
+        [MetadataSnapshotTests]::Configure($cache, 'function global:Test-SnapshotFunction { param($Example) }')
+        $first = [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotFunction')
+        $second = [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotFunction')
+        $first.ContainsKey('Example') | Should -BeTrue
+        [object]::ReferenceEquals($first, $second) | Should -BeFalse
+    }
+
+    It "observes changed dynamic parameters while retaining the previous detached result" {
+        [MetadataSnapshotTests]::Configure($cache, 'Import-Module -Assembly ([SnapshotDynamicCommand].Assembly)')
+        [SnapshotDynamicCommand]::ParameterName = 'First'
+        $first = [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotDynamic')
+        [SnapshotDynamicCommand]::ParameterName = 'Second'
+        $second = [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotDynamic')
+        $first.ContainsKey('First') | Should -BeTrue
+        $first.ContainsKey('Second') | Should -BeFalse
+        $second.ContainsKey('Second') | Should -BeTrue
+        $second.ContainsKey('First') | Should -BeFalse
+    }
+
+    It "bypasses static snapshots without replacing the cached snapshot" {
+        $first = [MetadataSnapshotTests]::Parameters($cache, 'Write-Output')
+        $fresh = [MetadataSnapshotTests]::Parameters($cache, 'Write-Output', $true)
+        [object]::ReferenceEquals($first, $fresh) | Should -BeFalse
+        [object]::ReferenceEquals($first, [MetadataSnapshotTests]::Parameters($cache, 'write-output')) | Should -BeTrue
+    }
+
+    It "combines mandatory metadata under one query and caches only static summaries" {
+        $first = [MetadataSnapshotTests]::Mandatory($cache, 'Write-Warning')
+        $first | Should -Contain 'Message'
+        [object]::ReferenceEquals($first, [MetadataSnapshotTests]::Mandatory($cache, 'Write-Warning')) | Should -BeTrue
+        $first = [MetadataSnapshotTests]::Mandatory($cache, 'Get-Item')
+        [object]::ReferenceEquals($first, [MetadataSnapshotTests]::Mandatory($cache, 'Get-Item')) | Should -BeFalse
+    }
+
+    It "does not return cached snapshots after disposal" {
+        $null = [MetadataSnapshotTests]::Parameters($cache, 'Write-Output')
+        $cache.Dispose()
+        [MetadataSnapshotTests]::Parameters($cache, 'Write-Output') | Should -BeNullOrEmpty
+        [MetadataSnapshotTests]::Mandatory($cache, 'Write-Output') | Should -BeNullOrEmpty
+    }
+
+    It "returns null when the engine cannot resolve Get-Command itself" {
+        [MetadataSnapshotTests]::Configure($cache, @'
+New-Module -Name Microsoft.PowerShell.Core -ScriptBlock {
+    function Get-Command {
+        [CmdletBinding()]
+        param($Name)
+        Write-Error -Exception ([System.Management.Automation.CommandNotFoundException]::new(
+            'Injected command resolution failure')) -ErrorAction Continue
+    }
+    Export-ModuleMember -Function Get-Command
+} | Import-Module -Force
+'@)
+        $lookup = $cache.GetType().GetMethod('GetCommandInfo')
+        $lookup.Invoke($cache, @('Write-Output', $null, $false)) | Should -BeNullOrEmpty
+    }
+
+    It "does not cache a command resolution failure as a missing command" {
+        [MetadataSnapshotTests]::Configure($cache, @'
+New-Module -Name Microsoft.PowerShell.Core -ScriptBlock {
+    function Get-Command {
+        param($Name)
+        Write-Error -Exception ([System.Management.Automation.CommandNotFoundException]::new(
+            'Transient command resolution failure')) -ErrorAction Continue
+    }
+    Export-ModuleMember -Function Get-Command
+} | Import-Module -Force
+'@)
+        [MetadataSnapshotTests]::Parameters($cache, 'Write-Output') | Should -BeNullOrEmpty
+        [MetadataSnapshotTests]::Configure($cache, 'Remove-Module Microsoft.PowerShell.Core')
+        [MetadataSnapshotTests]::Parameters($cache, 'Write-Output').ContainsKey('InputObject') | Should -BeTrue
+    }
+
+    It "retains negative caching for genuine missing commands" {
+        1..2 | ForEach-Object {
+            [MetadataSnapshotTests]::Parameters($cache, 'Test-NonexistentMetadataCommand') | Should -BeNullOrEmpty
+        }
+        $lookupCache.Count | Should -Be 1
+    }
+
+    It "resolves module-qualified command names against the named module only" {
+        $lookup = $cache.GetType().GetMethod('GetCommandInfo')
+        $lookup.Invoke($cache, @('Microsoft.PowerShell.Utility\Write-Output', $null, $false)).Name |
+            Should -BeExactly 'Write-Output'
+        $lookup.Invoke($cache, @('Microsoft.PowerShell.Management\Write-Output', $null, $false)) |
+            Should -BeNullOrEmpty
+    }
+
+    It "handles invalid PowerShell metadata centrally for <Method>" -TestCases @(
+        @{ Method = 'GetCommandParameters' }
+        @{ Method = 'GetCommandParameterSets' }
+        @{ Method = 'GetParameterSnapshot' }
+        @{ Method = 'GetMandatoryParameterNames' }
+    ) {
+        param($Method)
+        [MetadataSnapshotTests]::Configure($cache, @'
+function global:Test-InvalidMetadata {
+    param([Parameter(ParameterSetName='A')][Parameter(ParameterSetName='A')]$Example)
+}
+'@)
+        [MetadataSnapshotTests]::ReadMetadata($cache, 'Test-InvalidMetadata', $Method) | Should -BeNullOrEmpty
+
+        [MetadataSnapshotTests]::Configure($cache, 'function global:Test-InvalidMetadata { param([Parameter(Mandatory)]$Example) }')
+        [MetadataSnapshotTests]::ReadMetadata($cache, 'Test-InvalidMetadata', $Method) | Should -Not -BeNullOrEmpty
+    }
+
+    It "returns unavailable native-command metadata without an exception" {
+        $name = if ([Environment]::OSVersion.Platform -eq 'Win32NT') { 'cmd.exe' } else { 'sh' }
+        [MetadataSnapshotTests]::Parameters($cache, $name) | Should -BeNullOrEmpty
+        [MetadataSnapshotTests]::Mandatory($cache, $name) | Should -BeNullOrEmpty
+    }
+
+    Context "Runspace affinity failures" {
+        BeforeEach {
+            [MetadataSnapshotTests]::Configure($cache, @'
+New-Module -Name Microsoft.PowerShell.Core -ScriptBlock {
+    function Get-Command { param($Name); [FaultingMetadataInfo]::new() }
+    Export-ModuleMember -Function Get-Command
+} | Import-Module -Force
+'@)
+            [FaultingMetadataInfo]::Failure = [InvalidOperationException]::new('Injected metadata failure')
+            [FaultingMetadataInfo]::FailuresRemaining = 1
+        }
+
+        It "returns null for <Method> and recovers on the next call" -TestCases @(
+            @{ Method = 'GetCommandParameters' }
+            @{ Method = 'GetParameterSnapshot' }
+            @{ Method = 'GetMandatoryParameterNames' }
+        ) {
+            param($Method)
+            [MetadataSnapshotTests]::ReadMetadata($cache, 'Test-SnapshotStatic', $Method) | Should -BeNullOrEmpty
+            [MetadataSnapshotTests]::ReadMetadata($cache, 'Test-SnapshotStatic', $Method) | Should -Not -BeNullOrEmpty
+        }
+
+        It "does not cache a failed metadata result" {
+            [FaultingMetadataInfo]::Failure = [NullReferenceException]::new('Injected metadata failure')
+            [FaultingMetadataInfo]::FailuresRemaining = 2
+            [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotStatic') | Should -BeNullOrEmpty
+            [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotStatic') | Should -BeNullOrEmpty
+            [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotStatic').ContainsKey('Example') | Should -BeTrue
+        }
+
+        It "returns null for an explicitly fresh lookup that fails" {
+            [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotStatic', $true) | Should -BeNullOrEmpty
+        }
+
+        It "does not swallow unrelated exceptions" {
+            [FaultingMetadataInfo]::Failure = [ArgumentException]::new('Unexpected metadata failure')
+            { [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotStatic') } |
+                Should -Throw '*Unexpected metadata failure*'
+        }
+
+        It "contains metadata operations unsupported by PowerShell" {
+            [FaultingMetadataInfo]::Failure = [System.Management.Automation.PSNotSupportedException]::new(
+                'Unsupported metadata operation')
+            [MetadataSnapshotTests]::Parameters($cache, 'Test-SnapshotStatic') | Should -BeNullOrEmpty
+        }
+    }
+}
diff --git a/Tests/Rules/ParallelRuleExecution.tests.ps1 b/Tests/Rules/ParallelRuleExecution.tests.ps1
new file mode 100644
index 000000000..e027080b9
--- /dev/null
+++ b/Tests/Rules/ParallelRuleExecution.tests.ps1
@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+Describe 'Parallel rule execution' {
+    It 'analyzes many files with most rules enabled without failing' {
+        # Regression test for https://github.com/PowerShell/PSScriptAnalyzer/issues/2205:
+        # rules run in parallel for each file and share command lookups and metadata queries,
+        # which intermittently failed because the PowerShell engine is not thread safe.
+        # The workload is synthetic so the test stays fast and portable, while the aliases,
+        # miscased parameters, mandatory parameters and exports below still force every
+        # analyzed file through concurrent command lookups and metadata queries.
+        $settingsPath = Join-Path $PSScriptRoot 'ParallelRuleExecution/PSScriptAnalyzerSettings.psd1'
+        $root = Join-Path $TestDrive 'ParallelRuleExecution'
+        $null = New-Item -ItemType Directory -Path $root -Force
+        foreach ($index in 1..20) {
+            @"
+function Test-ParallelExample$index {
+    [CmdletBinding()]
+    param([Parameter(Mandatory)][string]`$Path)
+    gci -LiteralPath `$Path | where Name -like '*.ps1' | foreach {
+        Write-Output -inputobject `$_.FullName
+        Get-Item -path `$_.FullName
+        Test-Path -LiteralPath `$_.FullName
+    }
+}
+Export-ModuleMember -Function Test-ParallelExample$index
+"@ | Set-Content -LiteralPath (Join-Path $root "Example$index.psm1")
+        }
+
+        $diagnostics = Invoke-ScriptAnalyzer -Path $root -Recurse -Settings $settingsPath -ErrorAction Stop
+        @($diagnostics).Count | Should -BeGreaterThan 0
+    }
+}
diff --git a/Tests/Rules/ParallelRuleExecution/PSScriptAnalyzerSettings.psd1 b/Tests/Rules/ParallelRuleExecution/PSScriptAnalyzerSettings.psd1
new file mode 100644
index 000000000..1849a35d3
--- /dev/null
+++ b/Tests/Rules/ParallelRuleExecution/PSScriptAnalyzerSettings.psd1
@@ -0,0 +1,53 @@
+@{
+    Severity = @('Error', 'Warning', 'Information')
+    IncludeRules = @(
+        'PSAvoidUsingCmdletAliases', 'PSAvoidDefaultValueForMandatoryParameter',
+        'PSAvoidDefaultValueSwitchParameter', 'PSAvoidGlobalAliases',
+        'PSAvoidGlobalFunctions', 'PSAvoidGlobalVars', 'PSAvoidInvokingEmptyMembers',
+        'PSAvoidNullOrEmptyHelpMessageAttribute', 'PSAvoidShouldContinueWithoutForce',
+        'PSAvoidUsingComputerNameHardcoded', 'PSAvoidUsingConvertToSecureStringWithPlainText',
+        'PSAvoidUsingDeprecatedManifestFields', 'PSAvoidUsingEmptyCatchBlock',
+        'PSAvoidUsingInvokeExpression', 'PSAvoidUsingPlainTextForPassword',
+        'PSAvoidUsingPositionalParameters', 'PSAvoidUsingUsernameAndPasswordParams',
+        'PSAvoidUsingWMICmdlet', 'PSAvoidUsingWriteHost', 'PSMisleadingBacktick',
+        'PSMissingModuleManifestField', 'PSPossibleIncorrectComparisonWithNull',
+        'PSPossibleIncorrectUsageOfAssignmentOperator', 'PSPossibleIncorrectUsageOfRedirectionOperator',
+        'PSProvideCommentHelp', 'PSReservedCmdletChar', 'PSReservedParams',
+        'PSUseApprovedVerbs', 'PSUseBOMForUnicodeEncodedFile', 'PSUseCmdletCorrectly',
+        'PSUseConsistentIndentation', 'PSUseConsistentWhitespace', 'PSUseCorrectCasing',
+        'PSUseDeclaredVarsMoreThanAssignments', 'PSUseLiteralInitializerForHashtable',
+        'PSUseOutputTypeCorrectly', 'PSUsePSCredentialType', 'PSUseSingularNouns',
+        'PSUseToExportFieldsInManifest', 'PSUseUTF8EncodingForHelpFile'
+    )
+    ExcludeRules = @(
+        'PSAvoidUsingWriteHost', 'PSAvoidUsingPositionalParameters', 'PSUseApprovedVerbs',
+        'PSProvideCommentHelp', 'PSAvoidGlobalVars', 'PSAvoidGlobalFunctions',
+        'PSUseSingularNouns', 'PSUseOutputTypeCorrectly'
+    )
+    Rules = @{
+        PSUseConsistentIndentation = @{
+            Enable = $true
+            IndentationSize = 4
+            PipelineIndentation = 'IncreaseIndentationForFirstPipeline'
+            Kind = 'space'
+        }
+        PSUseConsistentWhitespace = @{
+            Enable = $true
+            CheckInnerBrace = $true
+            CheckOpenBrace = $true
+            CheckOpenParen = $true
+            CheckOperator = $true
+            CheckPipe = $true
+            CheckPipeForRedundantWhitespace = $false
+            CheckSeparator = $true
+            CheckParameter = $false
+            IgnoreAssignmentOperatorInsideHashTable = $true
+        }
+        PSUseCompatibleCmdlets = @{ Enable = $false }
+        PSUseCorrectCasing = @{ Enable = $true }
+        PSAvoidUsingCmdletAliases = @{ Enable = $true; allowlist = @() }
+        PSAlignAssignmentStatement = @{ Enable = $false; CheckHashtable = $false }
+        PSPlaceOpenBrace = @{ Enable = $true; OnSameLine = $true; NewLineAfter = $true; IgnoreOneLineBlock = $true }
+        PSPlaceCloseBrace = @{ Enable = $true; NewLineAfter = $true; IgnoreOneLineBlock = $true; NoEmptyLineBefore = $false }
+    }
+}
diff --git a/tools/Measure-ScriptAnalyzerPerformance.ps1 b/tools/Measure-ScriptAnalyzerPerformance.ps1
new file mode 100644
index 000000000..369de3db8
--- /dev/null
+++ b/tools/Measure-ScriptAnalyzerPerformance.ps1
@@ -0,0 +1,146 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)]
+    [string]$ModulePath,
+
+    [Parameter(Mandatory)]
+    [string]$ScriptPath,
+
+    [Parameter(Mandatory)]
+    [string]$ResultPath,
+
+    [switch]$Recurse,
+
+    [string]$SettingsPath
+)
+
+$ErrorActionPreference = 'Stop'
+$ModulePath = (Resolve-Path -LiteralPath $ModulePath).Path
+$ScriptPath = (Resolve-Path -LiteralPath $ScriptPath).Path
+$analyzerArguments = @{
+    Path = $ScriptPath
+    Recurse = $Recurse
+    ErrorAction = 'Stop'
+}
+if ($SettingsPath) {
+    $SettingsPath = (Resolve-Path -LiteralPath $SettingsPath).Path
+    $analyzerArguments.Settings = $SettingsPath
+}
+
+# Run this script in a new -NoProfile shell for each build. Import and shell
+# startup are excluded; cold means the first analysis in this process.
+if (Get-Module PSScriptAnalyzer) {
+    throw 'PSScriptAnalyzer is already loaded; run this benchmark in a fresh shell.'
+}
+$module = Import-Module -Name $ModulePath -PassThru
+$expectedModuleBase = Split-Path -Parent $ModulePath
+$expectedAssemblyPath = (Resolve-Path -LiteralPath (
+    Join-Path $expectedModuleBase "PSv$($PSVersionTable.PSVersion.Major)/Microsoft.Windows.PowerShell.ScriptAnalyzer.dll"
+)).Path
+$command = Get-Command PSScriptAnalyzer\Invoke-ScriptAnalyzer -CommandType Cmdlet
+if ($module.Name -ne 'PSScriptAnalyzer' -or
+    $module.ModuleBase -ne $expectedModuleBase -or
+    $command.Module.ModuleBase -ne $expectedModuleBase -or
+    $command.ImplementingType.Assembly.Location -ne $expectedAssemblyPath) {
+    throw "The loaded module or Invoke-ScriptAnalyzer assembly does not match the requested build at '$ModulePath'."
+}
+$inputItem = Get-Item -LiteralPath $ScriptPath
+$inputRoot = if ($inputItem.PSIsContainer) { $ScriptPath } else { Split-Path -Parent $ScriptPath }
+
+function ConvertTo-WorkloadPath([string]$Path) {
+    if ([string]::IsNullOrEmpty($Path)) { return $Path }
+    if ([IO.Path]::IsPathRooted($Path)) {
+        return [IO.Path]::GetRelativePath($inputRoot, $Path).Replace('\', '/')
+    }
+    return $Path.Replace('\', '/')
+}
+
+function ConvertTo-DiagnosticJson($Diagnostic) {
+    $corrections = @(foreach ($correction in $Diagnostic.SuggestedCorrections) {
+        [ordered]@{
+            File = ConvertTo-WorkloadPath $correction.File
+            StartLine = $correction.StartLineNumber
+            StartColumn = $correction.StartColumnNumber
+            EndLine = $correction.EndLineNumber
+            EndColumn = $correction.EndColumnNumber
+            Text = $correction.Text
+            Description = $correction.Description
+        }
+    })
+    [ordered]@{
+        RuleName = $Diagnostic.RuleName
+        Severity = $Diagnostic.Severity.ToString()
+        Message = $Diagnostic.Message.Replace($inputRoot, '<workload>')
+        ScriptName = $Diagnostic.ScriptName
+        ScriptPath = ConvertTo-WorkloadPath $Diagnostic.ScriptPath
+        RuleSuppressionID = $Diagnostic.RuleSuppressionID
+        IsSuppressed = $Diagnostic.IsSuppressed
+        Extent = if ($null -ne $Diagnostic.Extent) {
+            [ordered]@{
+                File = ConvertTo-WorkloadPath $Diagnostic.Extent.File
+                StartLine = $Diagnostic.Extent.StartLineNumber
+                StartColumn = $Diagnostic.Extent.StartColumnNumber
+                EndLine = $Diagnostic.Extent.EndLineNumber
+                EndColumn = $Diagnostic.Extent.EndColumnNumber
+                StartOffset = $Diagnostic.Extent.StartOffset
+                EndOffset = $Diagnostic.Extent.EndOffset
+                Text = $Diagnostic.Extent.Text
+            }
+        } else { $null }
+        SuggestedCorrections = $corrections
+    } | ConvertTo-Json -Depth 10 -Compress
+}
+
+if ($inputItem.PSIsContainer) {
+    $inputFiles = @(Get-ChildItem -LiteralPath $ScriptPath -File -Recurse:$Recurse |
+        Where-Object Extension -In '.ps1', '.psm1', '.psd1' |
+        Sort-Object FullName)
+    if ($inputFiles.Count -eq 0) {
+        throw "No PowerShell files found at '$ScriptPath'."
+    }
+    $fileHashes = foreach ($file in $inputFiles) {
+        $relativePath = [IO.Path]::GetRelativePath($ScriptPath, $file.FullName).Replace('\', '/')
+        "$relativePath`:$((Get-FileHash -LiteralPath $file.FullName -Algorithm SHA256).Hash)"
+    }
+    $inputHash = [Convert]::ToHexString([Security.Cryptography.SHA256]::HashData(
+        [Text.Encoding]::UTF8.GetBytes(($fileHashes -join "`n"))))
+} else {
+    $inputFiles = @($inputItem)
+    $inputHash = (Get-FileHash -LiteralPath $ScriptPath -Algorithm SHA256).Hash
+}
+$results = [ordered]@{
+    PowerShellVersion = $PSVersionTable.PSVersion.ToString()
+    ModuleVersion = $module.Version.ToString()
+    ModuleManifest = $ModulePath
+    ModulePath = $module.Path
+    AnalyzerAssemblyPath = $command.ImplementingType.Assembly.Location
+    ScriptPath = $ScriptPath
+    InputSHA256 = $inputHash
+    InputFileCount = $inputFiles.Count
+    Recurse = [bool]$Recurse
+    SettingsPath = $SettingsPath
+    SettingsSHA256 = if ($SettingsPath) { (Get-FileHash -LiteralPath $SettingsPath -Algorithm SHA256).Hash } else { $null }
+    Culture = [Globalization.CultureInfo]::CurrentCulture.Name
+    UICulture = [Globalization.CultureInfo]::CurrentUICulture.Name
+    StopwatchFrequency = [System.Diagnostics.Stopwatch]::Frequency
+}
+
+foreach ($run in 'Cold', 'Warm') {
+    $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
+    $diagnostics = @(& $command @analyzerArguments)
+    $stopwatch.Stop()
+    $results["${run}Seconds"] = $stopwatch.Elapsed.TotalSeconds
+    $results["${run}DiagnosticCount"] = $diagnostics.Count
+    # Canonicalize outside the timed region, retaining duplicates but ignoring
+    # nondeterministic rule completion order and checkout-root differences.
+    [string[]]$diagnosticJson = @($diagnostics | ForEach-Object { ConvertTo-DiagnosticJson $_ })
+    [Array]::Sort($diagnosticJson, [StringComparer]::Ordinal)
+    $results["${run}DiagnosticsSHA256"] = [Convert]::ToHexString([Security.Cryptography.SHA256]::HashData(
+        [Text.Encoding]::UTF8.GetBytes(($diagnosticJson -join "`n"))))
+    $results["${run}Diagnostics"] = @($diagnosticJson | ForEach-Object { ConvertFrom-Json -InputObject $_ })
+}
+
+[pscustomobject]$results | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath $ResultPath -Encoding utf8