diff --git a/GlobalUsings.FatV2.cs b/GlobalUsings.FatV2.cs
new file mode 100644
index 000000000..7eda92d5e
--- /dev/null
+++ b/GlobalUsings.FatV2.cs
@@ -0,0 +1 @@
+global using ArIED61850Tester.Models.IoTesting;
diff --git a/MainWindow.FatV2.cs b/MainWindow.FatV2.cs
index 22f346faa..bf9506750 100644
--- a/MainWindow.FatV2.cs
+++ b/MainWindow.FatV2.cs
@@ -14,12 +14,12 @@ namespace ArIED61850Tester;
 public partial class MainWindow
 {
     private FatVerificationWindow? _fatV2Window;
+    private FatSclWorkspaceLaunchResult? _fatV2Launch;
 
     private void ScheduleFatV2LauncherInstall()
     {
-        // P4 remains additive to the proven workbook FAT path. Install the SCL FAT command
-        // after the existing first-run card has been constructed instead of rewriting the
-        // legacy launcher or its session lifecycle.
+        // FAT v2 remains additive to the proven workbook FAT path. Install SCL/project
+        // commands after the existing first-run card has been constructed.
         Dispatcher.BeginInvoke(
             new Action(InstallFatV2Launcher),
             DispatcherPriority.Background);
@@ -42,47 +42,49 @@ private void InstallFatV2Launcher()
         if (description != null)
         {
             description.Text =
-                "Create FAT v2 directly from every static IEC 61850 DataSet membership in one or more SCL files, or continue using the proven Excel IO List workflow.";
+                "Create FAT v2 directly from every static IEC 61850 DataSet membership, reopen or save a portable FAT v2 ARSAS project, or continue using the proven Excel IO List workflow.";
         }
 
-        var button = CreateLauncherButton(
+        var sclButton = CreateLauncherButton(
             "Open SCL for FAT v2",
             "LucideFileInput",
             "PrimaryButton",
             OpenFatV2Scl_Click,
             Brushes.White,
             new Thickness(0, 0, 0, 8));
-        button.Tag = "FatV2SclLauncher";
+        sclButton.Tag = "FatV2SclLauncher";
 
-        var firstExistingButton = content.Children
-            .OfType<Button>()
-            .FirstOrDefault();
+        var projectButton = CreateLauncherButton(
+            "Open FAT v2 ARSAS Project",
+            "LucideFolderOpen",
+            "SecondaryButton",
+            OpenFatV2Project_Click,
+            Brushes.DarkSlateGray,
+            new Thickness(0, 0, 0, 8));
+        projectButton.Tag = "FatV2ProjectLauncher";
+
+        var saveButton = CreateLauncherButton(
+            "Save active FAT v2 ARSAS Project",
+            "LucideSave",
+            "SecondaryButton",
+            SaveFatV2Project_Click,
+            Brushes.DarkSlateGray,
+            new Thickness(0, 0, 0, 8));
+        saveButton.Tag = "FatV2SaveLauncher";
+
+        var firstExistingButton = content.Children.OfType<Button>().FirstOrDefault();
         var insertAt = firstExistingButton == null
             ? content.Children.Count
             : content.Children.IndexOf(firstExistingButton);
-        content.Children.Insert(insertAt, button);
+        content.Children.Insert(insertAt, saveButton);
+        content.Children.Insert(insertAt, projectButton);
+        content.Children.Insert(insertAt, sclButton);
     }
 
     private async void OpenFatV2Scl_Click(object sender, RoutedEventArgs e)
     {
-        if (_fatV2Window is { IsLoaded: true })
-        {
-            if (_fatV2Window.WindowState == WindowState.Minimized)
-                _fatV2Window.WindowState = WindowState.Normal;
-            _fatV2Window.Activate();
-            return;
-        }
-
-        if (_loadedIoFatWindow is { IsLoaded: true })
-        {
-            MessageBox.Show(
-                this,
-                "Close the active IO List FAT workspace before opening a FAT v2 SCL workspace.",
-                "FAT workspace already open",
-                MessageBoxButton.OK,
-                MessageBoxImage.Information);
+        if (!CanOpenFatV2Workspace())
             return;
-        }
 
         var dialog = new OpenFileDialog
         {
@@ -98,53 +100,175 @@ private async void OpenFatV2Scl_Click(object sender, RoutedEventArgs e)
         SetStatus($"Creating FAT v2 from {dialog.FileNames.Length} SCL source(s)…");
         try
         {
-            var bootstrap = new FatSclWorkspaceBootstrapService();
-            var launch = await bootstrap.OpenAsync(
+            var launch = await new FatSclWorkspaceBootstrapService().OpenAsync(
                 dialog.FileNames,
                 IoTestingProjectsRoot(),
                 _applicationCancellation.Token);
+            ShowFatV2Workspace(launch, sourceNames);
+        }
+        catch (OperationCanceledException)
+        {
+            SetStatus("FAT v2 SCL import cancelled.");
+        }
+        catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException or ArgumentException or InvalidOperationException)
+        {
+            ShowFatV2Failure(ex, "FAT v2 SCL import failed");
+        }
+    }
 
-            var digital = launch.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Discrete);
-            var analog = launch.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Analog);
-            var other = launch.Project.Signals.Count - digital - analog;
-            var status =
-                $"FAT v2 ready: {launch.Project.Signals.Count} static DataSet membership(s) from {launch.SourceFiles.Count} SCL source(s) — " +
-                $"{digital} digital, {analog} analog, {other} other.";
-            SetStatus(status);
-            AddLog("INFO", "FAT v2", $"{status} Sources: {sourceNames}");
-
-            var window = new FatVerificationWindow(launch) { Owner = this };
-            _fatV2Window = window;
-            _runtime.PointUpdated += Runtime_FatV2PointUpdated;
-            SeedFatV2LiveValues(window);
-
-            void WindowClosed(object? _, EventArgs __)
-            {
-                window.Closed -= WindowClosed;
-                _runtime.PointUpdated -= Runtime_FatV2PointUpdated;
-                if (ReferenceEquals(_fatV2Window, window))
-                    _fatV2Window = null;
-            }
+    private async void OpenFatV2Project_Click(object sender, RoutedEventArgs e)
+    {
+        if (!CanOpenFatV2Workspace())
+            return;
 
-            window.Closed += WindowClosed;
-            window.Show();
+        var dialog = new OpenFileDialog
+        {
+            Title = "Open ARSAS FAT v2 Project",
+            Filter = "ARSAS FAT v2 project (*.arsas)|*.arsas|All files (*.*)|*.*",
+            CheckFileExists = true,
+            Multiselect = false
+        };
+        if (dialog.ShowDialog(this) != true)
+            return;
+
+        SetStatus($"Opening FAT v2 project {Path.GetFileName(dialog.FileName)}…");
+        try
+        {
+            var launch = await FatVerificationPackageService.OpenAsync(
+                dialog.FileName,
+                IoTestingProjectsRoot(),
+                _applicationCancellation.Token);
+            ShowFatV2Workspace(launch, Path.GetFileName(dialog.FileName));
         }
         catch (OperationCanceledException)
         {
-            SetStatus("FAT v2 SCL import cancelled.");
+            SetStatus("FAT v2 project open cancelled.");
         }
         catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException or ArgumentException or InvalidOperationException)
         {
-            AddLog("ERROR", "FAT v2", ex.Message);
-            MarkDiagnosticAlert();
-            SetStatus("FAT v2 SCL import failed. The source SCL was not modified.");
+            ShowFatV2Failure(ex, "FAT v2 project open failed");
+        }
+    }
+
+    private async void SaveFatV2Project_Click(object sender, RoutedEventArgs e)
+    {
+        var launch = _fatV2Launch;
+        if (launch == null || _fatV2Window is not { IsLoaded: true })
+        {
             MessageBox.Show(
                 this,
-                $"ARSAS could not create FAT v2 from the selected SCL source set.\n\n{ex.Message}",
-                "FAT v2 import failed",
+                "Open a FAT v2 workspace before saving a portable ARSAS project.",
+                "No active FAT v2 workspace",
                 MessageBoxButton.OK,
-                MessageBoxImage.Error);
+                MessageBoxImage.Information);
+            return;
+        }
+
+        var dialog = new SaveFileDialog
+        {
+            Title = "Save ARSAS FAT v2 Project",
+            Filter = "ARSAS FAT v2 project (*.arsas)|*.arsas",
+            DefaultExt = ".arsas",
+            AddExtension = true,
+            FileName = $"FAT-v2-{DateTime.Now:yyyyMMdd-HHmm}.arsas"
+        };
+        if (dialog.ShowDialog(this) != true)
+            return;
+
+        SetStatus($"Saving FAT v2 project {Path.GetFileName(dialog.FileName)}…");
+        try
+        {
+            var saved = await FatVerificationPackageService.ExportAsync(
+                launch,
+                dialog.FileName,
+                _applicationCancellation.Token);
+            SetStatus($"FAT v2 project saved: {Path.GetFileName(saved)}");
+            AddLog("INFO", "FAT v2", $"Portable FAT v2 project saved to {saved}");
+        }
+        catch (OperationCanceledException)
+        {
+            SetStatus("FAT v2 project save cancelled.");
+        }
+        catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException or ArgumentException or InvalidOperationException)
+        {
+            ShowFatV2Failure(ex, "FAT v2 project save failed");
+        }
+    }
+
+    private bool CanOpenFatV2Workspace()
+    {
+        if (_fatV2Window is { IsLoaded: true })
+        {
+            if (_fatV2Window.WindowState == WindowState.Minimized)
+                _fatV2Window.WindowState = WindowState.Normal;
+            _fatV2Window.Activate();
+            return false;
         }
+
+        if (_loadedIoFatWindow is { IsLoaded: true })
+        {
+            MessageBox.Show(
+                this,
+                "Close the active IO List FAT workspace before opening a FAT v2 workspace.",
+                "FAT workspace already open",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+            return false;
+        }
+        return true;
+    }
+
+    private void ShowFatV2Workspace(FatSclWorkspaceLaunchResult launch, string sourceLabel)
+    {
+        var digital = launch.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Discrete);
+        var analog = launch.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Analog);
+        var other = launch.Project.Signals.Count - digital - analog;
+        var status =
+            $"FAT v2 ready: {launch.Project.Signals.Count} static DataSet membership(s) from {launch.SourceFiles.Count} SCL source(s) — " +
+            $"{digital} digital, {analog} analog, {other} other.";
+        SetStatus(status);
+        AddLog("INFO", "FAT v2", $"{status} Source: {sourceLabel}");
+
+        var window = new FatVerificationWindow(launch) { Owner = this };
+        _fatV2Window = window;
+        _fatV2Launch = launch;
+        _runtime.PointUpdated += Runtime_FatV2PointUpdated;
+        SeedFatV2LiveValues(window);
+
+        void WindowClosed(object? _, EventArgs __)
+        {
+            window.Closed -= WindowClosed;
+            _runtime.PointUpdated -= Runtime_FatV2PointUpdated;
+            try
+            {
+                FatVerificationPersistenceService.SaveNow(launch);
+            }
+            catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException)
+            {
+                AddLog("ERROR", "FAT v2 persistence", ex.Message);
+                MarkDiagnosticAlert();
+            }
+            if (ReferenceEquals(_fatV2Window, window))
+                _fatV2Window = null;
+            if (ReferenceEquals(_fatV2Launch, launch))
+                _fatV2Launch = null;
+        }
+
+        window.Closed += WindowClosed;
+        window.Show();
+    }
+
+    private void ShowFatV2Failure(Exception ex, string title)
+    {
+        AddLog("ERROR", "FAT v2", ex.Message);
+        MarkDiagnosticAlert();
+        SetStatus($"{title}. The source SCL was not modified.");
+        MessageBox.Show(
+            this,
+            ex.Message,
+            title,
+            MessageBoxButton.OK,
+            MessageBoxImage.Error);
     }
 
     private void Runtime_FatV2PointUpdated(Iec61850PointSnapshot snapshot)
diff --git a/Services/IoTesting/FatSclWorkspaceBootstrapService.cs b/Services/IoTesting/FatSclWorkspaceBootstrapService.cs
index 874875bc8..48e2302e2 100644
--- a/Services/IoTesting/FatSclWorkspaceBootstrapService.cs
+++ b/Services/IoTesting/FatSclWorkspaceBootstrapService.cs
@@ -104,12 +104,18 @@ public async Task<FatSclWorkspaceLaunchResult> OpenAsync(
             Path.Combine(workspaceDirectory, "source"),
             cancellationToken).ConfigureAwait(false);
 
-        return new FatSclWorkspaceLaunchResult(
+        var launch = new FatSclWorkspaceLaunchResult(
             import.Project,
             stagedSources,
             sourceSetSha256,
             import.SourceFingerprint,
             workspaceDirectory);
+
+        // Restore only operator disposition and current evidence after the authoritative
+        // DataSet projection has been recreated from the immutable SCL sources. A stale or
+        // mismatched snapshot therefore fails closed instead of becoming engineering truth.
+        FatVerificationPersistenceService.RestoreIfPresent(launch);
+        return launch;
     }
 
     private static async Task<IReadOnlyList<IoFatWorkspaceSource>> StageImmutableSourcesAsync(
diff --git a/Services/IoTesting/FatVerificationPackageService.cs b/Services/IoTesting/FatVerificationPackageService.cs
new file mode 100644
index 000000000..7275d6da3
--- /dev/null
+++ b/Services/IoTesting/FatVerificationPackageService.cs
@@ -0,0 +1,215 @@
+using System.IO.Compression;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+public static class FatVerificationPackageService
+{
+    public const string PackageExtension = ".arsas";
+    private const long MaximumPackageBytes = 500L * 1024 * 1024;
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = true
+    };
+
+    private sealed record Manifest(
+        string PackageVersion,
+        string PackageKind,
+        DateTimeOffset CreatedAtUtc,
+        string ProjectId,
+        string SourceSetSha256,
+        string EngineeringFingerprint,
+        string SnapshotEntry,
+        string SnapshotSha256,
+        string PdfEntry,
+        string PdfSha256,
+        string ExcelEntry,
+        string ExcelSha256,
+        List<IoFatPackageSource> SourceFiles);
+
+    public static async Task<string> ExportAsync(
+        FatSclWorkspaceLaunchResult launch,
+        string destinationPath,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        ArgumentException.ThrowIfNullOrWhiteSpace(destinationPath);
+        if (launch.SourceFiles.Count == 0)
+            throw new InvalidDataException("FAT v2 project contains no immutable SCL source bundle.");
+
+        FatVerificationPersistenceService.SaveNow(launch);
+        var snapshotBytes = await File.ReadAllBytesAsync(
+            FatVerificationPersistenceService.SnapshotPath(launch), cancellationToken).ConfigureAwait(false);
+        var pdfBytes = FatVerificationReportService.GeneratePdf(launch);
+        var excelBytes = FatVerificationReportService.GenerateXlsx(launch);
+        var sourceFiles = IoFatSourceWorkspaceService.ToPackageSources(launch.SourceFiles).ToList();
+        var manifest = new Manifest(
+            "fat-v2.1",
+            "fat-v2",
+            DateTimeOffset.UtcNow,
+            launch.Project.ProjectId,
+            launch.SourceSetSha256,
+            launch.EngineeringFingerprint,
+            FatVerificationPersistenceService.SnapshotFileName,
+            Hash(snapshotBytes),
+            "report/FAT-v2-Report.pdf",
+            Hash(pdfBytes),
+            "report/FAT-v2-Results.xlsx",
+            Hash(excelBytes),
+            sourceFiles);
+
+        var destination = Path.GetFullPath(destinationPath);
+        if (!destination.EndsWith(PackageExtension, StringComparison.OrdinalIgnoreCase))
+            destination += PackageExtension;
+        Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
+        var temporary = destination + ".tmp-" + Guid.NewGuid().ToString("N");
+        try
+        {
+            using (var archive = ZipFile.Open(temporary, ZipArchiveMode.Create))
+            {
+                await WriteAsync(archive, "manifest.json", JsonSerializer.SerializeToUtf8Bytes(manifest, JsonOptions), cancellationToken).ConfigureAwait(false);
+                await WriteAsync(archive, manifest.SnapshotEntry, snapshotBytes, cancellationToken).ConfigureAwait(false);
+                foreach (var source in launch.SourceFiles)
+                {
+                    var bytes = await IoFatSourceWorkspaceService.ReadVerifiedAsync(source, cancellationToken).ConfigureAwait(false);
+                    await WriteAsync(archive, source.PackageEntry, bytes, cancellationToken).ConfigureAwait(false);
+                }
+                await WriteAsync(archive, manifest.PdfEntry, pdfBytes, cancellationToken).ConfigureAwait(false);
+                await WriteAsync(archive, manifest.ExcelEntry, excelBytes, cancellationToken).ConfigureAwait(false);
+                await WriteAsync(archive, "README.txt", Encoding.UTF8.GetBytes(
+                    "ARSAS FAT v2 portable project\r\n\r\n" +
+                    "This project is driven by immutable IEC 61850 SCL source files.\r\n" +
+                    "FAT rows are recreated from ARIEC static DataSet authority before saved operator disposition and Value 1 / Value 2 evidence are restored.\r\n" +
+                    "Reports: report/FAT-v2-Report.pdf and report/FAT-v2-Results.xlsx\r\n"), cancellationToken).ConfigureAwait(false);
+            }
+            File.Move(temporary, destination, true);
+            return destination;
+        }
+        finally
+        {
+            if (File.Exists(temporary))
+                File.Delete(temporary);
+        }
+    }
+
+    public static async Task<FatSclWorkspaceLaunchResult> OpenAsync(
+        string packagePath,
+        string localProjectsRoot,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(packagePath);
+        ArgumentException.ThrowIfNullOrWhiteSpace(localProjectsRoot);
+        var info = new FileInfo(packagePath);
+        if (!info.Exists)
+            throw new FileNotFoundException("FAT v2 ARSAS project was not found.", packagePath);
+        if (info.Length > MaximumPackageBytes)
+            throw new InvalidDataException("FAT v2 ARSAS project exceeds the 500 MB safety limit.");
+
+        using var archive = ZipFile.OpenRead(packagePath);
+        var manifestBytes = await ReadAsync(RequiredEntry(archive, "manifest.json"), 5 * 1024 * 1024, cancellationToken).ConfigureAwait(false);
+        var manifest = JsonSerializer.Deserialize<Manifest>(manifestBytes, JsonOptions)
+            ?? throw new InvalidDataException("FAT v2 project manifest is invalid.");
+        if (!manifest.PackageKind.Equals("fat-v2", StringComparison.OrdinalIgnoreCase))
+            throw new InvalidDataException($"ARSAS project kind '{manifest.PackageKind}' is not a FAT v2 project.");
+        if (manifest.SourceFiles.Count == 0)
+            throw new InvalidDataException("FAT v2 project contains no SCL source bundle.");
+
+        var snapshotBytes = await ReadAsync(RequiredEntry(archive, manifest.SnapshotEntry), 50 * 1024 * 1024, cancellationToken).ConfigureAwait(false);
+        Verify(snapshotBytes, manifest.SnapshotSha256, "FAT v2 snapshot");
+        Verify(await ReadAsync(RequiredEntry(archive, manifest.PdfEntry), 100 * 1024 * 1024, cancellationToken).ConfigureAwait(false), manifest.PdfSha256, "FAT v2 PDF report");
+        Verify(await ReadAsync(RequiredEntry(archive, manifest.ExcelEntry), 100 * 1024 * 1024, cancellationToken).ConfigureAwait(false), manifest.ExcelSha256, "FAT v2 Excel report");
+
+        var sourceSet = IoFatSourceIdentity.ComputeSetFingerprint(manifest.SourceFiles.Select(source => source.Descriptor));
+        if (!sourceSet.Equals(manifest.SourceSetSha256, StringComparison.OrdinalIgnoreCase))
+            throw new InvalidDataException("FAT v2 source-set fingerprint is invalid.");
+
+        var extractionRoot = Path.Combine(Path.GetTempPath(), "ARSAS", "FAT-v2-import", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(extractionRoot);
+        try
+        {
+            var sourcePaths = new List<string>();
+            foreach (var source in manifest.SourceFiles.OrderBy(source => source.Descriptor.SourceId, StringComparer.Ordinal))
+            {
+                var descriptor = IoFatSourceIdentity.Normalize(source.Descriptor);
+                if (!descriptor.Kind.Equals(IoFatSourceKinds.Scl, StringComparison.OrdinalIgnoreCase))
+                    throw new InvalidDataException($"FAT v2 package source '{descriptor.FileName}' is not an SCL source.");
+                var bytes = await ReadAsync(RequiredEntry(archive, source.Entry), 100 * 1024 * 1024, cancellationToken).ConfigureAwait(false);
+                Verify(bytes, descriptor.Sha256, $"SCL source '{descriptor.FileName}'");
+                if (descriptor.Length > 0 && descriptor.Length != bytes.LongLength)
+                    throw new InvalidDataException($"SCL source '{descriptor.FileName}' length does not match the manifest.");
+
+                // SourceId includes the engineering filename. Keep that basename exactly while
+                // using a per-source directory to avoid collisions between equal filenames.
+                var sourceDirectory = Path.Combine(extractionRoot, descriptor.SourceId);
+                Directory.CreateDirectory(sourceDirectory);
+                var path = Path.Combine(sourceDirectory, descriptor.FileName);
+                await File.WriteAllBytesAsync(path, bytes, cancellationToken).ConfigureAwait(false);
+                sourcePaths.Add(path);
+            }
+
+            var workspaceDirectory = Path.Combine(
+                Path.GetFullPath(localProjectsRoot),
+                "fat-v2",
+                manifest.SourceSetSha256[..24]);
+            Directory.CreateDirectory(workspaceDirectory);
+            var snapshotPath = Path.Combine(workspaceDirectory, FatVerificationPersistenceService.SnapshotFileName);
+            var temporarySnapshot = snapshotPath + ".tmp-" + Guid.NewGuid().ToString("N");
+            await File.WriteAllBytesAsync(temporarySnapshot, snapshotBytes, cancellationToken).ConfigureAwait(false);
+            File.Move(temporarySnapshot, snapshotPath, true);
+
+            var launch = await new FatSclWorkspaceBootstrapService().OpenAsync(
+                sourcePaths,
+                localProjectsRoot,
+                cancellationToken).ConfigureAwait(false);
+            if (!launch.SourceSetSha256.Equals(manifest.SourceSetSha256, StringComparison.OrdinalIgnoreCase))
+                throw new InvalidDataException("Reopened FAT v2 project source identity changed after authoritative SCL import.");
+            if (!launch.EngineeringFingerprint.Equals(manifest.EngineeringFingerprint, StringComparison.OrdinalIgnoreCase))
+                throw new InvalidDataException("Reopened FAT v2 project engineering fingerprint does not match the packaged projection.");
+            return launch;
+        }
+        finally
+        {
+            if (Directory.Exists(extractionRoot))
+                Directory.Delete(extractionRoot, recursive: true);
+        }
+    }
+
+    private static ZipArchiveEntry RequiredEntry(ZipArchive archive, string name)
+    {
+        if (string.IsNullOrWhiteSpace(name) || name.Contains("..", StringComparison.Ordinal) || Path.IsPathRooted(name))
+            throw new InvalidDataException("FAT v2 package contains an unsafe entry path.");
+        return archive.GetEntry(name.Replace('\\', '/'))
+            ?? throw new InvalidDataException($"FAT v2 package entry '{name}' is missing.");
+    }
+
+    private static async Task<byte[]> ReadAsync(ZipArchiveEntry entry, long maximumBytes, CancellationToken cancellationToken)
+    {
+        if (entry.Length > maximumBytes)
+            throw new InvalidDataException($"FAT v2 package entry '{entry.FullName}' exceeds its safety limit.");
+        await using var source = entry.Open();
+        using var memory = new MemoryStream((int)Math.Min(entry.Length, int.MaxValue));
+        await source.CopyToAsync(memory, cancellationToken).ConfigureAwait(false);
+        if (memory.Length > maximumBytes)
+            throw new InvalidDataException($"FAT v2 package entry '{entry.FullName}' exceeds its safety limit.");
+        return memory.ToArray();
+    }
+
+    private static async Task WriteAsync(ZipArchive archive, string name, byte[] bytes, CancellationToken cancellationToken)
+    {
+        var entry = archive.CreateEntry(name.Replace('\\', '/'), CompressionLevel.Optimal);
+        await using var stream = entry.Open();
+        await stream.WriteAsync(bytes, cancellationToken).ConfigureAwait(false);
+    }
+
+    private static string Hash(byte[] bytes)
+        => Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
+
+    private static void Verify(byte[] bytes, string expected, string label)
+    {
+        if (!Hash(bytes).Equals(expected, StringComparison.OrdinalIgnoreCase))
+            throw new InvalidDataException($"{label} SHA-256 does not match the FAT v2 project manifest.");
+    }
+}
diff --git a/Services/IoTesting/FatVerificationPersistenceService.cs b/Services/IoTesting/FatVerificationPersistenceService.cs
new file mode 100644
index 000000000..a26ee3f55
--- /dev/null
+++ b/Services/IoTesting/FatVerificationPersistenceService.cs
@@ -0,0 +1,136 @@
+using System.Text.Json;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+public sealed record FatVerificationSnapshot(
+    string SchemaVersion,
+    string ProjectId,
+    string SourceSetSha256,
+    DateTimeOffset SavedAtUtc,
+    List<FatVerificationSignalSnapshot> Signals);
+
+public sealed record FatVerificationSignalSnapshot(
+    string SignalId,
+    FatSignalDisposition Disposition,
+    FatValueEvidence? Value1Evidence,
+    FatValueEvidence? Value2Evidence);
+
+public static class FatVerificationPersistenceService
+{
+    public const string SnapshotSchemaVersion = "fat-v2.1";
+    public const string SnapshotFileName = "fat-v2.snapshot.json";
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = true
+    };
+
+    public static string SnapshotPath(FatSclWorkspaceLaunchResult launch)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        return Path.Combine(launch.WorkspaceDirectory, SnapshotFileName);
+    }
+
+    public static void SaveNow(FatSclWorkspaceLaunchResult launch)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        var path = SnapshotPath(launch);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        var snapshot = CreateSnapshot(launch);
+        var bytes = JsonSerializer.SerializeToUtf8Bytes(snapshot, JsonOptions);
+        var temporary = path + ".tmp-" + Guid.NewGuid().ToString("N");
+        try
+        {
+            using (var stream = new FileStream(
+                       temporary,
+                       FileMode.CreateNew,
+                       FileAccess.Write,
+                       FileShare.None,
+                       4096,
+                       FileOptions.WriteThrough))
+            {
+                stream.Write(bytes);
+                stream.Flush(flushToDisk: true);
+            }
+            File.Move(temporary, path, true);
+        }
+        finally
+        {
+            if (File.Exists(temporary))
+                File.Delete(temporary);
+        }
+    }
+
+    public static bool RestoreIfPresent(FatSclWorkspaceLaunchResult launch)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        var path = SnapshotPath(launch);
+        if (!File.Exists(path))
+            return false;
+        var bytes = File.ReadAllBytes(path);
+        var snapshot = JsonSerializer.Deserialize<FatVerificationSnapshot>(bytes, JsonOptions)
+            ?? throw new InvalidDataException("FAT v2 snapshot is invalid.");
+        ApplySnapshot(launch, snapshot);
+        return true;
+    }
+
+    public static FatVerificationSnapshot CreateSnapshot(FatSclWorkspaceLaunchResult launch)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        return new FatVerificationSnapshot(
+            SnapshotSchemaVersion,
+            launch.Project.ProjectId,
+            launch.SourceSetSha256,
+            DateTimeOffset.UtcNow,
+            launch.Project.Signals
+                .OrderBy(signal => signal.SignalId, StringComparer.Ordinal)
+                .Select(signal => new FatVerificationSignalSnapshot(
+                    signal.SignalId,
+                    signal.Disposition,
+                    signal.Value1Evidence,
+                    signal.Value2Evidence))
+                .ToList());
+    }
+
+    public static void ApplySnapshot(
+        FatSclWorkspaceLaunchResult launch,
+        FatVerificationSnapshot snapshot)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        ArgumentNullException.ThrowIfNull(snapshot);
+        if (!snapshot.SchemaVersion.Equals(SnapshotSchemaVersion, StringComparison.Ordinal))
+            throw new InvalidDataException($"Unsupported FAT v2 snapshot schema '{snapshot.SchemaVersion}'.");
+        if (!snapshot.SourceSetSha256.Equals(launch.SourceSetSha256, StringComparison.OrdinalIgnoreCase))
+            throw new InvalidDataException("FAT v2 snapshot source-set identity does not match the opened SCL engineering source set.");
+
+        var current = launch.Project.Signals.ToDictionary(signal => signal.SignalId, StringComparer.OrdinalIgnoreCase);
+        if (snapshot.Signals.Count != current.Count)
+            throw new InvalidDataException("FAT v2 snapshot signal count does not match the authoritative current DataSet projection.");
+
+        foreach (var saved in snapshot.Signals)
+        {
+            if (!current.TryGetValue(saved.SignalId, out var signal))
+                throw new InvalidDataException($"FAT v2 snapshot references unknown static membership '{saved.SignalId}'.");
+
+            if (saved.Disposition == FatSignalDisposition.ExcludedByOperator)
+                signal.RemoveFromFat();
+            else
+                signal.RestoreToFat();
+
+            if (saved.Value1Evidence != null)
+            {
+                if (saved.Value1Evidence.Slot != FatValueSlot.Value1)
+                    throw new InvalidDataException($"FAT v2 Value 1 evidence slot is invalid for '{saved.SignalId}'.");
+                signal.SetCurrentEvidence(saved.Value1Evidence);
+            }
+            if (saved.Value2Evidence != null)
+            {
+                if (saved.Value2Evidence.Slot != FatValueSlot.Value2)
+                    throw new InvalidDataException($"FAT v2 Value 2 evidence slot is invalid for '{saved.SignalId}'.");
+                signal.SetCurrentEvidence(saved.Value2Evidence);
+            }
+        }
+    }
+}
diff --git a/Services/IoTesting/FatVerificationReportService.cs b/Services/IoTesting/FatVerificationReportService.cs
new file mode 100644
index 000000000..b3e00a3ab
--- /dev/null
+++ b/Services/IoTesting/FatVerificationReportService.cs
@@ -0,0 +1,203 @@
+using System.IO.Compression;
+using System.Text;
+using System.Xml.Linq;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+public static class FatVerificationReportService
+{
+    public static byte[] GeneratePdf(FatSclWorkspaceLaunchResult launch, DateTimeOffset? generatedAt = null)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        var at = generatedAt ?? DateTimeOffset.Now;
+        var lines = new List<string>
+        {
+            "ARSAS FAT v2 - Static DataSet Verification",
+            $"Generated: {at:yyyy-MM-dd HH:mm:ss zzz}",
+            $"Source set: {launch.SourceSetSha256}",
+            $"Signals: {launch.Project.Signals.Count} | Included: {launch.Project.IncludedSignals.Count} | Removed: {launch.Project.RemovedSignals.Count}",
+            string.Empty,
+            "IED | DataSet | # | Signal | Kind | Disposition | Value 1 | Value 2"
+        };
+        foreach (var signal in launch.Project.Signals
+                     .OrderBy(signal => signal.IedName, StringComparer.OrdinalIgnoreCase)
+                     .ThenBy(signal => signal.DataSetReference, StringComparer.OrdinalIgnoreCase)
+                     .ThenBy(signal => signal.DataSetMemberIndex))
+        {
+            lines.Add(string.Join(" | ", new[]
+            {
+                signal.IedName,
+                signal.DataSetReference,
+                signal.DataSetMemberIndex.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                signal.StaticMemberReference,
+                signal.SignalKind.ToString(),
+                signal.Disposition.ToString(),
+                signal.Value1Evidence?.RawValue ?? string.Empty,
+                signal.Value2Evidence?.RawValue ?? string.Empty
+            }));
+        }
+        return BuildSimplePdf(lines);
+    }
+
+    public static byte[] GenerateXlsx(FatSclWorkspaceLaunchResult launch)
+    {
+        ArgumentNullException.ThrowIfNull(launch);
+        using var memory = new MemoryStream();
+        using (var archive = new ZipArchive(memory, ZipArchiveMode.Create, leaveOpen: true))
+        {
+            WriteText(archive, "[Content_Types].xml", "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\"><Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/><Default Extension=\"xml\" ContentType=\"application/xml\"/><Override PartName=\"/xl/workbook.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\"/><Override PartName=\"/xl/worksheets/sheet1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\"/></Types>");
+            WriteText(archive, "_rels/.rels", "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"><Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"xl/workbook.xml\"/></Relationships>");
+            WriteText(archive, "xl/workbook.xml", "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"><sheets><sheet name=\"FAT v2 Results\" sheetId=\"1\" r:id=\"rId1\"/></sheets></workbook>");
+            WriteText(archive, "xl/_rels/workbook.xml.rels", "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"><Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet1.xml\"/></Relationships>");
+            WriteText(archive, "xl/worksheets/sheet1.xml", BuildWorksheetXml(launch));
+        }
+        return memory.ToArray();
+    }
+
+    private static string BuildWorksheetXml(FatSclWorkspaceLaunchResult launch)
+    {
+        XNamespace ns = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+        var headers = new[]
+        {
+            "IED", "AccessPoint", "DataSet", "MemberIndex", "StaticReference", "RuntimeReference", "FC", "DataType", "Kind", "Disposition",
+            "Value1", "Value1IEDTimestamp", "Value1ARSASTimestamp", "Value1Quality", "Value1Source",
+            "Value2", "Value2IEDTimestamp", "Value2ARSASTimestamp", "Value2Quality", "Value2Source", "Complete"
+        };
+        var sheetData = new XElement(ns + "sheetData");
+        var rowNumber = 1;
+        sheetData.Add(Row(ns, rowNumber++, headers));
+        foreach (var signal in launch.Project.Signals
+                     .OrderBy(signal => signal.IedName, StringComparer.OrdinalIgnoreCase)
+                     .ThenBy(signal => signal.DataSetReference, StringComparer.OrdinalIgnoreCase)
+                     .ThenBy(signal => signal.DataSetMemberIndex))
+        {
+            var v1 = signal.Value1Evidence;
+            var v2 = signal.Value2Evidence;
+            sheetData.Add(Row(ns, rowNumber++, new[]
+            {
+                signal.IedName,
+                signal.AccessPointName,
+                signal.DataSetReference,
+                signal.DataSetMemberIndex.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                signal.StaticMemberReference,
+                signal.RuntimeReference,
+                signal.FunctionalConstraint,
+                signal.DataType,
+                signal.SignalKind.ToString(),
+                signal.Disposition.ToString(),
+                v1?.RawValue ?? string.Empty,
+                Timestamp(v1?.IedTimestamp),
+                Timestamp(v1?.CapturedAt),
+                v1?.Quality ?? string.Empty,
+                v1?.AcquisitionSource ?? string.Empty,
+                v2?.RawValue ?? string.Empty,
+                Timestamp(v2?.IedTimestamp),
+                Timestamp(v2?.CapturedAt),
+                v2?.Quality ?? string.Empty,
+                v2?.AcquisitionSource ?? string.Empty,
+                signal.HasCompleteEvidence ? "YES" : "NO"
+            }));
+        }
+        return new XDocument(
+            new XDeclaration("1.0", "UTF-8", "yes"),
+            new XElement(ns + "worksheet", sheetData)).ToString(SaveOptions.DisableFormatting);
+    }
+
+    private static XElement Row(XNamespace ns, int rowNumber, IReadOnlyList<string> values)
+    {
+        var row = new XElement(ns + "row", new XAttribute("r", rowNumber));
+        for (var index = 0; index < values.Count; index++)
+        {
+            var text = new XElement(ns + "t", values[index] ?? string.Empty);
+            if (!string.IsNullOrEmpty(values[index]) && (char.IsWhiteSpace(values[index][0]) || char.IsWhiteSpace(values[index][^1])))
+                text.SetAttributeValue(XNamespace.Xml + "space", "preserve");
+            row.Add(new XElement(ns + "c",
+                new XAttribute("r", ColumnName(index) + rowNumber),
+                new XAttribute("t", "inlineStr"),
+                new XElement(ns + "is", text)));
+        }
+        return row;
+    }
+
+    private static string ColumnName(int zeroBased)
+    {
+        var value = zeroBased + 1;
+        var result = string.Empty;
+        while (value > 0)
+        {
+            value--;
+            result = (char)('A' + value % 26) + result;
+            value /= 26;
+        }
+        return result;
+    }
+
+    private static string Timestamp(DateTimeOffset? value)
+        => value?.ToString("yyyy-MM-dd HH:mm:ss.fff zzz", System.Globalization.CultureInfo.InvariantCulture) ?? string.Empty;
+
+    private static void WriteText(ZipArchive archive, string path, string text)
+    {
+        var entry = archive.CreateEntry(path, CompressionLevel.Optimal);
+        using var writer = new StreamWriter(entry.Open(), new UTF8Encoding(false));
+        writer.Write(text);
+    }
+
+    private static byte[] BuildSimplePdf(IReadOnlyList<string> lines)
+    {
+        const int linesPerPage = 48;
+        var pages = lines.Chunk(linesPerPage).ToArray();
+        var objects = new List<byte[]>();
+        objects.Add(Encoding.ASCII.GetBytes("<< /Type /Catalog /Pages 2 0 R >>"));
+        var pageObjectIds = Enumerable.Range(0, pages.Length).Select(i => 4 + i * 2).ToArray();
+        objects.Add(Encoding.ASCII.GetBytes($"<< /Type /Pages /Kids [{string.Join(' ', pageObjectIds.Select(id => $"{id} 0 R"))}] /Count {pages.Length} >>"));
+        objects.Add(Encoding.ASCII.GetBytes("<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"));
+
+        foreach (var page in pages)
+        {
+            var pageId = objects.Count + 1;
+            var contentId = pageId + 1;
+            objects.Add(Encoding.ASCII.GetBytes($"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 842 595] /Resources << /Font << /F1 3 0 R >> >> /Contents {contentId} 0 R >>"));
+            var content = new StringBuilder("BT /F1 7 Tf 28 565 Td 0 -11 Td ");
+            foreach (var line in page)
+            {
+                content.Append('(').Append(EscapePdf(line.Length > 150 ? line[..150] : line)).Append(") Tj T* ");
+            }
+            content.Append("ET");
+            var stream = Encoding.ASCII.GetBytes(content.ToString());
+            var header = Encoding.ASCII.GetBytes($"<< /Length {stream.Length} >>\nstream\n");
+            var footer = Encoding.ASCII.GetBytes("\nendstream");
+            objects.Add(header.Concat(stream).Concat(footer).ToArray());
+        }
+
+        using var output = new MemoryStream();
+        void Write(string value)
+        {
+            var bytes = Encoding.ASCII.GetBytes(value);
+            output.Write(bytes);
+        }
+        Write("%PDF-1.4\n");
+        var offsets = new List<long> { 0 };
+        for (var i = 0; i < objects.Count; i++)
+        {
+            offsets.Add(output.Position);
+            Write($"{i + 1} 0 obj\n");
+            output.Write(objects[i]);
+            Write("\nendobj\n");
+        }
+        var xref = output.Position;
+        Write($"xref\n0 {objects.Count + 1}\n0000000000 65535 f \n");
+        for (var i = 1; i < offsets.Count; i++)
+            Write($"{offsets[i]:0000000000} 00000 n \n");
+        Write($"trailer\n<< /Size {objects.Count + 1} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n");
+        return output.ToArray();
+    }
+
+    private static string EscapePdf(string value)
+        => value.Replace("\\", "\\\\", StringComparison.Ordinal)
+            .Replace("(", "\\(", StringComparison.Ordinal)
+            .Replace(")", "\\)", StringComparison.Ordinal)
+            .Select(ch => ch is >= ' ' and <= '~' ? ch : '?')
+            .Aggregate(new StringBuilder(), (builder, ch) => builder.Append(ch))
+            .ToString();
+}
diff --git a/tests/ARSAS.Tests/FatVerificationPersistencePackageTests.cs b/tests/ARSAS.Tests/FatVerificationPersistencePackageTests.cs
new file mode 100644
index 000000000..a34a113d1
--- /dev/null
+++ b/tests/ARSAS.Tests/FatVerificationPersistencePackageTests.cs
@@ -0,0 +1,204 @@
+using System.IO.Compression;
+using System.Text;
+using System.Xml.Linq;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ARSAS.Tests;
+
+public sealed class FatVerificationPersistencePackageTests
+{
+    [Fact]
+    public async Task SameSclReopen_RestoresOperatorDispositionAndCurrentEvidence()
+    {
+        using var temp = new TempDirectory();
+        var scl = Path.Combine(temp.Path, "relay.cid");
+        BuildFixture().Save(scl);
+        var projects = Path.Combine(temp.Path, "projects");
+        var first = await new FatSclWorkspaceBootstrapService().OpenAsync(new[] { scl }, projects);
+        var signal = Assert.Single(first.Project.Signals);
+        signal.RemoveFromFat();
+        signal.SetCurrentEvidence(Evidence(FatValueSlot.Value1, "12.3"));
+        signal.SetCurrentEvidence(Evidence(FatValueSlot.Value2, "13.7"));
+        FatVerificationPersistenceService.SaveNow(first);
+
+        var reopened = await new FatSclWorkspaceBootstrapService().OpenAsync(new[] { scl }, projects);
+        var restored = Assert.Single(reopened.Project.Signals);
+        Assert.Equal(FatSignalDisposition.ExcludedByOperator, restored.Disposition);
+        Assert.Equal("12.3", restored.Value1Evidence?.RawValue);
+        Assert.Equal("13.7", restored.Value2Evidence?.RawValue);
+    }
+
+    [Fact]
+    public async Task PortableArsasRoundTrip_RebuildsFromSclThenRestoresFatState()
+    {
+        using var temp = new TempDirectory();
+        var scl = Path.Combine(temp.Path, "relay.cid");
+        BuildFixture().Save(scl);
+        var sourceProjects = Path.Combine(temp.Path, "source-projects");
+        var launch = await new FatSclWorkspaceBootstrapService().OpenAsync(new[] { scl }, sourceProjects);
+        var signal = Assert.Single(launch.Project.Signals);
+        signal.RemoveFromFat();
+        signal.SetCurrentEvidence(Evidence(FatValueSlot.Value1, "100.0"));
+        signal.SetCurrentEvidence(Evidence(FatValueSlot.Value2, "110.0"));
+        var package = await FatVerificationPackageService.ExportAsync(launch, Path.Combine(temp.Path, "fat-project"));
+
+        using (var archive = ZipFile.OpenRead(package))
+        {
+            Assert.NotNull(archive.GetEntry("manifest.json"));
+            Assert.NotNull(archive.GetEntry(FatVerificationPersistenceService.SnapshotFileName));
+            Assert.NotNull(archive.GetEntry("report/FAT-v2-Report.pdf"));
+            Assert.NotNull(archive.GetEntry("report/FAT-v2-Results.xlsx"));
+            Assert.DoesNotContain(archive.Entries, entry => entry.FullName.Contains("workbook", StringComparison.OrdinalIgnoreCase));
+        }
+
+        var reopened = await FatVerificationPackageService.OpenAsync(
+            package,
+            Path.Combine(temp.Path, "imported-projects"));
+        var restored = Assert.Single(reopened.Project.Signals);
+        Assert.Equal(FatSignalDisposition.ExcludedByOperator, restored.Disposition);
+        Assert.Equal("100.0", restored.Value1Evidence?.RawValue);
+        Assert.Equal("110.0", restored.Value2Evidence?.RawValue);
+        Assert.Single(reopened.SourceFiles);
+        Assert.Equal(IoFatSourceKinds.Scl, reopened.SourceFiles[0].Source.Kind);
+    }
+
+    [Fact]
+    public async Task TamperedPackagedScl_IsRejectedBeforeEngineeringStateIsTrusted()
+    {
+        using var temp = new TempDirectory();
+        var scl = Path.Combine(temp.Path, "relay.cid");
+        BuildFixture().Save(scl);
+        var launch = await new FatSclWorkspaceBootstrapService().OpenAsync(
+            new[] { scl }, Path.Combine(temp.Path, "projects"));
+        var package = await FatVerificationPackageService.ExportAsync(launch, Path.Combine(temp.Path, "fat-project"));
+
+        using (var archive = ZipFile.Open(package, ZipArchiveMode.Update))
+        {
+            var sourceEntry = archive.Entries.Single(entry => entry.FullName.StartsWith("source/", StringComparison.OrdinalIgnoreCase));
+            var name = sourceEntry.FullName;
+            sourceEntry.Delete();
+            var replacement = archive.CreateEntry(name);
+            await using var stream = replacement.Open();
+            await stream.WriteAsync(Encoding.UTF8.GetBytes("tampered"));
+        }
+
+        var error = await Assert.ThrowsAsync<InvalidDataException>(() =>
+            FatVerificationPackageService.OpenAsync(package, Path.Combine(temp.Path, "import")));
+        Assert.Contains("SHA-256", error.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task ReportsUseGenericValueTerminologyAndPreserveRemovedRows()
+    {
+        using var temp = new TempDirectory();
+        var scl = Path.Combine(temp.Path, "relay.cid");
+        BuildFixture().Save(scl);
+        var launch = await new FatSclWorkspaceBootstrapService().OpenAsync(
+            new[] { scl }, Path.Combine(temp.Path, "projects"));
+        var signal = Assert.Single(launch.Project.Signals);
+        signal.RemoveFromFat();
+        signal.SetCurrentEvidence(Evidence(FatValueSlot.Value1, "1.25"));
+        signal.SetCurrentEvidence(Evidence(FatValueSlot.Value2, "2.50"));
+
+        var pdf = FatVerificationReportService.GeneratePdf(launch, DateTimeOffset.Parse("2026-09-02T00:00:00Z"));
+        Assert.StartsWith("%PDF-1.4", Encoding.ASCII.GetString(pdf, 0, 8), StringComparison.Ordinal);
+        var pdfText = Encoding.ASCII.GetString(pdf);
+        Assert.Contains("Value 1", pdfText, StringComparison.Ordinal);
+        Assert.Contains("Value 2", pdfText, StringComparison.Ordinal);
+        Assert.DoesNotContain("ONObservedValue", pdfText, StringComparison.Ordinal);
+
+        var xlsx = FatVerificationReportService.GenerateXlsx(launch);
+        using var memory = new MemoryStream(xlsx);
+        using var archive = new ZipArchive(memory, ZipArchiveMode.Read);
+        using var reader = new StreamReader(archive.GetEntry("xl/worksheets/sheet1.xml")!.Open());
+        var sheet = await reader.ReadToEndAsync();
+        Assert.Contains("Value1", sheet, StringComparison.Ordinal);
+        Assert.Contains("Value2", sheet, StringComparison.Ordinal);
+        Assert.Contains("ExcludedByOperator", sheet, StringComparison.Ordinal);
+        Assert.Contains("1.25", sheet, StringComparison.Ordinal);
+        Assert.Contains("2.50", sheet, StringComparison.Ordinal);
+    }
+
+    private static FatValueEvidence Evidence(FatValueSlot slot, string raw)
+        => new(
+            Guid.NewGuid(), slot, FatEvidenceCaptureKind.OperatorSnapshot, raw,
+            DateTimeOffset.Parse("2026-09-02T00:00:00Z"), null, "Good", "test", 1, 1);
+
+    private static XDocument BuildFixture()
+    {
+        XNamespace ns = "http://www.iec.ch/61850/2003/SCL";
+        return new XDocument(
+            new XElement(ns + "SCL",
+                new XAttribute("version", "2007"),
+                new XAttribute("revision", "B"),
+                new XElement(ns + "Header", new XAttribute("id", "FAT_P5")),
+                new XElement(ns + "IED",
+                    new XAttribute("name", "IED_P5"),
+                    new XElement(ns + "AccessPoint",
+                        new XAttribute("name", "S1"),
+                        new XElement(ns + "Server",
+                            new XElement(ns + "LDevice",
+                                new XAttribute("inst", "Application"),
+                                new XElement(ns + "LN0",
+                                    new XAttribute("lnClass", "LLN0"),
+                                    new XAttribute("lnType", "LLN0Type"),
+                                    new XElement(ns + "DataSet",
+                                        new XAttribute("name", "FAT"),
+                                        new XElement(ns + "FCDA",
+                                            new XAttribute("ldInst", "MEAS"),
+                                            new XAttribute("lnClass", "MMXU"),
+                                            new XAttribute("lnInst", "1"),
+                                            new XAttribute("doName", "Ana01"),
+                                            new XAttribute("fc", "MX"))))),
+                            new XElement(ns + "LDevice",
+                                new XAttribute("inst", "MEAS"),
+                                new XElement(ns + "LN0",
+                                    new XAttribute("lnClass", "LLN0"),
+                                    new XAttribute("lnType", "LLN0Type")),
+                                new XElement(ns + "LN",
+                                    new XAttribute("lnClass", "MMXU"),
+                                    new XAttribute("inst", "1"),
+                                    new XAttribute("lnType", "MMXUType")))))),
+                new XElement(ns + "DataTypeTemplates",
+                    new XElement(ns + "LNodeType",
+                        new XAttribute("id", "LLN0Type"),
+                        new XAttribute("lnClass", "LLN0")),
+                    new XElement(ns + "LNodeType",
+                        new XAttribute("id", "MMXUType"),
+                        new XAttribute("lnClass", "MMXU"),
+                        new XElement(ns + "DO",
+                            new XAttribute("name", "Ana01"),
+                            new XAttribute("type", "MvType"))),
+                    new XElement(ns + "DOType",
+                        new XAttribute("id", "MvType"),
+                        new XAttribute("cdc", "MV"),
+                        new XElement(ns + "DA",
+                            new XAttribute("name", "mag"),
+                            new XAttribute("bType", "Struct"),
+                            new XAttribute("type", "AnalogueValue"),
+                            new XAttribute("fc", "MX"))),
+                    new XElement(ns + "DAType",
+                        new XAttribute("id", "AnalogueValue"),
+                        new XElement(ns + "BDA",
+                            new XAttribute("name", "f"),
+                            new XAttribute("bType", "FLOAT32"))))));
+    }
+
+    private sealed class TempDirectory : IDisposable
+    {
+        public TempDirectory()
+        {
+            Path = System.IO.Path.Combine(
+                System.IO.Path.GetTempPath(),
+                "arsas-fat-v2-p5-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(Path);
+        }
+        public string Path { get; }
+        public void Dispose()
+        {
+            try { if (Directory.Exists(Path)) Directory.Delete(Path, true); }
+            catch { }
+        }
+    }
+}