feat(quest): QT2/QT4 — the contract catalog, and retail's progress column

The wire carries an id, a stage and two timers. Every word the player reads
lives in portal.dat's ContractTable, which nothing in the tree had ever
opened — the only reference counted its entries in a CLI diagnostic. Chorizite
does decode it (322 contracts installed), which was a real question given it
declares TabooTable without decoding it.

FillProgressString @0x00498DE0 is the one real algorithm in this panel, and it
is now ported whole. Its x87 compares are the usual fcom/sahf pattern, so the
(status & 0x41) tests decode as "<= 0" rather than "< 0" — the difference
between a cooldown that expires and one that never does.

Three readings recorded as tests because each looks like a mistake:
TimeWhenDone is on the wire and is never read; an EMPTY QuestflagRepeatTime is
the entire difference between "Done" and "Available"; and DescriptionProgress
is a printf format taking stage-4, not a literal — rendering it verbatim shows
the player "%d/20 Tuskers".

DeltaTimeToString @0x00565E10 emits every part with a trailing space and then
overwrites the last one. That truncation is invisible in the decompiler output
(the instruction reads as pointer noise), so it was settled by decoding the
bytes: mov byte ptr [esp+eax+0x1b], cl with cl == 0 and eax == strlen writes
the terminator over buffer[len-1]. Guessing either way was a coin flip that
decides whether every repeat timer reads "Done (1h 30s  to Repeat)".

The single-%d substitution is a MEASUREMENT, not a convenience: 89 of the 322
installed contracts author a progress format and every one uses exactly one
specifier. An installed-DAT test asserts that, so a future dat that ships two
fails there rather than silently rendering a raw specifier.

LayoutDump gained --contracts, which is how all of the above was measured.

Campaign QT slices 2 and 4 of 6.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/AcDream.Content.Tests/ContractTableReaderInstalledDatTests.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Linq;
+using AcDream.Core.Quests;
+using DatReaderWriter;
+using DatReaderWriter.Options;
+
+namespace AcDream.Content.Tests;
+
+/// <summary>
+/// Installed-DAT gate for <see cref="ContractTableReader"/>: proves the real
+/// ContractTable (portal.dat <c>0x0E00001D</c>) loads through the SAME
+/// <see cref="DatCollectionAdapter"/> production uses. Nothing read this table
+/// before Campaign QT, so "does Chorizite decode it at all, or merely declare
+/// the type?" was a live question — it decodes it.
+/// </summary>
+[Trait("Lane", "InstalledDat")]
+public sealed class ContractTableReaderInstalledDatTests
+{
+    private static ContractCatalog Load()
+    {
+        string? datDir = ContentConformanceDats.ResolveDatDir();
+        if (datDir is null)
+        {
+            Console.WriteLine("SKIP: installed retail DAT directory is unavailable.");
+            Assert.Fail(
+                "Lane=InstalledDat requires an installed retail DAT directory; "
+                + "see docs/release-gate.md.");
+        }
+
+        using var dats = new DatCollection(datDir, DatAccessType.Read);
+        using var adapter = new DatCollectionAdapter(dats);
+        return ContractTableReader.Load(adapter);
+    }
+
+    [Fact]
+    public void TheInstalledTableLoadsWithItsFullContractRoster()
+    {
+        ContractCatalog catalog = Load();
+
+        // 322 in the installed build. Asserted as a floor rather than an
+        // equality so a different dat revision is not a failure — the point is
+        // that the table decodes at all.
+        Assert.True(
+            catalog.Count >= 300,
+            $"expected the full contract roster, got {catalog.Count}");
+    }
+
+    [Fact]
+    public void EveryContractCarriesTheNameThePanelDraws()
+    {
+        // The wire sends only an id; if these come back empty the panel has
+        // nothing to show, and the failure would look like a UI bug.
+        ContractCatalog catalog = Load();
+
+        int named = catalog.Contracts.Values.Count(c => c.ContractName.Length > 0);
+
+        Assert.True(
+            named > catalog.Count / 2,
+            $"only {named} of {catalog.Count} contracts have a name");
+    }
+
+    [Fact]
+    public void EveryAuthoredProgressFormatUsesExactlyOneIntegerSpecifier()
+    {
+        // ContractProgressText substitutes only the FIRST %d, because retail's
+        // FillProgressString passes exactly one argument. This is the
+        // measurement that makes that reading safe rather than merely
+        // convenient — if a future dat ships a format with two specifiers, the
+        // single-substitution port needs revisiting and this fails first.
+        ContractCatalog catalog = Load();
+
+        var offenders = catalog.Contracts.Values
+            .Where(c => c.DescriptionProgress.Length > 0)
+            .Where(c => CountSpecifiers(c.DescriptionProgress) != 1)
+            .Select(c => $"0x{c.ContractId:X8} \"{c.DescriptionProgress}\"")
+            .ToArray();
+
+        Assert.Empty(offenders);
+    }
+
+    [Fact]
+    public void AMissingContractResolvesToTheUnknownEntryRatherThanThrowing()
+    {
+        // The server may track a contract this dat build has never heard of,
+        // and the panel still has to draw the row.
+        ContractCatalog catalog = Load();
+
+        ContractEntry entry = catalog.Lookup(0xDEADBEEFu);
+
+        Assert.Same(ContractEntry.Unknown, entry);
+    }
+
+    private static int CountSpecifiers(string format)
+    {
+        int count = 0;
+        for (int i = 0; i < format.Length - 1; i++)
+        {
+            if (format[i] == '%' && format[i + 1] != '%')
+                count++;
+        }
+        return count;
+    }
+}