@maka/maka-cli 5.5.0 → 5.7.0

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

@@ -3,6 +3,10 @@ import { Logger } from '../utilities/logger.js';
 import { Inventory } from './inventory.js';
 import { AbstractPlayer } from '../types/shared/abstracts.js';
 export const STANCE_CYCLE = ['manual', 'guarded', 'aggressive'];
+/** Meat and a jumped-in drone share the physical world. */
+export function isPhysicalPlane(plane) {
+    return plane === 'meat' || plane === 'drone';
+}
 export const SKILL_NAMES = [
     'firearms', 'blades', 'unarmed',
     'sneaking', 'perception', 'athletics',
@@ -166,13 +170,28 @@ export class Player extends AbstractPlayer {
     canPerceive(other) {
         if (this.plane === other.plane)
             return true;
-        return this.plane === 'astral' && other.plane === 'meat';
+        // A drone is a physical machine in the meat world: meat sees it, its
+        // sensors see meat -- and combat between them is ordinary physics.
+        if (isPhysicalPlane(this.plane) && isPhysicalPlane(other.plane))
+            return true;
+        return this.plane === 'astral' && isPhysicalPlane(other.plane);
+    }
+    /** Whether these two can trade physical blows (see attack.ts targeting). */
+    sharesCombatPlane(other) {
+        return this.plane === other.plane
+            || (isPhysicalPlane(this.plane) && isPhysicalPlane(other.plane));
     }
     // True while an AI-driven action is parked waiting for an in-flight
     // exchange to settle (CombatExchange.waitForLull). One queued action per
     // actor: a second colliding attempt is refused outright instead of
     // stacking a burst of delayed attacks behind the same lull.
     waitingForLull = false;
+    // Death-resolution claim (CombatExchange.resolveDeath): set
+    // SYNCHRONOUSLY by the first resolution to reach this actor, so a
+    // concurrent kill (autopilot + typed action racing -- a real session
+    // crashed on the second removeActor) skips cleanly instead of
+    // narrating a second death during the first one's narration beats.
+    deathClaimed = false;
     // Combat attributes (see ICombatAttributes). Defaults make an unseeded
     // actor a competent-but-mortal street-level runner; seeds can override
     // per-NPC to make a hardened enforcer or a soft civilian.
@@ -225,8 +244,192 @@ export class Player extends AbstractPlayer {
         this.resonance = config.combat?.resonance ?? 0;
         this.adept = config.combat?.adept ?? false;
         this.skills = { ...(config.combat?.skills ?? {}) };
+        // Essence bookkeeping needs the UNAUGMENTED talent to burn down from
+        // (see installAug) -- capture it before any 'ware lands.
+        this.baseMagic = this.magic;
+        this.baseResonance = this.resonance;
         this._equipment = this.initializeEquipment();
     }
+    // ==================== Augmentations (see augmentations.ts) ====================
+    /** Everyone is born whole. */
+    static ESSENCE_MAX = 6;
+    // What's left of the meat. Burned permanently by installAug; hitting 0
+    // is refused at the clinic -- there'd be nothing left to cut away.
+    essence = Player.ESSENCE_MAX;
+    // The unaugmented Magic/Resonance, from which essence loss burns down
+    // (SR5e: each full point of essence lost -- ROUNDED UP -- costs one).
+    // `magic`/`resonance` above stay the EFFECTIVE values every pool reads.
+    baseMagic = 0;
+    baseResonance = 0;
+    /** Installed 'ware, by catalog key (see AUGMENTATIONS). */
+    augmentations = new Set();
+    hasAug(key) {
+        return this.augmentations.has(key);
+    }
+    /** Full essence points lost, rounded up -- the toll Magic/Resonance pay. */
+    get essenceBurn() {
+        return Math.ceil(Player.ESSENCE_MAX - this.essence - 1e-9);
+    }
+    /**
+     * Burns the essence and records the 'ware. No gating here -- the clinic
+     * (commands/install.ts) owns the refusals (essence floor, conflicts,
+     * payment); archetype starting chrome installs through this too.
+     */
+    installAug(aug) {
+        this.augmentations.add(aug.key);
+        // One-decimal arithmetic: 6 - 0.1 - 0.2 must read 5.7, not 5.6999....
+        this.essence = Math.round((this.essence - aug.essence) * 10) / 10;
+        const burn = this.essenceBurn;
+        this.magic = Math.max(0, this.baseMagic - burn);
+        this.resonance = Math.max(0, this.baseResonance - burn);
+    }
+    /**
+     * 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.
+     */
+    augBonus(kind) {
+        if (this.augmentations.size === 0)
+            return 0;
+        const has = (k) => this.augmentations.has(k);
+        const reflexes = (has('wired-reflexes-2') ? 2 : has('wired-reflexes-1') ? 1 : 0) + (has('synaptic-booster') ? 1 : 0);
+        switch (kind) {
+            case 'initiative': return reflexes;
+            case 'defense': return reflexes;
+            case 'attack': return has('muscle-toner') ? 1 : 0;
+            case 'firearms': return has('smartlink') ? 2 : 0;
+            case 'soak': return (has('bone-lacing') ? 1 : 0) + (has('dermal-plating') ? 2 : 0);
+            case 'unarmed-damage': return has('bone-lacing') ? 2 : 0;
+            case 'perception': return has('cybereyes') ? 2 : 0;
+            case 'matrix': return has('datajack') ? 1 : 0;
+            case 'piloting': return has('control-rig') ? 2 : 0;
+        }
+    }
+    // ==================== Qualities (see qualities.ts) ====================
+    // SR5e's traits (p.71-85), baked into the archetype at creation
+    // (outfitArchetype). Every entry in the catalog has a real mechanical
+    // hook; the ones that read as flat pool nudges all tap through
+    // qualityBonus below, the same single-switch pattern as augBonus.
+    /** Installed qualities, by catalog key (see QUALITIES). */
+    qualities = new Set();
+    hasQuality(key) {
+        return this.qualities.has(key);
+    }
+    /**
+     * Records a quality and applies its one-time creation effect. Lucky is
+     * the only quality that edits an attribute (RAW raises the Edge ceiling;
+     * with no attribute point-buy here, the point lands directly).
+     */
+    addQuality(key) {
+        if (this.qualities.has(key))
+            return;
+        this.qualities.add(key);
+        if (key === 'lucky') {
+            this.edge += 1;
+            this.edgeRemaining += 1;
+        }
+    }
+    /** The single tap every pool reads qualities through (cf. augBonus). */
+    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;
+        }
+    }
+    // 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
+    // with the per-job resets in refreshEdge.
+    _firstImpressionUsed = false;
+    /** Spends the first impression: +2 for the social roll happening NOW. */
+    consumeFirstImpression() {
+        if (!this.qualities.has('first-impression') || this._firstImpressionUsed)
+            return 0;
+        this._firstImpressionUsed = true;
+        return 2;
+    }
+    /** SINner tax (p.84-85): the cut every payout loses to having a file. */
+    get sinTaxRate() {
+        if (this.qualities.has('sinner-corp'))
+            return 0.20;
+        if (this.qualities.has('sinner-criminal') || this.qualities.has('sinner-national'))
+            return 0.15;
+        return 0;
+    }
+    // Combat Paralysis (p.80): armed by beginExchange when a FRESH fight
+    // opens, consumed by the initiative roll-off -- pool halved, then the
+    // freeze passes (subsequent exchanges of the same fight roll normally).
+    paralysisFreeze = false;
+    // ==================== Initiation & Submersion (SR5e p.324-326 / p.257-258) ====================
+    // The Awakened (and technomancer) endgame: karma-priced grades (10 +
+    // grade x3, see commands/initiate.ts) that lift the talent ceiling to
+    // 6 + grade and grant one METAMAGIC (or echo) each. Grade can never
+    // exceed the BASE talent (RAW). The picks live here as a Set so every
+    // pool can read them the same way it reads qualities and chrome.
+    initiationGrade = 0;
+    /** Metamagics (casters/adepts) and echoes (technomancers), by key. */
+    metamagics = new Set();
+    hasMetamagic(key) {
+        return this.metamagics.has(key);
+    }
+    // ==================== Reputation (SR5e p.367-368) ====================
+    // Three tracked scores. STREET CRED is earned karma made visible: one
+    // point per full 10 career karma (earned on the street -- creation
+    // karma doesn't count; the name starts unknown). NOTORIETY starts from
+    // the qualities (the book's own list) and grows from incidents --
+    // walking out on a job, cutting down someone mid-surrender -- each
+    // counted ONCE (RAW: never twice for the same incident). PUBLIC
+    // AWARENESS derives from both, plus a Distinctive Style everyone can
+    // describe to a Knight Errant sketch artist.
+    /** Total karma EARNED in play -- spending it doesn't touch this. */
+    careerKarma = 0;
+    // Each stain on the record, in the player's own fiction ("walked out
+    // on 'Tacoma Rain'"). The strings ARE the dedupe keys.
+    _notorietyReasons = [];
+    /** Records an incident once; false means this exact stain already stands. */
+    addNotoriety(reason) {
+        if (this._notorietyReasons.includes(reason))
+            return false;
+        this._notorietyReasons.push(reason);
+        return true;
+    }
+    get notorietyReasons() {
+        return this._notorietyReasons;
+    }
+    get streetCred() {
+        return Math.floor(this.careerKarma / 10);
+    }
+    /** The p.368 quality list, restricted to the qualities this game ships. */
+    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;
+        const minus = ['first-impression', 'lucky'].filter(k => this.qualities.has(k)).length;
+        return plus - minus;
+    }
+    get notoriety() {
+        return Math.max(0, this.qualityNotoriety + this._notorietyReasons.length);
+    }
+    get publicAwareness() {
+        return Math.floor((this.streetCred + this.notoriety) / 3)
+            + (this.qualities.has('distinctive-style') ? 1 : 0);
+    }
+    /**
+     * The dice a NAME is worth in shadow-side social work (haggle,
+     * persuade): cred minus the stories that undercut it. RAW makes cred a
+     * social LIMIT bonus; with no limit system here, net-rep dice carry
+     * the same idea -- and notoriety eating cred keeps it self-balancing.
+     */
+    get socialRep() {
+        return Math.max(0, this.streetCred - this.notoriety);
+    }
     // ======================== Skills (see SkillName) ========================
     /** Explicit per-skill ratings; anything absent resolves via skillRating(). */
     skills = {};
@@ -241,6 +444,10 @@ export class Player extends AbstractPlayer {
      * everything else is 0 (unskilled).
      */
     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}`))
+            return 0;
         const explicit = this.skills[name];
         if (typeof explicit === 'number')
             return Math.max(0, explicit);
@@ -628,7 +835,22 @@ export class Player extends AbstractPlayer {
      * at everything, including not getting shot.
      */
     get woundModifier() {
-        return -(Math.floor(this._damageTaken / 3) + Math.floor(this._stunTaken / 3));
+        const painEditor = this.augmentations.has('pain-editor');
+        // High Pain Tolerance (p.74): one box simply doesn't count toward
+        // modifiers -- taken off the physical track first, spilling to stun if
+        // there's nothing physical to ignore. RAW forbids stacking it with a
+        // pain editor, so the chrome wins when both are present.
+        const ignore = !painEditor && this.qualities.has('high-pain-tolerance') ? 1 : 0;
+        const dmg = Math.max(0, this._damageTaken - ignore);
+        const spill = Math.max(0, ignore - this._damageTaken);
+        const stun = Math.max(0, this._stunTaken - spill);
+        // Low Pain Tolerance (p.82): the -1 arrives every 2 boxes, not 3.
+        const step = this.qualities.has('low-pain-tolerance') ? 2 : 3;
+        const raw = Math.floor(dmg / step) + Math.floor(stun / step);
+        // A pain editor files the first wound tier under "later": the -1 never
+        // arrives, though everything past it still does.
+        const eased = painEditor ? Math.max(0, raw - 1) : raw;
+        return -eased;
     }
     /** Dead: the physical track is full. */
     isDown() {
@@ -680,10 +902,17 @@ export class Player extends AbstractPlayer {
         const filled = Math.min(max, this._damageTaken);
         return `${'■'.repeat(filled)}${'□'.repeat(max - filled)} (${filled}/${max})`;
     }
-    /** Clears stun boxes; returns how many were actually recovered. */
+    /**
+     * Clears stun boxes; returns how many were actually recovered. FATIGUE
+     * boxes (see lockedFatigue) are untouchable until their need is met --
+     * SR5e p.172: fatigue damage cannot be healed while the condition
+     * causing it still exists. Eating/sleeping unlocks them (markFed /
+     * markSlept), after which they heal like any stun.
+     */
     healStun(boxes) {
         const before = this._stunTaken;
-        this._stunTaken = Math.max(0, before - Math.max(0, Math.floor(boxes)));
+        const floor = Math.min(before, this.lockedFatigue);
+        this._stunTaken = Math.max(floor, before - Math.max(0, Math.floor(boxes)));
         return before - this._stunTaken;
     }
     /** The stun track, same rendering as conditionSummary(). */
@@ -702,7 +931,14 @@ export class Player extends AbstractPlayer {
         // Off the meat plane your gun is just a memory: Matrix combat runs on
         // attack programs (Logic-scaled), astral combat on raw will given
         // form (Magic-scaled). Hot-sim's deeper immersion sharpens the
-        // programs' bite.
+        // programs' bite. A jumped-in drone fights with its MOUNT (armed
+        // airframes only -- attack.ts refuses an unarmed recon frame).
+        if (this.plane === 'drone') {
+            const quality = this.riggedDrone?.qualityBonus ?? 0;
+            return this.droneArmed
+                ? { name: `${this.riggedDrone?.name ?? 'drone'} weapon mount`, damage: 2 + quality, poolBonus: 0 }
+                : { name: 'no weapon mounts', damage: 0, poolBonus: 0 };
+        }
         if (this.plane === 'matrix') {
             const hot = this.simMode === 'hot' ? 1 : 0;
             // The deck IS the arsenal: its quality feeds program damage the way
@@ -717,19 +953,21 @@ export class Player extends AbstractPlayer {
         if (this.plane === 'astral') {
             return { name: 'astral strike', damage: 2 + Math.floor(Math.max(1, this.magic) / 2), poolBonus: 0 };
         }
-        // Muscle drives melee: unarmed 1 + STR/2, melee weapons 2 + STR/2 +
-        // quality (a strength-3 actor lands exactly the old flat numbers).
-        // Firearms don't care how strong you are. A HOLSTERED weapon counts
-        // for nothing -- until it's drawn (brandish, or the auto-draw when an
-        // exchange opens), your hands are empty.
+        // Muscle drives melee, and the weapon CLASS drives everything else
+        // now (RAW gear pass, see Item.rangedBase/meleeBase/armorPen): a
+        // holdout no longer hits like a shotgun, and a knife's bite comes
+        // partly from ignoring armor. Quality still rides on top. A HOLSTERED
+        // weapon counts for nothing -- until it's drawn (brandish, or the
+        // auto-draw when an exchange opens), your hands are empty.
         const strengthBase = Math.floor(this.strength / 2);
         const weapon = this.weaponDrawn ? this.getCarriedWeapon() : null;
         if (!weapon) {
-            return { name: 'bare fists', damage: 1 + strengthBase, poolBonus: 0 };
+            // Bone lacing turns the fists themselves into weapons.
+            return { name: 'bare fists', damage: 1 + strengthBase + this.augBonus('unarmed-damage'), poolBonus: 0, armorPen: 0 };
         }
         const bonus = weapon.qualityBonus;
-        const base = weapon.category === Category.MeleeWeapon ? 2 + strengthBase : 4;
-        return { name: weapon.name, damage: base + bonus, poolBonus: bonus };
+        const base = weapon.category === Category.MeleeWeapon ? weapon.meleeBase + strengthBase : weapon.rangedBase;
+        return { name: weapon.name, damage: base + bonus, poolBonus: bonus, armorPen: weapon.armorPen };
     }
     /** The weapon riding in a hand slot, drawn or holstered. */
     getCarriedWeapon() {
@@ -754,14 +992,28 @@ export class Player extends AbstractPlayer {
     }
     /** Total soak dice from every equipped armor-category item. */
     getArmorValue() {
+        // RAW armor pass (p.436-437, compressed): the BODY piece carries the
+        // real protection (1 + quality, +1 for jacket/plate-class weight --
+        // RAW clothing 6 vs jacket 12), a helmet or shield adds its flat
+        // point, and trim (boots, gloves, arm/leg pieces) is flavor, not
+        // dice -- stacking four rated accessories used to out-armor the
+        // jacket they hung off.
         let total = 0;
         for (const group of Object.values(this._equipment)) {
             if (!group)
                 continue;
             for (const item of Object.values(group)) {
-                if (item && Player.ARMOR_CATEGORIES.has(item.category)) {
-                    total += 1 + item.qualityBonus;
-                }
+                if (!item || !Player.ARMOR_CATEGORIES.has(item.category))
+                    continue;
+                if (item.category === Category.Helmet)
+                    total += 1;
+                else if (item.category === Category.Shield)
+                    total += 2;
+                else if (item.category === Category.Boots || item.category === Category.Gloves
+                    || item.category === Category.ArmArmor || item.category === Category.LegArmor)
+                    total += 0;
+                else
+                    total += 1 + item.qualityBonus + (item.isHeavyArmor ? 1 : 0);
             }
         }
         return total;
@@ -769,21 +1021,33 @@ export class Player extends AbstractPlayer {
     getAttackPool() {
         // Plane decides which attribute drives the fight: meat is muscle
         // (Agility), the Matrix is mind (Logic, hot-sim +2), the astral is
-        // will (Willpower + half Magic). The SKILL is per-armament now (see
+        // will (Willpower + half Magic), and a jumped-in drone is GUNNERY --
+        // Logic + piloting through the control rig (its +2 rides
+        // augBonus('piloting')), hot-sim +1 (p.266: matrix bonuses apply to
+        // vehicle actions). The SKILL is per-armament now (see
         // activeCombatSkill / skillRating): firearms, blades, or unarmed in
         // the meat; hacking is cybercombat; astral strikes ride unarmed (will
         // given form). Wounds and sustaining drag everywhere.
+        if (this.plane === 'drone') {
+            const hot = this.simMode === 'hot' ? 1 : 0;
+            return Math.max(0, this.logic + this.skillRating('piloting') + this.augBonus('piloting') + this.qualityBonus('piloting') + hot + this.woundModifier - this.sustainingPenalty);
+        }
         if (this.plane === 'matrix') {
             const hot = this.simMode === 'hot' ? 2 : 0;
-            return Math.max(0, this.logic + this.skillRating('hacking') + Math.floor(this.resonance / 2) + hot + this.woundModifier - this.sustainingPenalty);
+            // Attack Upgrade echo (p.258): +1 on the offensive matrix pool.
+            return Math.max(0, this.logic + this.skillRating('hacking') + Math.floor(this.resonance / 2) + hot + this.augBonus('matrix') + this.qualityBonus('hacking') + (this.hasMetamagic('attack-upgrade') ? 1 : 0) + this.woundModifier - this.sustainingPenalty);
         }
         if (this.plane === 'astral') {
             return Math.max(0, this.willpower + Math.floor(this.magic / 2) + this.skillRating('unarmed') + this.woundModifier - this.sustainingPenalty);
         }
         // An adept's magic lives in their hands: half of it (rounded down)
         // rides every meat-plane strike -- killing hands, improved reflexes.
-        const adeptBonus = this.adept ? Math.floor(this.magic / 2) : 0;
-        return Math.max(0, this.agility + this.skillRating(this.activeCombatSkill()) + adeptBonus + this.getWeaponProfile().poolBonus + this.woundModifier - this.sustainingPenalty);
+        // Chrome rides here too: muscle toner on every swing, the smartlink
+        // only when the drawn armament is actually a firearm.
+        // Power Point (initiation, adepts): one more point of magic-as-muscle.
+        const adeptBonus = this.adept ? Math.floor(this.magic / 2) + (this.hasMetamagic('power-point') ? 1 : 0) : 0;
+        const smartlink = this.activeCombatSkill() === 'firearms' && this.weaponDrawn ? this.augBonus('firearms') : 0;
+        return Math.max(0, this.agility + this.skillRating(this.activeCombatSkill()) + adeptBonus + this.getWeaponProfile().poolBonus + this.augBonus('attack') + smartlink + this.woundModifier - this.sustainingPenalty);
     }
     /**
      * The subdual pool: bare-hands work regardless of what's in the other
@@ -791,34 +1055,44 @@ export class Player extends AbstractPlayer {
      * See subdue.ts.
      */
     getUnarmedAttackPool() {
-        const adeptBonus = this.adept ? Math.floor(this.magic / 2) : 0;
-        return Math.max(0, this.agility + this.skillRating('unarmed') + adeptBonus + this.woundModifier - this.sustainingPenalty);
+        const adeptBonus = this.adept ? Math.floor(this.magic / 2) + (this.hasMetamagic('power-point') ? 1 : 0) : 0;
+        return Math.max(0, this.agility + this.skillRating('unarmed') + adeptBonus + this.augBonus('attack') + this.woundModifier - this.sustainingPenalty);
     }
     getDefensePool() {
         // Reaction plus HALF intuition (rounded down) -- full SR
         // Reaction+Intuition turned text-paced exchanges into whiff-fests, so
         // gut feel contributes at half weight. Intuition 3 (the default) adds
         // +1 over the old reaction-only pool. Off-plane variants swap the
-        // reflex attribute but keep the same shape.
+        // 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);
+        }
         if (this.plane === 'matrix') {
             const hot = this.simMode === 'hot' ? 1 : 0;
-            return Math.max(0, this.intuition + Math.floor(this.logic / 2) + Math.floor(this.resonance / 2) + hot + this.woundModifier - this.sustainingPenalty);
+            return Math.max(0, this.intuition + Math.floor(this.logic / 2) + Math.floor(this.resonance / 2) + hot + this.augBonus('matrix') + this.qualityBonus('matrix') + this.woundModifier - this.sustainingPenalty);
         }
         if (this.plane === 'astral') {
             return Math.max(0, this.intuition + Math.floor(this.magic / 2) + this.woundModifier - this.sustainingPenalty);
         }
         // Combat sense: the adept's magic reads the fight before it happens.
+        // Wired reflexes read it faster still.
         const adeptBonus = this.adept ? Math.floor(this.magic / 2) : 0;
-        return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + adeptBonus + this.woundModifier - this.sustainingPenalty);
+        return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + adeptBonus + this.augBonus('defense') + this.woundModifier - this.sustainingPenalty);
     }
     getSoakPool() {
         // Matrix: firewall -- Logic plus the DECK's quality (your deck is your
         // armor); a technomancer's firewall is Willpower plus half resonance
         // (their mind guards itself). Astral: pure Willpower; worn armor is
-        // meat left behind.
+        // meat left behind. Drone: the HULL soaks -- airframe body scaled by
+        // build quality; the rider's armor is streets away with their body.
+        if (this.plane === 'drone') {
+            return Math.max(0, 4 + 2 * (this.riggedDrone?.qualityBonus ?? 0));
+        }
         if (this.plane === 'matrix') {
             if (this.isTechnomancer()) {
-                return Math.max(0, this.willpower + Math.floor(this.resonance / 2));
+                // Firewall Upgrade echo (p.258): the living persona hardens.
+                return Math.max(0, this.willpower + Math.floor(this.resonance / 2) + (this.hasMetamagic('firewall-upgrade') ? 1 : 0));
             }
             const deck = this.activeDeck ?? this.getCyberdeck();
             return Math.max(0, this.logic + (deck?.qualityBonus ?? 0));
@@ -826,7 +1100,7 @@ export class Player extends AbstractPlayer {
         if (this.plane === 'astral') {
             return Math.max(0, this.willpower);
         }
-        return Math.max(0, this.body + this.getArmorValue() + this._sustainedArmor);
+        return Math.max(0, this.body + this.getArmorValue() + this._sustainedArmor + this.augBonus('soak') + this.qualityBonus('soak'));
     }
     /**
      * Initiative: Reaction + Intuition (straight SR), plus the AR edge from
@@ -838,18 +1112,34 @@ export class Player extends AbstractPlayer {
     getInitiativePool() {
         // Matrix speed is thought-speed: Logic + Intuition, hot-sim +2 (the
         // whole point of running hot). Astral forms move at the speed of
-        // intention: Intuition doubled.
+        // intention: Intuition doubled. Jumped-in rides VR reflexes (p.266:
+        // cold +2, hot +3 -- the engine's flattened take on the extra dice).
+        //
+        // NO sustaining penalty here (RAW spell pass): initiative is a score,
+        // not a TEST -- holding a spell slows what you DO, never when you get
+        // to do it. (This also lets Increase Reflexes actually work: its +2
+        // used to be eaten whole by its own -2 sustaining burden.) Wounds
+        // still slow the draw -- pain is not a spell.
+        if (this.plane === 'drone') {
+            const vr = this.simMode === 'hot' ? 3 : 2;
+            return Math.max(0, this.reaction + this.intuition + vr + this.woundModifier);
+        }
         if (this.plane === 'matrix') {
-            const hot = this.simMode === 'hot' ? 2 : 0;
-            return Math.max(0, this.logic + this.intuition + Math.floor(this.resonance / 2) + hot + this.woundModifier - this.sustainingPenalty);
+            // Overclocking echo (p.258): +1 while running hot -- the living
+            // persona accelerated past spec.
+            const hot = this.simMode === 'hot' ? 2 + (this.hasMetamagic('overclocking') ? 1 : 0) : 0;
+            return Math.max(0, this.logic + this.intuition + Math.floor(this.resonance / 2) + hot + this.augBonus('matrix') + this.qualityBonus('matrix') + this.woundModifier);
         }
         if (this.plane === 'astral') {
-            return Math.max(0, this.intuition * 2 + this.woundModifier - this.sustainingPenalty);
+            return Math.max(0, this.intuition * 2 + this.woundModifier);
         }
         const link = this._equipment.head?.commlink;
         // AR needs a link that's on you, broadcasting, and not hacked dark.
         const arBonus = link && !this.runningSilent && !this.arOffline ? link.qualityBonus : 0;
-        return Math.max(0, this.reaction + this.intuition + arBonus + this.woundModifier - this.sustainingPenalty);
+        // Increase Reflexes (sustained, cast.ts): the spellwork equivalent of
+        // wired reflexes, for as long as the caster holds it.
+        const spellReflexes = this.sustainedReflexes ? 2 : 0;
+        return Math.max(0, this.reaction + this.intuition + arBonus + this.augBonus('initiative') + spellReflexes + this.woundModifier);
     }
     /**
      * If an edge boost is armed (see commands/edge.ts), consume it: returns
@@ -863,11 +1153,60 @@ export class Player extends AbstractPlayer {
         this.edgeBoostArmed = false;
         return this.edge;
     }
-    /** New job, fresh luck -- and a fresh seat at the negotiating table. */
-    refreshEdge() {
-        this.edgeRemaining = this.edge;
+    // A comfortable home sharpens the luck: Middle+ lifestyles bank a bonus
+    // edge each job (set by Game from the active tier; 0 for NPCs).
+    lifestyleEdgeBonus = 0;
+    // ==================== Needs (SR5e p.56 / p.172) ====================
+    // Edge comes back from "a fulfilling meal and a good night's sleep" --
+    // so eating (use.ts) and sleeping (rest.ts, at a Residence) are tracked
+    // per JOB-CYCLE and cashed in at departure (Game.applyDepartureNeeds).
+    // Ignore a need across multiple cycles and RAW fatigue stacks: 1S, 2S,
+    // 3S... resisted Body + Willpower -- and fatigue stun is LOCKED (won't
+    // heal by rest, stim, food's own recovery, or the doc) until the need
+    // that caused it is finally met.
+    // Sessions start fresh off your own cot: fed, slept, sharp.
+    ateThisCycle = true;
+    sleptThisCycle = true;
+    hungerStreak = 0;
+    sleepStreak = 0;
+    _hungerFatigue = 0;
+    _sleepFatigue = 0;
+    /** Stun boxes no recovery can touch until their need is met. */
+    get lockedFatigue() {
+        return this._hungerFatigue + this._sleepFatigue;
+    }
+    /** A real meal: hunger resets and hunger-fatigue unlocks (heals normally now). */
+    markFed() {
+        this.ateThisCycle = true;
+        this.hungerStreak = 0;
+        this._hungerFatigue = 0;
+    }
+    /** A real sleep (a bed, not a jobsite corner): sleep debt resets and unlocks. */
+    markSlept() {
+        this.sleptThisCycle = true;
+        this.sleepStreak = 0;
+        this._sleepFatigue = 0;
+    }
+    /** Records freshly-taken stun as need-locked fatigue. */
+    addLockedFatigue(kind, boxes) {
+        if (kind === 'hunger')
+            this._hungerFatigue += Math.max(0, boxes);
+        else
+            this._sleepFatigue += Math.max(0, boxes);
+    }
+    /**
+     * New job bookkeeping -- the boost and the once-per-job haggle always
+     * reset, but the edge POOL only refills when the runner left fed and
+     * slept (SR5e p.56: a fulfilling meal and a good night's sleep).
+     */
+    refreshEdge(wellRested = true) {
+        if (wellRested) {
+            this.edgeRemaining = this.edge + this.lifestyleEdgeBonus;
+        }
         this.edgeBoostArmed = false;
         this.haggledThisJob = false;
+        // A new job is a new room to read: First Impression re-arms (p.74).
+        this._firstImpressionUsed = false;
     }
     // ======================== Magic (see commands/cast.ts) ========================
     // Two roads to casting. GEAR-DRIVEN: what a mundane can cast comes from
@@ -900,11 +1239,25 @@ export class Player extends AbstractPlayer {
     setSustainedArmor(bonus) {
         this._sustainedArmor = Math.max(0, Math.floor(bonus));
     }
+    // The other sustained spells (RAW gear/spell pass): invisibility bends
+    // light around the bearer (+3 on sneak contests, npc.ts), increase
+    // reflexes runs the nerves hot (+2 initiative). Each holds the standard
+    // -2 sustaining burden; cast again to release (cast.ts).
+    sustainedInvisibility = false;
+    sustainedReflexes = false;
     get sustainingPenalty() {
         // Each sustained effect costs -2 dice across the board: the armor
-        // spell, and open astral senses (see commands/assense.ts). They stack
-        // -- holding both is walking around half-blind.
-        return (this._sustainedArmor > 0 ? 2 : 0) + (this.astralPerceiving ? 2 : 0);
+        // spell, invisibility, hot reflexes, and open astral senses (see
+        // commands/assense.ts). They stack -- holding two is walking around
+        // half-blind. Dumpshock disorientation (p.229) rides the same rail.
+        // QUICKENING (metamagic, p.326 adapted): the armor spell anchors into
+        // the world and sustains itself -- its -2 simply never bills.
+        const armorCost = this._sustainedArmor > 0 && !this.hasMetamagic('quickening') ? 2 : 0;
+        return armorCost
+            + (this.sustainedInvisibility ? 2 : 0)
+            + (this.sustainedReflexes ? 2 : 0)
+            + (this.astralPerceiving ? 2 : 0)
+            + (this.dumpshocked ? 2 : 0);
     }
     // Astral perception (see commands/assense.ts): senses held OPEN as a
     // sustained state -- passive aura reads, at -2 dice to everything else.
@@ -915,9 +1268,40 @@ export class Player extends AbstractPlayer {
     // Sneaking-vs-Perception rolls per witness (NPC.see). Broken by any
     // loud act -- attacking, casting, speaking, brandishing, calling.
     sneaking = false;
+    // ==================== Jumped-in rigging (commands/jump.ts) ====================
+    // The drone currently being ridden while plane === 'drone': the item
+    // whose hull track (Item.droneDamage) eats what would hit the rider,
+    // whose quality feeds the drone pools, and whose destruction is a
+    // DUMPSHOCK (see planes.ts leaveDrone).
+    riggedDrone;
+    /** Whether the ridden drone carries a weapon mount (name/description duck-typing). */
+    get droneArmed() {
+        const d = this.riggedDrone;
+        if (!d)
+            return false;
+        return /armed|combat|gun|roto|assault|sentry|weapon/i.test(`${d.name} ${d.description ?? ''}`);
+    }
+    // Dumpshock disorientation (SR5e p.229): -2 on everything for
+    // (10 - Willpower) minutes after a forced dump, wall-clock -- the
+    // penalty rides sustainingPenalty so every pool already feels it.
+    dumpshockedUntil = 0;
+    get dumpshocked() {
+        return Date.now() < this.dumpshockedUntil;
+    }
     // One haggle per job (see commands/haggle.ts); reset with the edge pool
     // on each new job (refreshEdge).
     haggledThisJob = false;
+    // A drink in you (see use.ts): +1 die on the next social roll --
+    // persuade, haggle, bluff -- then it's gone. A second drink before it's
+    // spent doesn't stack, it just costs a stun box ("one too many").
+    liquidCourage = false;
+    /** Spends the drink: returns its bonus die for the roll happening NOW. */
+    consumeLiquidCourage() {
+        if (!this.liquidCourage)
+            return 0;
+        this.liquidCourage = false;
+        return 1;
+    }
     // Where this actor just came from and the direction BACK -- the HUD's
     // breadcrumb (see game.ts updateStatus / go.ts). Big scenes (the hub's
     // 18 rooms) made "which way did I come in" a real question. Cleared on