@maka/maka-cli 5.117.0 → 5.119.0

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

@@ -1,3 +1,4 @@
+import { getQuality, resolveQualityKey } from '../qualities.js';
 import { isAspectKey } from '../aspects.js';
 import { hint } from '../utilities/hints.js';
 import { Category } from '../types/shared/item-enum.js';
@@ -11,45 +12,22 @@ import { physicalLimit } from '../utilities/grapple.js';
 import { astralLimit } from '../utilities/limits.js';
 import { Inventory } from './inventory.js';
 import { AbstractPlayer } from '../types/shared/abstracts.js';
-export const STANCE_CYCLE = ['manual', 'guarded', 'aggressive'];
+export const STANCE_CYCLE = ['manual', 'non-lethal', 'lethal'];
+/** The old names, still accepted from saves and the stance command. */
+export const STANCE_ALIASES = { guarded: 'non-lethal', aggressive: 'lethal', nonlethal: 'non-lethal', 'non lethal': 'non-lethal' };
+export function normalizeStance(v) {
+    const k = (v ?? 'manual').toLowerCase();
+    return STANCE_ALIASES[k] ?? (STANCE_CYCLE.includes(k) ? k : 'manual');
+}
 /** Meat and a jumped-in drone share the physical world. */
 export function isPhysicalPlane(plane) {
     return plane === 'meat' || plane === 'drone';
 }
-/**
- * ARE THESE TWO STANDING ON THE SAME SIDE OF A HOST'S WALL?
- *
- * The companion to fileReach, and it exists for the same reason: the
- * boundary was being asked about in more than one place and the copies
- * disagreed. fileReach settled it for FILES; nothing settled it for
- * ICONS, so `look` honoured insideHost while every verb that picks a
- * target read the room's raw actor list and saw straight through the
- * wall. A technomancer standing inside a host was told "Empty
- * architecture -- turning geometry and nothing in it worth the trip" by
- * one surface and offered those same two IC as spike targets by the
- * next.
- *
- * CANON MAKES THE PANEL BINDING, not the target list. Inside a host you
- * see and interact with the icons inside it and not the ones outside,
- * and from the grid the inside is unreachable (p.246) -- and threading
- * adds its own half of the same rule: "You can only use complex forms
- * on icons you've spotted" (p.251). An icon the room refuses to name is
- * an icon nobody has spotted, so targeting it was never legal.
- *
- * BOTH IN THE SAME ROOM IS THE PRECONDITION, and every caller has it --
- * these are room-scoped target lists. Given that, comparing insideHost
- * directly is the whole rule: both undefined means both are out on the
- * open grid, both equal to the room means both are inside its
- * architecture. There is deliberately no third state.
- *
- * MEAT AND ASTRAL ACTORS PASS TRIVIALLY, which is correct and not an
- * oversight: insideHost is persona state, so a body in the room has
- * none. The plane filters the callers already apply are what keep those
- * actors out of a Matrix target list; this function answers one question
- * and is not a second plane check.
- */
 export function sameHostSide(actor, other) {
-    return actor.insideHost === other.insideHost;
+    // A real Player answers with its Host; a bare fixture ({ insideHost })
+    // answers with whatever it carries. Both sides read the same way.
+    const sideOf = (p) => p.hostInside ?? p.insideHost;
+    return sideOf(actor) === sideOf(other);
 }
 export const SKILL_NAMES = [
     'blades', 'clubs', 'unarmed', 'archery', 'free-fall',
@@ -426,7 +404,68 @@ export class Player extends AbstractPlayer {
      * Session state like hostAlert and linkLockedBy: leaving the Matrix
      * ends it, so nothing here is persisted.
      */
-    insideHost;
+    /**
+     * WHERE THE PERSONA IS (increment 2 of the Matrix position model): on a
+     * grid, or inside a host it entered from one. Session-only, like
+     * bodyRoom. The body stays in currentLocation on every plane -- the
+     * persona never writes it. The setter fires the live-sheet beat, which
+     * is the beat the currentLocation setter used to fire on enter/exit.
+     * `grid` may be unknown (fixtures, and increment 2 itself): unknown is
+     * not "another grid", so it costs nothing.
+     */
+    _matrixPosition;
+    get matrixPosition() { return this._matrixPosition; }
+    set matrixPosition(v) {
+        const same = v === this._matrixPosition
+            || (v !== undefined && this._matrixPosition !== undefined && v.kind === this._matrixPosition.kind
+                && (v.kind === 'host' ? v.host === this._matrixPosition.host
+                    : v.grid?.key === this._matrixPosition.grid?.key));
+        if (same)
+            return;
+        this._matrixPosition = v;
+        this.noteConditionChanged();
+    }
+    /** The grid the persona rides, when it is on one. */
+    get currentGrid() {
+        return this._matrixPosition?.kind === 'grid' ? this._matrixPosition.grid : undefined;
+    }
+    /** The host the persona is inside, when it is inside one. */
+    get hostInside() {
+        return this._matrixPosition?.kind === 'host' ? this._matrixPosition.host : undefined;
+    }
+    /**
+     * @deprecated compat through increment 4 -- read hostInside / write
+     * matrixPosition. The room a host stands over, when inside one. The
+     * setter still builds the position so every old writer keeps working.
+     */
+    _compatInsideRoom;
+    get insideHost() { return this.hostInside?.over ?? this._compatInsideRoom; }
+    set insideHost(room) {
+        if (room) {
+            // A room you are inside of IS a host. Fixtures (and older callers)
+            // set insideHost on a plain Room; install the Host they meant.
+            if (!room.host)
+                room.hasNode = true;
+            const host = room.host;
+            if (!host) {
+                // Not a real Room (a fixture stub): remember it so the getter and
+                // sameHostSide still answer, without a position to stand on.
+                this._compatInsideRoom = room;
+                return;
+            }
+            this._compatInsideRoom = undefined;
+            this.matrixPosition = { kind: 'host', host, from: this.currentGrid ?? this.lastGrid };
+        }
+        else {
+            this._compatInsideRoom = undefined;
+            if (this._matrixPosition?.kind === 'host')
+                this.matrixPosition = { kind: 'grid', grid: this._matrixPosition.from };
+        }
+    }
+    /** The grid last stood on, so an exit built through the old setter returns there. */
+    get lastGrid() {
+        return this._matrixPosition?.kind === 'host' ? this._matrixPosition.from : this._matrixPosition?.grid;
+    }
     /**
      * MATRIX ATTRIBUTES BURNED OFF BY IC (p.248): Acid eats Firewall,
      * Binder eats Data Processing, Jammer eats Attack, Marker eats Sleaze.
@@ -544,7 +583,29 @@ export class Player extends AbstractPlayer {
             return true;
         if (this.hasAug('datajack'))
             return true;
-        return this._inventory.getAllItems().some(i => i.category === Category.Electronics && /\btrodes?\b/i.test(i.name));
+        return this.dniSource() !== null;
+    }
+    /** True for the one Electronics item that is a trode net (p.439-440). */
+    static isTrodeNet(item) {
+        return item.category === Category.Electronics && /\btrodes?\b/i.test(item.name);
+    }
+    /**
+     * WHAT CARRIES THE DIRECT NEURAL INTERFACE, for the equipment panel and
+     * the jack-in gate: a living persona, an implanted datajack, a trode net
+     * worn on the head, or one still in the bag (it works from there too --
+     * the engine has never made the player put it on, and a net in the bag
+     * was the only place it could live before the head slot existed).
+     */
+    dniSource() {
+        if (this.isTechnomancer())
+            return { kind: 'technomancer' };
+        if (this.hasAug('datajack'))
+            return { kind: 'datajack' };
+        const worn = this._equipment.head?.trodes;
+        if (worn)
+            return { kind: 'trodes', worn: true, item: worn };
+        const bagged = this._inventory.getAllItems().find(i => Player.isTrodeNet(i));
+        return bagged ? { kind: 'trodes', worn: false, item: bagged } : null;
     }
     /**
      * THE PRICE OF SILENCE (canon p.235-236 "Running Silent",
@@ -647,7 +708,13 @@ export class Player extends AbstractPlayer {
         dataProcessing: 'Data Processing', firewall: 'Firewall',
     };
     /** The undamaged array, before any IC reduction. */
+    /** Set on an IC actor (utilities/ic-actors.ts): "IC uses the Matrix attributes of its host" (p.247). */
+    icHost;
+    /** The IC kind an IC actor was launched as -- the name the host's running list carries. */
+    icKind;
     baseMatrixAttribute(kind) {
+        if (this.icHost)
+            return this.icHost.attributes()[kind];
         if (this.isTechnomancer()) {
             switch (kind) {
                 case 'attack': return this.charisma;
@@ -922,7 +989,13 @@ export class Player extends AbstractPlayer {
     /** Routes Matrix combat damage into the jacked-in deck's hardware track. */
     takeMatrixDamage(boxes) {
         const deck = this.getAnyCyberdeck();
-        return deck ? deck.takeDeckDamage(boxes) : 0;
+        const taken = deck ? deck.takeDeckDamage(boxes) : 0;
+        // DECK DAMAGE BEATS (web report 2026-09-02: "the damage to the deck is not moving in realtime"):
+        // the Item has no path to its owner, so the owner fires here, and the
+        // exchange and rest fire on their own deck writes.
+        if (taken > 0)
+            this.noteConditionChanged();
+        return taken;
     }
     get matrixCrashed() {
         return this.getAnyCyberdeck()?.isBricked ?? false;
@@ -1145,7 +1218,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).
      */
-    addQuality(key) {
+    /** 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. */
+    qualityRating(key) {
+        if (!this.qualities.has(key))
+            return 0;
+        return this.qualityRatings.get(key) ?? 1;
+    }
+    addQuality(rawKey, rating) {
+        // A legacy "<key>-1" resolves to the rated key at 1 (qualities.ts).
+        const resolved = resolveQualityKey(rawKey);
+        const key = resolved.key;
+        const q = getQuality(key);
+        if (q?.maxRating) {
+            const r = Math.max(1, Math.min(q.maxRating, Math.floor(rating ?? resolved.rating)));
+            this.qualityRatings.set(key, r);
+        }
         if (this.qualities.has(key))
             return;
         this.qualities.add(key);
@@ -1371,7 +1460,8 @@ export class Player extends AbstractPlayer {
                 ears: null,
                 mouth: null,
                 nose: null,
-                commlink: null
+                commlink: null,
+                trodes: null
             },
             torso: {
                 clothing: null,
@@ -1379,31 +1469,26 @@ export class Player extends AbstractPlayer {
                 armorCoat: null,
                 backpack: null,
                 tacticalRig: null,
-                leftShoulder: null,
-                rightShoulder: null,
+                shoulder: null,
                 bandolier: null
             },
             legs: {
                 pants: null,
                 thighRig: null,
-                leftHip: null,
-                rightHip: null
+                hip: null
             },
             feet: {
                 boots: null,
-                leftAnkle: null,
-                rightAnkle: null
+                ankle: null
             },
             arms: {
-                leftBicept: null,
-                rightBicept: null,
-                leftForearm: null,
-                rightForearm: null,
+                bicep: null,
+                forearm: null,
                 cyberware: null
             },
             gloves: {
-                leftWrist: null,
-                rightWrist: null
+                gloves: null,
+                wrist: null
             },
             leftHand: {
                 weapon: null,
@@ -1598,8 +1683,143 @@ export class Player extends AbstractPlayer {
             this.logger.write("Failed to add item to inventory due to weight limits.");
             throw new Error("The item is too heavy to add to your inventory.");
         }
+        // A PROGRAM CHIP IS CONSUMED BY THE DECK (p.227, p.243): programs are
+        // files in deck storage, not gear in the pack. With a deck on you the
+        // chip installs and is gone; with none it waits in the bag for one.
+        // A PAPER GOES ON THE COMMLINK (p.443): with a device on you it lands
+        // there and never touches the pack; a license links to the SIN you
+        // present. With no device it waits in the bag like a chip does.
+        if (item.isPaper()) {
+            const device = this.paperDevice();
+            if (device) {
+                this.filePaper(device, item);
+                this.logger.write(`${item.name} filed on ${device.name}${item.linkedSin ? ` (linked to ${item.linkedSin})` : ''}.`);
+                this.noteConditionChanged();
+                return;
+            }
+        }
+        const key = item.programKey ?? item.softKey;
+        const deck = key ? (item.softKey ? this.softDevice() : this.getAnyCyberdeck()) : undefined;
+        if (key && deck) {
+            const fresh = deck.installProgram(key);
+            this.logger.write(`${item.name} ${fresh ? 'installed into' : 'already on'} ${deck.name} -- chip consumed.`);
+            this.noteConditionChanged();
+            return;
+        }
         this._inventory.addItem(item);
         this.logger.write(`Added ${item.name} to ${this.name}'s inventory.`);
+        // A new deck takes every chip that was waiting for it.
+        if (item.isCyberdeck() || item.category === Category.Commlink) {
+            this.sweepProgramChipsIntoDeck();
+            this.sweepPapersOntoDevice();
+        }
+    }
+    /** Where papers live (p.443): the commlink, else the deck -- the PAN's master. */
+    paperDevice() {
+        return this.commlinks()[0] ?? this.getAnyCyberdeck();
+    }
+    /** Every device that can hold papers, commlinks first. */
+    paperDevices() {
+        const deck = this.getAnyCyberdeck();
+        return [...this.commlinks(), ...(deck ? [deck] : [])];
+    }
+    /** Every paper on every device. */
+    papers() {
+        return this.paperDevices().flatMap(d => d.papers);
+    }
+    /** Files a paper on a device; a license links to the presented fake SIN (utilities/sin.ts resolves "presented"). */
+    filePaper(device, paper) {
+        if (paper.category === Category.License && !paper.linkedSin) {
+            const sins = this.papers().filter(p => p.category === Category.FakeSIN);
+            const chosen = sins.find(p => p.name === this.activeSin) ?? sins[0];
+            if (chosen)
+                paper.linkedSin = chosen.name;
+        }
+        device.papers.push(paper);
+        // A SIN arriving after an unlinked license takes it.
+        if (paper.category === Category.FakeSIN) {
+            for (const lic of this.papers())
+                if (lic.category === Category.License && !lic.linkedSin)
+                    lic.linkedSin = paper.name;
+        }
+    }
+    /** Burns a fake SIN: gone from its device, and every license linked to it goes with it (p.443). Returns the licenses lost. */
+    burnPaper(sin) {
+        const lost = [];
+        for (const device of this.paperDevices()) {
+            device.papers = device.papers.filter(p => {
+                if (p === sin)
+                    return false;
+                if (p.category === Category.License && p.linkedSin === sin.name) {
+                    lost.push(p);
+                    return false;
+                }
+                return true;
+            });
+        }
+        if (this.activeSin === sin.name)
+            this.activeSin = undefined;
+        this.noteConditionChanged();
+        return lost;
+    }
+    /** Every paper in the pack files onto the carried device; returns how many moved. */
+    sweepPapersOntoDevice() {
+        const device = this.paperDevice();
+        if (!device)
+            return 0;
+        let n = 0;
+        // SINs first, so a loose license has one to link to.
+        const loose = [...this._inventory.getAllItems()].filter(i => i.isPaper())
+            .sort((a, b) => (a.category === Category.License ? 1 : 0) - (b.category === Category.License ? 1 : 0));
+        for (const paper of loose) {
+            this._inventory.removeItem(paper.name);
+            this.filePaper(device, paper);
+            n++;
+        }
+        if (n > 0)
+            this.noteConditionChanged();
+        return n;
+    }
+    /** The commlinks on this runner: worn on the head, or in the pack. */
+    commlinks() {
+        const worn = this._equipment.head?.commlink;
+        return [...(worn ? [worn] : []), ...this._inventory.getAllItems().filter(i => i.category === Category.Commlink)];
+    }
+    /** Where a data soft lives (p.441-442): the deck if there is one, else a commlink. */
+    softDevice() {
+        return this.getAnyCyberdeck() ?? this.commlinks()[0];
+    }
+    /** A soft in the storage of any device on you -- a chip in the bag is not installed. */
+    hasSoft(key) {
+        const deck = this.getAnyCyberdeck();
+        return [...(deck ? [deck] : []), ...this.commlinks()].some(d => d.hasStored(key));
+    }
+    /**
+     * THE SOCIAL LIMIT (SR5 p.100-101): [(Charisma x 2) + Willpower + Essence]
+     * / 3, rounded up, with Essence rounded up first (p.95, p.100 -- the
+     * rounding rule is cited; the table row itself the RAG did not return,
+     * see rag-table-rows-missing). A Shopsoft adds one when buying or
+     * selling what it covers (p.442) -- see commands/haggle.ts.
+     */
+    get socialLimit() {
+        return Math.ceil((this.charisma * 2 + this.willpower + Math.ceil(this.essence - 1e-9)) / 3);
+    }
+    /** Every program chip in the pack installs into the carried deck; returns how many chips were consumed. */
+    sweepProgramChipsIntoDeck() {
+        const deck = this.getAnyCyberdeck();
+        const softHome = this.softDevice();
+        let n = 0;
+        for (const chip of [...this._inventory.getAllItems()]) {
+            const device = chip.programKey ? deck : chip.softKey ? softHome : undefined;
+            if (!device)
+                continue;
+            device.installProgram((chip.programKey ?? chip.softKey));
+            this._inventory.removeItem(chip.name);
+            n++;
+        }
+        if (n > 0)
+            this.noteConditionChanged();
+        return n;
     }
     removeInventory(item) {
         if (this._inventory.removeItem(item.name)) {
@@ -1616,7 +1836,7 @@ export class Player extends AbstractPlayer {
         if (!this.canEquip(item)) {
             return `You can't equip ${item.name}.`;
         }
-        const slotInfo = this.determineEquipmentSlot(item.category);
+        const slotInfo = this.slotForItem(item);
         if (!slotInfo) {
             return `${item.name} doesn't fit any known equipment slot.`;
         }
@@ -1629,7 +1849,7 @@ export class Player extends AbstractPlayer {
         let swapNotice = '';
         if (previousItem) {
             if (previousItem.name === item.name) {
-                return `You already have ${item.name} equipped in your ${group}.${slot} slot.`;
+                return `You already have ${item.name} on -- ${Player.slotWord(group, slot)}.`;
             }
             this.unequipBySlot(group, slot);
             swapNotice = ` (unequipped ${previousItem.name})`;
@@ -1643,7 +1863,21 @@ export class Player extends AbstractPlayer {
             this.weaponDrawn = false;
             return `You slide ${item.name} into your holster.${swapNotice}${hint(` "brandish" when you want it in hand.`)}`;
         }
-        return `You equipped ${item.name} in your ${group}.${slot} slot.${swapNotice}`;
+        return `You put on ${item.name} -- ${Player.slotWord(group, slot)}.${swapNotice}`;
+    }
+    /** The word a player would use for a slot -- never the key ("body armor", not "torso.armorVest"). */
+    static SLOT_WORDS = {
+        head: { eyes: 'eyes', skull: 'head', ears: 'ears', mouth: 'face', nose: 'nose', commlink: 'commlink', trodes: 'trode net' },
+        torso: { clothing: 'clothes', armorVest: 'body armor', armorCoat: 'coat', backpack: 'backpack', tacticalRig: 'rig', shoulder: 'shoulder', bandolier: 'bandolier' },
+        legs: { pants: 'legs', thighRig: 'thigh rig', hip: 'hip' },
+        feet: { boots: 'feet', ankle: 'ankle' },
+        arms: { forearm: 'forearm', bicep: 'upper arm', cyberware: 'arm implant' },
+        gloves: { gloves: 'hands', wrist: 'wrist' },
+        leftHand: { weapon: 'off hand', shield: 'shield arm', ring: 'ring', device: 'off hand' },
+        rightHand: { weapon: 'weapon hand', ring: 'ring', device: 'hand' },
+    };
+    static slotWord(group, slot) {
+        return Player.SLOT_WORDS[group]?.[slot] ?? `${group}.${slot}`;
     }
     /** True for the hand slots that hold a wielded weapon. */
     static isWeaponSlot(group, slot) {
@@ -1667,6 +1901,23 @@ export class Player extends AbstractPlayer {
         }
         return `No equipped item matches "${input}".`;
     }
+    /**
+     * The slot an ITEM wears in: the category decides (determineEquipmentSlot)
+     * except where the name has to -- a trode net is Electronics like a
+     * flashlight, and the flashlight has no slot. Kit devices (a deck, a
+     * drone, uninstalled 'ware) answer null: they are carried, not worn.
+     */
+    slotForItem(item) {
+        if (Player.isTrodeNet(item))
+            return { group: 'head', slot: 'trodes' };
+        if (item.category === Category.Cyberdeck || item.category === Category.Drone || item.category === Category.Cyberware)
+            return null;
+        return this.determineEquipmentSlot(item.category);
+    }
+    /** Everything in the bag that has a slot and is not in it -- armor left in the pack (a real save: Armor Clothing carried, nothing worn). */
+    wearablesInBag() {
+        return this._inventory.getAllItems().filter(i => this.slotForItem(i) !== null);
+    }
     determineEquipmentSlot(input) {
         const normalized = input.toLowerCase();
         switch (normalized) {
@@ -1708,10 +1959,10 @@ export class Player extends AbstractPlayer {
                 return { group: 'torso', slot: 'tacticalRig' };
             case 'backpack':
                 return { group: 'torso', slot: 'backpack' };
+            case 'shoulder holster':
             case 'left shoulder holster':
-                return { group: 'torso', slot: 'leftShoulder' };
             case 'right shoulder holster':
-                return { group: 'torso', slot: 'rightShoulder' };
+                return { group: 'torso', slot: 'shoulder' };
             case 'bandolier':
                 return { group: 'torso', slot: 'bandolier' };
             // LEGS
@@ -1722,39 +1973,38 @@ export class Player extends AbstractPlayer {
             case 'thigh rig':
             case 'thigh holster':
                 return { group: 'legs', slot: 'thighRig' };
+            case 'hip pouch':
             case 'left hip pouch':
-                return { group: 'legs', slot: 'leftHip' };
             case 'right hip pouch':
-                return { group: 'legs', slot: 'rightHip' };
+                return { group: 'legs', slot: 'hip' };
             // FEET
             case Category.Boots:
             case 'combat boots':
             case 'shoes':
                 return { group: 'feet', slot: 'boots' };
+            case 'anklet':
             case 'left anklet':
-                return { group: 'feet', slot: 'leftAnkle' };
             case 'right anklet':
-                return { group: 'feet', slot: 'rightAnkle' };
+                return { group: 'feet', slot: 'ankle' };
             // ARMS
             case Category.ArmArmor:
             case 'arm sleeve':
+            case 'bracer':
             case 'left forearm implant':
-                return { group: 'arms', slot: 'leftForearm' };
             case 'right forearm implant':
-                return { group: 'arms', slot: 'rightForearm' };
+                return { group: 'arms', slot: 'forearm' };
+            case 'armband':
             case 'left armband':
-                return { group: 'arms', slot: 'leftBicept' };
             case 'right armband':
-                return { group: 'arms', slot: 'rightBicept' };
+                return { group: 'arms', slot: 'bicep' };
             case Category.Cyberware:
                 return { group: 'arms', slot: 'cyberware' };
             // GLOVES / WRIST
             case Category.Gloves:
             case 'glove':
             case 'left glove':
-                return { group: 'gloves', slot: 'leftWrist' };
             case 'right glove':
-                return { group: 'gloves', slot: 'rightWrist' };
+                return { group: 'gloves', slot: 'gloves' };
             // WRIST-WORN gear -- a DocWagon band, a smartwatch, a med
             // bracelet (player note 2026-08-25: "docwagon wristband should
             // be wearable"). No new equipment GROUP was needed: the wrist
@@ -1767,9 +2017,9 @@ export class Player extends AbstractPlayer {
             case 'wristband':
             case 'bracelet':
             case 'watch':
-                return { group: 'gloves', slot: 'leftWrist' };
+            case 'left wrist':
             case 'right wrist':
-                return { group: 'gloves', slot: 'rightWrist' };
+                return { group: 'gloves', slot: 'wrist' };
             // LEFT HAND
             case Category.Shield:
                 return { group: 'leftHand', slot: 'shield' };
@@ -1802,14 +2052,14 @@ export class Player extends AbstractPlayer {
         }
         const itemToUnequip = groupRef[slot];
         if (!itemToUnequip) {
-            return `Nothing is equipped in the ${group}.${slot} slot.`;
+            return `Nothing on your ${Player.slotWord(group, slot)}.`;
         }
         this.addInventory(itemToUnequip);
         groupRef[slot] = null;
         // No weapon, nothing drawn -- keeps the flag honest for the next equip.
         if (Player.isWeaponSlot(group, slot))
             this.weaponDrawn = false;
-        return `You unequipped ${itemToUnequip.name} from your ${group}.${slot} slot.`;
+        return `You take off ${itemToUnequip.name} (${Player.slotWord(group, slot)}) and bag it.`;
     }
     hear(actor, message, opts) {
         // Cross-plane silence: a Matrix persona's chatter never reaches meat
@@ -2107,25 +2357,51 @@ export class Player extends AbstractPlayer {
         // 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;
+        return this.armorBreakdown().total;
+    }
+    /**
+     * ARMOR DOES NOT STACK (SR5 p.169, RAG-checked 2026-09-02): "only the
+     * highest Armor rating applies; all other pieces only add bulk". A helmet
+     * or shield is a "+" accessory and adds to that one piece (p.438). The
+     * old sum let a vest under a coat out-armor either -- the same deviation
+     * the trim rule below already closed for boots and gloves. `ignored` is
+     * what the player is wearing for nothing, so the panel can say so.
+     */
+    armorBreakdown() {
+        let piece = null;
+        let best = 0;
+        const extras = [];
+        const ignored = [];
         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))
                     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
+                if (item.category === Category.Helmet) {
+                    extras.push({ item, bonus: 1 });
+                    continue;
+                }
+                if (item.category === Category.Shield) {
+                    extras.push({ item, bonus: 2 });
+                    continue;
+                }
+                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);
+                    continue;
+                const value = 1 + item.qualityBonus + (item.isHeavyArmor ? 1 : 0);
+                if (value > best) {
+                    if (piece)
+                        ignored.push(piece);
+                    piece = item;
+                    best = value;
+                }
+                else {
+                    ignored.push(item);
+                }
             }
         }
-        return total;
+        return { total: best + extras.reduce((n, e) => n + e.bonus, 0), piece, extras, ignored };
     }
     getAttackPool() {
         // Plane decides which attribute drives the fight: meat is muscle
@@ -2819,6 +3095,15 @@ export class Player extends AbstractPlayer {
     get formDefenseBonus() {
         return this.sustainedForms.some(f => f.key === 'static-veil') ? 2 : 0;
     }
+    /** The Force each sustained spell was cast at (cast.ts records it) -- Focused Concentration reads it. */
+    sustainedForces = new Map();
+    noteSustainedForce(kind, force) {
+        this.sustainedForces.set(kind, force);
+    }
+    /** GREMLINS (p.81): the 1s a glitch needs, one fewer per rating, on external equipment -- the deck. */
+    get deckGremlins() {
+        return this.isTechnomancer() ? 0 : this.qualityRating('gremlins');
+    }
     get sustainingPenalty() {
         // Each sustained effect costs -2 dice across the board: the armor
         // spell, invisibility, hot reflexes, and open astral senses (see
@@ -2827,11 +3112,22 @@ export class Player extends AbstractPlayer {
         // 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.sustainedBarrier ? 2 : 0)
-            + (this.sustainedManaBarrier ? 2 : 0)
+        // FOCUSED CONCENTRATION (p.74, RAG-checked 2026-09-02): "sustain one
+        // spell with a Force equal to or less than your rating without
+        // penalty". One spell, whose Force the cast recorded; a spell with
+        // no recorded Force is not eligible (honest, not generous).
+        const spells = [
+            { cost: armorCost, force: this.sustainedForces.get('armor') },
+            { cost: this.sustainedInvisibility ? 2 : 0, force: this.sustainedForces.get('invisibility') },
+            { cost: this.sustainedReflexes ? 2 : 0, force: this.sustainedForces.get('reflexes') },
+            { cost: this.sustainedBarrier ? 2 : 0, force: this.sustainedBarrier?.force },
+            { cost: this.sustainedManaBarrier ? 2 : 0, force: this.sustainedManaBarrier?.force },
+        ];
+        const focus = this.qualityRating('focused-concentration');
+        const waived = focus > 0 ? spells.find(sp => sp.cost > 0 && sp.force !== undefined && sp.force <= focus) : undefined;
+        if (waived)
+            waived.cost = 0;
+        return spells.reduce((n, sp) => n + sp.cost, 0)
             + (this.astralPerceiving ? 2 : 0)
             + (this.dumpshocked ? 2 : 0)
             + this.sustainedForms.length * 2;