diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3f9d16d..2d3e973 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -38,6 +38,15 @@ phase plan these entries follow.
   and why — with three commands for checking a finished recording, because the failure this
   catches produces a file that plays perfectly and measures wrong.
 
+- **The Metadata page now shows what a file's own bitrate and codec actually are, not just its
+  tags.** Repairing a library's metadata never said anything about the audio underneath it — a
+  file downloaded at 96 kbps and a lossless rip looked identical on the one page built to review a
+  folder of them. Each row now carries a line under its name — `MP3 · 320 kbps`, `FLAC ·
+  Lossless` — read straight from the file's own container properties, so it costs one more file
+  open per row and nothing else: no ffprobe, no decoding, no spectral analysis, no guessing beyond
+  what the header already claims. Only the one tier worth a second look, a lossy file under 128
+  kbps, gets the caution colour; everything else is background information.
+
 ### Fixed
 
 - **One notch of the wheel jumped three tracks in the session list.** The list of what has been
diff --git a/src/Offstream.App/Resources/Strings.fr.resx b/src/Offstream.App/Resources/Strings.fr.resx
index e347c72..3be534d 100644
--- a/src/Offstream.App/Resources/Strings.fr.resx
+++ b/src/Offstream.App/Resources/Strings.fr.resx
@@ -562,6 +562,12 @@
   <data name="MetadataWillChange" xml:space="preserve">
     <value>Sera modifié</value>
   </data>
+  <data name="MetadataQualityLossless" xml:space="preserve">
+    <value>{0} · Sans perte</value>
+  </data>
+  <data name="MetadataQualityBitrate" xml:space="preserve">
+    <value>{0} · {1} kbit/s</value>
+  </data>
   <data name="MetadataFieldTitle" xml:space="preserve">
     <value>Titre</value>
   </data>
diff --git a/src/Offstream.App/Resources/Strings.resx b/src/Offstream.App/Resources/Strings.resx
index 6d17934..48395f5 100644
--- a/src/Offstream.App/Resources/Strings.resx
+++ b/src/Offstream.App/Resources/Strings.resx
@@ -718,6 +718,14 @@
     <value>Will change</value>
     <comment>Marks a row whose save would alter the file, so those rows can be found without opening each one.</comment>
   </data>
+  <data name="MetadataQualityLossless" xml:space="preserve">
+    <value>{0} · Lossless</value>
+    <comment>{0} is the codec name, e.g. "FLAC". Shown under a row for a lossless file.</comment>
+  </data>
+  <data name="MetadataQualityBitrate" xml:space="preserve">
+    <value>{0} · {1} kbps</value>
+    <comment>{0} is the codec name, e.g. "MP3"; {1} is the bitrate the file reports.</comment>
+  </data>
   <data name="MetadataFieldTitle" xml:space="preserve">
     <value>Title</value>
   </data>
diff --git a/src/Offstream.App/Services/AppServices.cs b/src/Offstream.App/Services/AppServices.cs
index ab7c66b..643613f 100644
--- a/src/Offstream.App/Services/AppServices.cs
+++ b/src/Offstream.App/Services/AppServices.cs
@@ -84,6 +84,7 @@ public static IServiceCollection AddOffstream(
         // independent of the recording pipeline's: a scanner over the file system, a TagLib#
         // store, and a provider chain rebuilt per run so signing in takes effect immediately.
         services.AddSingleton<ILibraryTagStore, TagLibTagStore>();
+        services.AddSingleton<IAudioQualityReader, TagLibAudioQualityReader>();
         services.AddSingleton<ILibraryScanner, LibraryScanner>();
         services.AddSingleton<ILibraryTagWriter, LibraryTagWriter>();
         services.AddSingleton<ILibraryMetadataChain, LibraryMetadataChain>();
diff --git a/src/Offstream.App/ViewModels/LibraryTrackViewModel.cs b/src/Offstream.App/ViewModels/LibraryTrackViewModel.cs
index dc69c98..4aa3892 100644
--- a/src/Offstream.App/ViewModels/LibraryTrackViewModel.cs
+++ b/src/Offstream.App/ViewModels/LibraryTrackViewModel.cs
@@ -2,6 +2,7 @@
 using System.ComponentModel.DataAnnotations;
 using System.Globalization;
 using System.IO;
+using System.Text;
 using System.Windows.Media.Imaging;
 using CommunityToolkit.Mvvm.ComponentModel;
 using Offstream.App.Resources;
@@ -27,6 +28,12 @@ namespace Offstream.App.ViewModels;
 /// </remarks>
 public sealed partial class LibraryTrackViewModel : ObservableValidator
 {
+    private static readonly CompositeFormat QualityLosslessFormat =
+        CompositeFormat.Parse(Strings.MetadataQualityLossless);
+
+    private static readonly CompositeFormat QualityBitrateFormat =
+        CompositeFormat.Parse(Strings.MetadataQualityBitrate);
+
     private readonly LibraryTrack _track;
     private readonly string? _existingTitle;
     private readonly string? _existingArtist;
@@ -87,6 +94,9 @@ public LibraryTrackViewModel(LibraryTrack track)
 
         CoverArt = LoadCoverArt(track.Existing.AlbumArtImage);
         ExistingCoverArt = CoverArt;
+
+        QualityLabel = FormatQuality(track.Quality, FileName);
+        IsQualityLow = track.Quality.Tier == AudioQualityTier.Low;
     }
 
     /// <summary>The file's own name, which is what identifies the row.</summary>
@@ -133,6 +143,21 @@ public LibraryTrackViewModel(LibraryTrack track)
     /// <inheritdoc cref="CurrentTitle" />
     public string CurrentCopyright { get; }
 
+    /// <summary>
+    /// What the file's own audio properties say, e.g. "MP3 · 128 kbps" or "FLAC · Lossless", or
+    /// null when the file reported nothing usable.
+    /// </summary>
+    public string? QualityLabel { get; }
+
+    /// <summary>Whether <see cref="QualityLabel"/> has anything to show.</summary>
+    public bool HasQuality => QualityLabel is not null;
+
+    /// <summary>
+    /// Whether the file is lossy at under 128 kbps — audibly compressed on most material, and the
+    /// one tier worth calling out rather than just stating.
+    /// </summary>
+    public bool IsQualityLow { get; }
+
     /// <summary>The scanned track this row edits.</summary>
     internal LibraryTrack Track => _track;
 
@@ -538,6 +563,41 @@ public void SeedMatchQuery()
         MatchQuery = string.Join(' ', new[] { Artist, Title }.Where(part => !string.IsNullOrWhiteSpace(part)));
     }
 
+    /// <summary>
+    /// Turns a container-property read into the one line the row shows. Deliberately just a
+    /// codec name and a number — no spectral analysis, no transcode detection, just what the
+    /// file's own header already says.
+    /// </summary>
+    private static string? FormatQuality(AudioQuality quality, string fileName)
+    {
+        var codec = CodecName(System.IO.Path.GetExtension(fileName), quality.Tier);
+
+        if (quality.Tier == AudioQualityTier.Lossless)
+        {
+            return string.Format(CultureInfo.CurrentCulture, QualityLosslessFormat, codec);
+        }
+
+        return quality.BitrateKbps is > 0
+            ? string.Format(CultureInfo.CurrentCulture, QualityBitrateFormat, codec, quality.BitrateKbps)
+            : null;
+    }
+
+    /// <summary>A short codec name from the file's extension, which the scanner already filtered on.</summary>
+    /// <remarks>
+    /// <c>.m4a</c> is ambiguous by extension alone — Offstream only ever writes AAC into it, but a
+    /// file from elsewhere can be ALAC. <see cref="AudioQuality.Tier"/> already tells the two
+    /// apart, so a lossless <c>.m4a</c> is labelled ALAC rather than guessed wrong.
+    /// </remarks>
+    private static string CodecName(string extension, AudioQualityTier tier) => extension.ToUpperInvariant() switch
+    {
+        ".M4A" => tier == AudioQualityTier.Lossless ? "ALAC" : "AAC",
+        ".MP3" => "MP3",
+        ".FLAC" => "FLAC",
+        ".OPUS" => "Opus",
+        ".OGG" => "Vorbis",
+        _ => extension.TrimStart('.').ToUpperInvariant(),
+    };
+
     private static string Or(string? value, string fallback) =>
         string.IsNullOrWhiteSpace(value) ? fallback : value;
 
diff --git a/src/Offstream.App/Views/Pages/MetadataPage.xaml b/src/Offstream.App/Views/Pages/MetadataPage.xaml
index b8f8b43..df9409c 100644
--- a/src/Offstream.App/Views/Pages/MetadataPage.xaml
+++ b/src/Offstream.App/Views/Pages/MetadataPage.xaml
@@ -107,6 +107,28 @@
                                    TextTrimming="CharacterEllipsis"
                                    TextWrapping="NoWrap" />
 
+                        <!--
+                            What the file's own header says about its audio — a codec name and a
+                            bitrate, or "Lossless". Nothing decoded, nothing guessed: exactly what
+                            TagLib# read off the container, so it costs one more file open per row
+                            and no spectral analysis. Only a lossy file under 128 kbps gets the
+                            caution colour; everything else is background information, not a warning.
+                        -->
+                        <TextBlock Text="{Binding QualityLabel, Mode=OneTime}"
+                                   TextTrimming="CharacterEllipsis"
+                                   TextWrapping="NoWrap"
+                                   Visibility="{Binding HasQuality, Converter={StaticResource BooleanToVisibility}}">
+                            <TextBlock.Style>
+                                <Style BasedOn="{StaticResource OffstreamHintStyle}" TargetType="TextBlock">
+                                    <Style.Triggers>
+                                        <DataTrigger Binding="{Binding IsQualityLow}" Value="True">
+                                            <Setter Property="Foreground" Value="{DynamicResource SystemFillColorCautionBrush}" />
+                                        </DataTrigger>
+                                    </Style.Triggers>
+                                </Style>
+                            </TextBlock.Style>
+                        </TextBlock>
+
                         <!--
                             The reason a row failed, wrapped rather than trimmed. It is the one
                             piece of text on the page the user can act on — a locked file, an
diff --git a/src/Offstream.Core/Metadata/Library/AudioQuality.cs b/src/Offstream.Core/Metadata/Library/AudioQuality.cs
new file mode 100644
index 0000000..2619d6b
--- /dev/null
+++ b/src/Offstream.Core/Metadata/Library/AudioQuality.cs
@@ -0,0 +1,100 @@
+namespace Offstream.Core.Metadata.Library;
+
+/// <summary>A rough, at-a-glance read on how good a file's audio actually is.</summary>
+public enum AudioQualityTier
+{
+    /// <summary>The file could not be opened, or reported no audio properties at all.</summary>
+    Unknown,
+
+    /// <summary>Lossy, under 128 kbps — audibly compressed on most material.</summary>
+    Low,
+
+    /// <summary>Lossy, 128–255 kbps — the range most lossy libraries live in.</summary>
+    Medium,
+
+    /// <summary>Lossy, 256 kbps or higher — as good as a lossy codec gets.</summary>
+    High,
+
+    /// <summary>A lossless codec (FLAC, ALAC, WAV, …).</summary>
+    Lossless,
+}
+
+/// <summary>
+/// What a file's own container reports about its audio, read once at scan time.
+/// </summary>
+/// <remarks>
+/// Deliberately shallow: this is a container-property read, not a spectral analysis of the decoded
+/// samples. It answers "what does the file claim" — which is enough to flag an obviously low
+/// bitrate or confirm a lossless codec — and not "is that claim actually true", which would need
+/// decoding the audio and is a different, heavier feature.
+/// </remarks>
+public readonly record struct AudioQuality(int? BitrateKbps, int SampleRateHz, int BitsPerSample)
+{
+    /// <summary>No audio properties available, e.g. because the file could not be opened.</summary>
+    public static AudioQuality Unknown => default;
+
+    /// <summary>Whether the file reported anything at all.</summary>
+    public bool IsKnown => SampleRateHz > 0;
+
+    /// <summary>
+    /// Whether the container reports a bit depth. TagLib# only populates this for codecs that
+    /// have a fixed sample bit depth — FLAC, ALAC, WAV, and the like — and reports zero for MP3,
+    /// AAC, Opus and Vorbis, none of which have one. That makes it a reliable, free lossless flag
+    /// with no need to inspect the codec name.
+    /// </summary>
+    public bool IsLossless => BitsPerSample > 0;
+
+    /// <summary>The tier a quality badge would show.</summary>
+    public AudioQualityTier Tier =>
+        !IsKnown ? AudioQualityTier.Unknown
+        : IsLossless ? AudioQualityTier.Lossless
+        : BitrateKbps switch
+        {
+            >= 256 => AudioQualityTier.High,
+            >= 128 => AudioQualityTier.Medium,
+            _ => AudioQualityTier.Low,
+        };
+}
+
+/// <summary>Reads a file's own audio properties — bitrate, sample rate, bit depth.</summary>
+public interface IAudioQualityReader
+{
+    /// <summary>
+    /// Reads <paramref name="path"/>'s audio properties, or <see cref="AudioQuality.Unknown"/> if
+    /// the file could not be opened.
+    /// </summary>
+    AudioQuality Read(string path);
+}
+
+/// <summary>
+/// The TagLib# implementation. Opens the file a second time, separately from
+/// <see cref="ILibraryTagStore"/> — the two answer different questions from the same file, and
+/// keeping them apart is what lets each be tested without the other.
+/// </summary>
+public sealed class TagLibAudioQualityReader : IAudioQualityReader
+{
+    /// <inheritdoc />
+    public AudioQuality Read(string path)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(path);
+
+        try
+        {
+            using var file = TagLib.File.Create(path);
+            var properties = file.Properties;
+
+            return new AudioQuality(
+                properties.AudioBitrate > 0 ? properties.AudioBitrate : null,
+                properties.AudioSampleRate,
+                properties.BitsPerSample);
+        }
+        catch (Exception ex) when (
+            ex is TagLib.CorruptFileException
+                or TagLib.UnsupportedFormatException
+                or IOException
+                or UnauthorizedAccessException)
+        {
+            return AudioQuality.Unknown;
+        }
+    }
+}
diff --git a/src/Offstream.Core/Metadata/Library/LibraryScanner.cs b/src/Offstream.Core/Metadata/Library/LibraryScanner.cs
index 9b3beb4..d6b20af 100644
--- a/src/Offstream.Core/Metadata/Library/LibraryScanner.cs
+++ b/src/Offstream.Core/Metadata/Library/LibraryScanner.cs
@@ -36,7 +36,10 @@ public interface ILibraryScanner
 /// way is what lets the interesting cases — a nested folder, a file with no tags, a file that
 /// cannot be opened — be tested without writing a valid MP3 for each one.
 /// </remarks>
-public sealed class LibraryScanner(IFileSystem fileSystem, ILibraryTagStore tagStore) : ILibraryScanner
+public sealed class LibraryScanner(
+    IFileSystem fileSystem,
+    ILibraryTagStore tagStore,
+    IAudioQualityReader qualityReader) : ILibraryScanner
 {
     /// <summary>
     /// Containers with a tag format worth offering to edit.
@@ -90,7 +93,7 @@ private LibraryScan Scan(string directory, CancellationToken cancellationToken)
 
             try
             {
-                tracks.Add(new LibraryTrack(path, ReadOrInferTags(path)));
+                tracks.Add(new LibraryTrack(path, ReadOrInferTags(path), qualityReader.Read(path)));
             }
             catch (LibraryTagException ex)
             {
diff --git a/src/Offstream.Core/Metadata/Library/LibraryTrack.cs b/src/Offstream.Core/Metadata/Library/LibraryTrack.cs
index 210af34..2f2bbee 100644
--- a/src/Offstream.Core/Metadata/Library/LibraryTrack.cs
+++ b/src/Offstream.Core/Metadata/Library/LibraryTrack.cs
@@ -19,7 +19,12 @@ public sealed class LibraryTrack
     /// <summary>Creates a scanned track from what the file already carries.</summary>
     /// <param name="path">Full path to the audio file.</param>
     /// <param name="existing">Tags read from the file, or parsed from its name when it has none.</param>
-    public LibraryTrack(string path, Track existing)
+    /// <param name="quality">
+    /// What the file's own container reports about its audio. Defaults to
+    /// <see cref="AudioQuality.Unknown"/> so every existing caller that has no quality to offer —
+    /// chiefly tests — keeps compiling unchanged.
+    /// </param>
+    public LibraryTrack(string path, Track existing, AudioQuality quality = default)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(path);
         ArgumentNullException.ThrowIfNull(existing);
@@ -27,6 +32,7 @@ public LibraryTrack(string path, Track existing)
         Path = path;
         FileName = System.IO.Path.GetFileName(path);
         Existing = existing;
+        Quality = quality;
 
         // A copy, not the same instance: the suggestion is enriched in place and the row needs
         // the original beside it to show what would change. Sharing one Track would make every
@@ -45,6 +51,9 @@ public LibraryTrack(string path, Track existing)
     /// <summary>What the file carries today. Never mutated.</summary>
     public Track Existing { get; }
 
+    /// <summary>What the file's own container reports about its audio.</summary>
+    public AudioQuality Quality { get; }
+
     /// <summary>What would be written, once a provider or the user has had a say.</summary>
     public Track Suggested { get; }
 
diff --git a/tests/Offstream.Core.Tests/Metadata/Library/AudioQualityTests.cs b/tests/Offstream.Core.Tests/Metadata/Library/AudioQualityTests.cs
new file mode 100644
index 0000000..918ea41
--- /dev/null
+++ b/tests/Offstream.Core.Tests/Metadata/Library/AudioQualityTests.cs
@@ -0,0 +1,33 @@
+using Offstream.Core.Metadata.Library;
+using Xunit;
+
+namespace Offstream.Core.Tests.Metadata.Library;
+
+/// <summary>The tier a badge would show, from nothing but the numbers a container reports.</summary>
+public sealed class AudioQualityTests
+{
+    /// <summary>No sample rate at all means the file said nothing worth showing.</summary>
+    [Fact]
+    public void Tier_OfTheUnknownValueIsUnknown() =>
+        Assert.Equal(AudioQualityTier.Unknown, AudioQuality.Unknown.Tier);
+
+    /// <summary>A bit depth is what marks a codec lossless, whatever its bitrate happens to be.</summary>
+    [Fact]
+    public void Tier_OfAnythingWithABitDepthIsLossless() =>
+        Assert.Equal(AudioQualityTier.Lossless, new AudioQuality(BitrateKbps: 1411, SampleRateHz: 44100, BitsPerSample: 16).Tier);
+
+    [Theory]
+    [InlineData(96, AudioQualityTier.Low)]
+    [InlineData(127, AudioQualityTier.Low)]
+    [InlineData(128, AudioQualityTier.Medium)]
+    [InlineData(255, AudioQualityTier.Medium)]
+    [InlineData(256, AudioQualityTier.High)]
+    [InlineData(320, AudioQualityTier.High)]
+    public void Tier_OfALossyBitrateFollowsTheThresholds(int bitrateKbps, AudioQualityTier expected) =>
+        Assert.Equal(expected, new AudioQuality(bitrateKbps, SampleRateHz: 44100, BitsPerSample: 0).Tier);
+
+    /// <summary>A known sample rate with no bitrate at all still resolves rather than throwing.</summary>
+    [Fact]
+    public void Tier_OfAKnownFileWithNoBitrateIsLow() =>
+        Assert.Equal(AudioQualityTier.Low, new AudioQuality(BitrateKbps: null, SampleRateHz: 44100, BitsPerSample: 0).Tier);
+}
diff --git a/tests/Offstream.Core.Tests/Metadata/Library/LibraryScannerTests.cs b/tests/Offstream.Core.Tests/Metadata/Library/LibraryScannerTests.cs
index 6ae52e5..b6447ae 100644
--- a/tests/Offstream.Core.Tests/Metadata/Library/LibraryScannerTests.cs
+++ b/tests/Offstream.Core.Tests/Metadata/Library/LibraryScannerTests.cs
@@ -108,7 +108,8 @@ public async Task Scan_ReportsAnUnreadableFileAndKeepsGoing()
                 [@"C:\Music\good.mp3"] = new(string.Empty),
                 [@"C:\Music\broken.mp3"] = new(string.Empty),
             }),
-            store);
+            store,
+            new StubQualityReader());
 
         var scan = await scanner.ScanAsync(Root);
 
@@ -199,7 +200,8 @@ public async Task Scan_PrefersEmbeddedTagsOverTheFileName()
             {
                 [@"C:\Music\Wrong - Name.mp3"] = new(string.Empty),
             }),
-            store);
+            store,
+            new StubQualityReader());
 
         var track = (await scanner.ScanAsync(Root)).Tracks.Single();
 
@@ -221,7 +223,8 @@ public async Task Scan_MarksAFullyTaggedFileAsMatched()
 
         var scanner = new LibraryScanner(
             new MockFileSystem(new Dictionary<string, MockFileData> { [@"C:\Music\a.mp3"] = new(string.Empty) }),
-            store);
+            store,
+            new StubQualityReader());
 
         var track = (await scanner.ScanAsync(Root)).Tracks.Single();
 
@@ -239,13 +242,33 @@ public async Task Scan_MarksAFileWithNoAlbumAsUntagged()
 
         var scanner = new LibraryScanner(
             new MockFileSystem(new Dictionary<string, MockFileData> { [@"C:\Music\a.mp3"] = new(string.Empty) }),
-            store);
+            store,
+            new StubQualityReader());
 
         Assert.Equal(LibraryTrackStatus.Untagged, (await scanner.ScanAsync(Root)).Tracks.Single().Status);
     }
 
+    /// <summary>
+    /// A file's own audio properties reach the row Save never touches them for. Covered here
+    /// rather than with a dedicated fixture because the interesting behaviour is entirely in the
+    /// wiring — the reader itself is <see cref="TagLibAudioQualityReaderTests"/>'s job.
+    /// </summary>
+    [Fact]
+    public async Task Scan_CarriesTheQualityReaderResultOntoTheRow()
+    {
+        var reader = new StubQualityReader { Result = new AudioQuality(320, 44100, 0) };
+        var scanner = new LibraryScanner(
+            new MockFileSystem(new Dictionary<string, MockFileData> { [@"C:\Music\a.mp3"] = new(string.Empty) }),
+            new StubTagStore(),
+            reader);
+
+        var track = (await scanner.ScanAsync(Root)).Tracks.Single();
+
+        Assert.Equal(320, track.Quality.BitrateKbps);
+    }
+
     private static LibraryScanner Build(Dictionary<string, MockFileData> files) =>
-        new(new MockFileSystem(files), new StubTagStore());
+        new(new MockFileSystem(files), new StubTagStore(), new StubQualityReader());
 
     /// <summary>An <see cref="ILibraryTagStore"/> that answers from a dictionary.</summary>
     private sealed class StubTagStore : ILibraryTagStore
@@ -268,4 +291,12 @@ public void Write(string path, Track track, byte[]? coverArt)
             Tags[path] = track;
         }
     }
+
+    /// <summary>An <see cref="IAudioQualityReader"/> that answers with a fixed result.</summary>
+    private sealed class StubQualityReader : IAudioQualityReader
+    {
+        public AudioQuality Result { get; init; } = AudioQuality.Unknown;
+
+        public AudioQuality Read(string path) => Result;
+    }
 }
diff --git a/tests/Offstream.Core.Tests/Metadata/Library/TagLibAudioQualityReaderTests.cs b/tests/Offstream.Core.Tests/Metadata/Library/TagLibAudioQualityReaderTests.cs
new file mode 100644
index 0000000..cee295f
--- /dev/null
+++ b/tests/Offstream.Core.Tests/Metadata/Library/TagLibAudioQualityReaderTests.cs
@@ -0,0 +1,90 @@
+using Offstream.Core.Encoding;
+using Offstream.Core.Metadata;
+using Offstream.Core.Metadata.Library;
+using Offstream.Core.Tests.Encoding;
+using Xunit;
+
+namespace Offstream.Core.Tests.Metadata.Library;
+
+/// <summary>
+/// Reading a file's own audio properties, against files ffmpeg actually encoded.
+/// </summary>
+/// <remarks>
+/// Tagged <c>Ffmpeg</c> for the same reason as <see cref="TagLibTagStoreTests"/>: the only honest
+/// way to test a container-property read is against a real encoded file, not a mock of one.
+/// </remarks>
+[Trait("Category", "Ffmpeg")]
+public sealed class TagLibAudioQualityReaderTests : IDisposable
+{
+    private readonly EncodeWorkspace _workspace = new();
+    private readonly TagLibAudioQualityReader _reader = new();
+
+    public void Dispose() => _workspace.Dispose();
+
+    /// <summary>A file requested well under 128 kbps reads back in the low tier.</summary>
+    [Fact]
+    public async Task Read_ReportsALowBitrateMp3AsLow()
+    {
+        var path = await EncodeAsync(MediaFormat.Mp3, 64);
+
+        var quality = _reader.Read(path);
+
+        Assert.True(quality.BitrateKbps is > 0);
+        Assert.Equal(AudioQualityTier.Low, quality.Tier);
+        Assert.False(quality.IsLossless);
+    }
+
+    /// <summary>A file requested well over 256 kbps reads back in the high tier.</summary>
+    [Fact]
+    public async Task Read_ReportsAHighBitrateMp3AsHigh()
+    {
+        var path = await EncodeAsync(MediaFormat.Mp3, 320);
+
+        Assert.Equal(AudioQualityTier.High, _reader.Read(path).Tier);
+    }
+
+    /// <summary>
+    /// FLAC is lossless regardless of what its reported bitrate happens to be — the bit depth is
+    /// what decides it, not a threshold on kbps.
+    /// </summary>
+    [Fact]
+    public async Task Read_ReportsFlacAsLossless()
+    {
+        var path = await EncodeAsync(MediaFormat.Flac, 192);
+
+        var quality = _reader.Read(path);
+
+        Assert.Equal(AudioQualityTier.Lossless, quality.Tier);
+        Assert.True(quality.BitsPerSample > 0);
+    }
+
+    /// <summary>A file that is not audio is a known-nothing result, not an exception.</summary>
+    [Fact]
+    public void Read_OfSomethingThatIsNotAudioReturnsUnknown()
+    {
+        var path = _workspace.PathTo("notes.mp3");
+
+        File.WriteAllText(path, "this is not an MP3");
+
+        Assert.Equal(AudioQualityTier.Unknown, _reader.Read(path).Tier);
+    }
+
+    private async Task<string> EncodeAsync(MediaFormat format, int bitrateKbps)
+    {
+        var source = await _workspace.CreateSourceWavAsync();
+        var output = _workspace.PathFor(format, "quality");
+
+        // Constant rather than the average-bitrate default: the source is a two-second sine
+        // tone, trivially compressible, and an averaging encoder spends far fewer bits on it
+        // than the requested rate — which is correct ABR behaviour but would make the actual
+        // bitrate this test reads back unpredictable. CBR pins every frame to the request.
+        await new AudioEncoder(_workspace.Runner).EncodeAsync(
+            new EncodeRequest(source, output, format, bitrateKbps, new Track
+            {
+                Artist = "Seed Artist",
+                Title = "Seed Title",
+            }, BitrateMode: BitrateMode.Constant));
+
+        return output;
+    }
+}
diff --git a/tests/Offstream.UI.Tests/LibraryTrackViewModelTests.cs b/tests/Offstream.UI.Tests/LibraryTrackViewModelTests.cs
index d34e0b6..a8d7e0d 100644
--- a/tests/Offstream.UI.Tests/LibraryTrackViewModelTests.cs
+++ b/tests/Offstream.UI.Tests/LibraryTrackViewModelTests.cs
@@ -350,6 +350,55 @@ public void Seeding_LeavesAQueryTheUserAlreadyTyped()
         Assert.Equal("cloudbusting", row.MatchQuery);
     }
 
+    /// <summary>A lossy file names its codec and bitrate on one line.</summary>
+    [Fact]
+    public void QualityLabel_NamesTheCodecAndBitrateForALossyFile()
+    {
+        var row = QualityRow("track.mp3", new AudioQuality(320, 44100, 0));
+
+        Assert.True(row.HasQuality);
+        Assert.Equal("MP3 · 320 kbps", row.QualityLabel);
+        Assert.False(row.IsQualityLow);
+    }
+
+    /// <summary>Only the under-128 tier is called out — the one worth a second look.</summary>
+    [Fact]
+    public void QualityLabel_FlagsALowBitrateFile() =>
+        Assert.True(QualityRow("track.mp3", new AudioQuality(96, 44100, 0)).IsQualityLow);
+
+    /// <summary>A lossless file says so, with no bitrate threshold involved.</summary>
+    [Fact]
+    public void QualityLabel_NamesLosslessFiles()
+    {
+        var row = QualityRow("track.flac", new AudioQuality(1411, 44100, 16));
+
+        Assert.Equal("FLAC · Lossless", row.QualityLabel);
+        Assert.False(row.IsQualityLow);
+    }
+
+    /// <summary>
+    /// A lossless <c>.m4a</c> is ALAC, not AAC — the extension alone cannot tell the two apart,
+    /// but the bit depth that makes it lossless can.
+    /// </summary>
+    [Fact]
+    public void QualityLabel_NamesALosslessM4aAsAlac() =>
+        Assert.Equal("ALAC · Lossless", QualityRow("track.m4a", new AudioQuality(1000, 44100, 16)).QualityLabel);
+
+    /// <summary>A file the reader could not open shows no quality line at all.</summary>
+    [Fact]
+    public void QualityLabel_IsAbsentWhenNothingWasRead()
+    {
+        var row = QualityRow("track.mp3", AudioQuality.Unknown);
+
+        Assert.False(row.HasQuality);
+        Assert.Null(row.QualityLabel);
+    }
+
+    private static LibraryTrackViewModel QualityRow(string fileName, AudioQuality quality) => new(new LibraryTrack(
+        $@"C:\Music\{fileName}",
+        new Track { Title = "Running Up That Hill", Artist = "Kate Bush" },
+        quality));
+
     private static LibraryTrackViewModel Row(
         string? title = "Running Up That Hill",
         string? artist = "Kate Bush",