@maka/maka-cli 5.181.0 → 5.183.0

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

@@ -2,10 +2,12 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { planeTintItemName, emphasizeFind, objectiveMark, fileReach } from '../utilities/planes.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
-import { perceptionTest } from '../utilities/perception.js';
+import { perceptionTest, matrixSearchTest, matrixSearchSeconds, MATRIX_SEARCH } from '../utilities/perception.js';
+import { gridVicinity } from '../utilities/grid-reach.js';
+import { hostLabel } from '../utilities/grid-names.js';
 import { canReach, exitSpot, spotsActive, revealWithPerception, theSpot, sealedRouteTo, } from '../utilities/spots.js';
 import { placeName } from '../utilities/log-style.js';
-import { billAction } from '../utilities/action-cost.js';
+import { billAction, encounterOf } from '../utilities/action-cost.js';
 /**
  * Barrier rendering (2026-08-24 playtest: "I don't see THE THING I'm
  * supposed to act on -- just a description... and I still see the
@@ -135,8 +137,84 @@ ${coach}`;
 export class SearchCommand extends Command {
     static verb = 'search';
     static description = 'Search for items in your area';
+    /**
+     * MATRIX SEARCH (SR5 p.241, player ruling 2026-09-13: "a true matrix
+     * search, not perception, revealing what is inside a host if it's
+     * cracked open").
+     *
+     * A Special action: Computer + Intuition [Data Processing] against a
+     * threshold from the Matrix Search Table, and it takes TIME -- one
+     * minute inside a host whatever the information, net hits over the
+     * threshold dividing it, a miss spending it all, a Browse program
+     * halving it (utilities/perception.ts). The time is real: it moves
+     * the persona's Overwatch clock back, so a slow search inside a host
+     * is what GOD bills for (utilities/overwatch.ts billTime, +2d6 per
+     * 15 minutes).
+     *
+     * WHAT IT FINDS. Inside a host, the host's archive: from then on the
+     * interior lists its files for this persona (Host.searchedBy,
+     * grid-view.ts). A CRACKED host spills them without the roll -- the
+     * seal is broken, there is nothing to find. Out on the grid it is the
+     * public-knowledge row: the loose data icons in reach.
+     */
+    matrixSearch() {
+        const actor = this.actor;
+        const host = actor.hostInside;
+        const where = host ? host.over : gridVicinity(actor);
+        const row = host ? MATRIX_SEARCH.inHost : MATRIX_SEARCH.public;
+        const browse = actor.activeDeck?.hasProgram('browse') ?? false;
+        const { pool, limit } = matrixSearchTest(actor);
+        const roll = rollPool(pool, limit);
+        const seconds = matrixSearchSeconds(row.seconds, roll.hits, row.threshold, browse);
+        const isPlayer = this.scene.isHumanControlled(actor);
+        if (isPlayer) {
+            this.logger.meta(`Matrix Search (Computer + Intuition [Data Processing], threshold ${row.threshold}${browse ? ', Browse' : ''}): ${formatRoll(roll)} -- ${seconds}s`);
+        }
+        // THE MINUTES ARE GOD'S (p.231-232): Overwatch bills time on the
+        // grid, and a search is time. Winding the last tick back by the
+        // seconds spent is what makes the next illegal action pay for them.
+        if (actor.overwatchLastTick > 0)
+            actor.overwatchLastTick -= seconds * 1000;
+        actor.performAction('runs a Matrix Search', host ? `inside ${hostLabel(where)}` : `across ${where.name}'s grid`);
+        const files = where.offlineServer ? [] : where.inventory.getAllItems().filter(i => i.plane === 'matrix');
+        const clock = `(${seconds}s of Matrix time${browse ? ', Browse cutting it' : ''})`;
+        if (roll.hits < row.threshold) {
+            return host
+                ? `You dig through ${hostLabel(where)}'s archive and the index keeps folding away from you -- nothing this pass. ${clock}${hint(` Try again; the host is not going anywhere.`)}`
+                : `You sweep ${where.name}'s grid for loose data and turn up nothing this pass. ${clock}`;
+        }
+        if (host) {
+            host.searchedBy.add(actor.name);
+            where.searchedBy.add(actor.name);
+            if (files.length === 0) {
+                return `The archive is indexed and EMPTY -- ${hostLabel(where)} keeps nothing worth the trip. ${clock}`;
+            }
+            const list = files.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+            const seal = where.hostCracked
+                ? hint(` ("take" them -- the seal is already broken.)`)
+                : hint(` (sealed in the host's data vault: "hack" the node to break the seal, then "take".)`);
+            return `The index gives up ${hostLabel(where)}'s archive: ${list}. ${clock}${seal}`;
+        }
+        where.searchedBy.add(actor.name);
+        const loose = where.hasNode ? [] : files;
+        if (loose.length === 0) {
+            const sealedElsewhere = files.length > 0 && where.hasNode;
+            return `Nothing loose on ${where.name}'s grid. ${clock}${sealedElsewhere ? hint(` (${hostLabel(where)} keeps its files INSIDE -- "enter" it and search from in there.)`) : ''}`;
+        }
+        const list = loose.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+        return `Loose on ${where.name}'s grid: ${list}. ${clock}${hint(` ("take" rides them out on your deck.)`)}`;
+    }
     async execute(_args) {
         const room = this.actor.currentLocation;
+        // A MATRIX SEARCH IS MEASURED IN MINUTES (p.241: base time one
+        // minute inside a host), not in Action Phases -- there is no cost to
+        // bill inside a Combat Turn, so it is refused there rather than
+        // priced by invention.
+        if (this.actor.plane === 'matrix' && encounterOf(this.scene, this.actor)) {
+            return `Not with the ice on you -- a Matrix Search takes minutes (p.241), and a Combat Turn is three seconds. Crash the ice or get out first.`;
+        }
+        if (this.actor.plane === 'matrix')
+            return this.matrixSearch();
         // OBSERVE IN DETAIL (SR5 p.165): the Perception Test below is the
         // Simple Action the book names, inside a Combat Turn.
         const bill = billAction(this.scene, this.actor, 'simple', 'Observe in Detail');
@@ -148,17 +226,14 @@ export class SearchCommand extends Command {
         // room stays uncased ("take all" stays gated). Barriers (puzzles) are
         // in plain sight and show regardless -- you can't fail to notice the
         // maglock you're staring at.
-        // On the GRID a search is Matrix Search (canon: Computer, Logic) --
-        // best-of with perception so pre-computer deckers lose nothing.
-        // A loaded Browse program is purpose-built for Matrix Search: +2.
-        const browse = this.actor.plane === 'matrix' && this.actor.activeDeck?.hasProgram('browse') ? 2 : 0;
         // ACTIVE: this is the deliberate hunt, so it carries p.135-136's +3
         // for "perceiver is specifically looking for it" -- the modifier
         // that makes `search` mechanically different from `look` rather
         // than only differently named (FNgptvRhbA5yMunbB). The pool and the
         // bracket both live in utilities/perception.ts; look.ts rolls the
-        // same test without the +3.
-        const { pool, limit } = perceptionTest(this.actor, { active: true, browse });
+        // same test without the +3. The grid never comes through here: a
+        // persona's search is matrixSearch() above.
+        const { pool, limit } = perceptionTest(this.actor, { active: true });
         const roll = rollPool(pool, limit);
         // Roll anatomy to the Mechanics ticker for the player; an NPC's
         // return string is its AI history, so IT keeps the roll inline
@@ -227,28 +302,7 @@ export class SearchCommand extends Command {
         if (spotted.length > 0) {
             description += `\n{yellow-fg}You pick ${spotted.map(a => a.name).join(', ')} out of the shadows -- ${spotted.length === 1 ? 'they were' : 'they were'} there the whole time.{/yellow-fg}`;
         }
-        // Data is LOOT -- say so while the persona is standing on it, with the
-        // vault state attached: sealed files need the host cracked first. A
-        // real session's decker found the paydata jacked-in, didn't realize it
-        // was takeable from the grid, and went hunting for it in the meat.
-        if (this.actor.plane === 'matrix' && found.some(i => i.plane === 'matrix')) {
-            description += room.hasNode && !room.offlineServer && !room.hostCracked
-                ? `\n{cyan-fg}(the files sit sealed in the host's data vault -- "hack" the node to unseal them){/cyan-fg}`
-                : hint(`\n{cyan-fg}(data files are loot -- "take" them right here on the grid; they ride out on your deck){/cyan-fg}`);
-        }
-        // A persona sweeping the grid OUTSIDE a host: the files exist and
-        // this sweep cannot reach them. Say why, rather than reading empty
-        // -- a silent nothing is what made the old air-gap case feel broken.
-        if (this.actor.plane === 'matrix' && !filesInReach
-            && room.inventory.getAllItems().some(i => i.plane === 'matrix')) {
-            if (room.offlineServer) {
-                description += `\n{cyan-fg}There is a ${room.offlineServer} in this room and it is NOT on the Matrix -- nothing you can do from out here touches it.${hint(` Walk in and cable into it in the flesh.`)}{/cyan-fg}`;
-            }
-            else {
-                const marked = (room.hostMarksBy.get(this.actor.name) ?? 0) > 0 || room.hostCracked;
-                description += `\n{cyan-fg}This sweep only covers the open grid. Whatever the host holds is INSIDE it, behind its wall (p.246).${hint(marked ? ` "enter" and search again.` : ` A mark is the door -- "mark" the host, then "enter".`)}{/cyan-fg}`;
-            }
-        }
+        // The grid never reaches here: a persona's search is matrixSearch().
         // The mirror hint: a meat-side search can't see matrix files, but it
         // shouldn't pretend the room is empty when the good stuff is one
         // "jack in" away.

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

@@ -440,5 +440,14 @@
 // 1.52.0 (2026-09-12): THE EMBEDDED HUB SEED IS GONE FROM SAVES. The one
 //   release of dual-writing is over: a save carries hubSeedRef only, and
 //   the site (sheet fallback) reads hubSeed on older docs alone.
-export const ENGINE_VERSION = '1.52.0';
+// 1.53.0 (2026-09-13): THE MATRIX JOINS THE COMBAT TURN. A host fight is a
+//   CombatEncounter in a host arena (encounters are keyed by arena: room,
+//   host, or the open grid); the host launches one IC per Combat Turn at
+//   the turn's start, each program is a participant with 4D6 whose phase
+//   the ice brain plays, a Data Spike is the phase's Complex attack, and
+//   hack/enter/exit/look/jack out bill their canon action cost inside a
+//   Combat Turn. IC no longer act once per player command, never speak,
+//   and a failed IC attack damages the program (p.247). Ice NPCs are no
+//   longer generated; the vault host's rating is its guard.
+export const ENGINE_VERSION = '1.53.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -41,8 +41,9 @@ import { getPref } from './utilities/prefs.js';
 import { rollPool, formatRoll } from './utilities/dice.js';
 import { Direction } from './types/shared/direction-enum.js';
 import { Logger } from './utilities/logger.js';
-import { runHostTurn } from './utilities/ic.js';
-import { leaveMatrix, endPersona } from './utilities/planes.js';
+import { hostIsHunting, ambientPatrol } from './utilities/ic.js';
+import { hostContactBeat } from './utilities/host-combat.js';
+import { endPersona } from './utilities/planes.js';
 import { CommandQueue } from './utilities/command-queue.js';
 import { currentSession } from './utilities/session-context.js';
 import { PlayersCommand } from './commands/players.js';
@@ -108,6 +109,7 @@ import { EndCallCommand } from './commands/end-call.js';
 import { fuzzyPickName, guessVerb } from './utilities/fuzzy-match.js';
 import { PickCommand } from './commands/pick.js';
 import { HackCommand } from './commands/hack.js';
+import { DisableCommand, BrickCommand } from './commands/disable.js';
 import { CastCommand } from './commands/cast.js';
 import { StanceCommand } from './commands/stance.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
@@ -2482,7 +2484,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 isParty: a => a !== player && this.scene.isHumanControlled(a),
                 // Whose Action Phase is live in the viewer's room
                 // (PYK6zCKhQcjRFwLSQ); undefined between phases and out of a fight.
-                phaseActor: () => this.scene.encounterIn(player.currentLocation)?.phaseActor?.name,
+                // The viewer's own fight first -- a persona's is inside its host,
+                // not in the room its body sits in.
+                phaseActor: () => (this.scene.encounterFor(player) ?? this.scene.encounterIn(player.currentLocation))?.phaseActor?.name,
             }))
                 .catch(() => undefined);
         };
@@ -2593,6 +2597,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('end-call', EndCallCommand);
         CommandFactory.registerCommand('pick', PickCommand);
         CommandFactory.registerCommand('hack', HackCommand);
+        CommandFactory.registerCommand('disable', DisableCommand);
+        CommandFactory.registerCommand('brick', BrickCommand);
         CommandFactory.registerCommand('cast', CastCommand);
         CommandFactory.registerCommand('stance', StanceCommand);
         CommandFactory.registerCommand('surrender', SurrenderCommand);
@@ -6044,7 +6050,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             if (this.scene.isHumanControlled(actor))
                 this.scene.beat += 1;
             const result = await command.execute(args);
-            const wrapped = await this.withHostileContact(actor, this.withEphemeralTurn(actor, this.withAlarmTurn(actor, this.withICTurn(actor, result))));
+            const hosted = await this.withHostTurn(actor, result);
+            const wrapped = await this.withHostileContact(actor, this.withEphemeralTurn(actor, this.withAlarmTurn(actor, hosted)));
             // The IC turn above may have filled a track -- settle it now, not
             // on the next keystroke.
             const settled = await settleUnresolvedHarm(this.scene, actor);
@@ -6178,19 +6185,43 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const lines = await hostileContactBeat(this.scene, actor, this.scene.beat);
         return lines.length === 0 ? result : `${result}\n\n${lines.join('\n')}`;
     }
-    withICTurn(actor, result) {
+    /**
+     * THE HOST'S BEAT after every command a persona types inside one
+     * (p.246-247: the ice acts on what is in the host).
+     *
+     * Before the host has made you, this is ambient Patrol on its clock
+     * (utilities/ic.ts ambientPatrol) -- the per-command tick of that
+     * clock is an engine mapping and its own comment says so. Once the
+     * host is hunting, the fight is a Combat Turn in the host's arena
+     * (utilities/host-combat.ts): the first beat opens it, and after
+     * that the programs act in their OWN Action Phases, not on every
+     * keystroke. The old shape -- every running program taking a swing
+     * per player command, with its dice and lines appended to whatever
+     * the command printed -- is gone; Vex's log had four programs and
+     * twelve lines answering "look".
+     */
+    async withHostTurn(actor, result) {
         if (result === null)
             return null;
-        // The host's turn happens INSIDE it (p.246-247): the ice acts on what
-        // is in the host, and the persona's position says whether it is.
         const host = actor.hostInside;
         if (!host || actor.plane !== 'matrix')
             return result;
-        const turn = runHostTurn(host.over, actor, this.scene);
+        if (hostIsHunting(host.over, actor)) {
+            if (this.scene.encounterInHost(host)?.has(actor))
+                return result;
+            // THE COMMAND'S OWN REPLY PRINTS FIRST. The encounter announces
+            // itself while it opens (the aggressor, Surprise, the order), so
+            // a result returned afterwards would land under all of that,
+            // out of order -- the same trick hostile-contact.ts uses.
+            if (result.length > 0 && this.scene.isHumanControlled(actor)) {
+                Logger.getInstance().log(result, { actor: actor.name });
+            }
+            await hostContactBeat(this.scene, actor);
+            return '';
+        }
+        const turn = ambientPatrol(host.over, actor);
         if (turn.lines.length === 0 && turn.meta.length === 0)
             return result;
-        // Dice to the Mechanics pane, and only for a human -- the same gate
-        // every other roll in this engine uses.
         if (this.scene.isHumanControlled(actor)) {
             const logger = Logger.getInstance();
             for (const m of turn.meta)
@@ -6198,36 +6229,16 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         }
         for (const w of turn.world)
             this.scene.addWorldEvent(w);
-        // A deck bricked by IC owes the same forced dump a convergence does.
-        // ic.ts reports it rather than performing it -- leaveMatrix needs the
-        // Scene and that module deliberately takes none, exactly as hack.ts
-        // splits the convergence hammer from the dump that follows it.
-        if (turn.bricked) {
-            turn.lines.push(...leaveMatrix(this.scene, actor, {
-                forced: true,
-                reason: `The host's ice burns your deck out from under you.`,
-            }));
-        }
-        else if (turn.scrambled) {
-            // SCRAMBLE IC (p.248): "you reboot immediately, taking dumpshock if
-            // you were in VR." A forced exit through the same door, which is
-            // what makes it a reboot rather than a graceful drop -- and the
-            // reboot is also what hands the reducers' damage back.
-            //
-            // `else if` on purpose: a deck already bricked this turn has been
-            // dumped, and dumping a persona twice would bill dumpshock twice.
-            turn.lines.push(...leaveMatrix(this.scene, actor, {
-                forced: true,
-                reason: `Scramble IC rips the connection out at the root --`,
-            }));
-        }
-        if (turn.traced) {
-            // TRACK IC (p.249): the location goes to the authorities. Routed
-            // into the heat the game already keeps for being made in the meat
-            // world, rather than a second parallel notion of "they know".
-            this.addHeat(4, `Track IC reported ${actor.name}'s location`);
-        }
         const body = turn.lines.join('\n');
+        // Made on this very sweep: the fight opens on the same beat, after
+        // the sighting has been read.
+        if (hostIsHunting(host.over, actor)) {
+            if (this.scene.isHumanControlled(actor)) {
+                Logger.getInstance().log(result.length > 0 ? `${result}\n${body}` : body, { actor: actor.name });
+            }
+            await hostContactBeat(this.scene, actor);
+            return '';
+        }
         return result.length > 0 ? `${result}\n${body}` : body;
     }
     /**
@@ -6267,7 +6278,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // players" / "crew street"); the bare verb still answers quietly.
         { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
         { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
-        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
         // The Emerged get their own shelf (player request: "there MUST be
         // resonance" -- matrix is the place, Resonance is the talent).
         // `sustain` shelves here and not under magic: the command is

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

@@ -126,6 +126,16 @@ export class Device {
     structure;
     armor;
     _barrierDamage = 0;
+    /**
+     * THE MATRIX CONDITION MONITOR (p.228): 8 + (Device Rating / 2)
+     * boxes, resisted with Device Rating + Firewall, filled by a Data
+     * Spike (commands/disable.ts, "brick"). Full = BRICKED: "the device
+     * ceases functioning" -- a camera records nothing, a smartgun sparks
+     * and dies -- but "a lock stays locked" (p.228): bricking is never a
+     * way through a maglock. Repaired on the bench (rest.ts), never by a
+     * reboot. A ward is not electronics and has no monitor at all.
+     */
+    _matrixDamage = 0;
     /**
      * THE LOCKSMITH EXTENDED TEST IN PROGRESS (p.48, p.359-360): picking a
      * maglock by hand accumulates hits toward Rating x 2 across attempts,
@@ -207,6 +217,33 @@ export class Device {
      * exact fault this codebase keeps having to close (see the gun in
      * aroTags, AKfemBJJWJP99nx8K).
      */
+    // ---- The Matrix condition monitor (commands/disable.ts) ----
+    /** p.228: 8 + (Device Rating / 2), rounded up as the deck's is. 0 for
+     *  a thing with no rating (a ward): nothing there to brick. */
+    get matrixMonitor() {
+        return this.rating > 0 ? 8 + Math.ceil(this.rating / 2) : 0;
+    }
+    get matrixDamage() {
+        return this._matrixDamage;
+    }
+    /** Returns boxes actually taken. */
+    takeMatrixDamage(boxes) {
+        if (this.matrixMonitor <= 0)
+            return 0;
+        const taken = Math.max(0, Math.floor(boxes));
+        this._matrixDamage = Math.min(this.matrixMonitor, this._matrixDamage + taken);
+        return taken;
+    }
+    get isBricked() {
+        return this.matrixMonitor > 0 && this._matrixDamage >= this.matrixMonitor;
+    }
+    /** Bench work (rest.ts): the whole monitor, at once. */
+    repairMatrix() {
+        this._matrixDamage = 0;
+    }
+    matrixSummary() {
+        return this.matrixMonitor > 0 ? `${this._matrixDamage}/${this.matrixMonitor} boxes` : '';
+    }
     broadcastsAro() {
         return this.wireless && this.rating > 0;
     }
@@ -328,11 +365,13 @@ export class Device {
         const text = hint(AFFORDANCE_FLAVOR[this.kind].hint);
         return text.length > 0 ? text : undefined;
     }
-    /** Persistence-only: one flag in, nothing out. */
+    /** Persistence-only: flags in, nothing out. */
     restoreState(state) {
         this.open = state.open;
         if (state.damage !== undefined)
             this._barrierDamage = Math.max(0, Math.min(this.structure, Math.floor(state.damage)));
+        if (state.bricked !== undefined)
+            this._matrixDamage = state.bricked ? this.matrixMonitor : 0;
     }
 }
 //# sourceMappingURL=device.js.map

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

@@ -41,6 +41,10 @@ export class Host {
     marksBy = new Map();
     /** player name -> marks the host holds on that player. */
     marksOn = new Map();
+    /** Personas whose Matrix Search (p.241, commands/search.ts) turned up
+     *  this host's files: the archive is listed for them from then on. A
+     *  cracked host lists it for everyone. Session-only. */
+    searchedBy = new Set();
     /** Walls up: the host holds a mark on an intruder and its ice is hunting. */
     alert = false;
     /** IC running now, by kind name. Names, not actors -- until increment 5. */

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

@@ -43,6 +43,12 @@ export class Item extends AbstractItem {
     // A jammed firearm can't fire (fists until cleared); "reboot" clears
     // every jammed device you carry, in the lull.
     jammed = false;
+    // BRICKED (p.228, commands/disable.ts "brick"): a Data Spike filled the
+    // device's Matrix condition monitor. Dead electronics -- a smartgun
+    // "sparks, crackles, and smokes" and will not fire -- until bench
+    // work (rest.ts). A reboot does NOT clear it; that is the whole
+    // difference from `jammed`.
+    bricked = false;
     _transferable;
     // New currency-related fields
     _currencyAmount = 0;

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

@@ -3554,6 +3554,12 @@ export class Player extends AbstractPlayer {
         if (this.plane === 'drone')
             return this.simMode === 'hot' ? 4 : 3;
         if (this.plane === 'matrix') {
+            // A HOST'S PROGRAM "should be treated as if it is in hot-sim, so
+            // it gets a total of 4D6 Initiative Dice" (p.247). It has no
+            // simMode of its own -- that field routes a visitor's damage into
+            // a deck -- so the rule is read off the host it runs for.
+            if (this.icHost)
+                return 4;
             if (this.simMode !== 'hot')
                 return 3;
             // Overclocking echo (p.258): "an additional +1D6 while you're in

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

@@ -469,6 +469,12 @@ export class Room extends AbstractRoom {
     warded = false;
     // See IRoomConstructorConfig.watched (utilities/surveillance.ts).
     watched = false;
+    /** The cluster is LOOPED by Control Device (commands/disable.ts): the
+     *  house sees empty hallways until the run ends. Session-only. */
+    camerasLooped = false;
+    /** The cluster is BRICKED by a Data Spike (p.228): dead lenses, until
+     *  somebody's bench work nobody in this run is doing. Session-only. */
+    camerasBricked = false;
     /**
      * THE HOST STANDING OVER THIS ROOM, as an object (models/host.ts) --
      * increment 1 of the Matrix position model. Every host field this class

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

@@ -1,4 +1,4 @@
-import { Item, NPC } from './_index.js';
+import { Room, Item, NPC } from './_index.js';
 import { capitalCase } from 'change-case';
 import { localGrid as makeLocalGrid } from '../utilities/grids.js';
 import { Logger } from '../utilities/logger.js';
@@ -6,7 +6,7 @@ import { hint } from '../utilities/hints.js';
 import { Category, Size, Rating } from '../types/shared/item-enum.js';
 import { AbstractScene } from '../types/shared/abstracts.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
-import { CombatEncounter } from '../utilities/combat-turn.js';
+import { CombatEncounter, arenaKey, arenaOf, inArena } from '../utilities/combat-turn.js';
 export class Scene extends AbstractScene {
     story;
     // SYMMETRIC PLAYERS: the scene holds a LIST of human players --
@@ -136,13 +136,27 @@ export class Scene extends AbstractScene {
     // the fight in the office are two initiative orders, as they would be
     // at a table. An encounter holds the participants, their scores and
     // whose Action Phase is live; the scene only owns the map.
+    //
+    // KEYED BY ARENA (utilities/combat-turn.ts, 2026-09-13): a room for
+    // the physical planes, a host for the personas inside it, the open
+    // grid for the rest. A persona's currentLocation is its body's room,
+    // so a room key could never find a decker's fight.
     encounters = new Map();
-    /** The live fight in a room, if any. */
+    encounterAt(arena) {
+        const enc = this.encounters.get(arenaKey(arena));
+        return enc && !enc.ended ? enc : undefined;
+    }
+    /** The live fight in a room (the physical arena), if any. */
     encounterIn(room) {
         if (!room)
             return undefined;
-        const enc = this.encounters.get(room);
-        return enc && !enc.ended ? enc : undefined;
+        return this.encounterAt({ kind: 'room', room });
+    }
+    /** The live fight inside a host, if any. */
+    encounterInHost(host) {
+        if (!host)
+            return undefined;
+        return this.encounterAt({ kind: 'host', host });
     }
     /**
      * THE BEAT CLOCK: which human command the world is on. Game bumps it
@@ -155,7 +169,7 @@ export class Scene extends AbstractScene {
     beat = 0;
     /** The fight this actor is a participant in, if any. */
     encounterFor(actor) {
-        const enc = this.encounterIn(actor.currentLocation);
+        const enc = this.encounterAt(arenaOf(actor));
         return enc?.has(actor) ? enc : undefined;
     }
     /**
@@ -165,11 +179,15 @@ export class Scene extends AbstractScene {
      * either. A bystander is scenery; a bartender is not opposition until
      * someone makes them so (noteAttack pulls them in then).
      */
-    encounterMembers(room, aggressor, target) {
+    encounterMembers(where, aggressor, target) {
+        const arena = where instanceof Room ? { kind: 'room', room: where } : where;
         const out = new Set([aggressor]);
         if (target)
             out.add(target);
-        for (const a of room.getActors()) {
+        // The physical arena's roster is the room's; a host's or the grid's
+        // is every persona on that side of the wall (matrix-roster.ts).
+        const roster = arena.kind === 'room' ? arena.room.getActors() : this.allActors.filter(a => inArena(arena, a));
+        for (const a of roster) {
             if (a === aggressor || a === target)
                 continue;
             if (!a.sharesCombatPlane(aggressor) || a.isIncapacitated())
@@ -190,8 +208,9 @@ export class Scene extends AbstractScene {
      * Resolves once the first pass has run up to a human's Action Phase
      * (or the fight has already ended).
      */
-    async startEncounter(room, opts) {
-        const existing = this.encounterIn(room);
+    async startEncounter(where, opts) {
+        const arena = where instanceof Room ? { kind: 'room', room: where } : where;
+        const existing = this.encounterAt(arena);
         if (existing) {
             if (opts.target)
                 existing.noteAttack(opts.aggressor, opts.target);
@@ -199,15 +218,21 @@ export class Scene extends AbstractScene {
                 existing.join(opts.aggressor);
             return existing;
         }
-        const enc = new CombatEncounter(this, this.logger, room);
-        this.encounters.set(room, enc);
-        await enc.start(this.encounterMembers(room, opts.aggressor, opts.target), opts);
+        // The room under the arena: the fight's own for the physical planes,
+        // the host's room for a host, the aggressor's body for the grid.
+        const room = arena.kind === 'room' ? arena.room : arena.kind === 'host' ? arena.host.over : opts.aggressor.currentLocation;
+        const enc = new CombatEncounter(this, this.logger, room, arena);
+        enc.onNewTurn = opts.onNewTurn;
+        enc.keepAlive = opts.keepAlive;
+        this.encounters.set(arenaKey(arena), enc);
+        await enc.start(this.encounterMembers(arena, opts.aggressor, opts.target), opts);
         return enc;
     }
     /** The encounter is over (called by the encounter itself). */
     endEncounter(enc) {
-        if (this.encounters.get(enc.room) === enc)
-            this.encounters.delete(enc.room);
+        const key = arenaKey(enc.arena);
+        if (this.encounters.get(key) === enc)
+            this.encounters.delete(key);
     }
     /**
      * Someone walks into a room where a fight is on (p.160 entering
@@ -215,7 +240,7 @@ export class Scene extends AbstractScene {
      * out until they act.
      */
     admitToEncounter(actor) {
-        const enc = this.encounterIn(actor.currentLocation);
+        const enc = this.encounterAt(arenaOf(actor));
         if (!enc || enc.has(actor) || actor.isIncapacitated())
             return undefined;
         const npc = actor;
@@ -599,7 +624,9 @@ export class Scene extends AbstractScene {
         // "still going" until the human explicitly ended their turn
         // (5aqFRn2xPtRYDvNxR). Mirrors leave()'s own direct stillHostile()
         // check for the same "nobody left to fight" shape.
-        const enc = room ? this.encounterIn(room) : undefined;
+        // The actor's own arena first: a crashed IC's fight is inside its
+        // host, not in the room under it.
+        const enc = this.encounterFor(actor) ?? (room ? this.encounterIn(room) : undefined);
         if (enc && !enc.ended) {
             if (enc.phaseActor === actor) {
                 void enc.dropPhaseActor(actor);