@maka/maka-cli 5.200.0 → 5.202.0

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/drone-prose.js

@@ -246,7 +246,15 @@ export function droneReconNowhereLine(item) {
         missile: `The ${item.name} climbs, circles once -- nowhere to go from here.`,
     });
 }
-export function droneReconLaunchLine(item, rollText, ok) {
+/**
+ * THE PROSE NO LONGER CARRIES THE DICE (wjFBY3zgyWzJP9adw sweep). This
+ * baked `Piloting: 8d6 -> 2 hits` into the world log while every other
+ * player test in the engine sends its anatomy to the Mechanics panel --
+ * the recon sweep was the one roll a rigger had to read out of a
+ * sentence. `rollText` is gone; commands/drone.ts emits the roll through
+ * logger.meta, and this line goes back to being prose.
+ */
+export function droneReconLaunchLine(item, ok) {
     const off = pick(item, {
         'flier-palm': `The ${item.name} whirs off your palm`,
         flier: `The ${item.name} lifts off your hand`,
@@ -256,7 +264,7 @@ export function droneReconLaunchLine(item, rollText, ok) {
         missile: `The ${item.name} kicks off its rail`,
     });
     if (!ok)
-        return `${off} -- Piloting: ${rollText}`;
+        return off;
     const threads = pick(item, {
         'flier-palm': 'threads the gaps',
         flier: 'threads the gaps',
@@ -265,7 +273,7 @@ export function droneReconLaunchLine(item, rollText, ok) {
         anthro: 'goes to look',
         missile: 'makes a fast pass',
     });
-    return `${off} and ${threads} -- Piloting: ${rollText}. Feed incoming:`;
+    return `${off} and ${threads}. Feed incoming:`;
 }
 export function droneReconReturnLine(item) {
     return pick(item, {

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/grid-names.js

@@ -77,6 +77,48 @@ export function hostLabel(room, opts = {}) {
     const bare = room.name.replace(/^the\s+/i, '');
     return `${opts.capital ? 'The' : 'the'} ${bare} host`;
 }
+/**
+ * WHAT THE HOST RUNS ON, ONCE YOU HAVE PAID FOR IT (np6YBSPsdfAY7NcuZ,
+ * Maka: "data like this ... shouldn't be visible without a matrix search
+ * on the host").
+ *
+ * `Host.purpose` is seed content and the generator is told to fill it
+ * with "what this place runs on its host and so what is worth protecting
+ * inside it" (factories/scene-chunks.ts) -- so in practice it enumerates
+ * the archive: "patient intake logs, med supply orders, and the doc's
+ * private black book of who paid what for what". Four renderers printed
+ * that on the host's OUTSIDE icon with no roll, which handed a passer-by
+ * the inventory of a sealed host for free. The file NAMES were already
+ * gated (grid-view.ts, Host.searchedBy); only this phrase leaked.
+ *
+ * TWO TIERS, and both are rolls the engine already makes
+ * (commands/search.ts matrixSearch):
+ *
+ *   tier 1  Room.searchedBy -- the threshold-1 public row out on the
+ *           grid (MATRIX_SEARCH.public). What the place runs on its host
+ *           is the kind of thing a public search turns up: canon has the
+ *           icon look like the shop (p.219). This set is also flipped by
+ *           a MEAT search of the room, and that is intended -- casing the
+ *           clinic in the flesh is a fair way to learn it keeps a ledger.
+ *   tier 2  Host.searchedBy -- the threshold-3 archive search from
+ *           inside, which additionally NAMES the files (grid-view.ts).
+ *
+ * A cracked host spills it free, exactly as its files already do: the
+ * seal is broken, there is nothing left to hide behind.
+ *
+ * Returns undefined when the seed declared no purpose OR the persona has
+ * not earned it, so every caller can `??` it away.
+ */
+export function hostPurposeFor(room, actor) {
+    const host = room.host;
+    if (!host?.purpose)
+        return undefined;
+    if (host.cracked)
+        return host.purpose;
+    return host.searchedBy.has(actor.name) || room.searchedBy.has(actor.name)
+        ? host.purpose
+        : undefined;
+}
 export function hostNameHint(room) {
     return room.hasNode ? `the host here answers to "host" or "${room.name}"` : '';
 }

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-reach.js

@@ -1,5 +1,5 @@
 import { hostConcealedFrom } from './jackpoint.js';
-import { matchesHostName, hostLabel, hostAliases } from './grid-names.js';
+import { matchesHostName, hostLabel, hostAliases, hostPurposeFor } from './grid-names.js';
 import { fuzzyPickName, normalizeLoose } from './fuzzy-match.js';
 import { MAX_MARKS } from './marks.js';
 /**
@@ -193,10 +193,15 @@ export function hostLine(room, actor) {
     // A haven shows no rating and no eyes (jackpoint.ts): it is not a
     // thing you crack, so the numbers you would crack it with stay off.
     const rating = room.hostSanctioned ? '' : ` [HR ${room.hostRating}]`;
-    // The host's business, where the seed declared one (Host.purpose): a
-    // grid map that tells a clinic's records from a club's door list is
-    // the map that lets a runner pick a target.
-    const purpose = room.host?.purpose ? ` (${room.host.purpose})` : '';
+    // The host's business, where the seed declared one AND this persona has
+    // searched for it (hostPurposeFor, np6YBSPsdfAY7NcuZ). A grid map that
+    // tells a clinic's records from a club's door list is the map that lets
+    // a runner pick a target -- but it is a Matrix Search that draws it,
+    // not a glance. Map rows stay terse when it is unearned: the verb is
+    // taught on the host's own icon (grid-view.ts gridIcons), not once per
+    // row of a map that may list a dozen.
+    const found = hostPurposeFor(room, actor);
+    const purpose = found ? ` (${found})` : '';
     return `${inside ? '▣' : '●'} ${hostLabel(room, { capital: true })}${rating}${purpose}${onGrid} -- ${standing}${alert}${over}${inside ? ' -- INSIDE' : ''}`;
 }
 /** The Map dock's one-line host: icon, name, rating, standing -- cut to the dock. */

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-view.js

@@ -2,7 +2,7 @@ import { sameHostSide } from '../models/player.js';
 import { personasInside } from './matrix-roster.js';
 import { hostsInReach, hostLine, roomsInReach, gridVicinity } from './grid-reach.js';
 import { NPC } from '../models/npc.js';
-import { hostLabel } from './grid-names.js';
+import { hostLabel, hostPurposeFor } from './grid-names.js';
 import { isLinked } from './comm-style.js';
 import { isWatched, camerasLive, canSnoopFeeds } from './surveillance.js';
 /**
@@ -65,10 +65,13 @@ export function gridIcons(scene, actor, room) {
         // books never gave it -- boilerplate describing the opposite of what
         // the place is. A member is standing in a room they belong to.
         const hr = ` {bold}[HR ${room.hostRating}]{/bold}`;
-        // WHAT IT IS FOR rides the outside icon too: a host's business is
-        // public knowledge -- "your local Stuffer Shack has a host icon"
-        // (p.219) and the icon looks like the shop. The inside stays sealed.
-        const purpose = room.host?.purpose ? ` (${room.host.purpose})` : '';
+        // WHAT IT IS FOR rides the outside icon -- but only once a Matrix
+        // Search has turned it up (hostPurposeFor, np6YBSPsdfAY7NcuZ). The
+        // icon looking like the shop (p.219) is the NAME, which this line
+        // always prints; the seed's purpose phrase is an inventory of the
+        // archive, and handing that over for free is the report.
+        const found = hostPurposeFor(room, actor);
+        const purpose = found ? ` (${found})` : '';
         if (room.hostSanctioned) {
             icons.push(`● ${hostLabel(room, { capital: true })} -- three spheres turning over rooms that were never sold to anyone. You're on the list; nothing here is hunting.`);
         }
@@ -82,7 +85,18 @@ export function gridIcons(scene, actor, room) {
             // anyone inside it are on the far side of a wall (p.246). The
             // marks line stays because a mark is the DOOR (p.239), so it is
             // the one fact about the inside that belongs on the outside.
-            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- sculpted ice geometry, sealed. Whatever it holds is inside it.${room.hostAlert ? ' Walls UP -- it holds a mark on an intruder.' : ''}${myMarks > 0 ? ` [your marks: ${myMarks}/3]` : ''} (${myMarks > 0 ? '"enter" walks in on your mark; ' : ''}"hack" slips in on sleaze; "hack loud" smashes; "mark" softens it first)`);
+            // The verb that EARNS the purpose phrase is offered only while it
+            // is still unearned -- a host that has already told you its
+            // business has nothing left to sell. Built as a list so a dropped
+            // entry cannot leave a dangling separator.
+            const ways = [
+                ...(myMarks > 0 ? ['"enter" walks in on your mark'] : []),
+                '"hack" slips in on sleaze',
+                '"hack loud" smashes',
+                '"mark" softens it first',
+                ...(found ? [] : ['"search" reads what it runs (p.241)']),
+            ];
+            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- sculpted ice geometry, sealed. Whatever it holds is inside it.${room.hostAlert ? ' Walls UP -- it holds a mark on an intruder.' : ''}${myMarks > 0 ? ` [your marks: ${myMarks}/3]` : ''} (${ways.join('; ')})`);
         }
     }
     // WHERE THE HOST'S OWN ICON ENDS AND THE STREET BEGINS.
@@ -457,7 +471,11 @@ export function gridSculpt(actor, room) {
         // sculpting is shown as that -- the purpose on the header, the
         // sculpt where the boilerplate used to stand. The boilerplate stays
         // for a hand-authored host that declared neither.
-        const purpose = room.host?.purpose;
+        // The purpose is still the searched-for fact in here (hostPurposeFor):
+        // standing inside a host is not the same as having read its index.
+        // The SCULPT is not gated -- it is the architecture around you, and
+        // you are looking at it.
+        const purpose = hostPurposeFor(room, actor);
         const sculpt = room.host?.sculpt;
         return [
             `{light-blue-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/light-blue-fg}`,
@@ -559,8 +577,11 @@ export function hostInteriorPanel(scene, actor, host, rows, cols) {
     const cut = (raw) => `{light-blue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/light-blue-fg}`;
     const lines = [];
     lines.push(cut(`INSIDE ${host.name}`));
-    if (host.purpose)
-        lines.push(cut(host.purpose));
+    // Same gate as every other renderer (hostPurposeFor): the dock is a
+    // view, not a back door.
+    const purpose = hostPurposeFor(host.over, actor);
+    if (purpose)
+        lines.push(cut(purpose));
     const marks = host.marksBy.get(actor.name) ?? 0;
     lines.push(cut(host.sanctioned
         ? 'haven -- welcome here'
@@ -574,7 +595,13 @@ export function hostInteriorPanel(scene, actor, host, rows, cols) {
             continue;
         lines.push(cut(`◆ ${a.name}`));
     }
-    const files = host.files().length;
+    // THE COUNT IS PART OF THE ARCHIVE (np6YBSPsdfAY7NcuZ). The icon list
+    // above gates the file NAMES on a Matrix Search; this line quietly
+    // published how many there were regardless, which is most of what the
+    // roll was protecting -- "three files sealed" tells a runner whether
+    // the trip is worth it. Same gate, same set.
+    const indexed = host.cracked || host.searchedBy.has(actor.name);
+    const files = indexed ? host.files().length : 0;
     if (files > 0)
         lines.push(cut(`◇ ${files} file${files === 1 ? '' : 's'} ${host.cracked ? 'open' : 'sealed'}`));
     return lines.slice(0, Math.max(1, rows));

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

@@ -47,6 +47,18 @@ async function tell(enc, scene, turn) {
  */
 export async function hostTurnStart(scene, host, enc) {
     const out = empty();
+    // SUPPRESSION (p.257, sprite-power-actions.ts): a sprite arguing with
+    // the host's launch paths delays what it brings up by (Level / 2)
+    // Combat Turns, and "delayed IC can't act or be targeted" -- which is
+    // exactly "the launch step does not happen this turn". Counted down
+    // here so the delay is spent whether or not the host wanted to launch.
+    if (host.icLaunchDelay > 0) {
+        host.icLaunchDelay -= 1;
+        out.lines.push(`{light-blue-fg}Something in ${host.name}'s architecture is arguing with itself -- whatever it meant to bring up does not arrive.{/light-blue-fg}`);
+        seatRunningIce(enc, host);
+        await tell(enc, scene, out);
+        return;
+    }
     hostLaunchStep(host.over, scene, out);
     seatRunningIce(enc, host);
     await tell(enc, scene, out);

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

@@ -18,6 +18,16 @@ export function clearMarksPlacedBy(scene, placerName) {
     for (const room of Object.values(scene.getRooms())) {
         if (room.hostMarksBy.delete(placerName))
             cleared++;
+        // A DEVICE'S MARKS ARE MARKS (f79LLqTerep4nKWcA sweep). Device.marksBy
+        // is the third ledger -- hack.ts writes it for every slaved and loose
+        // icon -- and no wipe had ever touched it, so the maglock you keyed
+        // last run still answered to a persona canon says was deleted on
+        // reboot (p.236). It also meant `disable` could drive a device on
+        // marks the sheet no longer showed you holding.
+        for (const device of room.allDevices()) {
+            if (device.marksBy.delete(placerName))
+                cleared++;
+        }
     }
     for (const a of scene.allActors) {
         if (a.panMarksBy.delete(placerName))
@@ -71,6 +81,13 @@ export function describeMarks(scene, placerName) {
         const n = room.hostMarksBy.get(placerName) ?? 0;
         if (n > 0)
             lines.push(`● ${hostLabel(room, { capital: true })} -- ${n} mark${n === 1 ? '' : 's'}${n >= MAX_MARKS ? ' (it thinks you belong)' : ''}`);
+        // Devices too -- the ledger `disable` reads to drive a maglock was
+        // invisible on the listing that is supposed to show what you hold.
+        for (const device of room.allDevices()) {
+            const d = device.marksBy.get(placerName) ?? 0;
+            if (d > 0)
+                lines.push(`▲ ${device.name} -- ${d} mark${d === 1 ? '' : 's'}`);
+        }
     }
     for (const a of scene.allActors) {
         const n = a.panMarksBy.get(placerName) ?? 0;
@@ -92,6 +109,11 @@ export function marksPlaced(scene, placerName) {
         const n = room.hostMarksBy.get(placerName) ?? 0;
         if (n > 0)
             out.push({ target: hostLabel(room, { capital: true }), count: n });
+        for (const device of room.allDevices()) {
+            const d = device.marksBy.get(placerName) ?? 0;
+            if (d > 0)
+                out.push({ target: device.name, count: d });
+        }
     }
     for (const a of scene.allActors) {
         const n = a.panMarksBy.get(placerName) ?? 0;

package/bundle/typescript/src/commands/game/sideQuest/utilities/mechanics-audience.js

@@ -0,0 +1,71 @@
+/**
+ * WHO IS WATCHING THE DICE (wjFBY3zgyWzJP9adw, Deditri: "the sprite put a
+ * mark on the target but there was no output about the rolls in the
+ * logs").
+ *
+ * The sprite's dice WERE rolled. `order <sprite> mark <lock>` runs the
+ * real verb with the sprite as actor -- commands/order.ts hands the
+ * string to NPC.tryRunCommand, commands/mark.ts re-dispatches into
+ * HackCommand, and hack.ts rolls Hack on the Fly against the device
+ * exactly as it would for a decker. The roll was then thrown away at the
+ * REPORTING layer, by a guard that has been copied into ~30 commands:
+ *
+ *     if (this.scene.isHumanControlled(actor)) this.logger.meta(...)
+ *
+ * That asks "is the ROLLER a human". The question the Mechanics panel
+ * actually wants is "is a HUMAN WATCHING" -- and the codebase already
+ * answers it correctly two files over, in CombatExchange.playerWitnesses
+ * (utilities/combat-exchange.ts), which is precisely why a sprite's
+ * COMBAT rolls have always shown up while the same sprite's ordered
+ * mark went silent. One question, asked two ways, in one engine.
+ *
+ * WHY OWNERSHIP AND NOT PROXIMITY. playerWitnesses is a bystander test:
+ * same place, perceivable plane. That is right for a fight, which is an
+ * event in a room. It is wrong for an ORDER, which is a thing the player
+ * deliberately did: a rigger whose drone is sweeping the floor above,
+ * or a technomancer whose sprite is working a host their body is nowhere
+ * near, typed that command and is owed its dice. So a companion's rolls
+ * are shown to its master wherever it is standing. Anything that is
+ * NOT a companion -- IC, a guard, a passer-by -- keeps the old silence
+ * and reports through the channels it already had (utilities/ic.ts
+ * accumulates into IICTurn.meta; a fight goes through announce).
+ *
+ * THE FORK MUST STAY EXCLUSIVE. Several commands route the roll to
+ * EITHER the Mechanics panel (player) OR their own return string, which
+ * for an NPC is its AI history:
+ *
+ *     const isPlayer = scene.isHumanControlled(actor);
+ *     if (isPlayer) this.logger.meta(`Perception: ${formatRoll(roll)}`);
+ *     const rollPrefix = isPlayer ? '' : `Perception: ${formatRoll(roll)}\n`;
+ *
+ * Both halves must read the SAME predicate or an ordered companion
+ * prints its dice twice. Callers swapping to showsMechanics must swap
+ * both.
+ */
+/** The companion ledger entry for this actor, if it is somebody's. */
+function companionEntryFor(scene, actor) {
+    return scene.ownerGame?.companions?.find(c => c.npc === actor);
+}
+/**
+ * Should this actor's dice anatomy go to the Mechanics panel?
+ *
+ * True for a human-controlled actor (the old rule, unchanged), and for a
+ * companion a human is running -- a sprite, spirit, agent or drone whose
+ * master typed the order that got here.
+ */
+export function showsMechanics(scene, actor) {
+    if (scene.isHumanControlled?.(actor) === true)
+        return true;
+    return companionEntryFor(scene, actor) !== undefined;
+}
+/**
+ * The name to hang on a Mechanics line when the roller is not the player
+ * -- "Crack Sprite -- Hack on the Fly (sleaze) on Hatch Maglock: ...".
+ * Empty for the player's own rolls, which stay exactly as they read
+ * today: a panel that started prefixing the player's own name on every
+ * line would be noisier for the common case to serve the rare one.
+ */
+export function mechanicsActorPrefix(scene, actor) {
+    return scene.isHumanControlled?.(actor) === true ? '' : `${actor.name} -- `;
+}
+//# sourceMappingURL=mechanics-audience.js.map

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)
@@ -601,6 +605,9 @@ function serializeRoomOverlay(room, player) {
             inventory: b.inventory.getAllItems().map(serializeItem),
         })),
         searchedBy: [...room.searchedBy],
+        // A SANCTIONED HOST KEEPS NO INDEX EITHER, for the same reason it
+        // forgets a crack: a haven is not a target you cased.
+        hostSearchedBy: room.hostSanctioned ? [] : [...(room.host?.searchedBy ?? [])],
         visitedBy: [...room.visitedBy],
         // A SANCTIONED HOST NEVER REMEMBERS A CRACK (Room.hostSanctioned).
         // The overlay rule is right for run content -- you broke that
@@ -771,6 +778,10 @@ export function applyHubOverlay(scene, saved, player, homeRoom) {
             return { name: b.name, cell: { ...b.cell }, inventory: held };
         });
         room.searchedBy = new Set(overlay.searchedBy);
+        // Only onto a room that HAS a host -- a seed that dropped its node
+        // between saves must not grow one back through the overlay.
+        if (room.host)
+            room.host.searchedBy = new Set(overlay.hostSearchedBy ?? []);
         room.visitedBy = new Set(overlay.visitedBy);
         // Both ends, so an OLD save written before hostSanctioned existed
         // cannot restore a cracked haven either.

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

@@ -14,7 +14,13 @@
  */
 export const PROGRAMS = [
     // ---- Common programs (p.245; pricing canon-approximate) ----
-    { key: 'browse', name: 'Browse', kind: 'common', cost: 80, availability: 2, effect: '+2 dice on Matrix Search while jacked in.' },
+    // BROWSE BUYS TIME, NOT DICE (Splintered State p.54: it "cuts the base
+    // time in half"). The catalogue advertised "+2 dice on Matrix Search"
+    // and no code ever added them -- utilities/perception.ts has always
+    // halved the clock, which is the half that is right. A program whose
+    // shop blurb promises a bonus it does not grant is a lie the player
+    // pays 80 nuyen for.
+    { key: 'browse', name: 'Browse', kind: 'common', cost: 80, availability: 2, effect: 'Halves the base time of a Matrix Search (p.241).' },
     { key: 'toolbox', name: 'Toolbox', kind: 'common', cost: 80, availability: 2, effect: '+1 Data Processing.' },
     { key: 'encryption', name: 'Encryption', kind: 'common', cost: 80, availability: 2, effect: '+1 Firewall.' },
     { key: 'signal-scrub', name: 'Signal Scrub', kind: 'common', cost: 80, availability: 2, effect: 'Cleans your noise floor: +1 die defending your PAN.' },