Implement applicant pool functionality in school simulation, allowing for the management of job seekers who are not yet part of the school roster. Update the catalog to include staffing definitions and enhance the API to support applicant data retrieval. Revise the school architecture to handle applicant refresh logic and ensure proper integration with existing roster management. Update tests to validate the new applicant functionalities and ensure robustness in handling staffing scenarios.

src/HSchool.Content/CatalogLoader.cs

@@ -308,6 +308,7 @@ public sealed class CatalogLoader
         var needs = new Dictionary<string, NeedDef>(StringComparer.Ordinal);
         var nameSets = new Dictionary<string, NameSetDef>(StringComparer.Ordinal);
         var subjects = new Dictionary<string, SubjectDef>(StringComparer.Ordinal);
+        var staffing = new Dictionary<string, StaffingDef>(StringComparer.Ordinal);
 
         foreach (var (key, json) in resolved)
         {
@@ -355,6 +356,9 @@ public sealed class CatalogLoader
                 case DefKind.Subject:
                     subjects[key.Name] = Jsonc.Deserialize<SubjectDef>(json);
                     break;
+                case DefKind.Staffing:
+                    staffing[key.Name] = Jsonc.Deserialize<StaffingDef>(json);
+                    break;
             }
         }
 
@@ -374,6 +378,7 @@ public sealed class CatalogLoader
             needs,
             nameSets,
             subjects,
+            staffing,
             ru,
             en);
     }

src/HSchool.Content/DefCatalog.cs

@@ -22,6 +22,7 @@ public sealed class DefCatalog
         IReadOnlyDictionary<string, NeedDef> needs,
         IReadOnlyDictionary<string, NameSetDef> nameSets,
         IReadOnlyDictionary<string, SubjectDef> subjects,
+        IReadOnlyDictionary<string, StaffingDef> staffing,
         IReadOnlyDictionary<string, string> ru,
         IReadOnlyDictionary<string, string> en)
     {
@@ -40,6 +41,7 @@ public sealed class DefCatalog
         Needs = needs;
         NameSets = nameSets;
         Subjects = subjects;
+        Staffing = staffing;
         _ru = ru;
         _en = en;
         AnyNeedDecays = needs.Values.Any(need => !need.Abstract && need.DecayPerHour > 0f);
@@ -82,6 +84,11 @@ public sealed class DefCatalog
 
     public IReadOnlyDictionary<string, SubjectDef> Subjects { get; }
 
+    public IReadOnlyDictionary<string, StaffingDef> Staffing { get; }
+
+    /// <summary>The one concrete staffing ruleset, or null when a pack has not defined it.</summary>
+    public StaffingDef? StaffingRules => Staffing.Values.FirstOrDefault(def => !def.Abstract);
+
     private readonly IReadOnlyDictionary<string, string> _ru;
     private readonly IReadOnlyDictionary<string, string> _en;
 
@@ -103,6 +110,7 @@ public sealed class DefCatalog
             DefKind.Need => Needs.GetValueOrDefault(defName),
             DefKind.NameSet => NameSets.GetValueOrDefault(defName),
             DefKind.Subject => Subjects.GetValueOrDefault(defName),
+            DefKind.Staffing => Staffing.GetValueOrDefault(defName),
             _ => null,
         };
 
@@ -177,6 +185,7 @@ public sealed class DefCatalog
         NeedDef => DefKind.Need,
         NameSetDef => DefKind.NameSet,
         SubjectDef => DefKind.Subject,
+        StaffingDef => DefKind.Staffing,
         _ => throw new ArgumentOutOfRangeException(nameof(def)),
     };
 

src/HSchool.Content/Defs.cs

@@ -16,6 +16,7 @@ public enum DefKind
     Need,
     NameSet,
     Subject,
+    Staffing,
 }
 
 /// <summary>Shared JSONC fields. Kind comes from the folder under <c>defs/</c>, not from the file.</summary>

src/HSchool.Content/PackPaths.cs

@@ -104,6 +104,9 @@ internal static class PackPaths
             case "subjects":
                 kind = DefKind.Subject;
                 return true;
+            case "staffing":
+                kind = DefKind.Staffing;
+                return true;
             default:
                 kind = default;
                 return false;

src/HSchool.Content/PeopleDefValidator.cs

@@ -34,6 +34,16 @@ internal static class PeopleDefValidator
             ValidateSubject(subject, catalog);
         }
 
+        foreach (var staffing in catalog.Staffing.Values)
+        {
+            ValidateStaffing(staffing);
+        }
+
+        if (catalog.Staffing.Values.Count(def => !def.Abstract) > 1)
+        {
+            throw new ContentLoadException("A catalog may only have one concrete StaffingDef.");
+        }
+
         RequireBuildInputs(catalog);
     }
 
@@ -260,6 +270,34 @@ internal static class PeopleDefValidator
         }
     }
 
+    private static void ValidateStaffing(StaffingDef staffing)
+    {
+        if (staffing.Abstract)
+        {
+            return;
+        }
+
+        if (staffing.PoolSize < 1 || staffing.PoolSize > 64)
+        {
+            throw new ContentLoadException($"StaffingDef '{staffing.DefName}' poolSize must be 1–64.");
+        }
+
+        if (staffing.StayChance <= 0f || staffing.StayChance >= 1f)
+        {
+            throw new ContentLoadException($"StaffingDef '{staffing.DefName}' stayChance must be between 0 and 1 exclusive.");
+        }
+
+        if (staffing.ParentChance < 0f || staffing.ParentChance > 1f)
+        {
+            throw new ContentLoadException($"StaffingDef '{staffing.DefName}' parentChance must be 0–1.");
+        }
+
+        if (staffing.HourlyWageBase < 0f || staffing.HourlyWagePerSkill < 0f)
+        {
+            throw new ContentLoadException($"StaffingDef '{staffing.DefName}' wage scale cannot be negative.");
+        }
+    }
+
     private static void ValidateNameSet(NameSetDef names)
     {
         if (!NameGrammar.IsKnownPatronymic(names.PatronymicRule))

src/HSchool.Content/PeopleDefs.cs

@@ -157,6 +157,24 @@ public sealed class TraitDef : Def
     public IntRange? Age { get; init; }
 
     public IReadOnlyList<TraitSkillModifier> SkillModifiers { get; init; } = [];
+
+    /// <summary>
+    /// Added to the hourly wage ask. Positive means the person wants more at the same skills.
+    /// </summary>
+    public float WageAsk { get; init; }
+}
+
+public sealed class StaffingDef : Def
+{
+    public int PoolSize { get; init; }
+
+    public float StayChance { get; init; }
+
+    public float ParentChance { get; init; }
+
+    public float HourlyWageBase { get; init; }
+
+    public float HourlyWagePerSkill { get; init; }
 }
 
 public enum BodyAttributeKind

src/HSchool.People/ApplicantPool.cs

@@ -0,0 +1,173 @@
+namespace HSchool.People;
+
+/// <summary>One person looking for work at this school, with the hourly rate they named.</summary>
+public sealed record Applicant(Person Person, float HourlyWageAsk);
+
+/// <summary>
+/// School-wide applicant list. Not the roster: a new candidate lives only here until hired.
+/// A parent already in the roster may appear with the same id — that is the same person.
+/// </summary>
+public sealed record ApplicantPool(int Week, int NextIndex, IReadOnlyList<Applicant> Applicants)
+{
+    public static ApplicantPool Empty { get; } = new(0, 0, []);
+
+    public static ApplicantPool Create(
+        DefCatalog catalog,
+        Roster roster,
+        int schoolSeed,
+        string nameSetId,
+        DateTime asOf)
+    {
+        var week = ApplicantWeeks.Id(asOf);
+        return Fill(catalog, roster, schoolSeed, nameSetId, asOf, new ApplicantPool(week, 0, []));
+    }
+
+    /// <summary>
+    /// Walks each week from <see cref="Week"/> exclusive to <paramref name="asOf"/> inclusive.
+    /// Same previous list, seed and week always yields the same stays and the same newcomers.
+    /// </summary>
+    public ApplicantPool Advance(
+        DefCatalog catalog,
+        Roster roster,
+        int schoolSeed,
+        string nameSetId,
+        DateTime asOf)
+    {
+        var target = ApplicantWeeks.Id(asOf);
+        if (target <= Week)
+        {
+            return this;
+        }
+
+        var pool = this;
+        for (var week = Week + 1; week <= target; week++)
+        {
+            pool = Step(pool, catalog, roster, schoolSeed, nameSetId, asOf, week);
+        }
+
+        return pool;
+    }
+
+    public static float HourlyAsk(DefCatalog catalog, Person person)
+    {
+        var rules = catalog.StaffingRules
+            ?? throw new InvalidOperationException("The catalog has no StaffingDef.");
+
+        var mean = 0d;
+        if (person.Skills.Count > 0)
+        {
+            var total = 0;
+            foreach (var value in person.Skills.Values)
+            {
+                total += value;
+            }
+
+            mean = total / (double)person.Skills.Count;
+        }
+
+        var trait = 0f;
+        foreach (var name in person.Traits)
+        {
+            if (catalog.Traits.TryGetValue(name, out var def))
+            {
+                trait += def.WageAsk;
+            }
+        }
+
+        var ask = rules.HourlyWageBase + (float)(rules.HourlyWagePerSkill * mean) + trait;
+        return MathF.Round(MathF.Max(ask, 0f), 2);
+    }
+
+    private static ApplicantPool Step(
+        ApplicantPool current,
+        DefCatalog catalog,
+        Roster roster,
+        int schoolSeed,
+        string nameSetId,
+        DateTime asOf,
+        int week)
+    {
+        var rules = RequireRules(catalog);
+        var rng = new Random(Seed.Mix(schoolSeed, week, Seed.ApplicantSalt));
+        var staying = new List<Applicant>(rules.PoolSize);
+        foreach (var applicant in current.Applicants)
+        {
+            if (rng.NextDouble() < rules.StayChance)
+            {
+                staying.Add(applicant);
+            }
+        }
+
+        return Fill(
+            catalog,
+            roster,
+            schoolSeed,
+            nameSetId,
+            asOf,
+            new ApplicantPool(week, current.NextIndex, staying),
+            rng);
+    }
+
+    private static ApplicantPool Fill(
+        DefCatalog catalog,
+        Roster roster,
+        int schoolSeed,
+        string nameSetId,
+        DateTime asOf,
+        ApplicantPool current,
+        Random? rng = null)
+    {
+        var rules = RequireRules(catalog);
+        if (!catalog.NameSets.TryGetValue(nameSetId, out var names))
+        {
+            throw new ArgumentException($"Unknown name set '{nameSetId}'.", nameof(nameSetId));
+        }
+
+        rng ??= new Random(Seed.Mix(schoolSeed, current.Week, Seed.ApplicantSalt));
+        var applicants = new List<Applicant>(rules.PoolSize);
+        var taken = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var applicant in current.Applicants)
+        {
+            if (applicants.Count >= rules.PoolSize || !taken.Add(applicant.Person.Id))
+            {
+                continue;
+            }
+
+            applicants.Add(applicant);
+        }
+
+        var eligible = roster.People
+            .Where(person => person.IsParent && !person.IsStaff && !taken.Contains(person.Id))
+            .OrderBy(person => person.Id, StringComparer.Ordinal)
+            .ToList();
+
+        var nextIndex = current.NextIndex;
+        while (applicants.Count < rules.PoolSize)
+        {
+            Applicant next;
+            if (eligible.Count > 0 && rng.NextDouble() < rules.ParentChance)
+            {
+                var pick = rng.Next(eligible.Count);
+                var parent = eligible[pick];
+                eligible.RemoveAt(pick);
+                taken.Add(parent.Id);
+                next = new Applicant(parent, HourlyAsk(catalog, parent));
+            }
+            else
+            {
+                var (_, person) = FamilyFactory.CreateStaffOnly(catalog, names, schoolSeed, nextIndex, asOf);
+                nextIndex++;
+                taken.Add(person.Id);
+                next = new Applicant(person, HourlyAsk(catalog, person));
+            }
+
+            applicants.Add(next);
+        }
+
+        return new ApplicantPool(current.Week, nextIndex, applicants);
+    }
+
+    private static StaffingDef RequireRules(DefCatalog catalog) =>
+        catalog.StaffingRules
+        ?? throw new InvalidOperationException("The catalog has no StaffingDef.");
+}

src/HSchool.People/ApplicantWeeks.cs

@@ -0,0 +1,17 @@
+namespace HSchool.People;
+
+/// <summary>
+/// Monday-based week index from a fixed UTC epoch. The pool refreshes when this value increases,
+/// so a school created on Saturday keeps its first list through the weekend.
+/// </summary>
+internal static class ApplicantWeeks
+{
+    private static readonly DateTime EpochMonday = new(2000, 1, 3, 0, 0, 0, DateTimeKind.Utc);
+
+    public static int Id(DateTime asOf)
+    {
+        var utc = DateTime.SpecifyKind(asOf, DateTimeKind.Utc).Date;
+        var days = (int)(utc - EpochMonday).TotalDays;
+        return days >= 0 ? days / 7 : (days - 6) / 7;
+    }
+}

src/HSchool.People/FamilyFactory.cs

@@ -199,19 +199,20 @@ internal static class FamilyFactory
     }
 
     /// <summary>
-    /// One adult who lives alone and works at the school. Deliberately not a couple: the top-up
-    /// loop counts openings one at a time, so a two-adult household overshot an odd deficit and
-    /// left behind an adult who was neither staff, parent nor pupil — invisible to every filter.
+    /// One adult who is not on the school roster. Used for the applicant pool: a new candidate
+    /// gets a family id under <paramref name="idPrefix"/> so it can never collide with roster
+    /// households (<c>fN</c>).
     /// </summary>
     public static (Family Family, Person Member) CreateStaffOnly(
         DefCatalog catalog,
         NameSetDef names,
         int schoolSeed,
         int familyIndex,
-        DateTime asOf)
+        DateTime asOf,
+        string idPrefix = "a")
     {
         var rng = new Random(Seed.Mix(schoolSeed, familyIndex, Seed.AppearanceSalt));
-        var familyId = $"f{familyIndex}";
+        var familyId = $"{idPrefix}{familyIndex}";
         var surname = names.Surnames[rng.Next(names.Surnames.Count)];
         var female = rng.Next(2) == 0;
         var given = PickGiven(female ? names.FemaleGiven : names.MaleGiven, rng);

src/HSchool.People/RosterFit.cs

@@ -3,6 +3,7 @@ namespace HSchool.People;
 /// <summary>
 /// Whether a generated or loaded roster still fills this map. A mismatch means the file is stale
 /// relative to the layout — the school must not start and the file must stay untouched.
+/// Staff openings are the player's to fill; only pupil seats have to be occupied.
 /// </summary>
 public static class RosterFit
 {
@@ -24,24 +25,6 @@ public static class RosterFit
             }
         }
 
-        var staffed = roster.People
-            .Where(person => person.IsStaff && person.Position is not null && person.WorkplaceRoomId is not null)
-            .Select(person => new StaffOpening(person.WorkplaceRoomId!, person.Position!))
-            .ToHashSet();
-
-        if (staffed.Count != demand.Staff.Count)
-        {
-            return false;
-        }
-
-        foreach (var opening in demand.Staff)
-        {
-            if (!staffed.Contains(opening))
-            {
-                return false;
-            }
-        }
-
         return true;
     }
 }

src/HSchool.People/RosterGenerator.cs

@@ -41,20 +41,8 @@ public static class RosterGenerator
             people.AddRange(members);
         }
 
-        var nextFamily = plans.Count;
-        var adults = people.Count(person => !person.IsStudent);
-        while (adults < demand.Staff.Count)
-        {
-            var (family, member) = FamilyFactory.CreateStaffOnly(catalog, names, schoolSeed, nextFamily, when);
-            families.Add(family);
-            people.Add(member);
-            nextFamily++;
-            adults++;
-        }
-
-        var staffed = AssignStaff(people, demand.Staff);
-        var classes = FillClasses(demand.Classes, staffed);
-        return new Roster(staffed, families, classes);
+        var classes = FillClasses(demand.Classes, people);
+        return new Roster(people, families, classes);
     }
 
     /// <summary>
@@ -76,48 +64,6 @@ public static class RosterGenerator
         return shuffled;
     }
 
-    private static IReadOnlyList<Person> AssignStaff(List<Person> people, IReadOnlyList<StaffOpening> openings)
-    {
-        if (openings.Count == 0)
-        {
-            return people;
-        }
-
-        var jobs = new Dictionary<string, StaffOpening>(StringComparer.Ordinal);
-        var index = 0;
-        foreach (var person in people)
-        {
-            if (person.IsStudent || index >= openings.Count)
-            {
-                continue;
-            }
-
-            jobs[person.Id] = openings[index];
-            index++;
-        }
-
-        if (jobs.Count == 0)
-        {
-            return people;
-        }
-
-        var result = new Person[people.Count];
-        for (var i = 0; i < people.Count; i++)
-        {
-            var person = people[i];
-            result[i] = jobs.TryGetValue(person.Id, out var job)
-                ? person with
-                {
-                    IsStaff = true,
-                    Position = job.Position,
-                    WorkplaceRoomId = job.RoomId,
-                }
-                : person;
-        }
-
-        return result;
-    }
-
     private static IReadOnlyList<SchoolClass> FillClasses(
         IReadOnlyList<SchoolClass> classes,
         IReadOnlyList<Person> people)

src/HSchool.People/RosterJson.cs

@@ -18,9 +18,11 @@ public sealed class RosterDocument
 
     public required IReadOnlyList<SchoolClass> Classes { get; init; }
 
+    public ApplicantPool? Applicants { get; init; }
+
     public Roster ToRoster() => new(People, Families, Classes);
 
-    public static RosterDocument From(int seed, Roster roster) =>
+    public static RosterDocument From(int seed, Roster roster, ApplicantPool? applicants = null) =>
         new()
         {
             Format = CurrentFormat,
@@ -28,6 +30,7 @@ public sealed class RosterDocument
             People = roster.People,
             Families = roster.Families,
             Classes = roster.Classes,
+            Applicants = applicants,
         };
 }
 

src/HSchool.People/Seed.cs

@@ -11,6 +11,7 @@ internal static class Seed
     public const int IntakeSalt = 3;
     public const int SeatShuffleSalt = 4;
     public const int HouseholdSalt = 5;
+    public const int ApplicantSalt = 6;
 
     /// <summary>A stream that belongs to the school rather than to one family.</summary>
     public static int ForSchool(int schoolSeed, int salt) => Mix(schoolSeed, familyIndex: -1, salt);

src/HSchool.Server/Game/GameLoopService.cs

@@ -64,7 +64,7 @@ internal sealed class GameLoopService(
         {
             if (worker.Id == schoolId)
             {
-                return new PublishedSchoolPeople(worker.Snapshot, worker.RosterSnapshot, worker.CatalogSnapshot);
+                return new PublishedSchoolPeople(worker.Snapshot, worker.RosterSnapshot, worker.ApplicantSnapshot, worker.CatalogSnapshot);
             }
         }
 
@@ -581,4 +581,4 @@ internal sealed class GameLoopService(
     }
 }
 
-internal sealed record PublishedSchoolPeople(SchoolState School, Roster? Roster, DefCatalog? Catalog);
+internal sealed record PublishedSchoolPeople(SchoolState School, Roster? Roster, ApplicantPool? Applicants, DefCatalog? Catalog);

src/HSchool.Server/Game/SchoolWorker.cs

@@ -42,6 +42,7 @@ internal sealed class SchoolWorker
 
     private SchoolState _snapshot;
     private Roster? _rosterSnapshot;
+    private ApplicantPool? _applicantSnapshot;
     private DefCatalog? _catalogSnapshot;
     private School? _school;
     private Task? _run;
@@ -96,6 +97,9 @@ internal sealed class SchoolWorker
     /// <summary>Last roster composition. Published like <see cref="Snapshot"/>; needs live on entities.</summary>
     public Roster? RosterSnapshot => Volatile.Read(ref _rosterSnapshot);
 
+    /// <summary>Last applicant pool. Same publication rules as the roster — not a live World query.</summary>
+    public ApplicantPool? ApplicantSnapshot => Volatile.Read(ref _applicantSnapshot);
+
     /// <summary>Frozen catalog for this school. Safe to read from HTTP; it never mutates after load.</summary>
     public DefCatalog? CatalogSnapshot => Volatile.Read(ref _catalogSnapshot);
 
@@ -450,11 +454,12 @@ internal sealed class SchoolWorker
                 school.Clock.IsRunning,
                 (byte)school.Clock.SpeedIndex));
         Volatile.Write(ref _rosterSnapshot, school.Roster);
+        Volatile.Write(ref _applicantSnapshot, school.Applicants);
     }
 
     /// <summary>
-    /// Writes the composition file. Not called from the 30-second clock save — the roster changes
-    /// on create, load-migration and (later) yearly intake, not every tick.
+    /// Writes the composition file. Not called from the 30-second clock save — the roster and
+    /// applicant pool change on create, weekly refresh and yearly intake, not every tick.
     /// </summary>
     private void PersistPeople()
     {
@@ -466,7 +471,7 @@ internal sealed class SchoolWorker
 
         try
         {
-            _store.SavePeople(school.Id, RosterDocument.From(school.PeopleSeed, school.Roster));
+            _store.SavePeople(school.Id, RosterDocument.From(school.PeopleSeed, school.Roster, school.Applicants));
         }
         catch (Exception ex)
         {
@@ -484,6 +489,7 @@ internal sealed class SchoolWorker
 
         var demand = SchoolDemand.From(catalog, map);
         Roster roster;
+        ApplicantPool applicants;
         int seed;
         var generated = false;
 
@@ -491,6 +497,7 @@ internal sealed class SchoolWorker
         {
             seed = school.Id;
             roster = RosterGenerator.Generate(catalog, map, seed, nameSetId, school.Clock.Time);
+            applicants = ApplicantPool.Create(catalog, roster, seed, nameSetId, school.Clock.Time);
             generated = true;
         }
         else
@@ -500,12 +507,22 @@ internal sealed class SchoolWorker
             {
                 seed = school.Id;
                 roster = RosterGenerator.Generate(catalog, map, seed, nameSetId, school.Clock.Time);
+                applicants = ApplicantPool.Create(catalog, roster, seed, nameSetId, school.Clock.Time);
                 generated = true;
             }
             else
             {
                 seed = loaded.Seed;
                 roster = loaded.ToRoster();
+                if (loaded.Applicants is { Applicants.Count: > 0 })
+                {
+                    applicants = loaded.Applicants;
+                }
+                else
+                {
+                    applicants = ApplicantPool.Create(catalog, roster, seed, nameSetId, school.Clock.Time);
+                    generated = true;
+                }
             }
         }
 
@@ -515,7 +532,7 @@ internal sealed class SchoolWorker
                 $"School {_id} roster does not match its map; the people file was left untouched.");
         }
 
-        school.InstallPeople(roster, seed, nameSetId);
+        school.InstallPeople(roster, seed, nameSetId, applicants);
         return generated;
     }
 

src/HSchool.Server/mods/core/defs/staffing/rules.jsonc

@@ -0,0 +1,8 @@
+{
+  "defName": "Staffing",
+  "poolSize": 12,
+  "stayChance": 0.65,
+  "parentChance": 0.35,
+  "hourlyWageBase": 30,
+  "hourlyWagePerSkill": 0.6,
+}

src/HSchool.Server/mods/core/defs/traits/traits.jsonc

@@ -32,11 +32,13 @@
     "defName": "Quiet",
     "weight": 7,
     "incompatible": ["Leader", "Bully"],
+    "wageAsk": -8,
   },
   {
     "defName": "Leader",
     "weight": 4,
     "incompatible": ["Quiet"],
+    "wageAsk": 10,
     "skillModifiers": [
       { "skill": "History", "offset": 4 },
     ],
@@ -62,6 +64,7 @@
     "defName": "HotTempered",
     "weight": 5,
     "incompatible": ["Quiet"],
+    "wageAsk": 6,
   },
   {
     "defName": "Kind",

src/HSchool.Server/mods/core/localizations/en.jsonc

@@ -68,6 +68,7 @@
   "HotTempered": "Hot-tempered",
   "Kind": "Kind",
   "Neat": "Neat",
+  "Staffing": "Staffing",
   "Height": "Height",
   "Weight": "Weight",
   "HairColor": "Hair colour",

src/HSchool.Server/mods/core/localizations/ru.jsonc

@@ -68,6 +68,7 @@
   "HotTempered": "Вспыльчивый",
   "Kind": "Добрый",
   "Neat": "Аккуратный",
+  "Staffing": "Штат",
   "Height": "Рост",
   "Weight": "Вес",
   "HairColor": "Цвет волос",

src/HSchool.Simulation/School.cs

@@ -68,6 +68,9 @@ public sealed class School : IDisposable
     /// <summary>Composition snapshot. Null in clock-only tests or before <see cref="InstallPeople"/>.</summary>
     public Roster? Roster { get; private set; }
 
+    /// <summary>People looking for work. Not in the roster and not in the World until hired.</summary>
+    public ApplicantPool? Applicants { get; private set; }
+
     public int PeopleSeed { get; private set; }
 
     /// <summary>Name pack used to generate this school's people. Needed again on 1 September.</summary>
@@ -76,7 +79,7 @@ public sealed class School : IDisposable
     /// <summary>
     /// Installs a roster that already matches the map. Spawns entities; does not write to disk.
     /// </summary>
-    public void InstallPeople(Roster roster, int seed, string? nameSetId = null)
+    public void InstallPeople(Roster roster, int seed, string? nameSetId = null, ApplicantPool? applicants = null)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
         ArgumentNullException.ThrowIfNull(roster);
@@ -84,11 +87,12 @@ public sealed class School : IDisposable
         Roster = roster;
         PeopleSeed = seed;
         NameSetId = nameSetId;
+        Applicants = applicants;
         RosterSpawner.Spawn(World, roster);
     }
 
-    /// <summary>Runs one fixed step of the school: calendar, yearly intake if 1 September passed, then need decay.</summary>
-    /// <returns><see langword="true"/> when the roster changed this step.</returns>
+    /// <summary>Runs one fixed step of the school: calendar, yearly intake, applicant refresh, then need decay.</summary>
+    /// <returns><see langword="true"/> when the roster or the applicant pool changed this step.</returns>
     public bool Tick(double deltaTime, double gameMinutesPerRealSecond)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
@@ -99,6 +103,7 @@ public sealed class School : IDisposable
         if (gameMinutes > 0)
         {
             peopleChanged = TryYearlyIntake(before, Clock.Time);
+            peopleChanged |= TryApplicantRefresh();
             if (Catalog is not null)
             {
                 NeedDecay.Apply(World, Catalog, gameMinutes);
@@ -130,6 +135,23 @@ public sealed class School : IDisposable
         return changed;
     }
 
+    private bool TryApplicantRefresh()
+    {
+        if (Applicants is null || Roster is null || Catalog is null || NameSetId is null || Catalog.StaffingRules is null)
+        {
+            return false;
+        }
+
+        var next = Applicants.Advance(Catalog, Roster, PeopleSeed, NameSetId, Clock.Time);
+        if (next.Week == Applicants.Week)
+        {
+            return false;
+        }
+
+        Applicants = next;
+        return true;
+    }
+
     public void Dispose()
     {
         if (_disposed)