@maka/maka-cli 5.181.0 → 5.182.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.181.0",
+  "version": "5.182.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/commands/attack.js

@@ -10,6 +10,7 @@ import { spotOf, ensureAtSpot, ensureAtExit, canReach, spotDistanceMeters, OPEN_
 import { distanceMeters } from '../utilities/room-grid.js';
 import { resolveBarrierStrike } from '../utilities/barrier-combat.js';
 import { billAction, notYourPhase, phaseHint } from '../utilities/action-cost.js';
+import { arenaOf, inArena } from '../utilities/combat-turn.js';
 import { spendMovementMeters } from '../utilities/movement-cost.js';
 /**
  * Shadowrun-style dice-pool combat, one full exchange per command:
@@ -224,11 +225,12 @@ export class AttackCommand extends Command {
             return `Click -- the ${weaponItem.name} is dry. "reload" (needs ammunition), or go in swinging with something else.`;
         }
         // THE COMBAT TURN (utilities/combat-turn.ts): on the physical planes
-        // a fight is a turn/pass loop and this attack is ONE action in the
-        // actor's own Action Phase. The Matrix and the astral keep the older
-        // exchange below -- the Matrix has its own initiative structure
-        // (utilities/ic.ts) and astral combat has not been swept yet.
-        if (this.actor.plane === 'meat' || this.actor.plane === 'drone') {
+        // and the Matrix a fight is a turn/pass loop and this attack is ONE
+        // action in the actor's own Action Phase. The Matrix joined it on
+        // 2026-09-13 (utilities/host-combat.ts): a Data Spike used to roll a
+        // fresh two-actor initiative per command and print "FREEZES" every
+        // time. Only the astral still rides the older exchange below.
+        if (this.actor.plane === 'meat' || this.actor.plane === 'drone' || this.actor.plane === 'matrix') {
             return await this.executeInEncounter(target, room, weaponItem ?? undefined, ambush);
         }
         const report = [];
@@ -340,8 +342,9 @@ export class AttackCommand extends Command {
         const actor = this.actor;
         const human = this.scene.isHumanControlled(actor);
         let enc = this.scene.encounterFor?.(actor);
+        const arena = arenaOf(actor);
         if (!enc) {
-            enc = await this.scene.startEncounter(room, { aggressor: actor, target, ambush });
+            enc = await this.scene.startEncounter(arena, { aggressor: actor, target, ambush });
             if (enc.ended) {
                 return human ? `` : `The fight was over before ${actor.name} got to act.`;
             }
@@ -356,7 +359,7 @@ export class AttackCommand extends Command {
                     ? `Initiative rolled -- ${who} ${enc.phaseActor ? 'acts' : 'act'} first. Your ${this.actionVerb() === 'attacks' ? 'attack' : 'move'} waits for your Action Phase.${hint(` ("initiative" shows the order.)`)}`
                     : `${actor.name} squares up -- initiative rolled; ${who} first.`;
             }
-            if (target.isIncapacitated() || target.currentLocation !== room) {
+            if (target.isIncapacitated() || !inArena(arena, target)) {
                 return human ? `${target.name} is no longer standing in front of you.` : `${target.name} is no longer a target.`;
             }
         }
@@ -372,7 +375,10 @@ export class AttackCommand extends Command {
         // shoot or swing the blade instead? READY WEAPON (p.165) is its own
         // Simple Action -- "draw" first (2jbprbSYqF7EPXrkR).
         const activeWeapon = this.usesEquippedWeapon() && actor.weaponDrawn ? weaponItem : undefined;
-        const isMelee = !activeWeapon || !activeWeapon.isFirearm();
+        // A DATA SPIKE (p.239) is neither a swing nor a shot: no ground to
+        // close, no recoil, a Complex Action. The grid sees no distance.
+        const onGrid = actor.plane === 'matrix';
+        const isMelee = !onGrid && (!activeWeapon || !activeWeapon.isFirearm());
         const report = [];
         // MELEE REACH: ground costs (p.161-162).
         if (isMelee) {
@@ -428,8 +434,8 @@ export class AttackCommand extends Command {
             }
         }
         // THE ACTION.
-        const label = isMelee ? (this.usesEquippedWeapon() ? 'Melee Attack' : 'Subdue') : 'Fire Weapon';
-        const bill = billAction(this.scene, actor, isMelee ? 'complex' : 'simple', label, { attack: true });
+        const label = onGrid ? 'Data Spike' : isMelee ? (this.usesEquippedWeapon() ? 'Melee Attack' : 'Subdue') : 'Fire Weapon';
+        const bill = billAction(this.scene, actor, onGrid || isMelee ? 'complex' : 'simple', label, { attack: true });
         if (bill)
             return bill;
         const exchange = new CombatExchange(this.scene, this.logger, actor);
@@ -442,7 +448,7 @@ export class AttackCommand extends Command {
         target.combatOpponent = target.combatOpponent ?? actor;
         target.lastExchangeAt = now;
         actor.surrendered = false;
-        if (!isMelee) {
+        if (!isMelee && !onGrid) {
             actor.firedThisPhase = true;
             actor.recoilRoundsFired += 1;
         }

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

@@ -3,6 +3,7 @@ import { movePersonaWith } from '../utilities/matrix-roster.js';
 import { resolveHostInReach, hostsInReach, gridVicinity, hostOver } from '../utilities/grid-reach.js';
 import { hint } from '../utilities/hints.js';
 import { hostLabel } from '../utilities/grid-names.js';
+import { billAction } from '../utilities/action-cost.js';
 /**
  * ENTER/EXIT HOST (SR5 p.239, Complex Action).
  *
@@ -67,6 +68,12 @@ export class EnterHostCommand extends Command {
                 hint(`A host opens to anyone holding a MARK on it (p.239) -- "mark ${target.name}" softens it, or "hack" takes one by force.`),
             ].join('\n');
         }
+        // A Complex Action (p.239) -- billed only inside a Combat Turn.
+        const bill = billAction(this.scene, actor, 'complex', 'Enter Host');
+        if (bill)
+            return bill;
+        // Crossing the wall leaves whatever fight was on this side of it.
+        this.scene.encounterFor?.(actor)?.leave(actor);
         // THE PERSONA CROSSES, THE BODY STAYS (increment 2): position becomes
         // the host, remembering the grid it came from (p.239: exit returns
         // you there). currentLocation is never written -- it is the body's.
@@ -130,6 +137,13 @@ export class ExitHostCommand extends Command {
             const by = [...actor.linkLockedBy].join(', ');
             return `{red-fg}You reach for the door and it isn't there. LINK-LOCKED by ${by}: the connection is held open and Enter/Exit Host is closed to you (p.229). "jack out" still works -- it just costs you dumpshock.{/red-fg}`;
         }
+        // A Complex Action (p.239), and the way out of the host's fight
+        // (utilities/host-combat.ts): a persona back on the grid is beyond
+        // the ice, which "does not operate out on the grid".
+        const bill = billAction(this.scene, actor, 'complex', 'Exit Host');
+        if (bill)
+            return bill;
+        this.scene.encounterFor?.(actor)?.leave(actor);
         const host = actor.insideHost;
         const from = actor.matrixPosition?.kind === 'host' ? actor.matrixPosition.from : undefined;
         actor.matrixPosition = { kind: 'grid', grid: from };

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

@@ -12,6 +12,7 @@ import { matchesCameraName, hostLabel } from '../utilities/grid-names.js';
 import { TapCommand } from './tap.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS } from '../utilities/marks.js';
+import { billAction } from '../utilities/action-cost.js';
 import { declarationPenalty, parseMarkDeclaration, hostDefensePool, wanDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
 /**
  * MARKS A PAN INTRUSION MUST ALREADY HOLD before it can command the
@@ -74,6 +75,12 @@ export class HackCommand extends BypassCommand {
         // here so a declaration never lands in a target name, the same way
         // the mode words are.
         const { marks: declaredMarks, rest } = parseMarkDeclaration(afterMode);
+        // BRUTE FORCE and HACK ON THE FLY are Complex Actions (p.238, p.240)
+        // -- billed only inside a Combat Turn, where one intrusion is the
+        // whole Action Phase.
+        const bill = billAction(this.scene, this.actor, 'complex', mode === 'sleaze' ? 'Hack on the Fly' : 'Brute Force');
+        if (bill)
+            return bill;
         // PAN warfare: "hack <name>" cracks a meat actor's personal area
         // network -- from inside the Matrix, or right here in AR with a
         // working deck in hand (which is also how enemy deckers get YOU).

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

@@ -3,6 +3,7 @@ import { gridVicinity } from '../utilities/grid-reach.js';
 import { enterMatrix, leaveMatrix } from '../utilities/planes.js';
 import { hint } from '../utilities/hints.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
+import { billAction } from '../utilities/action-cost.js';
 /**
  * The Matrix door, both directions: "jack in [hot|cold]" and "jack out".
  * Needs a working CYBERDECK carried (a commlink is calls and AR only) --
@@ -97,6 +98,11 @@ export class JackCommand extends Command {
             if (actor.inExchange) {
                 return `The ice has your persona locked in the exchange -- survive it first, then jack out in the lull.`;
             }
+            // JACK OUT is a Simple Action (p.240) -- billed inside a Combat
+            // Turn; leaving the Matrix then leaves the fight (planes.ts).
+            const bill = billAction(this.scene, actor, 'simple', 'Jack Out');
+            if (bill)
+                return bill;
             // LINK-LOCKED: leaving stops being a decision and becomes a test
             // (p.229/p.240). Everything below is the Jack Out action.
             if (actor.linkLockedBy.size > 0) {

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

@@ -17,6 +17,7 @@ import { BULLET } from '../utilities/log-style.js';
 import { spotsActive, whoIsWhereLine, highlightSpots, highlightActors, canReach, sealedRouteTo } from '../utilities/spots.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { findCatalogItem, describeEffect } from '../utilities/catalog.js';
+import { billAction } from '../utilities/action-cost.js';
 export class LookCommand extends Command {
     static verb = 'look';
     static description = 'Examine your surroundings';
@@ -301,6 +302,11 @@ export class LookCommand extends Command {
      * match the grid map: ● host, ◆ persona, ▣ PAN, ◇ data.
      */
     gridLook(room) {
+        // MATRIX PERCEPTION is a Complex Action (p.241) -- billed only inside
+        // a Combat Turn, where a look at the room costs the phase.
+        const bill = billAction(this.scene, this.actor, 'complex', 'Matrix Perception');
+        if (bill)
+            return bill;
         // NO MEAT PROSE AT ALL (player ruling 2026-08-26: "looking in the
         // matrix shouldn't show the meatworld"). The room's own description
         // used to open this view "for orientation" -- but that description

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

@@ -5,7 +5,7 @@ import { rollPool, formatRoll } from '../utilities/dice.js';
 import { perceptionTest } from '../utilities/perception.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
@@ -137,6 +137,13 @@ export class SearchCommand extends Command {
     static description = 'Search for items in your area';
     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.`;
+        }
         // 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');

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';
@@ -2482,7 +2483,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);
         };
@@ -6044,7 +6047,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 +6182,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 +6226,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;
     }
     /**

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/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);

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

@@ -1,6 +1,29 @@
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
 import { runNpcActionPhase } from './npc-combat-brain.js';
+export function arenaKey(a) {
+    return a.kind === 'room' ? `room:${a.room.name}` : a.kind === 'host' ? `host:${a.host.name}` : 'grid:open';
+}
+/** The arena this actor would fight in right now. */
+export function arenaOf(actor) {
+    if (actor.plane === 'matrix') {
+        const host = actor.hostInside;
+        return host ? { kind: 'host', host } : { kind: 'grid' };
+    }
+    return { kind: 'room', room: actor.currentLocation };
+}
+/** Standing in the arena: the body in the room, or the persona on
+ *  that side of the host wall. */
+export function inArena(arena, actor) {
+    if (arena.kind === 'room')
+        return actor.plane !== 'matrix' && actor.currentLocation === arena.room;
+    if (actor.plane !== 'matrix')
+        return false;
+    return arena.kind === 'host' ? actor.hostInside === arena.host : actor.hostInside === undefined;
+}
+export function arenaName(arena) {
+    return arena.kind === 'room' ? arena.room.name : arena.kind === 'host' ? `the ${arena.host.name} host` : 'the open grid';
+}
 /**
  * THE COMBAT TURN (SR5 p.158-161, RAG-checked 2026-09-06).
  *
@@ -96,10 +119,23 @@ export class CombatEncounter {
      *  autopilot was retired 2026-09-07: a phase you commit with "end
      *  turn" is yours to play). */
     onHumanPhase;
-    constructor(scene, logger, room) {
+    /** A fresh Combat Turn is about to be rolled (p.159 step 5) -- the
+     *  seam a host uses to launch one IC "at the beginning of each Combat
+     *  Turn" (p.247), before the roll so the new program rolls with
+     *  everyone. */
+    onNewTurn;
+    /** The fight goes on even with nobody paired against anybody: a host
+     *  whose ice is all crashed still gets its next turn to relaunch
+     *  (p.355-356). Consulted by stillHostile(). */
+    keepAlive;
+    /** Where this fight is. `room` stays for the physical arena and for
+     *  world events; a host arena's room is the room under the host. */
+    arena;
+    constructor(scene, logger, room, arena) {
         this.scene = scene;
         this.logger = logger;
         this.room = room;
+        this.arena = arena ?? { kind: 'room', room };
     }
     // ------------------------------------------------------------ setup ----
     /**
@@ -153,7 +189,7 @@ export class CombatEncounter {
             metaLines.push(`  ${p.actor.name}: ${formatInitiative(p.roll)}${p.score !== p.roll.score ? ` -> ${p.score}` : ''}`);
         }
         worldLines.push(`Combat Turn ${this.turn} -- ${this.orderLine()}.`);
-        this.scene.addWorldEvent(`A fight broke out in ${this.room.name} -- ${opts.aggressor.name} opened${opts.target ? ` on ${opts.target.name}` : ''}. In it: ${this.participants.map(p => p.actor.name).join(', ')}.`);
+        this.scene.addWorldEvent(`A fight broke out in ${arenaName(this.arena)} -- ${opts.aggressor.name} opened${opts.target ? ` on ${opts.target.name}` : ''}. In it: ${this.participants.map(p => p.actor.name).join(', ')}.`);
         await this.announce(worldLines, metaLines);
         await this.run();
     }
@@ -233,9 +269,14 @@ export class CombatEncounter {
     fullDefenseActive(actor) {
         return this.participantOf(actor)?.fullDefenseTurn === this.turn;
     }
-    /** Present in the room, on their feet, still a participant. */
+    /** Present in the arena, on their feet, still a participant. */
     present(p) {
-        return p.actor.currentLocation === this.room && !p.actor.isIncapacitated();
+        return inArena(this.arena, p.actor) && !p.actor.isIncapacitated() && !p.actor.deathClaimed;
+    }
+    /** A program the host runs (utilities/ic-actors.ts) -- its phase is
+     *  played by the ice brain and narrated by its own lines. */
+    isConstruct(actor) {
+        return actor.icKind !== undefined;
     }
     isNpc(actor) {
         return !this.scene.isHumanControlled(actor);
@@ -261,9 +302,9 @@ export class CombatEncounter {
     }
     /** An attack renews (or creates) the hostility between two actors. */
     noteAttack(attacker, defender) {
-        if (!this.has(defender) && defender.currentLocation === this.room)
+        if (!this.has(defender) && inArena(this.arena, defender))
             this.join(defender);
-        if (!this.has(attacker) && attacker.currentLocation === this.room)
+        if (!this.has(attacker) && inArena(this.arena, attacker))
             this.join(attacker);
         this.notePair(attacker, defender);
     }
@@ -273,6 +314,8 @@ export class CombatEncounter {
      * by an attack -- hands up ends a fight unless somebody keeps shooting.
      */
     stillHostile() {
+        if (this.keepAlive?.())
+            return true;
         for (const pair of this.pairs.values()) {
             const a = this.participants.find(p => p.actor.name === pair.a);
             const b = this.participants.find(p => p.actor.name === pair.b);
@@ -400,10 +443,15 @@ export class CombatEncounter {
      * phase that opens and closes in one tick is one beat per watcher.
      */
     notePhaseChanged() {
-        for (const a of this.room.getActors()) {
-            if (this.scene.isHumanControlled(a))
-                a.noteConditionChanged();
-        }
+        for (const a of this.watchers())
+            a.noteConditionChanged();
+    }
+    /** The humans who can see this fight: bodies in the room, or the
+     *  human personas on this side of the host wall. */
+    watchers() {
+        if (this.arena.kind === 'room')
+            return this.room.getActors().filter(a => this.scene.isHumanControlled(a));
+        return this.scene.getPlayers().filter(p => inArena(this.arena, p));
     }
     async beginPhase(p) {
         this.phaseActor = p.actor;
@@ -424,12 +472,18 @@ export class CombatEncounter {
             this.budget.spend('free', 'Run (still running)');
         const human = this.scene.isHumanControlled(p.actor);
         if (human) {
-            const budgetLine = `Your Action Phase -- Combat Turn ${this.turn}, pass ${this.pass}, Initiative ${p.score}. ${this.budget.describe()}; ${this.movementLine(p.actor)}. "end turn" when you're done.`;
+            // A persona has no metres to spend: the grid sees no distance.
+            const ground = this.arena.kind === 'room' ? `; ${this.movementLine(p.actor)}` : '';
+            const budgetLine = `Your Action Phase -- Combat Turn ${this.turn}, pass ${this.pass}, Initiative ${p.score}. ${this.budget.describe()}${ground}. "end turn" when you're done.`;
             this.logger.log(`\n{cyan-fg}${budgetLine}{/cyan-fg}`, { actor: p.actor.name });
             this.scene.updateStatus();
             this.onHumanPhase?.(p.actor, this);
             return;
         }
+        // Ice narrates its own action (utilities/ic-brain.ts); a second
+        // "acts" line per program per pass was half the wall of text.
+        if (this.isConstruct(p.actor))
+            return;
         await this.announce([`${p.actor.name} acts (Initiative ${p.score}).`], []);
     }
     movementLine(actor) {
@@ -543,6 +597,11 @@ export class CombatEncounter {
         }
         this.turn += 1;
         this.pass = 1;
+        // The host launches at the START of the turn (p.247), before the
+        // roll, so a fresh program rolls initiative with everyone else.
+        await this.onNewTurn?.(this);
+        if (this.ended)
+            return;
         const metaLines = [`Combat Turn ${this.turn} -- new Initiative (p.159):`];
         for (const p of this.participants) {
             p.roll = rollInitiativeScore(p.actor.getInitiativeAttribute(), p.actor.getInitiativeDice());
@@ -590,7 +649,7 @@ export class CombatEncounter {
                 : `${actor.name} has only ${p.score} Initiative left -- ${label} costs ${cost} (SR5 p.168).`;
         }
         p.score -= cost;
-        this.logger.meta(`  ${actor.name}: ${label} (-${cost} Initiative -> ${p.score})`, undefined, { room: this.room.name });
+        this.logger.meta(`  ${actor.name}: ${label} (-${cost} Initiative -> ${p.score})`, undefined, this.arena.kind === 'room' ? { room: this.room.name } : { actor: actor.name });
         return undefined;
     }
     /** Full Defense (p.191): -10, Willpower to every defense this turn. */
@@ -620,29 +679,37 @@ export class CombatEncounter {
             p.actor.firedThisPhase = false;
         }
         this.scene.endEncounter(this);
+        const where = arenaName(this.arena);
         const line = reason === 'burnout'
-            ? `The fight in ${this.room.name} burns out -- nobody can land the finishing blow.`
+            ? `The fight in ${where} burns out -- nobody can land the finishing blow.`
             : reason === 'left'
-                ? `The fight in ${this.room.name} is over -- nobody left to fight.`
-                : `The fight in ${this.room.name} is over.`;
+                ? `The fight in ${where} is over -- nobody left to fight.`
+                : `The fight in ${where} is over.`;
         await this.announce([line], []);
         this.scene.updateStatus();
         // Spirits whose services ran out depart once the dust settles.
         this.scene.ownerGame?.settleSpiritServices?.();
     }
     // ------------------------------------------------------------ output ----
-    /** A human is present in the room to see it. */
+    /** A human is present in the arena to see it. */
     witnessed() {
-        return this.scene.getPlayers().some(p => p.currentLocation === this.room);
+        return this.watchers().length > 0;
     }
     async announce(lines, meta) {
         if ((lines.length === 0 && meta.length === 0) || !this.witnessed())
             return;
-        const scope = { room: this.room.name };
-        for (const m of meta)
-            this.logger.meta(m, undefined, scope);
-        if (lines.length > 0)
-            this.logger.log(`\n${lines.join('\n')}`, scope);
+        // A room scope resolves by BODY room (headless.ts), which is not
+        // where a persona stands -- so a host or grid fight addresses each
+        // watching persona by name instead.
+        const scopes = this.arena.kind === 'room'
+            ? [{ room: this.room.name }]
+            : this.watchers().map(p => ({ actor: p.name }));
+        for (const scope of scopes) {
+            for (const m of meta)
+                this.logger.meta(m, undefined, scope);
+            if (lines.length > 0)
+                this.logger.log(`\n${lines.join('\n')}`, scope);
+        }
         this.scene.updateStatus();
         const beat = process.env.MAKA_NO_BEATS === '1' ? 0 : CombatEncounter.BEAT_MS;
         if (beat > 0)
@@ -674,7 +741,8 @@ export class CombatEncounter {
         if (!p)
             return undefined;
         if (this.phaseActor === player && this.budget) {
-            return `{cyan-fg}⏱ YOUR PHASE{/cyan-fg} T${this.turn}/P${this.pass} Init ${p.score} · ${this.budget.describe()} · ${player.movementLeftMeters} m · "end turn"`;
+            const ground = this.arena.kind === 'room' ? ` · ${player.movementLeftMeters} m` : '';
+            return `{cyan-fg}⏱ YOUR PHASE{/cyan-fg} T${this.turn}/P${this.pass} Init ${p.score} · ${this.budget.describe()}${ground} · "end turn"`;
         }
         const who = this.phaseActor ? `${this.phaseActor.name} acting` : 'resolving';
         return `⏱ COMBAT T${this.turn}/P${this.pass} Init ${p.score} · ${who}${p.fullDefenseTurn === this.turn ? ' · FULL DEFENSE' : ''}`;

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

@@ -0,0 +1,107 @@
+import { hostIsHunting, hostLaunchStep } from './ic.js';
+import { personasInside } from './matrix-roster.js';
+/**
+ * THE HOST OWNS ITS FIGHT (2026-09-13, the Matrix joins the Combat Turn).
+ *
+ * Before this the host's ice acted once per PLAYER COMMAND (game.ts
+ * withICTurn -> ic.ts runICTurn): type "look" inside an alerted host and
+ * every running program took a swing, four programs and twelve lines a
+ * keystroke, with no initiative and no turn to end -- an engine mapping
+ * that its own comment called "not a rule". Cybercombat, meanwhile, ran
+ * on the two-actor exchange: every `attack Patrol IC` rolled a fresh
+ * initiative and printed "FREEZES".
+ *
+ * Canon has one structure for both (SR5 p.247, p.229-230, RAG-checked
+ * 2026-09-13): Combat Turns and Initiative Passes shared with the meat
+ * world; a persona's initiative is Data Processing + Intuition with
+ * 3D6/4D6; each IC program has its own persona, condition monitor and
+ * Initiative Score, treated as hot-sim (4D6); the host launches ONE IC
+ * per Combat Turn at the beginning of the turn, up to its rating
+ * running; IC attacks are Complex Actions. So the host's fight is a
+ * CombatEncounter in a host ARENA (combat-turn.ts): the host launches
+ * on the encounter's newTurn hook, each program is a participant whose
+ * Action Phase the ice brain plays (ic-brain.ts), and the persona spends
+ * its own budget and types "end turn" like anywhere else.
+ *
+ * `ic.ts` stays scene-free and dice-only; this file is the seam that
+ * holds the Scene and the encounter.
+ */
+const empty = () => ({ lines: [], meta: [], world: [] });
+/** Every program the host has running as an actor, seated in the fight. */
+function seatRunningIce(enc, host) {
+    for (const ice of host.iceActors.values()) {
+        if (!enc.has(ice) && !ice.isIncapacitated())
+            enc.join(ice);
+    }
+}
+/** Report one host step to the persona's watchers. */
+async function tell(enc, scene, turn) {
+    for (const w of turn.world)
+        scene.addWorldEvent(w);
+    await enc.announce(turn.lines, turn.meta);
+}
+/**
+ * THE START OF THE HOST'S COMBAT TURN (p.247): crashed programs leave,
+ * one program launches, and the newcomer rolls initiative with everyone
+ * else -- the encounter calls this from newTurn() before the roll.
+ */
+export async function hostTurnStart(scene, host, enc) {
+    const out = empty();
+    hostLaunchStep(host.over, scene, out);
+    seatRunningIce(enc, host);
+    await tell(enc, scene, out);
+}
+/** The fight goes on while the host is alert and someone human is still
+ *  inside it -- even with every program crashed, the host gets its next
+ *  turn to relaunch (p.355-356). */
+export function hostKeepsFighting(scene, host) {
+    return host.alert && !host.sanctioned
+        && personasInside(scene, host).some(p => scene.isHumanControlled(p) && !p.isIncapacitated());
+}
+/**
+ * OPEN THE HOST'S FIGHT on an intruder it has made. The aggressor is a
+ * running program -- Patrol, which "is already walking the host", if
+ * nothing else is -- so the initiative block reads like a fight and not
+ * like a system message.
+ */
+export async function openHostEncounter(scene, host, intruder) {
+    const out = empty();
+    let aggressor = [...host.iceActors.values()].find(ice => !ice.isIncapacitated());
+    if (!aggressor) {
+        aggressor = hostLaunchStep(host.over, scene, out);
+    }
+    if (!aggressor)
+        return undefined;
+    for (const w of out.world)
+        scene.addWorldEvent(w);
+    const enc = await scene.startEncounter({ kind: 'host', host }, {
+        aggressor, target: intruder, ambush: false,
+        onNewTurn: e => hostTurnStart(scene, host, e),
+        keepAlive: () => hostKeepsFighting(scene, host),
+    });
+    seatRunningIce(enc, host);
+    if (out.lines.length > 0)
+        await enc.announce(out.lines, out.meta);
+    return enc;
+}
+/**
+ * The beat after every command a persona types inside a host (game.ts
+ * withHostTurn): an alerted host that is not yet fighting this persona
+ * opens on it. Returns true when a fight was opened this beat.
+ */
+export async function hostContactBeat(scene, player) {
+    const host = player.hostInside;
+    if (!host || player.plane !== 'matrix')
+        return false;
+    if (!hostIsHunting(host.over, player))
+        return false;
+    const live = scene.encounterInHost(host);
+    if (live) {
+        if (!live.has(player))
+            live.join(player);
+        return false;
+    }
+    const enc = await openHostEncounter(scene, host, player);
+    return enc !== undefined;
+}
+//# sourceMappingURL=host-combat.js.map

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

@@ -0,0 +1,84 @@
+import { IC_TYPES, icActs } from './ic.js';
+import { leaveMatrix } from './planes.js';
+import { Logger } from './logger.js';
+/**
+ * A PROGRAM'S ACTION PHASE (SR5 p.247): one Complex Action, by rule.
+ *
+ * The meat brain (npc-combat-brain.ts) plays verbs -- draw, close, fire.
+ * Ice has no verbs and no mind (models/npc.ts isConstruct): its whole
+ * repertoire is the one test its type makes, and utilities/ic.ts already
+ * rolls that with the right dice. So the phase is: pick the persona the
+ * host is after, run the program's act once, spend the Complex, and
+ * route what happened to the same places game.ts used to -- the lines to
+ * the watchers, the world events to the table, a bricked or scrambled
+ * persona to the forced dump, a trace to the heat ledger.
+ *
+ * Nothing here narrates a second "X acts" line: the program's own act
+ * line is the narration (combat-turn.ts beginPhase skips it for ice).
+ */
+export async function runIcActionPhase(enc, ice) {
+    const logger = Logger.getInstance();
+    const host = ice.icHost;
+    const type = IC_TYPES.find(t => t.name === ice.icKind);
+    if (!host || !type || ice.isIncapacitated())
+        return;
+    const budget = enc.budgetOf(ice);
+    if (!budget)
+        return;
+    const target = pickTarget(enc, ice);
+    if (!target) {
+        logger.write(`Ice: ${ice.name} has nobody in the host to hunt -- phase forfeited.`);
+        budget.spend('complex', `${type.name} (idle)`);
+        return;
+    }
+    ice.combatOpponent = target;
+    ice.lastExchangeAt = Date.now();
+    const out = { lines: [], meta: [], world: [] };
+    icActs(host.over, target, type, out, ice);
+    budget.spend('complex', type.name);
+    // The forced dumps ic.ts reports rather than performs -- it takes no
+    // Scene. Reasons verbatim from the old game.ts withICTurn.
+    if (out.bricked) {
+        out.lines.push(...leaveMatrix(enc.scene, target, {
+            forced: true,
+            reason: `The host's ice burns your deck out from under you.`,
+        }));
+    }
+    else if (out.scrambled) {
+        out.lines.push(...leaveMatrix(enc.scene, target, {
+            forced: true,
+            reason: `Scramble IC rips the connection out at the root --`,
+        }));
+    }
+    if (out.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.
+        enc.scene.ownerGame?.addHeat?.(4, `Track IC reported ${target.name}'s location`);
+    }
+    for (const w of out.world)
+        enc.scene.addWorldEvent(w);
+    await enc.announce(out.lines, out.meta);
+    enc.syncWounds();
+}
+/**
+ * Who the program goes for: the persona the host holds the most marks
+ * on (Probe's work, and what Killer's DV and the mark-gated programs
+ * read), then whoever it last engaged, then the first enemy standing.
+ */
+function pickTarget(enc, ice) {
+    const enemies = enc.enemiesOf(ice).filter(e => e.plane === 'matrix');
+    if (enemies.length === 0)
+        return undefined;
+    const marksOn = ice.icHost?.marksOn;
+    let best = enemies[0];
+    let bestMarks = -1;
+    for (const e of enemies) {
+        const m = marksOn?.get(e.name) ?? 0;
+        if (m > bestMarks || (m === bestMarks && e === ice.combatOpponent)) {
+            best = e;
+            bestMarks = m;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=ic-brain.js.map

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

@@ -297,37 +297,37 @@ export function runHostTurn(room, actor, scene) {
     return ambientPatrol(room, actor);
 }
 /**
- * ONE COMBAT TURN of the host's ice.
+ * THE START OF A HOST'S COMBAT TURN (p.247): "a host can launch one IC
+ * program per Combat Turn, at the beginning of each Combat Turn", up to
+ * its rating running, never two of a kind. Crashed programs leave the
+ * list first and come back the very next turn (p.355-356, "delayed,
+ * never destroyed") -- the relaunch takes the turn's one launch.
  *
- * THE TURN MAPPING IS AN ENGINE MAPPING, NOT A RULE, and is labelled so
- * deliberately. Canon paces IC in Combat Turns -- one program launched
- * per turn, at the beginning of it. sideQuest has no Matrix initiative
- * structure to hang that on, so ONE PLAYER ACTION TAKEN INSIDE AN
- * ALERTED HOST counts as one Combat Turn. That is the closest structural
- * analogue available; it is not something the book says, and it is not
- * dressed up as a citation.
+ * Launches only; nothing acts here. In play the encounter's newTurn
+ * hook calls this (utilities/host-combat.ts) and each program then acts
+ * in its own Action Phase (utilities/ic-brain.ts). Returns the actor a
+ * launch produced, so the caller can seat it in the fight.
  */
-export function runICTurn(room, actor, scene) {
-    if (!hostIsHunting(room, actor))
-        return empty();
-    const out = empty();
+export function hostLaunchStep(room, scene, out) {
     const host = room.host;
-    // CRASHED IC LEAVES, AND COMES BACK (p.355-356): a program whose monitor
-    // filled since the last turn is off the list now, and the host
-    // relaunches it the very next turn -- "delayed, never destroyed".
+    let launched;
     if (host) {
-        // Last turn's crashes come back FIRST (p.355-356: "reactivated the very
-        // next turn"); what crashes this turn waits for the next call.
+        // Crashes first, then the relaunch: a program whose monitor filled
+        // during the last turn is off the list at the start of this one and
+        // comes straight back -- "reactivated the very next turn" -- taking
+        // the turn's one launch.
+        for (const kind of crashedIC(host)) {
+            crashIC(scene, host, kind);
+            out.lines.push(`  {red-fg}${kind} shears apart -- crashed. The host is already recompiling it.{/red-fg}`);
+        }
         if (host.relaunchQueue.length > 0 && room.runningIC.length < room.hostRating) {
             const kind = host.relaunchQueue.shift();
             room.runningIC.push(kind);
             if (scene)
-                spawnIC(scene, host, kind);
+                launched = spawnIC(scene, host, kind);
             out.lines.push(`  {red-fg}The host relaunches ${kind}.{/red-fg}`);
-        }
-        for (const kind of crashedIC(host)) {
-            crashIC(scene, host, kind);
-            out.lines.push(`  {red-fg}${kind} shears apart -- crashed. The host is already recompiling it.{/red-fg}`);
+            // ONE launch per turn (p.247): the relaunch was it.
+            return launched;
         }
     }
     if (room.runningIC.length < room.hostRating) {
@@ -335,26 +335,49 @@ export function runICTurn(room, actor, scene) {
         if (next) {
             room.runningIC.push(next.name);
             if (host && scene)
-                spawnIC(scene, host, next.name);
+                launched = spawnIC(scene, host, next.name) ?? launched;
             out.lines.push(next.kind === 'patrol'
                 ? `  {red-fg}${next.name} is already walking the host -- it never had to be launched.{/red-fg}`
                 : `  {red-fg}The host launches ${next.name}.{/red-fg}`);
         }
     }
-    // Every running program acts. An IC attack is a Complex Action
-    // (p.247), which is one program's whole turn.
+    return launched;
+}
+/**
+ * ONE PROGRAM'S ACTION -- an IC attack is a Complex Action (p.247), which
+ * is one program's whole Action Phase. `ice` is the program's own actor
+ * when the scene has one: it is what a failed attack damages.
+ */
+export function icActs(room, actor, type, out, ice) {
+    if (type.kind === 'patrol')
+        patrolActs(room, actor, out);
+    else if (type.kind === 'probe')
+        probeActs(room, actor, type, out, ice);
+    else if (type.kind === 'damage')
+        damageActs(room, actor, type, out, ice);
+    else
+        reducerOrConditionalActs(room, actor, type, out, ice);
+}
+/**
+ * ONE WHOLE COMBAT TURN of the host's ice, as a single call: the launch
+ * step, then every running program acts once. This is the shape the
+ * tests drive and the shape the engine used to run after EVERY player
+ * command ("one action inside an alerted host = one Combat Turn" -- an
+ * engine mapping that was never a rule, and that had four programs
+ * hitting a persona for typing "look"). In play the Combat Turn owns the
+ * pacing now (utilities/host-combat.ts): the launch at newTurn, each
+ * program in its own phase.
+ */
+export function runICTurn(room, actor, scene) {
+    if (!hostIsHunting(room, actor))
+        return empty();
+    const out = empty();
+    hostLaunchStep(room, scene, out);
     for (const name of room.runningIC) {
         const type = IC_TYPES.find(t => t.name === name);
         if (!type)
             continue;
-        if (type.kind === 'patrol')
-            patrolActs(room, actor, out);
-        else if (type.kind === 'probe')
-            probeActs(room, actor, out);
-        else if (type.kind === 'damage')
-            damageActs(room, actor, type, out);
-        else
-            reducerOrConditionalActs(room, actor, type, out);
+        icActs(room, actor, type, out, room.host?.iceActors.get(name));
     }
     return out;
 }
@@ -363,13 +386,29 @@ export function runICTurn(room, actor, scene) {
  * v. Intuition + Firewall (p.248). Returns the net hits; 0 or less is a
  * miss. Shared so the four reducers, Track and Scramble cannot drift
  * from Killer's version of the same roll.
+ *
+ * A FAILED ATTACK ACTION HURTS THE ATTACKER (p.247 "as with all Attack
+ * actions, a failed attack causes damage to the IC"; the amount is the
+ * general rule, Data Trails p.181: one box of Matrix damage per net hit
+ * the defender got, unresisted). Patrol makes no Attack action and is
+ * never here (hurtByFailure false). Applied to the program's own actor,
+ * which is its condition monitor (ic-actors.ts); a program crashed this
+ * way leaves at the next launch step like any other.
  */
-function icAttack(room, actor, type, out) {
+function icAttack(room, actor, type, out, ice) {
     const { pool, limit } = icAttackPool(room);
     const attack = rollPool(pool, limit);
     const defence = rollPool(icDefencePool(actor));
     const net = attack.hits - defence.hits;
     out.meta.push(`${type.name} -- Host Rating x2 [Attack ${limit}]: ${formatRoll(attack)} v. Intuition + Firewall: ${formatRoll(defence)} (net ${net})`);
+    if (net < 0 && type.hurtByFailure && ice && !ice.isDown()) {
+        const rebound = -net;
+        ice.takeDamage(rebound);
+        out.meta.push(`${type.name} -- failed Attack action: ${rebound} box${rebound === 1 ? '' : 'es'} back on the program, unresisted (p.247)`);
+        out.lines.push(ice.isDown()
+            ? `  {red-fg}${ice.name}'s own attack code rejects and tears it apart -- ${rebound} box${rebound === 1 ? '' : 'es'}, and its monitor fills.{/red-fg}`
+            : `  ${ice.name} eats its own rejected code -- ${rebound} box${rebound === 1 ? '' : 'es'} (${ice.conditionSummary()}).`);
+    }
     return net;
 }
 /**
@@ -389,8 +428,8 @@ function icAttack(room, actor, type, out) {
  * against the next IC, and Jammer really does lower the ceiling on your
  * own Brute Force.
  */
-function reducerOrConditionalActs(room, actor, type, out) {
-    const net = icAttack(room, actor, type, out);
+function reducerOrConditionalActs(room, actor, type, out, ice) {
+    const net = icAttack(room, actor, type, out, ice);
     if (net <= 0) {
         out.lines.push(`  ${type.name} probes at your icon and finds no purchase.`);
         return;
@@ -467,17 +506,13 @@ function applyMatrixDamage(actor, dealt, type, out) {
  * Probe IC spends its turns building. That coupling is canon's own, and
  * it is why Probe is worth a slot on a host that also fields a Killer.
  *
- * A FAILED IC ATTACK SHOULD DAMAGE THE IC (p.247) AND DOES NOT YET,
- * stated here rather than left for the next reader to discover. Modelling
- * it needs a condition monitor per program AND a way for the player to
- * attack ice, and neither exists: there is no cybercombat path against
- * IC in this engine at all. Half of it -- ice that hurts itself while
- * the player still cannot swing back -- would be worse than neither
- * half. It lands with the verb.
+ * A FAILED IC ATTACK DAMAGES THE IC (p.247) -- see icAttack, where it
+ * lands for every attacking program at once. The player's side of it,
+ * cybercombat against ice, is `attack <program>` inside the host.
  */
-function damageActs(room, actor, type, out) {
+function damageActs(room, actor, type, out, ice) {
     const { limit } = icAttackPool(room);
-    const net = icAttack(room, actor, type, out);
+    const net = icAttack(room, actor, type, out, ice);
     if (net <= 0) {
         out.lines.push(`  ${type.name} lunges at your icon and closes on nothing.`);
         return;
@@ -608,12 +643,10 @@ function patrolActs(room, actor, out) {
  * read in Phase 4. The engine previously modelled the host's side as the
  * single boolean `hostAlert`, which cannot answer "how many".
  */
-function probeActs(room, actor, out) {
-    const { pool, limit } = icAttackPool(room);
-    const attack = rollPool(pool, limit);
-    const defence = rollPool(icDefencePool(actor));
-    const net = attack.hits - defence.hits;
-    out.meta.push(`Probe IC -- Host Rating x2 [Attack ${limit}]: ${formatRoll(attack)} v. Intuition + Firewall: ${formatRoll(defence)} (net ${net})`);
+function probeActs(room, actor, type, out, ice) {
+    // The same opposed roll as every attacking program (icAttack), so a
+    // failed probe rebounds on the program like any failed Attack action.
+    const net = icAttack(room, actor, type, out, ice);
     const held = room.hostMarksOn.get(actor.name) ?? 0;
     if (net <= 0) {
         out.lines.push(`  Probe IC tests your edges and finds nothing to hold onto.`);

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

@@ -1,6 +1,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';
 /**
  * AN NPC'S ACTION PHASE, PLAYED BY RULE (SR5 p.163-167).
  *
@@ -25,6 +26,10 @@ import { Logger } from './logger.js';
  * Nothing here rolls a die of its own: the verbs do.
  */
 export async function runNpcActionPhase(enc, npc) {
+    // A HOST'S PROGRAM HAS ITS OWN BRAIN (utilities/ic-brain.ts): no
+    // weapon to draw, no ground to close -- one test, by type.
+    if (npc.icKind !== undefined)
+        return runIcActionPhase(enc, npc);
     const logger = Logger.getInstance();
     if (npc.isIncapacitated() || npc.surrendered)
         return;

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

@@ -209,6 +209,11 @@ export const DUMPSHOCK_DV = 6;
 export function leaveMatrix(scene, actor, opts) {
     const lines = [];
     const body = actor.bodyRoom;
+    // OUT OF THE MATRIX IS OUT OF THE FIGHT (utilities/host-combat.ts): a
+    // persona leaving its host arena -- jack out, link-lock broken, deck
+    // bricked, Scramble, convergence -- is no longer a participant. Before
+    // endPersona clears the position the arena is read off.
+    scene.encounterFor?.(actor)?.leave(actor);
     if (opts?.forced) {
         lines.push(...applyDumpshock(actor, opts.reason ?? `The connection is severed from the other side.`));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.181.0",
+  "version": "5.182.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.",