@maka/maka-cli 5.180.0 → 5.182.0

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

@@ -935,6 +935,29 @@ description text.`;
     combatPhaseLocked() {
         return !!this._scene?.encounterFor?.(this);
     }
+    /**
+     * ICE HAS NO VOICE AND NO MIND OF ITS OWN (player ruling 2026-09-13,
+     * from Vex's Borrowed Time log: "Patrol IC: That chip belongs to
+     * Corvid. Put it back on the desk, nice and slow" -- four programs
+     * bargaining over a chip in four voices, and Killer IC "assembling
+     * in the back room" after the persona had already jacked out).
+     *
+     * SR5 p.247: IC is "mercilessly efficient, not very bright" -- it
+     * finds, disables, destroys and repels, and nothing in the books has
+     * it speak. A spawned program (icKind) and a seeded matrix-plane
+     * construct are the same thing to the engine: driven by dice
+     * (utilities/ic.ts), never by the model. No speech, no reflection,
+     * no exposition, and no listening either -- there is nothing for a
+     * stimulus to wake.
+     */
+    isConstruct() {
+        return this.icKind !== undefined || this.plane === 'matrix';
+    }
+    /** Every AI entry point asks this: a construct never runs the model,
+     *  and anyone in a Combat Turn yields to the turn loop. */
+    aiSuspended() {
+        return this.isConstruct() || this.combatPhaseLocked();
+    }
     /**
      * One verb, executed now, no reflection -- the brain's way of acting
      * inside an Action Phase. Returns the command's own result so the
@@ -963,6 +986,10 @@ description text.`;
             this.logger.write(`${this.name} is gone from the world -- dropping queued action "${commandString}".`);
             return;
         }
+        if (this.isConstruct()) {
+            this.logger.write(`${this.name} is ice -- the host's dice act for it; dropping "${commandString}".`);
+            return;
+        }
         if (this.combatPhaseLocked()) {
             this.logger.write(`${this.name} is in a Combat Turn -- the turn loop acts for them; dropping "${commandString}".`);
             return;
@@ -995,6 +1022,10 @@ description text.`;
             // removed shell's AI.
             if (this.deathClaimed)
                 return;
+            // NOR DOES ICE (isConstruct): a program has no conversation to
+            // hold and no history worth keeping.
+            if (this.isConstruct())
+                return;
             // NEITHER DO THE UNCONSCIOUS. A knocked-out actor now STAYS in the
             // scene so they can be brought round (player ruling 2026-08-25) --
             // which means every AI entry point has to check, or the body on the
@@ -1113,6 +1144,10 @@ description text.`;
             // Same cross-plane blindness as hear() above.
             if (!this.canPerceive(actor))
                 return;
+            // Ice watches with the host's dice, not with a model (see
+            // isConstruct): what it notices, utilities/ic.ts rolls for.
+            if (this.isConstruct())
+                return;
             // The unconscious see nothing (see hear()): a KO'd actor stays in
             // the scene now, and must not react to what happens over it.
             if (this.isIncapacitated())
@@ -1428,8 +1463,8 @@ description text.`;
             this.logger.write(`${this.name} is gone from the world -- reflect chain ends.`);
             return;
         }
-        if (this.combatPhaseLocked()) {
-            this.logger.write(`${this.name} is in a Combat Turn -- reflect chain yields to the turn loop.`);
+        if (this.aiSuspended()) {
+            this.logger.write(`${this.name} ${this.isConstruct() ? 'is ice -- no reflect chain' : 'is in a Combat Turn -- reflect chain yields to the turn loop'}.`);
             return;
         }
         // THE GRIND BREAKER. Record what just happened, then refuse to keep
@@ -1609,8 +1644,8 @@ ${worldEventsSummary}
             : [];
     }
     async respondTo(actor, message) {
-        if (this.combatPhaseLocked()) {
-            this.logger.write(`${this.name} is in a Combat Turn -- no AI reaction to "${message.slice(0, 40)}".`);
+        if (this.aiSuspended()) {
+            this.logger.write(`${this.name} ${this.isConstruct() ? 'is ice' : 'is in a Combat Turn'} -- no AI reaction to "${message.slice(0, 40)}".`);
             return;
         }
         this.logger.write('Attempting to respond');

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/alarmed-staff.js

@@ -59,6 +59,9 @@ export function alarmedStaff(scene, player) {
         .filter((a) => a instanceof NPC)
         .filter(npc => !isEphemeral(npc))
         .filter(npc => npc.allyOf === undefined)
+        // Ice is not staff: a program answers to the host's dice
+        // (utilities/ic.ts), never to an alarm beat (NPC.isConstruct).
+        .filter(npc => !npc.isConstruct())
         .filter(npc => !npc.isIncapacitated());
 }
 /**

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