@maka/maka-cli 5.122.1 → 5.123.1

package/bundle/typescript/src/commands/game/sideQuest/models/player.js

@@ -1,6 +1,11 @@
 import { getSoft, getProgram } from '../utilities/programs.js';
+import { GEAR_LANES, CHROME_LANES, QUALITY_LANES, ART_LANES, ADEPT_LANES, scaleOf } from '../utilities/effects.js';
 import { catalogRowFor } from '../utilities/catalog.js';
 import { getQuality, resolveQualityKey } from '../qualities.js';
+import { ADEPT_POWERS } from '../adept-powers.js';
+import { skillsInGroup } from '../skill-groups.js';
+import { spellFor } from '../utilities/catalog.js';
+import { METAMAGICS_BY_KEY } from '../commands/initiate.js';
 import { isAspectKey } from '../aspects.js';
 import { hint } from '../utilities/hints.js';
 import { Category } from '../types/shared/item-enum.js';
@@ -48,28 +53,36 @@ export function sameHostSide(actor, other) {
     const sideOf = (p) => p.hostInside ?? p.insideHost;
     return sideOf(actor) === sideOf(other);
 }
-export const SKILL_NAMES = [
-    'blades', 'clubs', 'unarmed', 'archery', 'free-fall',
-    'gunnery', 'astral-combat', 'cybercombat',
-    'sneaking', 'perception',
-    'palming', 'escape-artist', 'disguise',
-    'hacking', 'locksmith', 'computer', 'electronic-warfare', 'hardware',
-    'negotiation', 'con', 'intimidation', 'etiquette', 'leadership',
-    'performance', 'instruction',
-    'first-aid', 'medicine',
-    'assensing', 'spellcasting', 'counterspelling',
-    'piloting', 'conjuring', 'compiling', 'decompiling', 'registering', 'software',
-    // Stage 2 additions -- see the union above for why these twenty-three.
-    'impersonation', 'ritual-spellcasting',
-    'gymnastics', 'running', 'swimming',
-    'automatics', 'pistols', 'longarms',
-    'banishing', 'summoning', 'binding',
-    'cybertechnology',
-    'alchemy', 'disenchanting', 'artificing',
-    'aeronautics-mechanic', 'industrial-mechanic', 'automotive-mechanic', 'nautical-mechanic',
-    'navigation', 'tracking', 'survival',
-    'heavy-weapons', 'throwing-weapons', 'exotic-melee', 'exotic-ranged',
-];
+/**
+ * The SR5e-condensed active skill list. Every pool that used to lean on
+ * the single generic `combatSkill` attribute now draws the SPECIFIC
+ * skill (firearms for guns, blades for melee weapons, unarmed for fists
+ * and subdual, hacking for cybercombat). Non-combat skills back their own
+ * mechanics as they land -- perception drives search rolls today; the
+ * rest are rated on the sheet and waiting for their verbs.
+ */
+/**
+ * The active-skill sheet, rounded out from the SR5e canon list (p.90-91,
+ * p.151) at this engine's granularity. CONDENSATIONS (canon -> here):
+ * Automatics/Longarms/Pistols/Heavy Weapons/Archery -> firearms;
+ * Gymnastics/Running/Swimming -> athletics; the Pilot family ->
+ * piloting; Summoning/Binding/Banishing -> conjuring; Impersonation
+ * rides disguise (its voice half). Every skill listed HOOKS a live
+ * system -- see the site named beside it. Canon skills acknowledged but
+ * NOT yet carried (no system to hook): Throwing Weapons, Exotic
+ * Weapons, Diving, Free-Fall, Survival, Tracking, Navigation, Animal
+ * Handling, Demolitions, Forgery, Chemistry, Armorer, the Mechanic
+ * family, Biotechnology, Cybertechnology, Arcana, Alchemy, Artificing,
+ * Ritual Spellcasting, Disenchanting, and Knowledge/Language skills.
+ * (The Resonance trio -- Compiling, Decompiling, Registering -- WAS on
+ * this not-yet-carried list; all three are now real and hooked, one per
+ * command file beside them.)
+ */
+// The skill vocabulary now lives in skills.ts, a module with no imports
+// of its own, so skill-groups.ts can read it without a cycle back
+// through this file. Re-exported so nothing that imports SkillName or
+// SKILL_NAMES from here has to change.
+export { SKILL_NAMES } from '../skills.js';
 /**
  * Skills that fall back to the legacy `combatSkill` attribute when no
  * explicit rating is given -- this is what keeps every existing NPC seed
@@ -824,8 +837,8 @@ export class Player extends AbstractPlayer {
         const silent = this.runningSilent ? 2 : 0;
         // What the running programs add (catalog v13): Signal Scrub always,
         // Sneak only while silent -- the rows carry both, and the `only`.
-        const scrub = this.gearBonus('pan-defense');
-        const sneak = this.runningSilent ? this.gearBonus('pan-defense', { only: 'silent' }) - scrub : 0;
+        const scrub = this.bonus('pan-defense');
+        const sneak = this.runningSilent ? this.bonus('pan-defense', { only: 'silent' }) - scrub : 0;
         const attributeName = against === 'attack' ? 'Willpower' : 'Intuition';
         const attribute = against === 'attack' ? this.willpower : this.intuition;
         const firewall = this.isTechnomancer()
@@ -962,6 +975,11 @@ export class Player extends AbstractPlayer {
      * check lives here and not at either call site.
      */
     smartlinkTier() {
+        // CHROME SPECIFICALLY, not every source of firearms dice. This is
+        // asking which TIER of smartlink you have -- the implant behind
+        // your eye (p.453) or the unit clipped to the gun (p.432) -- and
+        // `bonus` would answer true for the gear one and collapse the very
+        // distinction the method exists to draw.
         if (this.augBonus('firearms') > 0)
             return 'augmentation';
         // ON YOUR FACE, NOT IN YOUR BAG (fxPHSuE4nrH3gAGiy, rejected:
@@ -1295,19 +1313,39 @@ export class Player extends AbstractPlayer {
         if (getAug(aug.key)?.implantsCarriedDeck)
             this.getAnyCyberdeck()?.implantIntoBody();
     }
-    // ==================== Gear effects (catalog v13) ====================
-    // A catalog row says what it does (`effects`), and this is the one
-    // place the engine reads that: what is worn (and fitted into it), what
-    // is drawn, what is carried, what runs on the deck, what is stored on
-    // a commlink. Same shape as augBonus / qualityBonus so a pool adds the
-    // three the same way.
-    /** Every effect that applies right now, with the rating it scales by. */
+    // ================= THE EFFECTS LANE (one resolver) =================
+    // A catalog row says what it DOES (`effects`), and this is the one
+    // place the engine reads that -- for every kind of row, not just
+    // gear. What is worn (and fitted into it), what is drawn, what is
+    // carried, what runs on the deck, what is stored on a commlink, the
+    // chrome that is installed, the qualities held, the adept powers and
+    // metamagics a character simply has, and the spells being sustained.
+    //
+    // WHY ONE RESOLVER (user, 2026-09-04: "no matter if it's a quality,
+    // augmentation, metatype ability, it has a lane to follow to apply
+    // stats to the character"). Before this there were six shapes and six
+    // readers, and every pool in the game hand-added whichever ones its
+    // author remembered -- which is why a rigger's chrome worked on a
+    // drone and silently did nothing on a bench repair two files away.
+    // A term that has to be remembered is a term that gets forgotten.
+    /**
+     * Which SOURCE an effect came from. The single accessor `bonus()`
+     * sums them all; the older per-source getters each sum their own,
+     * which is what lets the call sites migrate one at a time instead of
+     * in one unreviewable commit.
+     */
+    /** Every effect applying right now, with its source and its scale. */
     applyingEffects() {
         const out = [];
-        const take = (effects, defaultWhen, state, rating) => {
+        // `slug` is which ROW the effect came from, and it is what a
+        // `chosen` property resolves through. Recorded here rather than
+        // searched for later: the first version of pickFor walked the
+        // qualities looking for an array that CONTAINED the effect object,
+        // which worked only for qualities and only by object identity.
+        const take = (effects, defaultWhen, state, rating, lane = 'gear', slug = '') => {
             for (const e of effects)
                 if ((e.when ?? defaultWhen) === state)
-                    out.push({ effect: e, rating: rating ?? 1 });
+                    out.push({ effect: e, rating: rating ?? 1, lane, slug });
         };
         for (const [groupName, group] of Object.entries(this._equipment)) {
             if (!group)
@@ -1317,14 +1355,14 @@ export class Player extends AbstractPlayer {
                     continue;
                 if (Player.isWeaponSlot(groupName, slot)) {
                     if (this.weaponDrawn)
-                        take(item.effects, item.defaultWhen, 'held', item.ratingValue);
+                        take(item.effects, item.defaultWhen, 'held', item.ratingValue, 'gear', item.row?.slug ?? item.name);
                     continue;
                 }
-                take(item.effects, item.defaultWhen, 'worn', item.ratingValue);
+                take(item.effects, item.defaultWhen, 'worn', item.ratingValue, 'gear', item.row?.slug ?? item.name);
             }
         }
         for (const item of this._inventory.getAllItems())
-            take(item.effects, item.defaultWhen, 'carried', item.ratingValue);
+            take(item.effects, item.defaultWhen, 'carried', item.ratingValue, 'gear', item.row?.slug ?? item.name);
         const runningOn = new Set();
         const deck = this.activeDeck ?? this.getCyberdeck();
         if (deck)
@@ -1337,7 +1375,7 @@ export class Player extends AbstractPlayer {
                 const p = getProgram(key);
                 const row = p ? catalogRowFor(`${p.name} Program`) ?? catalogRowFor(p.name) : undefined;
                 if (row?.effects)
-                    take(row.effects, 'running', 'running', row.ratingValue);
+                    take(row.effects, 'running', 'running', row.ratingValue, 'gear', row.slug);
             }
         }
         for (const device of [...this.commlinks(), ...this._inventory.getAllItems().filter(i => i.isCyberdeck())]) {
@@ -1345,62 +1383,265 @@ export class Player extends AbstractPlayer {
                 const soft = getSoft(key);
                 const row = soft ? catalogRowFor(soft.name) : undefined;
                 if (row?.effects)
-                    take(row.effects, 'stored', 'stored', row.ratingValue);
+                    take(row.effects, 'stored', 'stored', row.ratingValue, 'gear', row.slug);
             }
         }
+        // ---- The CHROME lane. Installed 'ware, with ONE relationship the
+        // rows cannot state themselves: the wired tiers SUPERSEDE each other
+        // (III beats II beats I) rather than stacking, and a synaptic booster
+        // rides on top as bioware. Resolved by dropping the superseded rows
+        // here, once, so every reader sees the same surviving set -- rather
+        // than in a getter, where only that getter would have been right.
+        for (const key of this.chromeThatCounts()) {
+            const a = getAug(key);
+            if (a?.effects)
+                take(a.effects, 'installed', 'installed', undefined, 'chrome', key);
+        }
+        // ---- The ADEPT lane. A power is 'innate': there is no object to
+        // carry and no state to enter, and its LEVEL is what "per level"
+        // scales by. A character with no `adeptPowers` at all is on the
+        // compressed legacy model and contributes nothing here -- that shape
+        // is resolved in adeptAttackBonus/adeptDefenseBonus, which is where
+        // it has always lived and where the tests that pin it can see it.
+        for (const [key, level] of Object.entries(this.adeptPowers ?? {})) {
+            if (level <= 0)
+                continue;
+            const power = ADEPT_POWERS[key];
+            if (power?.effects)
+                take(power.effects, 'innate', 'innate', level, 'adept', key);
+        }
+        // ---- The INITIATE lane. A metamagic applies from the moment it is
+        // learned, and 'grade' is what Centering multiplies by.
+        for (const key of this.metamagics) {
+            const m = METAMAGICS_BY_KEY[key];
+            if (m?.effects)
+                take(m.effects, 'initiated', 'initiated', this.initiationGrade, 'initiate', key);
+        }
+        // ---- The SUSTAINED lane. A spell held up applies until it is
+        // dropped, and the magnitude it scales by is the hits it landed --
+        // read from the state cast.ts already keeps rather than duplicated
+        // into a second map. Barriers are absent on purpose: they raise a
+        // wall in a room (models/scene.ts reads them), and that is world
+        // state rather than a modifier on anybody.
+        for (const [key, hits] of this.sustainedMagnitudes()) {
+            const sp = spellFor(key);
+            if (sp?.effects)
+                take(sp.effects, 'sustained', 'sustained', hits, 'sustained', key);
+        }
+        // ---- The QUALITY lane. A quality is "held" in the same sense a
+        // coat is worn: it is on the sheet, so it applies. A RETIRED one is
+        // dormant rather than deleted (qualities.ts) -- its holder keeps it
+        // and it rolls nothing, which is enforced here, once, rather than
+        // at each reader.
+        for (const key of this.qualities) {
+            const q = getQuality(key);
+            if (!q?.effects || q.retired)
+                continue;
+            take(q.effects, 'held-quality', 'held-quality', this.qualityRating(key), 'quality', key);
+        }
+        return out;
+    }
+    /**
+     * Sums one kind of effect. `lanes` narrows to particular sources --
+     * omitted means EVERY source, which is what the unified `bonus()`
+     * wants; the legacy getters each pass their own single lane so that
+     * a call site still adding two of them by hand cannot double.
+     */
+    /**
+     * The spells being sustained, and what each scales by.
+     *
+     * READS THE STATE cast.ts ALREADY KEEPS rather than a second map:
+     * the armor spell stores its hits, and the other two are booleans
+     * whose rows carry a flat value, so 1 is the right multiplier for
+     * them. Adding a parallel store would be two places to forget to
+     * update, which is the shape this whole pass has been removing.
+     */
+    sustainedMagnitudes() {
+        const out = [];
+        if (this._sustainedArmor > 0)
+            out.push(['armor', this._sustainedArmor]);
+        if (this.sustainedInvisibility)
+            out.push(['invisibility', 1]);
+        if (this.sustainedReflexes)
+            out.push(['reflexes', 1]);
         return out;
     }
-    sumEffects(type, property, only) {
+    sumEffects(type, property, only, lanes) {
         let total = 0;
-        for (const { effect, rating } of this.applyingEffects()) {
-            if (effect.type !== type || effect.property !== property)
+        for (const { effect, rating, lane, slug } of this.applyingEffects()) {
+            if (lanes !== undefined && !lanes.includes(lane))
+                continue;
+            // FORBIDDEN never sums. It carries no value on purpose, and a
+            // summing reader must not be able to fold it in as a zero --
+            // "you cannot have this" is a different statement from "this
+            // adds nothing", and only the second one is arithmetic.
+            if (effect.type === 'forbid')
+                continue;
+            if (effect.type !== type)
+                continue;
+            // A `chosen` property belongs to whatever the holder named, and
+            // it resolves the same way for dice and flags as it already did
+            // for ceilings. It did NOT until 2026-09-04: only capBonus knew
+            // the word, so a quality like Codeslinger -- +2 to ONE Matrix
+            // action you pick -- could not be written as an effect at all,
+            // and baked its answer into the slug instead.
+            const target = effect.property === 'chosen' ? this.picks.get(slug) : effect.property;
+            if (target !== property)
                 continue;
             if (effect.only !== undefined && effect.only !== only)
                 continue;
-            total += effect.value * (effect.scaleBy === 'rating' ? rating : 1);
+            total += effect.value * scaleOf(effect, rating);
         }
         return total;
     }
     /**
-     * Dice the gear adds to a pool or a skill's tests (cf. augBonus,
-     * qualityBonus): `kind` is a pool kind or a SkillName; `only` names a
-     * narrowing an effect may carry ('haggle', 'silent', 'matrix-search').
+     * Dice the GEAR LANE adds, and nothing else.
+     *
+     * A LANE READER, NOT A POOL. Every pool in the game reads `bonus()`
+     * now; this survives as the way to ask what one source contributes,
+     * which is what the behaviour fixture interrogates and what a "where
+     * did that die come from" answer would need. It has no production
+     * caller of its own, and that is the correct state for it rather than
+     * a sign it should go: deleting it would delete the fixture's ability
+     * to see the lanes apart, which is the only thing that can catch one
+     * lane being counted twice.
      */
     gearBonus(kind, opts = {}) {
-        return this.sumEffects('dice', kind, opts.only);
+        return this.sumEffects('dice', kind, opts.only, GEAR_LANES);
     }
     /** What the gear adds to a LIMIT (a Shopsoft's +1 Social on a haggle). */
     gearLimit(kind, opts = {}) {
+        return this.sumEffects('limit', kind, opts.only, GEAR_LANES);
+    }
+    // ---------------- THE UNIFIED ACCESSORS ----------------
+    // Four calls, every source. A pool written against these cannot lose
+    // a term to a new kind of catalog row, because there is nothing left
+    // for it to forget to add.
+    /**
+     * EVERY die the character has for this pool or skill, from every
+     * source -- gear, chrome, qualities, adept powers, metamagics, a
+     * metatype trait, a sustained spell.
+     *
+     * `only` names a narrowing an effect may carry ('haggle', 'silent',
+     * 'matrix-search'). `skill` lets a combat pool pick up dice that were
+     * declared against the SKILL being rolled rather than the pool --
+     * a smartlink says `firearms`, and the attack pool has to see it.
+     *
+     * The sources that have not yet moved onto the shared shape are added
+     * explicitly below, each named, so that migrating one is a matter of
+     * deleting its line here rather than hunting for what it fed.
+     */
+    bonus(kind, opts = {}) {
+        let total = this.sumEffects('dice', kind, opts.only);
+        if (opts.skill !== undefined && opts.skill !== kind) {
+            total += this.sumEffects('dice', opts.skill, opts.only);
+        }
+        // Chrome moved onto the shared shape (2026-09-04), so it arrives
+        // through the lane above and must NOT be added again here. Every
+        // source that migrates loses its hand-added line at the same moment
+        // -- the fixture is what makes forgetting that loud instead of a
+        // quietly doubled pool.
+        // THE FAN-IN. Hacking is Matrix work, so whatever taxes the Matrix
+        // taxes hacking too (Simsense Vertigo, p.83). It is a relationship
+        // between two POOLS, which no single row can declare, so it lives
+        // here -- and it applies across every lane, not only qualities.
+        //
+        // That is a wider reading than the getter it replaces: today
+        // `qualityBonus('hacking')` folds in only the QUALITY side, so a
+        // datajack helps a Matrix action and does nothing for a hacking
+        // test. Both readings cannot be right, and the canon sentence does
+        // not care where the dice came from. The change is deliberate, and
+        // lands where a call site adopts `bonus()` -- the fixture prints
+        // the exact pools that move when it does.
+        if (kind === 'hacking')
+            total += this.bonus('matrix', opts);
+        return total;
+    }
+    /**
+     * What a source adds to the initiative SCORE -- the number you roll
+     * against -- as opposed to `bonus('initiative')`, which is the DICE.
+     *
+     * The `initiative` effect arm has existed since the gear pass and
+     * was read by nothing at all until the Increase Reflexes spell came
+     * onto the lane (2026-09-04). Two different quantities sharing the
+     * word "initiative" is exactly why the arm is separate.
+     */
+    initiativeBonus(of) {
+        return this.sumEffects('initiative', of);
+    }
+    /** Every point on a LIMIT, from every source. */
+    limitBonus(kind, opts = {}) {
         return this.sumEffects('limit', kind, opts.only);
     }
-    /** A capability the gear grants (dni, smartlink, no-fog, low-light...), by key. */
-    hasCapability(key) {
+    /**
+     * How much further this character may raise one skill or attribute
+     * than anyone else -- Aptitude's chosen skill (p.72), Exceptional
+     * Attribute's chosen attribute (p.73-74).
+     *
+     * The book states absolute numbers against ITS ceilings (a skill at 7
+     * rather than 6 at creation, 13 rather than 12 after). This engine
+     * caps lower than the book does, so what carries across is the DELTA
+     * -- one step further than anyone else gets -- applied to whatever
+     * ceiling the engine is enforcing. Writing the book's 13 over a house
+     * cap of 7 would not be more faithful, only a bigger number in the
+     * wrong system.
+     *
+     * A `chosen` ceiling resolves through the holder's own pick, so a
+     * quality bought but never answered lifts nothing at all.
+     */
+    capBonus(of, name) {
+        const category = of === 'skill' ? 'skills' : 'attributes';
+        let total = 0;
+        for (const { effect, rating, slug } of this.applyingEffects()) {
+            if (effect.type !== 'cap' || effect.category !== category)
+                continue;
+            const target = effect.property === 'chosen' ? this.picks.get(slug) : effect.property;
+            if (target !== name)
+                continue;
+            total += effect.value * (effect.scaleBy === 'rating' ? rating : 1);
+        }
+        return total;
+    }
+    /**
+  
+  
+    /** A capability the character has, from any source, by key. */
+    can(key) {
         return this.sumEffects('flag', key) > 0;
     }
     /**
-     * The single tap every pool reads chrome through. Wired Reflexes tiers
-     * don't stack -- the higher tier wins (II supersedes I) -- but the
-     * synaptic-vs-wired conflict is the clinic's job, not this getter's.
+     * THE CHROME THAT ACTUALLY COUNTS: everything installed, minus the
+     * wired-reflex tiers a higher tier supersedes.
+     *
+     * Wired Reflexes I, II and III do not stack -- the best one wins (a
+     * synaptic booster is bioware and rides on top of whichever that is).
+     * That is a relationship BETWEEN rows, so no row can declare it and it
+     * has to live in code; it lives HERE, in the one place the resolver
+     * reads, rather than inside a getter, where only that getter would
+     * have been right and every other reader would have double-counted.
+     *
+     * The synaptic-vs-wired legality conflict remains the clinic's job.
      */
-    augBonus(kind) {
+    chromeThatCounts() {
         if (this.augmentations.size === 0)
-            return 0;
+            return [];
         const has = (k) => this.augmentations.has(k);
-        // The reflex family is the one hand-resolved case: the tiers
-        // SUPERSEDE each other (III beats II beats I) instead of stacking,
-        // with a synaptic booster riding on top as bioware. Everything else
-        // is data -- augmentations.ts declares its own dice (IAugmentation
-        // .bonuses), so new chrome never touches this method again.
-        const reflexFamily = new Set(['wired-reflexes-1', 'wired-reflexes-2', 'wired-reflexes-3', 'synaptic-booster']);
-        const reflexes = (has('wired-reflexes-3') ? 3 : has('wired-reflexes-2') ? 2 : has('wired-reflexes-1') ? 1 : 0)
-            + (has('synaptic-booster') ? 1 : 0);
-        let total = (kind === 'initiative' || kind === 'defense') ? reflexes : 0;
-        for (const key of this.augmentations) {
-            if (reflexFamily.has(key))
-                continue; // resolved above
-            total += getAug(key)?.bonuses?.[kind] ?? 0;
-        }
-        return total;
+        const best = has('wired-reflexes-3') ? 'wired-reflexes-3'
+            : has('wired-reflexes-2') ? 'wired-reflexes-2'
+                : has('wired-reflexes-1') ? 'wired-reflexes-1' : undefined;
+        const superseded = new Set(['wired-reflexes-1', 'wired-reflexes-2', 'wired-reflexes-3'].filter(k => k !== best));
+        return [...this.augmentations].filter(k => !superseded.has(k));
+    }
+    /**
+     * The chrome lane, by pool. A LANE READER, like gearBonus above.
+     *
+     * Every pool now reads `bonus()`, with exactly two deliberate
+     * exceptions, both in smartlinkTier and both commented there: that
+     * method asks which TIER of smartlink you have, implant or clip-on,
+     * and only the chrome lane can answer it.
+     */
+    augBonus(kind) {
+        return this.sumEffects('dice', kind, undefined, CHROME_LANES);
     }
     // ==================== Qualities (see qualities.ts) ====================
     // SR5e's traits (p.71-85), baked into the archetype at creation
@@ -1409,6 +1650,43 @@ export class Player extends AbstractPlayer {
     // qualityBonus below, the same single-switch pattern as augBonus.
     /** Installed qualities, by catalog key (see QUALITIES). */
     qualities = new Set();
+    /**
+     * IS THIS SKILL OR ATTRIBUTE FORBIDDEN OUTRIGHT to this character?
+     *
+     * Reads the same lane every other rule reads, so a second quality
+     * (or a piece of chrome, or a metatype trait) that bars something
+     * needs no new reader. A `chosen` forbid resolves through the
+     * holder's pick, and where the pick names a skill GROUP the bar
+     * falls on every member -- which is what Incompetent actually is
+     * (p.81: "all skills in the skill group").
+     */
+    isForbidden(of, name) {
+        const category = of === 'skill' ? 'skills' : 'attributes';
+        for (const { effect, slug } of this.applyingEffects()) {
+            if (effect.type !== 'forbid' || effect.category !== category)
+                continue;
+            const target = effect.property === 'chosen' ? this.picks.get(slug) : effect.property;
+            if (target === undefined)
+                continue;
+            if (target === name)
+                return true;
+            if (of === 'skill' && skillsInGroup(target).includes(name))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Incompetent (p.81) names ONE skill group, and this is the only place
+     * that knows how to ask which. It was three separate reads of
+     * `hasQuality(`incompetent-${skill}`)` -- the slug convention -- and a
+     * fourth that counted slugs by prefix for notoriety. The quality is
+     * now 'incompetent' with a pick, and a legacy slug resolves to the
+     * same thing on load (qualities.ts LEGACY_CHOICE_KEYS), so this
+     * answers the same for an old save and a new one.
+     */
+    isIncompetentAt(skill) {
+        return this.isForbidden('skill', skill);
+    }
     hasQuality(key) {
         return this.qualities.has(key);
     }
@@ -1417,6 +1695,23 @@ export class Player extends AbstractPlayer {
      * the only quality that edits an attribute (RAW raises the Edge ceiling;
      * with no attribute point-buy here, the point lands directly).
      */
+    /**
+     * WHAT THE HOLDER PICKED, per ROW that demands a pick (ICatalogChoice):
+     * slug -> the skill or attribute named.
+     *
+     * KEYED BY SLUG, NOT BY QUALITY (mjmcee, 2026-09-04). A Hardwire is an
+     * augmentation that gives +2 to a chosen skill and asks exactly the
+     * question Aptitude asks; a map that only qualities could reach would
+     * mean a second map for chrome and a third for spells. One map, one
+     * picker, one payload field.
+     */
+    picks = new Map();
+    /**
+     * The former name for `picks`, back when only qualities could ask.
+     * Kept as the SAME Map -- not a copy -- so a save written or read
+     * through the old name still lands in one place.
+     */
+    get qualityChoices() { return this.picks; }
     /** Rating per rated quality (qualities.ts maxRating); absent = 1. */
     qualityRatings = new Map();
     /** The rating held, 0 when the quality is not held; a flat quality reads 1. */
@@ -1429,6 +1724,13 @@ export class Player extends AbstractPlayer {
         // A legacy "<key>-1" resolves to the rated key at 1 (qualities.ts).
         const resolved = resolveQualityKey(rawKey);
         const key = resolved.key;
+        // A legacy slug carries its pick with it (qualities.ts
+        // LEGACY_CHOICE_KEYS): incompetent-hacking IS incompetent, having
+        // named hacking. Recorded before anything reads it, and never
+        // overwriting a pick the payload supplied explicitly.
+        if (resolved.pick !== undefined && !this.picks.has(key)) {
+            this.picks.set(key, resolved.pick);
+        }
         const q = getQuality(key);
         if (q?.maxRating) {
             const r = Math.max(1, Math.min(q.maxRating, Math.floor(rating ?? resolved.rating)));
@@ -1437,16 +1739,78 @@ export class Player extends AbstractPlayer {
         if (this.qualities.has(key))
             return;
         this.qualities.add(key);
-        if (key === 'lucky') {
-            this.edge += 1;
-            this.edgeRemaining += 1;
+        this.applyQualityAttributes(q);
+    }
+    /**
+     * A quality that MOVES AN ATTRIBUTE does it once, here, at install.
+     *
+     * Unlike a dice effect -- which qualityBonus re-reads on every roll
+     * -- an attribute is a stored number, so it is edited rather than
+     * summed. Lucky (p.76) is the long-standing case: RAW it raises the
+     * Edge CEILING, and with no attribute point-buy here the point lands
+     * directly. It used to be an `if (key === 'lucky')` in addQuality;
+     * it is data now, which is what let Ugly and Doesn't Care (Cutting
+     * Aces p.152-153) arrive as data too instead of as a second `if`.
+     *
+     * The floor is 1: no quality reduces an attribute below the minimum
+     * a metahuman can have, and Ugly and Doesn't Care says so in as many
+     * words ("minimum 1").
+     */
+    applyQualityAttributes(q) {
+        for (const e of q?.effects ?? []) {
+            if (e.type !== 'attribute' || e.category !== 'attributes')
+                continue;
+            const by = e.value;
+            switch (e.property) {
+                case 'edge':
+                    // Edge is two numbers: the ceiling and what is left in the
+                    // pool tonight. A quality that raises one raises both, or the
+                    // point exists on the sheet and cannot be spent.
+                    this.edge = Math.max(1, this.edge + by);
+                    this.edgeRemaining = Math.max(0, this.edgeRemaining + by);
+                    break;
+                case 'body':
+                    this.body = Math.max(1, this.body + by);
+                    break;
+                case 'agility':
+                    this.agility = Math.max(1, this.agility + by);
+                    break;
+                case 'reaction':
+                    this.reaction = Math.max(1, this.reaction + by);
+                    break;
+                case 'strength':
+                    this.strength = Math.max(1, this.strength + by);
+                    break;
+                case 'willpower':
+                    this.willpower = Math.max(1, this.willpower + by);
+                    break;
+                case 'logic':
+                    this.logic = Math.max(1, this.logic + by);
+                    break;
+                case 'intuition':
+                    this.intuition = Math.max(1, this.intuition + by);
+                    break;
+                case 'charisma':
+                    this.charisma = Math.max(1, this.charisma + by);
+                    break;
+                default: break; // magic, resonance, reach, armor-bonus: no quality moves them
+            }
         }
     }
     /**
      * The single tap every pool reads qualities through (cf. augBonus).
      *
+     * DATA, NOT A SWITCH (2026-09-04). Every number below used to be a
+     * `case` here; each one now lives on its own quality in qualities.ts
+     * as an `effects` entry, in the same vocabulary gear and chrome
+     * already speak. A quality that adds dice therefore needs no edit to
+     * this method -- which is the property that matters, because the
+     * cost of the old shape was that the catalog could only ever print a
+     * quality's PROSE while its actual numbers lived somewhere a reader
+     * could not reach.
+     *
      * `perception` and `social` mirror the augBonus kinds of the same
-     * names, and are read at the same call sites, so a quality and a piece
+     * names and are read at the same call sites, so a quality and a piece
      * of chrome that do the same thing are added the same way.
      *
      * `sleaze` and `attack` are the two Matrix ACTIONS this engine names
@@ -1455,25 +1819,51 @@ export class Player extends AbstractPlayer {
      * a mark IS one of those two. They exist because Codeslinger and
      * Codeblock (p.72 / p.80) modify ONE chosen Matrix action rather than
      * Matrix work in general, so a `hacking`-wide bonus would be a
-     * different quality wearing the name.
+     * different quality wearing the name. In the DATA they are spelled
+     * `matrix-attack` / `matrix-sleaze`: EffectPool already spends the
+     * bare word `attack` on the COMBAT attack pool, and a quality that
+     * fired in a firefight because it shared a word with a Matrix action
+     * would be a bug nobody would look for.
      */
     qualityBonus(kind) {
         if (this.qualities.size === 0)
             return 0;
-        const has = (k) => this.qualities.has(k);
-        switch (kind) {
-            case 'sneak': return (has('catlike') ? 2 : 0) + (has('distinctive-style') ? -2 : 0);
-            case 'athletics': return has('natural-athlete') ? 2 : 0;
-            case 'matrix': return has('simsense-vertigo') ? -2 : 0;
-            case 'hacking': return (has('analytical-mind') ? 2 : 0) + this.qualityBonus('matrix');
-            case 'piloting': return has('juryrigger') ? 2 : 0;
-            case 'soak': return has('toughness') ? 1 : 0;
-            case 'healing': return has('quick-healer') ? 2 : 0;
-            case 'perception': return has('perceptive') ? 1 : 0;
-            case 'social': return (has('trustworthy') ? 1 : 0) + (has('uncouth') ? -2 : 0);
-            case 'sleaze': return has('codeslinger-hack-on-the-fly') ? 2 : 0;
-            case 'attack': return has('codeblock-brute-force') ? -2 : 0;
-        }
+        const property = kind === 'sleaze' ? 'matrix-sleaze' : kind === 'attack' ? 'matrix-attack' : kind;
+        let total = this.sumQualityEffects(property);
+        // The one FAN-IN, and it is a rule rather than a number: hacking is
+        // Matrix work, so anything that taxes the Matrix taxes hacking too
+        // (Simsense Vertigo, p.83). Kept here because it is a relationship
+        // between two pools, which no single quality can declare.
+        if (kind === 'hacking')
+            total += this.qualityBonus('matrix');
+        return total;
+    }
+    /**
+     * Dice the QUALITIES add to one pool or skill. Deliberately its own
+     * summation rather than a source inside applyingEffects(): the pools
+     * are read as `augBonus(k) + qualityBonus(k)` at call sites that do
+     * NOT also add gearBonus(k), and folding qualities into the shared
+     * effect walk would have made every site that DOES add gearBonus
+     * count a quality twice, silently, in a number nobody prints.
+     */
+    /**
+     * How much further this character may raise one skill or attribute
+     * than anyone else -- Aptitude's chosen skill (p.72), Exceptional
+     * Attribute's chosen attribute (p.73-74).
+     *
+     * The book states absolute numbers against ITS ceilings (a skill at
+     * 7 rather than 6 at creation, 13 rather than 12 after). This engine
+     * caps lower than the book does, so what carries across is the DELTA
+     * -- one step further than anyone else gets -- applied to whatever
+     * ceiling the engine is enforcing. Writing the book's 13 over a house
+     * cap of 7 would not be more faithful, it would just be a bigger
+     * number in the wrong system.
+     */
+    qualityCap(of, name) {
+        return this.capBonus(of, name);
+    }
+    sumQualityEffects(property) {
+        return this.sumEffects('dice', property, undefined, QUALITY_LANES);
     }
     // First Impression (p.74): the first social play of each job rolls +2.
     // Consumed like the edge boost and the liquid-courage die; re-armed
@@ -1576,7 +1966,7 @@ export class Player extends AbstractPlayer {
     get qualityNotoriety() {
         const plus = ['bad-luck', 'combat-paralysis', 'sinner-criminal']
             .filter(k => this.qualities.has(k)).length
-            + [...this.qualities].filter(k => k.startsWith('incompetent-')).length;
+            + (this.qualities.has('incompetent') ? 1 : 0);
         const minus = ['first-impression', 'lucky'].filter(k => this.qualities.has(k)).length;
         // BAD REP CARRIES ITS OWN NUMBER (p.79): "starts play with 3 points
         // of Notoriety" -- not one entry on p.368's list, which is why it is
@@ -1625,7 +2015,7 @@ export class Player extends AbstractPlayer {
     skillRating(name) {
         // Incompetent (p.81): the skill isn't low, it's ABSENT -- pinned to 0
         // no matter what the sheet or the fallback would say.
-        if (this.qualities.has(`incompetent-${name}`))
+        if (this.isForbidden('skill', name))
             return 0;
         const explicit = this.skills[name];
         if (typeof explicit === 'number')
@@ -2368,7 +2758,7 @@ export class Player extends AbstractPlayer {
         // A damage compensator (p.461) ignores boxes outright -- chrome that
         // stacks with High Pain Tolerance, unlike the pain editor's tier skip.
         const ignore = (!painEditor && this.qualities.has('high-pain-tolerance') ? 1 : 0)
-            + this.augBonus('wound-ignore');
+            + this.bonus('wound-ignore');
         const dmg = Math.max(0, this._damageTaken - ignore);
         const spill = Math.max(0, ignore - this._damageTaken);
         const stun = Math.max(0, this._stunTaken - spill);
@@ -2556,7 +2946,7 @@ export class Player extends AbstractPlayer {
                     armorPen: implant.ap,
                 };
             }
-            return { name: 'bare fists', damage: this.strength + this.augBonus('unarmed-damage'), poolBonus: 0, armorPen: 0 };
+            return { name: 'bare fists', damage: this.strength + this.bonus('unarmed-damage'), poolBonus: 0, armorPen: 0 };
         }
         const base = weapon.weaponDv + (weapon.dvAttribute === 'strength' ? this.strength : 0);
         return { name: weapon.name, damage: base, poolBonus: 0, armorPen: weapon.armorPen };
@@ -2658,7 +3048,7 @@ export class Player extends AbstractPlayer {
             // GUNNERY (canon: the vehicle-weapon skill) -- best-of with
             // piloting so pre-gunnery riggers lose nothing.
             const droneSkill = Math.max(this.skillRating('piloting'), this.skillRating('gunnery'));
-            return Math.max(0, this.logic + droneSkill + this.augBonus('piloting') + this.qualityBonus('piloting') + hot + this.woundModifier - this.sustainingPenalty);
+            return Math.max(0, this.logic + droneSkill + this.bonus('piloting') + hot + this.woundModifier - this.sustainingPenalty);
         }
         if (this.plane === 'matrix') {
             const hot = this.simMode === 'hot' ? 2 : 0;
@@ -2674,7 +3064,7 @@ export class Player extends AbstractPlayer {
             // for a technomancer, Resonance/2. A living persona's Attack is
             // Charisma (p.251) and rides in the bracket too. See
             // getAttackLimit, and utilities/dice.ts for what a limit does.
-            return Math.max(0, this.logic + matrixSkill + hot + this.augBonus('matrix') + this.qualityBonus('hacking') + (this.hasMetamagic('attack-upgrade') ? 1 : 0) + this.formMatrixBonus + this.woundModifier - this.sustainingPenalty);
+            return Math.max(0, this.logic + matrixSkill + hot + this.bonus('hacking') + (this.hasMetamagic('attack-upgrade') ? 1 : 0) + this.formMatrixBonus + this.woundModifier - this.sustainingPenalty);
         }
         if (this.plane === 'astral') {
             // ASTRAL COMBAT IS `Astral Combat + Willpower [Astral]` (p.315),
@@ -2701,7 +3091,6 @@ export class Player extends AbstractPlayer {
         // Power Points ride every strike. Chosen powers: Improved Ability
         // (Combat) is the striking bonus. See adeptAttackBonus.
         // Power Point (initiation, adepts): one more point of magic-as-muscle.
-        const adeptBonus = this.adeptAttackBonus();
         // THE WIRELESS SMARTGUN BONUS IS DICE, NOT ACCURACY (p.433), and it
         // has TWO TIERS this engine only had one of: "+1 if you're using
         // gear with a smartlink, +2 if you're using an augmentation for
@@ -2721,6 +3110,8 @@ export class Player extends AbstractPlayer {
         // bonus is the smartgun system talking to the smartlink.
         const drawnGun = this.weaponDrawn ? this.getCarriedWeapon() : null;
         const smartlink = drawnGun?.isSmartgun && FIREARM_SKILLS.includes(this.activeCombatSkill())
+            // Chrome again, and for the same reason: the tier is already
+            // decided above, and this branch is the implant's own dice.
             ? (this.smartlinkTier() === 'gear' ? 1 : this.augBonus('firearms'))
             : 0;
         // RUNNING COSTS YOU (p.162 Running Modifiers): -2 dice on everything
@@ -2731,7 +3122,15 @@ export class Player extends AbstractPlayer {
         // sprinted across a room to reach someone arrived shooting exactly
         // as straight as one who strolled -- and the movement budget's whole
         // point is that ground has a price.
-        return Math.max(0, this.agility + this.skillRating(this.activeCombatSkill()) + adeptBonus + this.getWeaponProfile().poolBonus + this.augBonus('attack') + this.gearBonus('attack') + this.gearBonus(this.activeCombatSkill()) + smartlink + this.woundModifier - this.sustainingPenalty - this.runningPenalty - this.encumbrancePenalty);
+        // ONE accessor for every source of attack dice: chrome, gear, the
+        // gear that names the SKILL rather than the pool (a smartlink says
+        // `firearms`), qualities, adept powers and the Power Point metamagic.
+        // This line used to add five of those by hand and a sixth was always
+        // one refactor away from being forgotten.
+        return Math.max(0, this.agility + this.skillRating(this.activeCombatSkill())
+            + this.adeptCompressedBonus() + this.getWeaponProfile().poolBonus
+            + this.bonus('attack', { skill: this.activeCombatSkill() })
+            + smartlink + this.woundModifier - this.sustainingPenalty - this.runningPenalty - this.encumbrancePenalty);
     }
     /**
      * The subdual pool: bare-hands work regardless of what's in the other
@@ -2739,8 +3138,8 @@ export class Player extends AbstractPlayer {
      * See subdue.ts.
      */
     getUnarmedAttackPool() {
-        const adeptBonus = this.adeptAttackBonus();
-        return Math.max(0, this.agility + this.skillRating('unarmed') + adeptBonus + this.augBonus('attack') + this.woundModifier - this.sustainingPenalty);
+        return Math.max(0, this.agility + this.skillRating('unarmed') + this.adeptCompressedBonus()
+            + this.bonus('attack', { skill: 'unarmed' }) + this.woundModifier - this.sustainingPenalty);
     }
     getDefensePool() {
         // Reaction plus HALF intuition (rounded down) -- full SR
@@ -2750,7 +3149,7 @@ export class Player extends AbstractPlayer {
         // reflex attribute but keep the same shape. Jumped-in: the rigger's
         // own reflexes drive the airframe, control rig sharpening handling.
         if (this.plane === 'drone') {
-            return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + this.augBonus('piloting') + this.qualityBonus('piloting') + this.woundModifier - this.sustainingPenalty);
+            return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + this.bonus('piloting') + this.woundModifier - this.sustainingPenalty);
         }
         if (this.plane === 'matrix') {
             const hot = this.simMode === 'hot' ? 1 : 0;
@@ -2767,7 +3166,7 @@ export class Player extends AbstractPlayer {
             // matrixAttribute is the persona's Firewall WHOLE: the deck's for a
             // decker, Willpower for a living persona (p.251), and a
             // commlink's Device Rating for anyone else (p.222/p.234).
-            return Math.max(0, this.intuition + this.matrixAttribute('firewall') + hot + this.augBonus('matrix') + this.qualityBonus('matrix') + this.formDefenseBonus + this.woundModifier - this.sustainingPenalty);
+            return Math.max(0, this.intuition + this.matrixAttribute('firewall') + hot + this.bonus('matrix') + this.formDefenseBonus + this.woundModifier - this.sustainingPenalty);
         }
         if (this.plane === 'astral') {
             return Math.max(0, this.intuition + Math.floor(this.magic / 2) + this.woundModifier - this.sustainingPenalty);
@@ -2776,9 +3175,9 @@ export class Player extends AbstractPlayer {
         // Wired reflexes read it faster still. Locked in someone's grapple
         // (p.195: a subdued character counts as PRONE against attacks): -2.
         // Improved Reflexes rides Reaction itself (p.309), so it lands here too.
-        const adeptBonus = this.adeptDefenseBonus() + this.adeptReactionBonus();
         const grappled = this.grappledBy ? 2 : 0;
-        return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + adeptBonus + this.augBonus('defense') + this.gearBonus('defense') + this.woundModifier - this.sustainingPenalty - grappled - this.encumbrancePenalty);
+        return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + this.adeptCompressedBonus(false)
+            + this.bonus('defense') + this.woundModifier - this.sustainingPenalty - grappled - this.encumbrancePenalty);
     }
     getSoakPool() {
         // Matrix: firewall -- Logic plus the DECK's quality (your deck is your
@@ -2805,13 +3204,15 @@ export class Player extends AbstractPlayer {
             }
             // A loaded Armor program hardens it further (+2, p.245 cited).
             const deck = this.activeDeck ?? this.getCyberdeck();
-            return Math.max(0, (deck?.deviceRating ?? 0) + this.matrixAttribute('firewall') + this.gearBonus('matrix-soak'));
+            return Math.max(0, (deck?.deviceRating ?? 0) + this.matrixAttribute('firewall') + this.bonus('matrix-soak'));
         }
         if (this.plane === 'astral') {
             return Math.max(0, this.willpower);
         }
         // Mystic Armor (p.309): the adept power is armor that was never worn.
-        return Math.max(0, this.body + this.getArmorValue() + this._sustainedArmor + this.adeptArmorBonus() + this.augBonus('soak') + this.qualityBonus('soak') + this.gearBonus('soak'));
+        // The armor spell arrives through the sustained lane now, in
+        // bonus('soak'), rather than as a term of its own.
+        return Math.max(0, this.body + this.getArmorValue() + this.adeptArmorBonus() + this.bonus('soak'));
     }
     /**
      * THE INITIATIVE ATTRIBUTE -- what the dice are added TO (p.159,
@@ -2929,7 +3330,7 @@ export class Player extends AbstractPlayer {
             // of bug to have reported: the archetype it works for never sees
             // it, and the one it fails for has nothing to compare against.
             // matrixAttribute answers both cases from one place.
-            return Math.max(0, this.matrixAttribute('dataProcessing') + this.intuition + this.augBonus('matrix') + this.qualityBonus('matrix') + this.woundModifier);
+            return Math.max(0, this.matrixAttribute('dataProcessing') + this.intuition + this.bonus('matrix') + this.woundModifier);
         }
         if (this.plane === 'astral') {
             // Intuition x 2 (p.159 chart, p.314 astral attributes).
@@ -2950,7 +3351,9 @@ export class Player extends AbstractPlayer {
         // cannot be computed from what is stored. The flat +2 is kept as the
         // engine's standing two-hit stand-in rather than inventing a dice
         // grant the save file cannot justify. Reported, not guessed.
-        const spellReflexes = this.sustainedReflexes ? 2 : 0;
+        // Increase Reflexes declares its own +2 on the score now
+        // (spells.ts), read through the initiative arm.
+        const spellReflexes = this.initiativeBonus('score');
         // Improved Reflexes (p.309): +level Reaction, and Reaction feeds the
         // initiative score (p.160) -- the adept's speed is body speed.
         return Math.max(0, this.reaction + this.adeptReactionBonus() + this.intuition + arBonus + spellReflexes + this.woundModifier);
@@ -2992,7 +3395,9 @@ export class Player extends AbstractPlayer {
         // Improved Reflexes (p.309): "+1 Initiative Die" per level -- body
         // speed, so it rides the meat line beside the chrome, and the 5D6
         // ceiling in rollInitiativeScore governs it like every other source.
-        return Math.max(1, 1 + this.augBonus('initiative') + this.adeptReactionBonus());
+        // Chrome initiative and Improved Reflexes both declare `initiative`,
+        // so the lane carries the pair.
+        return Math.max(1, 1 + this.bonus('initiative'));
     }
     /**
      * If an edge boost is armed (see commands/edge.ts), consume it: returns
@@ -3140,30 +3545,47 @@ export class Player extends AbstractPlayer {
      * Combat Sense. The Power Point metamagic stays what it always was --
      * a point of magic-as-muscle on the STRIKING side only.
      */
+    /**
+     * The COMPRESSED adept's flat bonus, or zero for anyone who chose
+     * powers. Split out of adeptAttackBonus so the combat pools can read
+     * `bonus()` for every other source without counting the chosen powers
+     * twice -- they arrive through the adept lane, and this is the only
+     * part of the adept that never became data.
+     */
+    adeptCompressedBonus(withMetamagic = true) {
+        return this.adeptPowers === undefined ? this.adeptPoolBonus(withMetamagic) : 0;
+    }
     adeptAttackBonus() {
+        // The COMPRESSED model is the one thing here that is not data: a save
+        // written before powers could be chosen has no `adeptPowers` at all
+        // and gets floor(pp/2) as a flat pool bonus. It is a legacy shape,
+        // not a rule, and the two models never stack.
         if (this.adeptPowers === undefined)
             return this.adeptPoolBonus();
-        return (this.adeptPowers['improved-ability-combat'] ?? 0)
-            + (this.hasMetamagic('power-point') ? 1 : 0);
+        // Improved Ability (Combat) from the adept lane, the Power Point
+        // metamagic from the initiate lane -- both declare `attack`, and the
+        // resolver adds them without either being named here.
+        return this.sumEffects('dice', 'attack', undefined, ART_LANES);
     }
     adeptDefenseBonus() {
         if (this.adeptPowers === undefined)
             return this.adeptPoolBonus(false);
-        return this.adeptPowers['combat-sense'] ?? 0;
+        // Combat Sense AND Improved Reflexes both land on defence (p.308-309).
+        return this.sumEffects('dice', 'defense', undefined, ADEPT_LANES);
     }
     /** Mystic Armor (p.309): +1 Armor per level. Zero under the compressed
      *  model -- the flat pool bonus never granted armor, so none is owed. */
     adeptArmorBonus() {
-        return this.adeptPowers?.['mystic-armor'] ?? 0;
+        return this.sumEffects('attribute', 'armor-bonus', undefined, ADEPT_LANES);
     }
-    /** Improved Reflexes (p.309): +level Reaction, read by the defence and
-     *  initiative math. Zero under the compressed model. */
+    /** Improved Reflexes (p.309): the initiative dice it adds. Zero under
+     *  the compressed model. */
     adeptReactionBonus() {
-        return this.adeptPowers?.['improved-reflexes'] ?? 0;
+        return this.sumEffects('dice', 'initiative', undefined, ADEPT_LANES);
     }
     /** Killing Hands (p.309): unarmed strikes deal PHYSICAL damage. */
     hasKillingHands() {
-        return (this.adeptPowers?.['killing-hands'] ?? 0) > 0;
+        return this.sumEffects('flag', 'killing-hands', undefined, ADEPT_LANES) > 0;
     }
     isAwakened() {
         return this.magic > 0;
@@ -3443,7 +3865,7 @@ export class Player extends AbstractPlayer {
     getMagicPool() {
         // A focus adds its Force to the tests it is bonded for (p.318): the
         // row's effects, scaled by Force (catalog v13).
-        const focusBonus = this.gearBonus('spellcasting');
+        const focusBonus = this.bonus('spellcasting');
         // SR-proper when the SPELLCASTING skill is rated: Magic + Spellcasting
         // for the Awakened, base + skill for a book-caster. Unrated falls back
         // to the legacy shapes (talent max(5, magic+2); scholar's flat 5), so
@@ -3470,9 +3892,18 @@ export class Player extends AbstractPlayer {
         // meat-plane combat pools.
         if (this.adept)
             return false;
-        const wanted = spellName.toLowerCase();
+        // THE FORMULA NAMES ITS SPELL, and this reads that name.
+        //
+        // It used to look for the spell name INSIDE the item name, which
+        // could only ever have worked if a formula were called after its
+        // spell. The five that shipped were named after their CATEGORY --
+        // "Combat Spell Formula" -- so the test never once returned true,
+        // and a mage could buy every formula in the shop and learn nothing.
+        // Formulae are one row per spell now, each declaring `teaches`.
+        //
+        // A Grimoire is still the blanket case: a whole book, any spell.
         const carried = this._inventory.getAllItems().some(i => i.category === Category.Grimoire ||
-            (i.category === Category.SpellFormula && i.name.toLowerCase().includes(wanted)));
+            (i.category === Category.SpellFormula && i.row?.teaches === spellName));
         if (this.isAwakened()) {
             return this.knownSpells === undefined
                 || this.knownSpells.includes(spellName)