Always keep a caster's signature attack cantrip

Thematic selection could drop a sorcerer/wizard/warlock's attack cantrip,
leaving the sheet's attack line (e.g. Fire Bolt) referencing a spell the
character no longer knew. buildSpellcasting now reserves one cantrip slot for
the class's signature attack cantrip, and ensureCharacterFields repairs
already-curated casters that are missing it (even when their counts are
otherwise correct). 41 server tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: SociableSteve

packages/server/src/backend.test.ts

@@ -13,7 +13,7 @@ import { getAdventureTemplate } from "./adventureTemplates.js";
 import { buildStateContext } from "./dm.js";
 import { addCharacterToSession, appendLog, createSession, fromSnapshot, toSnapshot } from "./session.js";
 import { buildCharacter, ensureCharacterFields } from "./srd.js";
-import { buildSpellcasting, spellCounts, startingInventory, topUpBackgroundGear } from "./srdContent.js";
+import { buildSpellcasting, spellCounts, spellPool, startingInventory, topUpBackgroundGear } from "./srdContent.js";
 import { chooseSpells, suggestCharacterBuild } from "./suggest.js";
 import { JsonStore, newId, type Character, type User } from "./store.js";
 
@@ -144,6 +144,32 @@ describe("character sheet: spells, inventory, gold", () => {
     expect(fixed.map((s) => s.name)).toEqual(expect.arrayContaining(leveled.slice(0, 2).map((s) => s.name)));
   });
 
+  it("always keeps the class's signature attack cantrip", () => {
+    // Even when the chosen spells are all utility, Fire Bolt is reserved.
+    const sc = buildSpellcasting("sorcerer", 1, ARRAY, 2, ["Prestidigitation", "Mage Hand", "Light", "Minor Illusion"])!;
+    expect(sc.known.some((s) => s.name === "Fire Bolt")).toBe(true);
+  });
+
+  it("repairs a curated caster missing its attack cantrip (count already correct)", () => {
+    const d = buildCharacter({
+      name: "Grafton", raceId: "human", classId: "sorcerer", backgroundId: "sage",
+      level: 1, baseScores: ARRAY, chosenSkills: ["arcana", "insight"],
+    });
+    // Correct counts (4 cantrips + 2 leveled) but no Fire Bolt — the old re-roll.
+    d.creature.spellcasting!.known = [
+      ...spellPool("sorcerer").filter((s) => s.level === 0 && s.name !== "Fire Bolt").slice(0, 4),
+      ...spellPool("sorcerer").filter((s) => s.level === 1).slice(0, 2),
+    ];
+    const ch: Character = {
+      id: d.creature.id, userId: "u", name: d.creature.name, createdAt: 0, spellsCurated: true,
+      meta: { race: "Human", className: "Sorcerer", background: "Sage", level: 1 },
+      sheet: { creature: d.creature, attack: d.attack },
+    };
+    expect(ensureCharacterFields(ch)).toBe(true);
+    expect(ch.sheet.creature.spellcasting!.known.some((s) => s.name === "Fire Bolt")).toBe(true);
+    expect(ensureCharacterFields(ch)).toBe(false); // idempotent
+  });
+
   it("builds inventory from class + background and tops it up idempotently", () => {
     const inv = startingInventory("sorcerer", "sage");
     expect(inv.some((i) => i.name === "Arcane Focus")).toBe(true); // class kit

packages/server/src/srd.ts

@@ -16,7 +16,7 @@ import {
   type Roleplay,
   type Skill,
 } from "@ai-dm/engine";
-import { buildSpellcasting, spellCounts, startingGold, startingInventory, topUpBackgroundGear } from "./srdContent.js";
+import { ATTACK_CANTRIP, buildSpellcasting, spellCounts, startingGold, startingInventory, topUpBackgroundGear } from "./srdContent.js";
 import { type Character, newId } from "./store.js";
 
 export interface RaceDef {
@@ -246,7 +246,11 @@ export function ensureCharacterFields(character: Character): boolean {
     const have = c.spellcasting.known;
     const cantrips = have.filter((s) => s.level === 0).length;
     const leveled = have.length - cantrips;
-    if (cantrips !== want.cantrips || leveled !== want.leveled) {
+    // Also repair casters that lack their signature attack cantrip (the sheet's
+    // attack would otherwise reference a spell they don't know).
+    const attackCantrip = ATTACK_CANTRIP[classId];
+    const missingAttack = !!attackCantrip && !have.some((s) => s.name === attackCantrip);
+    if (cantrips !== want.cantrips || leveled !== want.leveled || missingAttack) {
       const sc = buildSpellcasting(classId, character.meta.level, c.abilities, c.proficiencyBonus, have.map((s) => s.name));
       if (sc) {
         c.spellcasting = sc;

packages/server/src/srdContent.ts

@@ -215,6 +215,14 @@ const CANTRIPS_KNOWN: Record<string, number[]> = {
   warlock: [0, 2, 2, 2, 3, 3],
 };
 
+// Classes whose primary attack IS a cantrip must always know that cantrip, so
+// the sheet's attack line stays consistent with their known spells.
+export const ATTACK_CANTRIP: Record<string, string> = {
+  wizard: "Fire Bolt",
+  sorcerer: "Fire Bolt",
+  warlock: "Eldritch Blast",
+};
+
 // Leveled "spells known" for known-casters (others prepare; see below).
 const SPELLS_KNOWN: Record<string, number[]> = {
   sorcerer: [0, 2, 3, 4, 5, 6],
@@ -299,8 +307,12 @@ export function buildSpellcasting(
 
   const eligible = eligibleSpells(classId, level);
   const want = spellCounts(classId, level, abilities);
+  // Reserve a cantrip for the class's signature attack cantrip when its primary
+  // attack is a spell, so the character can always make their basic attack.
+  const attackCantrip = ATTACK_CANTRIP[classId];
+  const cantripPicks = attackCantrip ? [attackCantrip, ...(chosen ?? [])] : chosen;
   const known = [
-    ...selectSpells(eligible.cantrips, chosen, want.cantrips),
+    ...selectSpells(eligible.cantrips, cantripPicks, want.cantrips),
     ...selectSpells(eligible.leveled, chosen, want.leveled),
   ];
   const mod = abilityModifier(abilities[def.ability]);