@maka/maka-cli 5.201.0 → 5.202.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.201.0",
+  "version": "5.202.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -715,5 +715,31 @@
 //     somebody happened to look -- the "wrong ability on a sprite is
 //     worse than a missing one" case. It wants the glitch contract in one
 //     place first, and that is its own piece of work.
-export const ENGINE_VERSION = '1.63.0';
+// 1.64.0 (2026-09-15): NPC KITS -- "everyone is basically naked."
+//   - NEW CATALOG KIND 'npc-kit' (v21): SR5 p.379-385's Professional
+//     Rating tiers 0-6 as rows, each the book's own statblock AND gear
+//     (npc-kits.ts reads them; catalog.ts npcKitFor). Before this every
+//     NPC was an attribute block: no armor (soak on Body alone), no
+//     weapon (bare fists, always melee).
+//   - SEED SHAPE: ISceneSeedJson.securityTier (the SITE's PR, never the
+//     campaign job number), IPlayerSeedJson.kit / lieutenant. The
+//     generator declares the tier from a closed 0-6 table, clamps it
+//     against the job number, and assigns a kit to every hostile
+//     deterministically -- the model never writes a slug.
+//   - THE PARTY NUDGE IS THE LIEUTENANT (p.380-381): a party that
+//     outguns the tier draws the printed lieutenant, and the group's PR
+//     and Group Edge read one higher. Never a kit from a tier above.
+//   - GROUP EDGE (p.380) on the CombatEncounter keyed by kit; MORALE
+//     (p.379-380) breaks a team to surrender at the book's casualty
+//     thresholds, PR 5-6 never. npc-combat-brain.ts is the gamemaster.
+//   - EPHEMERALS: gangers are the PR 1 kit, sweep officers the PR 3
+//     kit with a real Biometric Reader; bystanders stay unarmed.
+//     Scene.removeActor(name, {spill:false}) so a departing body takes
+//     its gun with it.
+//   - LOOT: worn armor is RUINED on a kill (Item.ruined -- rated 0,
+//     worth nothing, saved); guns and commlinks drop intact.
+//   - PURGED: the dead `firearms` skill key from the NPC prompt, the
+//     ganger constant and the seed doc; a seed still carrying it maps
+//     onto pistols/automatics/longarms at the boundary.
+export const ENGINE_VERSION = '1.64.0';
 //# sourceMappingURL=engine-version.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/npc-factory.js

@@ -28,6 +28,15 @@ export class NPCFactory {
             npc.setAuthoredAppearance(json.appearance);
         return npc;
     }
+    /**
+     * ONLY FOUR FIELDS CROSS HERE, on purpose. `startSpot`, `guarding`,
+     * `hostile`, `kit` and `lieutenant` are applied by scene-factory AFTER
+     * the NPC is placed (Steps 3 and 4.04), because each depends on
+     * something the constructor cannot see -- the room it stands in, the
+     * items heldBy already put in its hands. Adding one of them to this
+     * config would silently reorder it ahead of that. (`startingItems` is
+     * dropped too, and documented as ignored for NPCs in repro-scene.ts.)
+     */
     convertPlayerSeedToConstructorConfig(seed) {
         if (!seed.name) {
             throw new Error(`Cannot create NPC without a name`);
@@ -40,8 +49,35 @@ export class NPCFactory {
             playerName: seed.name,
             lifestyleChoices: seed.lifestyleChoices,
             startLocation,
-            combat: seed.combat
+            combat: seed.combat ? { ...seed.combat, skills: splitLegacySkills(seed.combat.skills) } : undefined,
         };
     }
 }
+/**
+ * A SEED STILL SPEAKING THE OLD SKILL NAMES (skills.ts, stage 3): the
+ * same group-purchase reading persistence.ts applies to saves -- a
+ * condensed `firearms: N` meant "good with guns, all of them", so it
+ * lands as Pistols, Automatics and Longarms at N (p.88) where none was
+ * set; `athletics: N` lands as Gymnastics, Running and Swimming. The
+ * retired keys are dropped so they cannot ride into `Player.skills` as
+ * dead entries. Mapped, never merely deleted: a "sharpshooter" the
+ * model wrote with the old key was a sharpshooter, not a nobody.
+ */
+export function splitLegacySkills(skills) {
+    if (!skills)
+        return undefined;
+    const out = { ...skills };
+    const spread = (legacy, onto) => {
+        const n = out[legacy];
+        if (n === undefined)
+            return;
+        if (n > 0)
+            for (const key of onto)
+                out[key] ??= n;
+        delete out[legacy];
+    };
+    spread('firearms', ['pistols', 'automatics', 'longarms']);
+    spread('athletics', ['gymnastics', 'running', 'swimming']);
+    return out;
+}
 //# sourceMappingURL=npc-factory.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-chunks.js

@@ -4,6 +4,7 @@ import { Logger } from '../utilities/logger.js';
 import { catalogAugmentations } from '../utilities/catalog.js';
 import { isOutdoorsPlace } from '../utilities/outdoors.js';
 import { clampDeviceKind } from '../utilities/affordances.js';
+import { clampSecurityTier, expectedStrengthFor, kitSlugForTier, maxSecurityTierFor, partyDrawsLieutenant } from '../npc-kits.js';
 /**
  * CHUNKED scene generation (see SceneSeedGenerator.generate for the
  * pipeline that drives this module). One monolithic whole-scene completion
@@ -195,6 +196,73 @@ function repairNote(previousError) {
 export function partyHeadcount(crew) {
     return (crew?.length ?? 0) + 1;
 }
+/**
+ * HOW HARD THIS TABLE HITS, per head, on the scale npc-kits.ts
+ * expectedStrengthFor uses for a grunt (attack pool + defense pool).
+ *
+ * REUSES THE NUMBERS THAT ALREADY EXIST rather than inventing a third
+ * formula: the leader's figure is exactly the "Combat calibration"
+ * line buildPlayerDossier prints (getAttackPool + getDefensePool), and
+ * a crew member's is the body + agility + logic + magic sum the hiring
+ * price already reads (Game.spawnCrew's asking cut), scaled onto the
+ * same axis. Averaged per head, because the lieutenant question is
+ * "does this party outclass the tier", not "how many of them are there"
+ * -- head count already scales the OPPOSITION COUNT (Scope, above).
+ *
+ * A dossier player that is not a real Player (the tests' stubs, a
+ * server-side draft with no engine handle) contributes nothing and the
+ * crew alone decides; no player and no crew is 0, which never draws a
+ * lieutenant.
+ */
+export function partyStrength(player, crew) {
+    const heads = [];
+    const p = player;
+    if (p && typeof p.getAttackPool === 'function' && typeof p.getDefensePool === 'function') {
+        heads.push(p.getAttackPool() + p.getDefensePool());
+    }
+    for (const m of crew ?? []) {
+        const c = m.combat;
+        heads.push(1.5 * ((c.body ?? 3) + (c.agility ?? 3) + (c.logic ?? 3) + (c.magic ?? 0)));
+    }
+    if (heads.length === 0)
+        return 0;
+    return heads.reduce((s, h) => s + h, 0) / heads.length;
+}
+/**
+ * SETTLE WHO GUARDS THIS PLACE (npc-kits.ts, SR5 p.379-385). Called once
+ * per accepted skeleton, after validateSkeleton and before the detail
+ * passes: clamps the declared securityTier against the campaign job
+ * number (a job #1 does not draw elite corporate security however the
+ * model felt about it), and decides whether the site posts its
+ * lieutenant -- p.380-381's own mechanism for a tougher group, and the
+ * whole of how opposition scales to a strong party. The lieutenant is
+ * the hostile guarding the prize's room if there is one, else the first
+ * hostile. Returns the notes for the generation log.
+ */
+export function settleSecurity(skeleton, campaignTier, player, crew) {
+    const notes = [];
+    const declared = skeleton.securityTier;
+    const settled = clampSecurityTier(declared, campaignTier);
+    if (declared !== settled) {
+        notes.push(`securityTier ${declared === undefined ? 'absent' : JSON.stringify(declared)} -> ${settled} (job #${campaignTier} fields at most PR ${maxSecurityTierFor(campaignTier)}).`);
+    }
+    skeleton.securityTier = settled;
+    const hostiles = skeleton.npcs.filter(n => n.name !== skeleton.client && n.hostile === true);
+    if (hostiles.length === 0) {
+        delete skeleton.lieutenant;
+        return notes;
+    }
+    const strength = partyStrength(player, crew);
+    if (!partyDrawsLieutenant(strength, settled)) {
+        delete skeleton.lieutenant;
+        return notes;
+    }
+    const prizeRoom = skeleton.items.find(i => i.name === skeleton.winCondition?.item)?.room;
+    const pick = hostiles.find(n => prizeRoom !== undefined && n.startLocation === prizeRoom) ?? hostiles[0];
+    skeleton.lieutenant = pick.name;
+    notes.push(`party strength ${strength.toFixed(1)} outguns PR ${settled} (expects ~${expectedStrengthFor(settled)}) -- ${pick.name} is the lieutenant.`);
+    return notes;
+}
 function buildTeamBlock(crew) {
     if (!crew || crew.length === 0)
         return '';
@@ -478,7 +546,19 @@ ${JSON_ONLY}
                        // again more per job after that
     "rewardItem"?: string // optional bonus: an items[].name with role "reward"
   },
-  "client": string // the npcs[].name of the run's CLIENT -- see CLIENT below
+  "client": string, // the npcs[].name of the run's CLIENT -- see CLIENT below
+  "securityTier": 0|1|2|3|4|5|6 // WHO GUARDS THIS PLACE. Pick from the SITE, not the payout,
+                                // and use EXACTLY one of these integers:
+                                //   0 street thugs, squatters, a mall cop
+                                //   1 a gang's block, street scum holding a corner
+                                //   2 corporate security at an ordinary office or warehouse
+                                //   3 a police patrol, a licensed private force
+                                //   4 an organized-crime crew on its own ground
+                                //   5 elite corporate security -- a real corp facility
+                                //   6 elite special forces -- military; needs a real reason
+                                // Every "hostile" npc is armed and armored by the engine
+                                // from this tier's statblock; you write WHO they are, the
+                                // engine writes WHAT they carry.
 }
 
 CLIENT: every run has a CLIENT -- "a Mr. Johnson", the employer's deniable face, the person
@@ -646,17 +726,22 @@ For EVERY npc in the skeleton, expand its "concept":
   will refuse it and the player will burn a run trusting it. An NPC may say that a code
   EXISTS, who holds it, or where it's written down -- never what it is. The engine hands
   the real pass to whoever genuinely holds it, at runtime (see npc.ts).
-- "combat": OPTIONAL attribute block -- omit for anyone who'd never fight. Each attribute
-  1-8 (soft civilian 1-2, street-level 3-4, hardened enforcer 5-6, elite 7-8):
+- "combat": OPTIONAL attribute block -- omit for anyone who'd never fight, and OMIT IT FOR
+  EVERY HOSTILE: the engine outfits opposition from the site's security tier (the book's
+  own Professional Rating statblocks, gear included), and a "combat" block on a hostile is
+  ignored. Write one only for a NON-hostile who might still end up in a fight (a bodyguard
+  who is not security, a bartender with a shotgun). Each attribute 1-8 (soft civilian 1-2,
+  street-level 3-4, hardened enforcer 5-6, elite 7-8):
   { "body", "agility", "reaction", "combatSkill", "strength"?, "willpower"?, "logic"?,
     "intuition"?, "charisma"?, "magic"?, "resonance"?, "adept"?,
-    "skills"?: { "firearms"?, "blades"?, "clubs"?, "unarmed"?, "sneaking"?, "perception"?, "palming"?,
-                 "hacking"?, "cybercombat"?, "electronic-warfare"?, "hardware"?, "locksmith"?, "computer"?,
-                 "negotiation"?, "con"?, "intimidation"?, "etiquette"?, "leadership"?, "performance"?, "disguise"?,
-                 "medicine"?, "assensing"?, "counterspelling"?, "conjuring"?, "gunnery"? } }
-  "magic" 3-6 ONLY for a genuinely Awakened concept; give combat blocks to anyone the story
-  expects in a firefight. "skills" is
-  optional flavor for defined concepts (a sharpshooter's "firearms": 6).
+    "skills"?: { "pistols"?, "automatics"?, "longarms"?, "blades"?, "clubs"?, "unarmed"?, "sneaking"?,
+                 "perception"?, "palming"?, "hacking"?, "cybercombat"?, "electronic-warfare"?, "hardware"?,
+                 "locksmith"?, "computer"?, "negotiation"?, "con"?, "intimidation"?, "etiquette"?,
+                 "leadership"?, "performance"?, "disguise"?, "medicine"?, "assensing"?, "counterspelling"?,
+                 "conjuring"?, "gunnery"? } }
+  "magic" 3-6 ONLY for a genuinely Awakened concept. "skills" is optional flavor for defined
+  concepts (a sharpshooter's "longarms": 6). There is no generic gun skill: guns are "pistols",
+  "automatics" (SMGs, machine pistols, assault rifles) or "longarms" (rifles, shotguns).
 
 ${JSON_ONLY}
 [ { "name": string, "description": string, "dialogue": string[], "combat"?: { ... } } ]
@@ -2605,9 +2690,11 @@ export function assembleScene(skeleton, details, playerName) {
     // from the exit they hold, so moving one would leave `guarding: true`
     // with nothing behind it. See factories/npc-spread.ts.
     const spreadStations = spreadStationedNpcs(npcStation, new Map(rooms.map(r => [r.name, (r.spots ?? []).map(s => s.name)])), name => guardPost.has(name));
+    const tierKit = skeleton.securityTier === undefined ? undefined : kitSlugForTier(skeleton.securityTier);
     const npcs = skeleton.npcs.map(npc => {
         const detail = npcDetail.get(npc.name);
         const station = spreadStations.get(npc.name);
+        const kit = npc.hostile === true && npc.name !== skeleton.client ? tierKit : undefined;
         const roomSpots = (rooms.find(r => r.name === npc.startLocation)?.spots ?? []);
         const startSpot = station && station.room === npc.startLocation && roomSpots.some(s => s.name === station.spot)
             ? station.spot
@@ -2630,8 +2717,18 @@ export function assembleScene(skeleton, details, playerName) {
                 // other would put the flag on every checkpoint clerk in the
                 // game, which is the failure this feature is built to avoid.
                 hostile: npc.hostile === true || undefined,
+                // WHAT THEY CARRY (npc-kits.ts, catalog v21): every hostile is
+                // outfitted from the site's security tier, deterministically --
+                // the model never writes a kit slug, because a slug it invented
+                // is a whole failure class (itemFromCatalog throws on one) and
+                // the tier is the one number it was asked for. THE KIT IS THE
+                // STATLINE: a `combat` block the model wrote for a guard is
+                // dropped here, not merged, so a dead key cannot ride in beside
+                // the book's numbers. Non-hostiles keep theirs.
+                ...(kit ? { kit } : {}),
+                ...(kit && skeleton.lieutenant === npc.name ? { lieutenant: true } : {}),
                 lifestyleChoices: [],
-                combat: detail?.combat,
+                combat: kit ? undefined : detail?.combat,
             },
         };
     });
@@ -2772,6 +2869,7 @@ export function assembleScene(skeleton, details, playerName) {
             completionMessage: skeleton.completionMessage,
         },
         client: skeleton.client,
+        ...(skeleton.securityTier !== undefined ? { securityTier: skeleton.securityTier } : {}),
     };
 }
 /**

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-factory.js

@@ -14,6 +14,7 @@ import { migrateLegacySeed } from './seed-migration.js';
 import { Device } from '../models/device.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { adoptSeededIce } from '../utilities/ic-actors.js';
+import { NPC_EQUIP_CATEGORIES, outfitNpcBySlug } from '../npc-kits.js';
 /**
  * How many AI enrichment calls may be in flight at once.
  *
@@ -512,27 +513,58 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
                 logger.error(`Scene "${json.name}": the door ${String(direction)} of ${room.name} was locked by "${wanted ?? '(nothing)'}", which no device holds and no item matches -- it ships unlocked rather than as a wall.`);
             }
         }
+        // Step 4.04: NPCs get their kit (npc-kits.ts, SR5 p.379-385, catalog
+        // v21). AFTER "heldBy" has landed (Step 4.5 above -- the numbering is
+        // historical, the source order is what runs) and BEFORE the equip
+        // step below, on purpose: an author who put a weapon in this NPC's
+        // hands with heldBy is the author speaking, and the kit yields its
+        // own weapon to it (respectCarried) while its armor still layers.
+        // The seed's `kit` is applied here rather than in npc-factory for
+        // the same reason startSpot/guarding/hostile are applied at Step 3
+        // instead of the constructor: the factory drops every field but four,
+        // and the ordering guarantee above only holds in THIS loop.
+        for (const npcJson of json.npcs ?? []) {
+            if (!npcJson.player.kit)
+                continue;
+            const npc = scene.getActor(npcJson.player.name);
+            if (!npc)
+                continue;
+            outfitNpcBySlug(npc, npcJson.player.kit, {
+                lieutenant: npcJson.player.lieutenant === true,
+                respectCarried: true,
+            });
+        }
         // Step 4.05: NPCs wear their gear. "heldBy" only puts items in an NPC's
         // inventory, but combat pools (see Player.getWeaponProfile /
         // getArmorValue) read from EQUIPPED slots -- without this, an enforcer
         // "holding" an assault rifle and an armored jacket would fight
         // bare-fisted in street clothes. Only weapon/armor categories are
-        // auto-equipped: plot items (datachips, books, keys) stay in inventory
-        // where "give"/death-drops expect them. Failures are non-fatal -- a
-        // second weapon just stays holstered in inventory.
-        const combatCategories = new Set([
-            Category.Weapon, Category.MeleeWeapon, Category.RangedWeapon,
-            Category.Armor, Category.BodyArmor, Category.ArmorClothing, Category.Shield,
-            Category.Helmet, Category.ArmArmor, Category.LegArmor, Category.Boots, Category.Gloves,
-        ]);
+        // auto-equipped (NPC_EQUIP_CATEGORIES -- the one list, shared with the
+        // ephemeral governor): plot items (datachips, books, keys) stay in
+        // inventory where "give"/death-drops expect them. Failures are
+        // non-fatal -- a second weapon just stays holstered in inventory.
+        //
+        // FIRST WEAPON WINS (2026-09-15, the day kits gave every guard two).
+        // `equip` SWAPS, so the unguarded loop this used to be would have
+        // ended every PR 1 ganger holding the knife with the Browning
+        // holstered -- the exact bug archetypes.ts:outfitArchetype documents
+        // for runners. It never fired here only because no seeded NPC ever
+        // carried two weapons. Armor still layers, so only weapons are
+        // guarded.
+        const weaponCategories = new Set([Category.Weapon, Category.MeleeWeapon, Category.RangedWeapon]);
         for (const npcJson of json.npcs ?? []) {
             const npc = scene.getActor(npcJson.player.name);
             if (!npc)
                 continue;
             for (const item of [...npc.inventory.getAllItems()]) {
-                if (combatCategories.has(item.category)) {
+                if (!NPC_EQUIP_CATEGORIES.has(item.category))
+                    continue;
+                if (weaponCategories.has(item.category) && npc.getCarriedWeapon())
+                    continue;
+                try {
                     npc.equip(item);
                 }
+                catch { /* nothing to slot it into -- stays holstered */ }
             }
         }
         // Step 4.1: Add Starting Items for the Player (skipped when continuing

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-seed-generator.js

@@ -9,7 +9,7 @@ import { GenerationCapture } from '../utilities/generation-capture.js';
 import { fetchCanonContext } from '../utilities/canon-lore.js';
 import { providerUnavailable } from '../utilities/draft-failure-note.js';
 import { SceneSynthesizer } from './scene-factory.js';
-import { buildSkeletonPrompt, buildRoomsPrompt, buildNpcsPrompt, buildDevicesPrompt, buildItemsPrompt, pickRunType, parseJsonReply, validateSkeleton, normalizeSkeleton, assembleScene, classifyRepair, CHUNK_SCHEMAS, unwrapChunk, VAULT_HOST_RATING, } from './scene-chunks.js';
+import { buildSkeletonPrompt, buildRoomsPrompt, buildNpcsPrompt, buildDevicesPrompt, buildItemsPrompt, pickRunType, parseJsonReply, validateSkeleton, normalizeSkeleton, settleSecurity, assembleScene, classifyRepair, CHUNK_SCHEMAS, unwrapChunk, VAULT_HOST_RATING, } from './scene-chunks.js';
 // The fixer name convention and the player dossier live with the prompt
 // builders now (see scene-chunks.ts); re-exported so the existing
 // import sites (call.ts, game.ts) keep working unchanged.
@@ -241,6 +241,15 @@ export class SceneSeedGenerator {
                 // for a scaled opposition, and this is what makes the aim
                 // stick when the model quietly ignores it.
                 validateSkeleton(skeleton, player, crew);
+                // WHO GUARDS THIS PLACE (npc-kits.ts): clamp the declared tier
+                // against the job number and post the lieutenant if this table
+                // outguns it. After validation, so a rejected skeleton never
+                // has its security settled; before the detail passes, so the
+                // NPC prompt can be told which entries the kit will dress.
+                for (const note of settleSecurity(skeleton, tier, player, crew)) {
+                    notes.push(note);
+                    logger.write(`SceneSeedGenerator: ${note}`);
+                }
                 GenerationCapture.record({
                     stage: 'skeleton', outcome: 'accepted', pipeline, attempt,
                     prompt, reply, notes,

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

@@ -1759,7 +1759,11 @@ export default class Game {
             name: `${item.name} (autopilot)`,
             description: `${this.player.name}'s drone running its dog-brain autopilot: it follows them, watches, and ${armed ? 'shoots what threatens them' : 'has cameras where guns would go -- it never attacks'}.`,
             kind: 'drone',
-            combat: { body: item.droneBody, agility: pilot, reaction: pilot, logic: pilot, intuition: pilot, willpower: pilot, strength: 1, charisma: 1, skills: { perception: pilot, ...(armed ? { firearms: pilot } : {}) } },
+            // `firearms` is not a skill (skills.ts, stage 3) and this shell
+            // carried it as a dead key until 2026-09-15: an armed drone rolls
+            // Gunnery (p.131, and what getAttackPool reads for a jumped-in
+            // frame) and, for a mounted gun's own skill, the split three.
+            combat: { body: item.droneBody, agility: pilot, reaction: pilot, logic: pilot, intuition: pilot, willpower: pilot, strength: 1, charisma: 1, skills: { perception: pilot, ...(armed ? { gunnery: pilot, automatics: pilot, pistols: pilot, longarms: pilot } : {}) } },
             room, plane: 'meat', force: pilot, boundDevice: item,
         });
         // Take-command weight checks (Player.addInventory) enforce this cap

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

@@ -49,6 +49,21 @@ export class Item extends AbstractItem {
     // work (rest.ts). A reboot does NOT clear it; that is the whole
     // difference from `jammed`.
     bricked = false;
+    /**
+     * RUINED (Room.layOutBody, catalog v21 NPC kits): armor that soaked
+     * the rounds that killed its wearer. Rated 0 (armorValue, armorBonus)
+     * and worth nothing (commerce.ts priceOf); it drops, so the runner
+     * sees what the guard was wearing, and it is not a free set of full
+     * body armor -- the plates are what stopped the rounds. Saved.
+     */
+    ruined = false;
+    /** Mark this piece ruined, and say so on it. Idempotent. */
+    ruin(how) {
+        if (this.ruined)
+            return;
+        this.ruined = true;
+        this.description = `${this.description} RUINED -- ${how}.`;
+    }
     /**
      * SPRITE POWERS ON A FILE (SR5 p.256-257,
      * utilities/sprite-power-actions.ts). Matrix-plane items only; all
@@ -581,6 +596,8 @@ export class Item extends AbstractItem {
      * clothing 0. Only the highest worn piece counts (Player.armorBreakdown).
      */
     get armorValue() {
+        if (this.ruined)
+            return 0;
         const w = this.row?.wearable;
         if (w?.armor !== undefined)
             return w.armor;
@@ -598,6 +615,8 @@ export class Item extends AbstractItem {
     }
     /** A "+" accessory's bonus (helmet +2, shield +6, p.437-438): the row's, else the class value. */
     get armorBonus() {
+        if (this.ruined)
+            return 0;
         const w = this.row?.wearable;
         if (w?.armorBonus !== undefined)
             return w.armorBonus;

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

@@ -705,6 +705,18 @@ export class NPC extends Player {
      * "nobody in particular", which every rule reads as no opinion.
      */
     faction;
+    /**
+     * WHAT THIS GRUNT CARRIES AND HOW TRAINED THEY ARE (npc-kits.ts, SR5
+     * p.379-385): the kit row's slug, its Professional Rating, and
+     * whether this one is the team's lieutenant (p.380-381). Set by
+     * outfitNpcKit and read by the Combat Turn for Group Edge and morale.
+     * Absent on every NPC built from an attribute block alone, which is
+     * every NPC there was before catalog v21. Session state, never saved:
+     * a seeded NPC is re-outfitted from its seed on every synthesis.
+     */
+    kit;
+    professionalRating;
+    lieutenant;
     /**
      * SET ONLY BY THE EPHEMERAL GOVERNOR (utilities/ephemeral.ts): this
      * body is a passing face, not a character. Its presence trims the

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

@@ -124,9 +124,18 @@ export class Room extends AbstractRoom {
                 for (const [slot, item] of Object.entries(group)) {
                     if (!item)
                         continue;
-                    held.addItem(item);
+                    const piece = item;
+                    // WORN ARMOR COMES OFF RUINED (2026-09-15, with the NPC kits
+                    // that put real armor on guards): the jacket stopped the rounds
+                    // that killed the wearer, and that is what a jacket is for.
+                    // Guns and commlinks drop intact -- a PR 5 kill is still the
+                    // Ares Alpha, it is just not a free set of full body armor.
+                    if (piece.armorValue > 0 || piece.armorBonus > 0) {
+                        piece.ruin(`it took the rounds that dropped ${actor.name}`);
+                    }
+                    held.addItem(piece);
                     group[slot] = null;
-                    this.logger.write(`${actor.name}'s ${slot} falls with the body in ${this.name}.`);
+                    this.logger.write(`${actor.name}'s ${slot} falls with the body in ${this.name}${piece.ruined ? ' (ruined)' : ''}.`);
                 }
             }
         }

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

@@ -628,7 +628,23 @@ export class Scene extends AbstractScene {
         this.logger.write(`Actor with name ${actor.name} has been added to the scene.`);
         this.actors.set(actor.name, actor);
     }
-    removeActor(name) {
+    /**
+     * Take an actor out of the world.
+     *
+     * `spill` (default true) is whether what they carried lands on the
+     * floor. TRUE IS A BODY: a kill has already been stripped by
+     * Room.layOutBody, and anything left is the leftover a corpse drops.
+     * FALSE IS A DEPARTURE (utilities/ephemeral.ts despawnEphemerals): a
+     * ganger who walks off their corner, an officer whose sweep moved on,
+     * takes their gun with them. Before kits (catalog v21) ephemerals
+     * carried nothing so the distinction cost nothing; the day they got
+     * a Browning and an armor vest, walking away from a street corner
+     * rained both onto the pavement, per ganger, per block -- and the
+     * governor's founding denial is that an ephemeral cannot create
+     * obligations. A gun the world has to keep track of after the body
+     * is gone is exactly that.
+     */
+    removeActor(name, opts = {}) {
         const actor = this.actors.get(name);
         // Removal is cleanup, not an assertion: a concurrent kill resolution
         // (or any double-remove) finding the actor already gone is a no-op,
@@ -639,6 +655,10 @@ export class Scene extends AbstractScene {
             return;
         }
         const room = actor.currentLocation;
+        const spill = opts.spill !== false;
+        if (!spill && room) {
+            this.logger.write(`removeActor: ${actor.name} leaves ${room.name} with everything they carried.`);
+        }
         // One consolidated observer line for the whole spill, not one stilted
         // "on death drops" line per item -- and everything that falls is IN
         // PLAIN SIGHT (see Room.plainSightItems): the player just watched it
@@ -649,7 +669,7 @@ export class Scene extends AbstractScene {
         // "counter" that didn't exist in the room (the note had ridden a
         // crew member's pack from a different scene entirely).
         const fallSpot = actor.atSpot;
-        if (room && actor.inventory) {
+        if (spill && room && actor.inventory) {
             const items = actor.inventory.getAllItems();
             for (const item of items) {
                 const didDrop = actor.inventory.transferItemTo(item.name, room.inventory);
@@ -666,7 +686,7 @@ export class Scene extends AbstractScene {
         // holstered pistol are exactly the loot a runner expects to strip.
         // Without this, everything an NPC had equipped would silently vanish
         // from the world on death.
-        if (room && actor.equipment) {
+        if (spill && room && actor.equipment) {
             for (const group of Object.values(actor.equipment)) {
                 if (!group)
                     continue;

package/bundle/typescript/src/commands/game/sideQuest/npc-kits.js

@@ -0,0 +1,295 @@
+import { augFor, itemFromCatalog, npcKitFor } from './utilities/catalog.js';
+import { Category } from './types/shared/item-enum.js';
+import { Logger } from './utilities/logger.js';
+// ============================================================================
+// Tiers
+// ============================================================================
+/**
+ * WHICH KIT A SITE'S SECURITY TIER FIELDS. The slugs match the shipped
+ * rows (maka-cli.com full-catalog.json v21); a row that is missing
+ * resolves to no kit, per the file comment.
+ */
+export const KIT_FOR_TIER = {
+    0: 'thugs',
+    1: 'gangers',
+    2: 'corp-security',
+    3: 'police-patrol',
+    4: 'organized-crime',
+    5: 'elite-corp-security',
+    6: 'elite-special-forces',
+};
+export function kitSlugForTier(tier) {
+    return KIT_FOR_TIER[tier];
+}
+/**
+ * THE MOST A JOB OF THIS SIZE PLAUSIBLY FIELDS. `campaignTier` is the
+ * job number (buildSkeletonPrompt's `tier`), NOT the security tier --
+ * the two words collide and this is the one place they meet. Job #1 is
+ * a warehouse, not an arcology: elite corporate security (PR 5) is a
+ * tier-3+ problem, and PR 6 special forces never come from a generated
+ * draft at all -- a hand-authored seed may declare them.
+ */
+export function maxSecurityTierFor(campaignTier) {
+    if (campaignTier <= 1)
+        return 2;
+    if (campaignTier === 2)
+        return 3;
+    return 5;
+}
+/** What a draft that declared nothing gets: a gang block for job #1, a
+ *  corporate office for #2, a patrolled site after that. */
+export function defaultSecurityTierFor(campaignTier) {
+    if (campaignTier <= 1)
+        return 1;
+    if (campaignTier === 2)
+        return 2;
+    return 3;
+}
+/**
+ * CLAMP, NEVER REJECT. A model that wrote "securityTier": 9, or "high",
+ * or nothing, has still written a usable scene; failing the skeleton
+ * over it would spend a real generation retry on a number the engine
+ * can repair in one line. Same policy as the keyed-door and keyItem
+ * repairs in scene-factory.ts.
+ */
+export function clampSecurityTier(raw, campaignTier) {
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    const base = Number.isFinite(n) ? Math.round(n) : defaultSecurityTierFor(campaignTier);
+    return Math.max(0, Math.min(maxSecurityTierFor(campaignTier), base));
+}
+/**
+ * ROUGHLY WHAT A RANK-AND-FILE GRUNT OF THIS TIER ROLLS, attack pool
+ * plus defense pool, read off the p.381-384 statblocks (Agility +
+ * weapon skill + smartlink/toner; Reaction + Intuition/2 + wired
+ * reflexes). The party's own figure (scene-chunks.ts partyStrength) is
+ * on the same scale, and a party that clears this by a margin draws
+ * the tier's lieutenant.
+ */
+export function expectedStrengthFor(securityTier) {
+    const table = { 0: 11, 1: 12, 2: 13, 3: 12, 4: 16, 5: 25, 6: 29 };
+    return table[Math.max(0, Math.min(6, securityTier))] ?? 12;
+}
+/** The margin past expectedStrengthFor at which a site posts its lieutenant. */
+export const LIEUTENANT_MARGIN = 3;
+export function partyDrawsLieutenant(partyStrength, securityTier) {
+    return partyStrength > expectedStrengthFor(securityTier) + LIEUTENANT_MARGIN;
+}
+// ============================================================================
+// Group Edge and morale (p.379-380)
+// ============================================================================
+/** p.380: "a team of grunts has a Group Edge equal to its Professional Rating." */
+export function groupEdgeFor(professionalRating) {
+    return Math.max(0, Math.min(6, Math.round(professionalRating)));
+}
+/**
+ * p.379-380, verbatim in spirit: PR 0 "will flee if somebody in their
+ * group goes down"; PR 1-2 "retreat if more than a quarter of their
+ * team is taken out"; PR 3-4 "withdraw after casualties exceed half";
+ * PR 5-6 "will not break -- they fight to the last man".
+ */
+export function moraleBandFor(professionalRating) {
+    if (professionalRating <= 0)
+        return 'one-drops';
+    if (professionalRating <= 2)
+        return 'quarter';
+    if (professionalRating <= 4)
+        return 'half';
+    return 'never';
+}
+/** Does a team of `total` that has lost `casualties` break at this PR? */
+export function moraleBreaks(professionalRating, casualties, total) {
+    if (total <= 0 || casualties <= 0)
+        return false;
+    switch (moraleBandFor(professionalRating)) {
+        case 'one-drops': return casualties >= 1;
+        case 'quarter': return casualties > total / 4;
+        case 'half': return casualties > total / 2;
+        case 'never': return false;
+    }
+}
+/** The line the room hears when a team breaks, by how trained it was. */
+export function moraleBreakLine(name, band) {
+    switch (band) {
+        case 'one-drops': return `${name} sees the body drop and wants no part of this -- hands up, backing off.`;
+        case 'quarter': return `${name} has seen enough of their own go down -- weapon lowered, backing out of it.`;
+        default: return `${name} calls it: too many down. Weapon down, hands where you can see them.`;
+    }
+}
+// ============================================================================
+// Outfitting
+// ============================================================================
+/**
+ * WHAT AN NPC WEARS OR HOLDS, out of what a kit puts in its pack. The
+ * one list, shared by scene-factory's equip step and the ephemeral
+ * governor, so a guard built by a seed and a ganger spawned on a corner
+ * dress the same way. Weapons and armor only: a commlink stays in the
+ * pocket, and plot items (keys, chips) stay in inventory where "give"
+ * and the loot lane expect them.
+ */
+export const NPC_EQUIP_CATEGORIES = new Set([
+    Category.Weapon, Category.MeleeWeapon, Category.RangedWeapon,
+    Category.Armor, Category.BodyArmor, Category.ArmorClothing, Category.Shield,
+    Category.Helmet, Category.ArmArmor, Category.LegArmor, Category.Boots, Category.Gloves,
+]);
+const WEAPON_CATEGORIES = new Set([
+    Category.Weapon, Category.MeleeWeapon, Category.RangedWeapon,
+]);
+/**
+ * Slots every weapon and armor piece in the pack into the actor's
+ * equipment, FIRST WEAPON WINS. `equip` swaps, so an unguarded loop
+ * over a pack holding a pistol and a knife ends with the knife in hand
+ * and the pistol holstered -- the exact bug archetypes.ts:outfitArchetype
+ * documents for runners, reproduced here for everyone else. Armor
+ * layers (a helmet over a jacket), so only weapons are guarded.
+ */
+export function equipKitIntoHands(actor) {
+    for (const item of [...actor.inventory.getAllItems()]) {
+        if (!NPC_EQUIP_CATEGORIES.has(item.category))
+            continue;
+        if (WEAPON_CATEGORIES.has(item.category) && actor.getCarriedWeapon())
+            continue;
+        try {
+            actor.equip(item);
+        }
+        catch { /* nothing to slot it into -- stays holstered */ }
+    }
+}
+/**
+ * STAMP A KIT ONTO AN NPC. The NPC analogue of archetypes.ts
+ * outfitArchetype, minus the chargen ledger and the credstick.
+ *
+ * INTO THE PACK, NOT INTO THE HANDS. This adds gear to inventory and
+ * stops; equipping is the caller's step (scene-factory's Step 4.05 for
+ * a seeded NPC, equipKitIntoHands for an ephemeral), because the seeded
+ * path has an author to defer to: an item the seed put in this NPC's
+ * hands with `heldBy` is the author speaking, and the kit skips its
+ * own weapon rather than argue -- `respectCarried` below. Armor still
+ * layers.
+ *
+ * Idempotent on augs and qualities (hasAug / the Set), so a kit applied
+ * twice does not double-install wired reflexes.
+ */
+export function outfitNpcKit(npc, kit, opts = {}) {
+    const logger = Logger.getInstance();
+    const lt = opts.lieutenant ? kit.lieutenant : undefined;
+    const attrs = { ...kit.attributes, ...(lt?.attributes ?? {}) };
+    const skills = { ...kit.skills, ...(lt?.skills ?? {}) };
+    const gear = lt?.gear ?? kit.gear;
+    const ammo = lt?.ammo ?? kit.ammo;
+    const augs = [...kit.augs, ...(lt?.augs ?? [])];
+    const qualities = [...kit.qualities, ...(lt?.qualities ?? [])];
+    const spells = [...kit.spells, ...(lt?.spells ?? [])];
+    const adeptPowers = { ...(kit.adeptPowers ?? {}), ...(lt?.adeptPowers ?? {}) };
+    npc.kit = kit.key;
+    npc.professionalRating = kit.professionalRating;
+    if (opts.lieutenant)
+        npc.lieutenant = true;
+    // The faction feature (factions.ts) ships rows and rules and no seed
+    // wiring; a kit row knows who fields it, so the gap closes here. An
+    // author's explicit faction still wins.
+    if (kit.faction && !npc.faction)
+        npc.faction = kit.faction;
+    npc.body = attrs.body;
+    npc.agility = attrs.agility;
+    npc.reaction = attrs.reaction;
+    npc.strength = attrs.strength;
+    npc.willpower = attrs.willpower;
+    npc.logic = attrs.logic;
+    npc.intuition = attrs.intuition;
+    npc.charisma = attrs.charisma;
+    if (attrs.magic !== undefined)
+        npc.magic = attrs.magic;
+    if (attrs.resonance !== undefined)
+        npc.resonance = attrs.resonance;
+    if (attrs.adept !== undefined)
+        npc.adept = attrs.adept;
+    // Grunts have no Edge POOL of their own (p.380): the team shares one
+    // equal to its PR, held on the CombatEncounter. The RATING stays on
+    // the actor because Player.consumeEdgeBoost adds `this.edge` dice
+    // when a boost lands -- p.56's "add Edge to the dice pool" -- and a
+    // grunt's Edge for that purpose is the group's. edgeRemaining is 0
+    // so nothing reads a per-actor pool.
+    npc.edge = groupEdgeFor(kit.professionalRating + (opts.lieutenant ? 1 : 0));
+    npc.edgeRemaining = 0;
+    // THE KIT IS THE STATLINE: replace, never merge. A `combat.skills`
+    // block a model wrote for a guard is superseded by the book's, and a
+    // merge would keep a dead key like `firearms` alive beside the live ones.
+    npc.skills = { ...skills };
+    const top = Object.entries(skills).sort((a, b) => b[1] - a[1])[0];
+    if (top)
+        npc.combatSkill = top[1];
+    for (const key of qualities) {
+        if (!npc.qualities.has(key))
+            npc.addQuality(key);
+    }
+    for (const key of augs) {
+        const aug = augFor(key);
+        if (aug && !npc.hasAug(key))
+            npc.installAug(aug);
+        else if (!aug)
+            logger.write(`npc-kit ${kit.key}: augmentation "${key}" has no row -- skipped.`);
+    }
+    if (spells.length > 0)
+        npc.knownSpells = [...new Set([...(npc.knownSpells ?? []), ...spells])];
+    if (Object.keys(adeptPowers).length > 0) {
+        npc.adept = true;
+        npc.adeptPowers = { ...(npc.adeptPowers ?? {}), ...adeptPowers };
+    }
+    const carriesWeapon = opts.respectCarried
+        && npc.inventory.getAllItems().some(i => WEAPON_CATEGORIES.has(i.category));
+    let firstGun;
+    for (const slug of gear) {
+        let item;
+        try {
+            item = itemFromCatalog(slug);
+        }
+        catch (err) {
+            // A missing gear row is a catalog problem, logged and survived:
+            // the guard is a little lighter, not absent. The kit suite walks
+            // every slug so this never reaches a player from a shipped row.
+            logger.write(`npc-kit ${kit.key}: ${err instanceof Error ? err.message : String(err)} -- skipped.`);
+            continue;
+        }
+        if (carriesWeapon && WEAPON_CATEGORIES.has(item.category))
+            continue;
+        try {
+            npc.addInventory(item);
+        }
+        catch (err) {
+            logger.write(`npc-kit ${kit.key}: could not give ${npc.name} ${item.name} (${err instanceof Error ? err.message : 'carry cap?'}).`);
+            continue;
+        }
+        item.owner = npc.name;
+        if (!firstGun && item.isFirearm())
+            firstGun = item;
+    }
+    // p.433-434: what is loaded shifts the gun's line -- this is how the
+    // PR 6 HK 227 gets its APDS AP -4 without the row lying about the gun.
+    if (ammo && firstGun) {
+        const round = itemFromCatalogQuiet(ammo);
+        if (round)
+            firstGun.loadedAmmo = round.name;
+    }
+    logger.write(`npc-kit: ${npc.name} outfitted as ${kit.key}${opts.lieutenant ? ' (lieutenant)' : ''} -- PR ${kit.professionalRating}, ${gear.length} piece(s).`);
+}
+function itemFromCatalogQuiet(slug) {
+    try {
+        return itemFromCatalog(slug);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Resolve-and-outfit in one call; a slug with no row is a no-op. Returns whether a kit landed. */
+export function outfitNpcBySlug(npc, slug, opts = {}) {
+    if (!slug)
+        return false;
+    const kit = npcKitFor(slug);
+    if (!kit) {
+        Logger.getInstance().write(`npc-kit: no row for "${slug}" -- ${npc.name} keeps their attribute block.`);
+        return false;
+    }
+    outfitNpcKit(npc, kit, opts);
+    return true;
+}
+//# sourceMappingURL=npc-kits.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/catalog.js

@@ -952,6 +952,40 @@ export function factionFor(key) {
 export function catalogFactions() {
     return listOfKind('faction', factionFor);
 }
+/**
+ * AN NPC KIT ROW, rebuilt as the engine reads it (catalog v21, "everyone
+ * is basically naked"). Same contract as factionFor: the rows live on
+ * maka-cli.com, an unknown slug answers undefined, and npc-kits.ts
+ * treats that as "no kit" -- a cached catalog from before v21 builds
+ * NPCs exactly as the engine always did.
+ */
+export function npcKitFor(key) {
+    return kindIndex('npc-kit', row => {
+        const k = row.npcKit;
+        return {
+            key: row.slug,
+            name: row.name,
+            description: row.description,
+            professionalRating: k.professionalRating,
+            ...(k.faction !== undefined ? { faction: k.faction } : {}),
+            sort: k.sort,
+            attributes: { ...k.attributes },
+            skills: { ...k.skills },
+            gear: [...k.gear],
+            ...(k.ammo !== undefined ? { ammo: k.ammo } : {}),
+            augs: [...(k.augs ?? [])],
+            qualities: [...(k.qualities ?? [])],
+            spells: [...(k.spells ?? [])],
+            ...(k.adeptPowers !== undefined ? { adeptPowers: { ...k.adeptPowers } } : {}),
+            ...(k.lieutenant !== undefined ? { lieutenant: { ...k.lieutenant } } : {}),
+            page: row.page ?? '',
+        };
+    }).get(key);
+}
+/** Every NPC kit the resolved catalog knows. */
+export function catalogNpcKits() {
+    return listOfKind('npc-kit', npcKitFor);
+}
 /** Every metamagic and echo the resolved catalog knows. */
 export function catalogMetamagics() {
     return listOfKind('metamagic', metamagicFor);

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-turn.js

@@ -1,6 +1,7 @@
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
 import { runNpcActionPhase } from './npc-combat-brain.js';
+import { groupEdgeFor } from '../npc-kits.js';
 export function arenaKey(a) {
     return a.kind === 'room' ? `room:${a.room.name}` : a.kind === 'host' ? `host:${a.host.name}` : 'grid:open';
 }
@@ -114,6 +115,20 @@ export class CombatEncounter {
     pairs = new Map();
     surrenderSeenAt = new Map();
     running = false;
+    /**
+     * GRUNT TEAMS BY KIT (p.379-380, npc-kits.ts). Every kitted NPC who
+     * enters the fight is rostered under its kit slug, and the roster is
+     * the denominator morale reads -- a team that started four and lost
+     * two has lost half, whether or not the dead are still actors. Group
+     * Edge is a pool per kit, seeded to the PR on first sight (+1 with a
+     * lieutenant, p.380-381) and spent by the brain one point per grunt
+     * per fight. Keyed by KIT rather than by side because one scene can
+     * field a PR 1 gang and a PR 3 patrol, and the book prices them
+     * separately.
+     */
+    kitRoster = new Map();
+    groupEdge = new Map();
+    edgeSpentBy = new Set();
     /** Every human phase that began -- a seam for tests and for any future
      *  phase clock; nothing plays the phase for a human (the fight
      *  autopilot was retired 2026-09-07: a phase you commit with "end
@@ -213,8 +228,80 @@ export class CombatEncounter {
             acted: false, delayed: false, surprised: false,
         };
         this.participants.push(p);
+        this.rosterGrunt(actor);
         return p;
     }
+    /** Put a kitted NPC on its team's roster; seed the team's Group Edge on first sight. */
+    rosterGrunt(actor) {
+        const npc = actor;
+        if (!this.isNpc(actor) || npc.kit === undefined || npc.professionalRating === undefined)
+            return;
+        let roster = this.kitRoster.get(npc.kit);
+        if (!roster) {
+            roster = new Set();
+            this.kitRoster.set(npc.kit, roster);
+        }
+        roster.add(npc.name);
+        // p.380: "a team of grunts has a Group Edge equal to its Professional
+        // Rating". p.380-381: a lieutenant "adds 1 to their Edge". Seeded once;
+        // a lieutenant who joins late tops it up by their one point.
+        if (!this.groupEdge.has(npc.kit)) {
+            this.groupEdge.set(npc.kit, groupEdgeFor(npc.professionalRating));
+        }
+        if (npc.lieutenant)
+            this.groupEdge.set(npc.kit, (this.groupEdge.get(npc.kit) ?? 0) + 1);
+    }
+    /**
+     * THE STATE OF A GRUNT'S TEAM, for the brain's morale check. Casualties
+     * are rostered names that are dead (gone from the scene), incapacitated
+     * or death-claimed; a grunt who surrendered still stands and is not
+     * one. The lieutenant's +1 to PR lasts only while the lieutenant does.
+     */
+    teamOf(npc) {
+        if (npc.kit === undefined || npc.professionalRating === undefined)
+            return undefined;
+        const roster = this.kitRoster.get(npc.kit);
+        if (!roster)
+            return undefined;
+        let casualties = 0;
+        let lieutenantStands = false;
+        for (const name of roster) {
+            const member = this.scene.getActor(name);
+            const down = !member || member.isIncapacitated() || member.deathClaimed;
+            if (down)
+                casualties++;
+            else if (member.lieutenant)
+                lieutenantStands = true;
+        }
+        return {
+            kit: npc.kit,
+            total: roster.size,
+            casualties,
+            effectivePr: npc.professionalRating + (lieutenantStands ? 1 : 0),
+            edge: this.groupEdge.get(npc.kit) ?? 0,
+        };
+    }
+    /**
+     * SPEND A POINT OF GROUP EDGE ON THIS GRUNT (p.380: "the gamemaster
+     * can spend a point of Group Edge on any grunt on the team"). The
+     * engine is the gamemaster, and its standing policy is the plain one:
+     * one point per grunt per fight, on that grunt's first attack, while
+     * the pool lasts. Arms the same boost a runner's "edge" verb arms
+     * (Player.consumeEdgeBoost adds `edge` dice to the next strike), so
+     * the spend goes through the one lane every edge boost already uses.
+     */
+    spendGroupEdge(npc) {
+        if (npc.kit === undefined || npc.edgeBoostArmed || this.edgeSpentBy.has(npc.name))
+            return false;
+        const pool = this.groupEdge.get(npc.kit) ?? 0;
+        if (pool <= 0)
+            return false;
+        this.groupEdge.set(npc.kit, pool - 1);
+        this.edgeSpentBy.add(npc.name);
+        npc.edgeBoostArmed = true;
+        this.logger.write(`Encounter: Group Edge spent on ${npc.name} (${npc.kit}: ${pool - 1} left).`);
+        return true;
+    }
     /**
      * Someone walks into a running fight (p.160 Changing Initiative):
      * roll as normal, minus 10 per pass already gone this turn.

package/bundle/typescript/src/commands/game/sideQuest/utilities/commerce.js

@@ -72,6 +72,11 @@ const roundTo5 = (n) => Math.max(5, Math.round(n / 5) * 5);
  * 120-nuyen credstick selling for its 25-nuyen shell prints money. */
 export function priceOf(item) {
     const cash = item.isCurrencyCarrier() ? item.currencyAmount : 0;
+    // Armor that stopped the rounds that killed its wearer is not a
+    // trade good (Room.layOutBody): a fence pays for the plates, and the
+    // plates are what is gone.
+    if (item.ruined)
+        return cash;
     if (typeof item.price === 'number' && item.price > 0)
         return Math.round(item.price) + cash;
     const base = CATEGORY_BASE[item.category] ?? 50;

package/bundle/typescript/src/commands/game/sideQuest/utilities/ephemeral.js

@@ -3,6 +3,7 @@ import { Logger } from './logger.js';
 import { CommandRegistry } from '../commands/command-registry.js';
 import { actorCell, actorDistanceMeters, standingRoomNear, ADJACENT_METERS } from './spots.js';
 import { METERS_PER_CELL } from './room-grid.js';
+import { outfitNpcBySlug, equipKitIntoHands } from '../npc-kits.js';
 /**
  * Bring one into the world. Returns the NPC, or null when the name is
  * already taken -- the same refusal spawnCompanionShell makes, and for
@@ -17,9 +18,11 @@ export function spawnEphemeral(host, opts) {
     const npc = new NPC({
         dialog: [],
         description: opts.description,
-        playerConstructorConfig: { playerName: opts.name, startLocation: opts.room, combat: opts.combat },
+        playerConstructorConfig: { playerName: opts.name, startLocation: opts.room, combat: opts.combat ?? {} },
     }, new CommandRegistry(host.scene));
     npc.plane = 'meat';
+    if (outfitNpcBySlug(npc, opts.kit))
+        equipKitIntoHands(npc);
     // NOT allyOf, and NOT companionKind: an ephemeral belongs to nobody
     // and is on no roster. Those two fields are what make a companion
     // persist, follow, and take orders.
@@ -62,8 +65,19 @@ export function despawnEphemerals(host, opts) {
                 : opts.playerRoomName !== undefined && opts.playerRoomName !== mark.roomName;
         if (!ended)
             continue;
-        if (host.scene.getActor(name) instanceof NPC)
-            host.scene.removeActor(name);
+        const body = host.scene.getActor(name);
+        // A DEPARTURE IS NOT A DEATH (2026-09-15, the day kits gave gangers
+        // a Browning and an armor vest). removeActor spills what an actor
+        // carried onto the floor, which is right for a corpse and wrong for
+        // a ganger who watched you walk off their corner: the street was
+        // raining pistols, per ganger, per block. A body that is DOWN when
+        // its scope ends spills, because it is a body; one that simply
+        // stops existing takes its gear with it. That is also the honest
+        // reading of this governor's founding denial -- an ephemeral
+        // cannot create obligations, and a gun the world must keep track
+        // of after its owner is gone is one.
+        if (body instanceof NPC)
+            host.scene.removeActor(name, { spill: body.isIncapacitated() });
         host.ephemerals.delete(name);
         removed.push(name);
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/npc-combat-brain.js

@@ -2,6 +2,7 @@ import { Category } from '../types/shared/item-enum.js';
 import { inMeleeReach, isInCover, coverAvailableFor, actorDistanceMeters } from './spots.js';
 import { Logger } from './logger.js';
 import { runIcActionPhase } from './ic-brain.js';
+import { moraleBandFor, moraleBreakLine, moraleBreaks } from '../npc-kits.js';
 /**
  * AN NPC'S ACTION PHASE, PLAYED BY RULE (SR5 p.163-167).
  *
@@ -54,6 +55,27 @@ export async function runNpcActionPhase(enc, npc) {
         tell(`${npc.name} looks for a target and finds none.`);
         return;
     }
+    // MORALE (SR5 p.379-380, npc-kits.ts moraleBreaks): a team of grunts
+    // breaks at the book's casualty thresholds -- untrained when one
+    // drops, semi-trained past a quarter, trained past half, elite never.
+    // THE VERB IS SURRENDER where the book says flee / retreat / withdraw:
+    // this engine's one primitive for "stops fighting without dying" is
+    // `surrender`, and it carries the consequence the book intends -- the
+    // fight ends cleanly, no parting shot, and the pair drops out of
+    // stillHostile(). A grunt sent through `go` instead would stand in the
+    // next room still hostile and still on the contact ladder, which is
+    // the opposite of having broken. The THRESHOLD is canon; only the word
+    // is the engine's. Without this, a kitted ganger who fights to the
+    // death is a harder, longer, less canon fight than a naked one.
+    const team = enc.teamOf(npc);
+    if (team && moraleBreaks(team.effectivePr, team.casualties, team.total)) {
+        const r = await npc.actInCombat('surrender');
+        logger.write(`Brain: ${npc.name} morale breaks (${team.kit}: ${team.casualties}/${team.total} down, PR ${team.effectivePr}) -> ${r}`);
+        if (npc.surrendered) {
+            tell(moraleBreakLine(npc.name, moraleBandFor(team.effectivePr)));
+            return;
+        }
+    }
     const target = pickTarget(npc, enemies);
     npc.combatOpponent = target;
     npc.lastExchangeAt = Date.now();
@@ -109,6 +131,7 @@ export async function runNpcActionPhase(enc, npc) {
             }
             const b = enc.budgetOf(npc);
             if (b?.complexAvailable) {
+                spendGroupEdge(enc, npc, tell);
                 const r = await npc.actInCombat(`attack ${target.name}`);
                 logger.write(`Brain: ${npc.name} attack ${target.name} -> ${r.split('\n')[0]}`);
                 if (!enc.budgetOf(npc)?.attackTaken)
@@ -126,6 +149,7 @@ export async function runNpcActionPhase(enc, npc) {
             continue;
         }
         if (!budget.attackTaken && budget.simple >= 1) {
+            spendGroupEdge(enc, npc, tell);
             const r = await npc.actInCombat(`attack ${target.name}`);
             logger.write(`Brain: ${npc.name} attack ${target.name} -> ${r.split('\n')[0]}`);
             if (!enc.budgetOf(npc)?.attackTaken) {
@@ -139,6 +163,18 @@ export async function runNpcActionPhase(enc, npc) {
         return;
     }
 }
+/**
+ * GROUP EDGE (SR5 p.380): the gamemaster spends the team's pool on a
+ * grunt about to strike. The engine is the gamemaster; the policy is
+ * CombatEncounter.spendGroupEdge's. One line to the room when it lands,
+ * so the runner knows why that shot rolled hot.
+ */
+function spendGroupEdge(enc, npc, tell) {
+    if (npc.kit === undefined)
+        return;
+    if (enc.spendGroupEdge(npc))
+        tell(`${npc.name} digs deep.`);
+}
 /** The opponent already engaged, else the nearest of the rest. */
 function pickTarget(npc, enemies) {
     const engaged = npc.combatOpponent;

package/bundle/typescript/src/commands/game/sideQuest/utilities/persistence.js

@@ -184,6 +184,8 @@ export function serializeItem(item) {
         out.revealedTo = [...item.revealedTo];
     if (item.isCyberdeck() && item.deckOrder.join() !== '0,1,2,3')
         out.deckOrder = item.deckOrder;
+    if (item.ruined)
+        out.ruined = true;
     return out;
 }
 /** Mirrors ItemFactory.createItemFromJson (synchronously), then lays
@@ -223,6 +225,8 @@ export function restoreItem(json) {
         item.jammed = true;
     if (json.bricked)
         item.bricked = true;
+    if (json.ruined)
+        item.ruined = true;
     if (json.deckDamage)
         item.takeDeckDamage(json.deckDamage);
     if (json.droneDamage)

package/bundle/typescript/src/commands/game/sideQuest/utilities/sin.js

@@ -174,9 +174,17 @@ function postSweepOfficer(game, room, band) {
         // not follow.
         until: 'exchange',
         room,
-        // A working rent-a-cop, not a boss fight. Deliberately ordinary:
-        // the player who decides to swing at security should be picking a
-        // fight with a person, not a set piece.
+        // PROFESSIONAL RATING 3, "Police Patrols" (SR5 p.383): the catalog's
+        // `police-patrol` npc-kit row -- armor jacket, Ares Predator V,
+        // Defiance EX Shocker, stun baton, Renraku Sensei, and a Biometric
+        // Reader (p.440), which is what the book has where this prose says
+        // "wand" -- SR5 prints no such item. factionOf() already read an
+        // 'authority' ephemeral as Knight Errant; the row says so too.
+        // A working beat cop, not a boss fight: the player who decides to
+        // swing at one is picking a fight with a person, not a set piece.
+        kit: SWEEP_OFFICER_KIT,
+        // A pre-v21 cache resolves to no kit and gets this instead: the old
+        // rent-a-cop numbers, exactly as before.
         combat: {
             body: 3, agility: 3, reaction: 3, strength: 3, willpower: 3,
             logic: 3, intuition: 3, charisma: 3, edge: 1, combatSkill: 3,
@@ -184,6 +192,8 @@ function postSweepOfficer(game, room, band) {
         },
     });
 }
+/** The sweep officer's npc-kit row (npc-kits.ts). */
+export const SWEEP_OFFICER_KIT = 'police-patrol';
 /**
  * THE OFFICERS, and there is more than one of them now.
  *

package/bundle/typescript/src/commands/game/sideQuest/utilities/street-gang.js

@@ -38,21 +38,32 @@ import { AI } from '../../../../tools/ai/ai.class.js';
  * the ephemeral never decides anything.
  */
 /**
- * PROFESSIONAL RATING 1 GANGER, canon stats (SR5 p.382, "Gangers &
- * Street Scum"): B/A/R/S 4, W/L/I/C 3, with Blades, Clubs,
- * Intimidation, Pistols and Unarmed Combat.
+ * PROFESSIONAL RATING 1 GANGER (SR5 p.382, "Gangers & Street Scum"):
+ * the catalog's `gangers` npc-kit row -- B/A 4, R 3, S 4, W/I/C 3, L 2,
+ * Blades 4 / Clubs 3 / Intimidation 4 / Pistols 4 / Unarmed 3,
+ * Toughness, an armor vest, a Browning Ultra-Power, a knife and a Meta
+ * Link (npc-kits.ts; the rows live on maka-cli.com, catalog v21).
  *
- * Copied rather than invented, and deliberately NOT scaled up. Canon's
- * own barrens encounter calls a gang ambush "a straightforward, quick,
- * and easy fight" for runners (Splintered State p.11). A mob that
- * threatened a professional crew would be a set piece, and a set piece
- * is a scene NPC's job, not a passing face's.
+ * THIS USED TO BE A CONSTANT HERE, and the constant was the bug. It
+ * said "canon stats" while giving them `firearms: 3` -- a skill that
+ * has not existed since stage 3 (skills.ts), written and never read --
+ * and no gun, so a "ganger with Pistols" always closed to punching
+ * range. The row carries the book's line, gear included, and a
+ * pre-v21 cache resolves to no kit, in which case the fallback block
+ * below is what they get: the old numbers, minus the dead key.
+ *
+ * Deliberately NOT scaled up. Canon's own barrens encounter calls a
+ * gang ambush "a straightforward, quick, and easy fight" for runners
+ * (Splintered State p.11). A mob that threatened a professional crew
+ * would be a set piece, and a set piece is a scene NPC's job, not a
+ * passing face's.
  */
-const GANGER_COMBAT = {
-    body: 4, agility: 4, reaction: 4, strength: 4,
-    willpower: 3, logic: 3, intuition: 3, charisma: 3,
+export const GANGER_KIT = 'gangers';
+const GANGER_FALLBACK_COMBAT = {
+    body: 4, agility: 4, reaction: 3, strength: 4,
+    willpower: 3, logic: 2, intuition: 3, charisma: 3,
     edge: 1, combatSkill: 3,
-    skills: { blades: 3, clubs: 3, intimidation: 3, firearms: 3, unarmed: 3, perception: 2 },
+    skills: { blades: 4, clubs: 3, intimidation: 4, pistols: 4, unarmed: 3, perception: 2 },
 };
 /** How often a street corner turns out to be somebody's corner. */
 const GANG_CHANCE = 0.08;
@@ -116,7 +127,8 @@ export function maybeStreetGang(host, actor, room) {
             // with it through the doorway.
             until: 'fight',
             room,
-            combat: GANGER_COMBAT,
+            kit: GANGER_KIT,
+            combat: GANGER_FALLBACK_COMBAT,
         });
         if (!npc)
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.201.0",
+  "version": "5.202.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",