@maka/maka-cli 5.138.0 → 5.140.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.138.0",
+  "version": "5.140.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/nudge.js

@@ -0,0 +1,88 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { NUDGES_TO_SKIP } from '../utilities/combat-turn.js';
+/**
+ * NUDGE -- the table's answer to a runner who is holding the Action
+ * Phase and has gone quiet (project owner, 2026-09-07: "three nudges
+ * skips the player being nudged").
+ *
+ * Since the Combat Turn (utilities/combat-turn.ts) a human's phase
+ * waits for "end turn", and since the autopilot went (v5.136.0)
+ * nothing plays a phase for anyone. On a shared run that leaves one
+ * hole: a human who walks away mid-phase stalls the whole table. There
+ * is deliberately no clock -- a timer skips the player who was reading
+ * the rules -- so the escape is the table's: every nudge tells the
+ * nudged runner, in their own log, that people are waiting; the third
+ * nudge on one phase ends it for them, whatever they had left forfeit,
+ * exactly as "end turn" with nothing spent (SR5 p.158-159; the book
+ * gives no refund). The count is the phase's (CombatEncounter.noteNudge)
+ * and starts over the next time they act.
+ *
+ * Off the phase, or out of a fight, a nudge is a tap on the shoulder
+ * only the nudged runner sees. Human-only: an NPC acts by rule on its
+ * own phase and must never be able to skip a human's.
+ */
+export class NudgeCommand extends Command {
+    static verb = 'nudge';
+    static humanOnly = true;
+    static description = 'Prod another runner on a shared run: "nudge <name>". If they are holding the Action Phase, that tells them the table is waiting -- the third nudge on one phase ends it for them, whatever is unspent forfeit, the same as "end turn" with nothing spent. Off the phase, or out of a fight, it is a tap on the shoulder only they see. "initiative" names who is holding the phase.';
+    /** The scene's other humans -- the only legal targets. */
+    others() {
+        return this.scene.getPlayers().filter(p => p !== this.actor);
+    }
+    async execute(args = []) {
+        if (!this.scene.isHumanControlled(this.actor))
+            return '';
+        const me = this.actor;
+        const query = (args ?? []).join(' ').trim();
+        const others = this.others();
+        if (others.length === 0) {
+            return `You're running this one alone -- there's nobody to nudge.${hint(` (Seat a table with "crew hire"; "nudge" is for a shared run.)`)}`;
+        }
+        if (!query) {
+            return `Nudge who? ${others.map(p => p.name).join(', ')}.  Usage: "nudge <runner>".`;
+        }
+        if (query.toLowerCase() === me.name.toLowerCase()) {
+            return `Nudging yourself moves nothing. If it's your phase, act -- or "end turn".`;
+        }
+        const picked = fuzzyPickName(query, others.map(p => p.name));
+        const target = picked ? others.find(p => p.name === picked) : undefined;
+        if (!target) {
+            return `No runner on this job answers to "${query}". Out here with you: ${others.map(p => p.name).join(', ')}. (An NPC acts by rule on its own phase -- nothing to nudge there.)`;
+        }
+        if (this.scene.getKnockout?.(target.name)) {
+            return `${target.name} is out cold -- no nudge reaches them.`;
+        }
+        const enc = this.scene.encounterFor?.(target);
+        const count = enc?.noteNudge(target);
+        if (count === undefined) {
+            // A TAP ON THE SHOULDER, seen by them alone -- the same per-human
+            // scope beginPhase uses for the cyan "your Action Phase" line.
+            this.logger.log(`{yellow-fg}${me.name} nudges you.{/yellow-fg}`, { actor: target.name });
+            this.logger.write(`${me.name} nudged ${target.name} (no phase to count against).`);
+            const holder = enc?.phaseActor;
+            const aside = enc && holder && holder !== target
+                ? ` It isn't ${target.name}'s Action Phase -- ${holder === me ? `it's yours` : `${holder.name} is holding it`}.`
+                : '';
+            return `You nudge ${target.name}.${aside}`;
+        }
+        const room = target.currentLocation;
+        if (count >= NUDGES_TO_SKIP) {
+            // THE SKIP. Logged, not returned: the phases that follow announce
+            // themselves while this command is still running (end-turn.ts has
+            // the same note), and a return value would land under them.
+            this.logger.log(`{yellow-fg}${target.name}'s Action Phase is skipped -- nudged ${NUDGES_TO_SKIP} times; whatever they had left is forfeit.{/yellow-fg}`, { room: room.name });
+            this.logger.write(`${me.name}'s nudge #${count} skips ${target.name}'s Action Phase.`);
+            await enc.endPhase(target);
+            return '';
+        }
+        this.logger.log(`{yellow-fg}${me.name} nudges you -- the table is waiting on your Action Phase (${count}/${NUDGES_TO_SKIP}; ${NUDGES_TO_SKIP} and it is skipped). "end turn" when you're done.{/yellow-fg}`, { actor: target.name });
+        this.logger.log(`${me.name} nudges ${target.name} (${count}/${NUDGES_TO_SKIP}).`, { room: room.name });
+        this.logger.write(`${me.name} nudged ${target.name} (${count}/${NUDGES_TO_SKIP}).`);
+        // The room line above already reached the nudger when they share the
+        // room; from elsewhere they get the summary instead.
+        return me.currentLocation === room ? '' : `You nudge ${target.name} (${count}/${NUDGES_TO_SKIP}).`;
+    }
+}
+//# sourceMappingURL=nudge.js.map

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

@@ -384,5 +384,13 @@
 //   arrival. During a live encounter the ephemeral governor, open-floor
 //   re-seating and doorway yielding are frozen: nobody moves off the
 //   player's keystrokes. bluff/persuade wins clear the hostile flag.
-export const ENGINE_VERSION = '1.42.0';
+// 1.43.0 (2026-09-07): NUDGE. New verb in shared scenes: "nudge <runner>"
+//   tells a human holding the Action Phase that the table is waiting; the
+//   third nudge on one phase ends it for them (forfeit, as "end turn" with
+//   nothing spent). Off the phase it is a private tap on the shoulder.
+// 1.44.0 (2026-09-07): WHO STARTED IT. The fight's first line names the
+//   aggressor and their target; the world event carries it; "initiative"
+//   marks them. Hostiles are red on the room map by stance or by live
+//   enmity, not by the retired exchange flag.
+export const ENGINE_VERSION = '1.44.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -35,7 +35,7 @@ import { hostileContactBeat } from './utilities/hostile-contact.js';
 import { requestAlarmBeat, newAlarmBeatLatch, ALARM_STIMULUS } from './utilities/alarmed-staff.js';
 import { renderMapViewport, mapCaption } from './utilities/map-view.js';
 import { tallestRoomRows } from './utilities/room-grid.js';
-import { renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
+import { hostileByStance, enemyInFight, renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
 import { getPref } from './utilities/prefs.js';
 import { rollPool, formatRoll } from './utilities/dice.js';
 import { Direction } from './types/shared/direction-enum.js';
@@ -80,6 +80,7 @@ import { InitiativeCommand } from './commands/initiative.js';
 import { AimCommand } from './commands/aim.js';
 import { DefendCommand } from './commands/defend.js';
 import { DelayCommand } from './commands/delay.js';
+import { NudgeCommand } from './commands/nudge.js';
 import { SpellsCommand } from './commands/spells.js';
 import { InventoryCommand } from './commands/inv.js';
 import { EquipmentCommand } from './commands/equipment.js';
@@ -2553,6 +2554,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('aim', AimCommand);
         CommandFactory.registerCommand('defend', DefendCommand);
         CommandFactory.registerCommand('delay', DelayCommand);
+        CommandFactory.registerCommand('nudge', NudgeCommand);
         // 'train' used to alias advance; it belongs to crew instruction now
         // (commands/crew.ts) -- self-training is "advance".
         CommandFactory.registerCommand('advance', AdvanceCommand);
@@ -5621,6 +5623,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 isTableAlly: crewOfTable(this.scene.getPlayers()),
                 boxWidth,
                 isOtherPlayer: a => this.scene.isHumanControlled(a),
+                // Red is the stance flag OR whoever the Combat Turn says is
+                // fighting you (room-view.ts hostileByStance).
+                isHostile: a => hostileByStance(a) || enemyInFight(this.scene, this.player, a),
             });
             if (roomLines.length > 0) {
                 roomLines.push(caption(roomCaption(here, this.player), boxWidth));
@@ -6040,7 +6045,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     static HELP_CATEGORIES = [
         { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
         { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['loot'], ['drop'], ['give'], ['store'], ['open'], ['close'], ['put'], ['equip'], ['unequip'], ['fit'], ['unfit'], ['brandish', 'draw'], ['holster'], ['reload'], ['use'], ['read']] },
-        { title: 'combat', entries: [['attack'], ['kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['stance'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
+        { title: 'combat', entries: [['attack'], ['kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['stance'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
         // The party layer: everyone who walks (or flies, or manifests) at
         // your side answers to these.
         // "players" folded back under crew after playtesting ("crew

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

@@ -17,7 +17,7 @@ import { Logger } from './utilities/logger.js';
 import { currentSession, runInSession } from './utilities/session-context.js';
 import { restorePlayer, serializePlayer } from './utilities/persistence.js';
 import { renderMapViewport, mapCaption } from './utilities/map-view.js';
-import { renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
+import { hostileByStance, enemyInFight, renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
 import { serializeRoomGrid } from './utilities/room-grid.js';
 import { entrySpotFor, spotOf } from './utilities/spots.js';
 import { equipIntoEmptySlots } from './archetypes.js';
@@ -319,6 +319,7 @@ export async function createHeadlessSession(opts) {
                 try {
                     const roomLines = renderRoomLayoutCompact(here, p, {
                         isOtherPlayer: a => game.scene.isHumanControlled(a),
+                        isHostile: a => hostileByStance(a) || enemyInFight(game.scene, p, a),
                         // The leader's crew are the TABLE's crew -- without this
                         // every non-leader saw them as neutral bystanders.
                         isTableAlly: crewOfTable(game.scene.getPlayers()),

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

@@ -1,6 +1,71 @@
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
 import { runNpcActionPhase } from './npc-combat-brain.js';
+/**
+ * THE COMBAT TURN (SR5 p.158-161, RAG-checked 2026-09-06).
+ *
+ * This engine used to resolve a fight as EXCHANGES: one typed "attack"
+ * rolled a two-actor initiative, both sides struck, and a >10 gap bought
+ * one extra strike. That was the closest thing it had to the book's
+ * turn, and combat-exchange.ts said so. What it could never express was
+ * the thing the book is built on -- a sequence of Action Phases in
+ * which every participant spends a budget of actions, in an order the
+ * dice decided, until nobody has Initiative Score left.
+ *
+ * The sequence, as the book gives it:
+ *   1. ROLL INITIATIVE: Initiative attribute + Initiative Dice, summed
+ *      (p.159). Highest acts first; ties break Edge, Reaction,
+ *      Intuition, coin (p.159 "ERIC").
+ *   2-4. INITIATIVE PASS: each participant, highest score first, takes
+ *      an ACTION PHASE -- two Simple Actions or one Complex, plus one
+ *      Free (p.158). When everyone has acted, EVERY score drops by 10
+ *      (p.159), and anyone still above zero goes again.
+ *   5. When nobody is above zero the Combat Turn ends and a new one
+ *      begins at step 1 (p.159).
+ *
+ * Also carried here because the score lives here:
+ *   - INTERRUPT ACTIONS (p.167-168) spend Initiative Score: Full
+ *     Defense -10 for the Combat Turn, Block/Dodge/Parry -5 each for
+ *     one test. Only affordable "if he has enough Initiative Score
+ *     left" -- a score already at or below zero buys nothing (the p.191
+ *     worked example).
+ *   - WOUND MODIFIERS CHANGE THE SCORE AS THEY LAND (p.160 Changing
+ *     Initiative): the difference is applied immediately, and it can
+ *     reorder the pass. It never grants an extra action.
+ *   - ENTERING LATE (p.160): roll as normal, then subtract 10 for every
+ *     pass already gone.
+ *   - DELAYING (p.161): an actor may hold their Action Phase and take
+ *     it later in the same pass. Modelled as "act after everyone else
+ *     this pass, keeping your score"; the pass-end -10 still applies.
+ *   - SURPRISE (p.192): a fight opened on the unaware makes every other
+ *     participant roll Reaction + Intuition (3); failure is -10 and no
+ *     defense against, nor action against, the surprising side until
+ *     their next Action Phase. +3 for anyone already alert.
+ *   - MOVEMENT is a WHOLE-TURN total (p.161-162, Player.movedMetersThisTurn)
+ *     and comes back at step 5, not per pass.
+ *
+ * SCOPE: one encounter per ROOM, on the physical planes (meat and a
+ * jumped-in drone). The Matrix keeps its own initiative structure
+ * (utilities/ic.ts maps IC to Combat Turns per player action) and
+ * astral combat still rides the exchange engine -- both are noted as
+ * gaps rather than folded in half-right.
+ *
+ * WHO DRIVES IT: a human's Action Phase waits for them to type actions
+ * and then "end turn" (commands/end-turn.ts). An NPC's phase is played
+ * by a deterministic brain (utilities/npc-combat-brain.ts) -- the LLM
+ * reflect chain is suspended for participants while the encounter runs,
+ * because a model answering "what next?" in a second or two cannot be
+ * sequenced against a dice-ordered pass, and was the reason NPCs used
+ * to shoot from between the beats of the player's own exchange.
+ */
+/**
+ * Nudges on one Action Phase before the table ends it for the holder
+ * (commands/nudge.ts, owner ruling 2026-09-07). A ruling, not canon --
+ * the book has no idle player -- kept as a count rather than a clock so
+ * that a runner reading the rules is never skipped by a timer, only by
+ * three people saying so.
+ */
+export const NUDGES_TO_SKIP = 3;
 export class CombatEncounter {
     scene;
     logger;
@@ -19,6 +84,10 @@ export class CombatEncounter {
     /** Whose Action Phase is live, and their budget. */
     phaseActor;
     budget;
+    /** Who opened the fight, and on whom (playtest 2026-09-07: "nothing
+     *  tells me who the aggressor is"). The tracker marks them. */
+    openedBy;
+    openedOn;
     pairs = new Map();
     surrenderSeenAt = new Map();
     running = false;
@@ -41,13 +110,21 @@ export class CombatEncounter {
     async start(members, opts) {
         this.turn = 1;
         this.pass = 1;
+        this.openedBy = opts.aggressor;
+        this.openedOn = opts.target;
         for (const m of members)
             this.addParticipant(m);
         if (opts.target)
             this.noteAttack(opts.aggressor, opts.target);
         this.seedHostility();
         const metaLines = ['Initiative (SR5 p.159):'];
-        const worldLines = [];
+        // WHO STARTED IT is the first thing the room hears (playtest
+        // 2026-09-07): before the Surprise results and before the order.
+        const worldLines = [
+            opts.target
+                ? `{red-fg}⚔ ${opts.aggressor.name} starts it -- opening on ${opts.target.name}.{/red-fg}`
+                : `{red-fg}⚔ ${opts.aggressor.name} starts it.{/red-fg}`,
+        ];
         // SURPRISE (p.192): the ambushed side rolls Reaction + Intuition (3).
         // Failure: -10 Initiative and no defense against the surprisers
         // until their next Action Phase. The aggressor never rolls -- an
@@ -76,7 +153,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}: ${this.participants.map(p => p.actor.name).join(', ')}.`);
+        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(', ')}.`);
         await this.announce(worldLines, metaLines);
         await this.run();
     }
@@ -317,6 +394,7 @@ export class CombatEncounter {
         this.budget = new ActionBudget();
         p.surprised = false;
         p.delayed = false;
+        p.nudges = 0;
         p.actor.clearAim();
         // Recoil resets the moment an Action Phase passes without firing --
         // tracked by the phase, settled by attack.ts (p.175-176).
@@ -342,6 +420,19 @@ export class CombatEncounter {
         const walkLeft = Math.max(0, actor.walkRateMeters - actor.movedMetersThisTurn);
         return `${left} m of movement left this turn (${walkLeft} m at a walk)`;
     }
+    /**
+     * Another human nudged the phase holder (commands/nudge.ts): the
+     * running count for this phase, or undefined when `target` is not
+     * the one holding it. Bookkeeping only -- the verb owns the wording
+     * and calls endPhase() itself at NUDGES_TO_SKIP.
+     */
+    noteNudge(target) {
+        const p = this.participantOf(target);
+        if (!p || this.ended || this.phaseActor !== target)
+            return undefined;
+        p.nudges = (p.nudges ?? 0) + 1;
+        return p.nudges;
+    }
     /** The human typed "end turn" (or lost the phase -- fled, dropped). */
     async endPhase(actor) {
         const p = this.participantOf(actor);
@@ -545,6 +636,7 @@ export class CombatEncounter {
                 : p.actor.surrendered ? 'surrendered'
                     : p.acted ? 'acted' : p.delayed ? 'delaying' : p.score > 0 ? 'to act' : 'spent';
             const marks = [
+                p.actor === this.openedBy ? 'started it' : '',
                 p.surprised ? 'surprised' : '',
                 p.fullDefenseTurn === this.turn ? 'full defense' : '',
                 p.actor.aimBonus > 0 ? `aiming +${p.actor.aimBonus}` : '',

package/bundle/typescript/src/commands/game/sideQuest/utilities/hostile-contact.js

@@ -98,7 +98,12 @@ async function open(scene, room, npc, player, why) {
         : why === 'contact'
             ? `{yellow-fg}${npc.name} is done looking at you.{/yellow-fg}`
             : `{yellow-fg}${npc.name} has waited long enough.{/yellow-fg}`;
+    // Logged to the room BEFORE the encounter opens, not returned after
+    // it: the fight announces itself ("⚔ X starts it -- opening on Y",
+    // Surprise, the order) while startEncounter runs, and a returned line
+    // would print under all of that, out of order.
+    Logger.getInstance().log(line, { room: room.name });
     await scene.startEncounter(room, { aggressor: npc, target: player, ambush: false });
-    return [line];
+    return [];
 }
 //# sourceMappingURL=hostile-contact.js.map

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

@@ -276,7 +276,33 @@ export function crewOfTable(humans) {
         return !!master && seated.has(master);
     };
 }
-function actorGlyph(a, viewer, isOtherPlayer, isTableAlly) {
+/**
+ * RED MEANS HOSTILE (playtest 2026-09-07: "the icons on the map should
+ * be red if they are hostile"). Until then the sword was keyed to
+ * `inExchange`, which only the old two-actor exchange ever set -- the
+ * Combat Turn (combat-turn.ts) never touches it, so a ganger standing
+ * over you drew as a white local. The stance flag (Player.hostile: set
+ * only by a seed or a scene that means it, cleared when talked round)
+ * is the structural answer that needs no Scene; the exchange case stays
+ * for the astral/Matrix fights still on that engine. A caller with a
+ * Scene adds live enmity through `isHostile` (game.ts, headless.ts).
+ */
+export function hostileByStance(a) {
+    if (a.surrendered)
+        return false;
+    const npc = a;
+    return (npc.hostile === true && !npc.allyOf) || a.inExchange;
+}
+/**
+ * Live enmity, for a caller that holds the Scene: `a` is in a running
+ * Combat Turn the viewer is also in, on the other side. Typed
+ * structurally so this file stays free of the Scene import.
+ */
+export function enemyInFight(scene, viewer, a) {
+    const enc = scene.encounterFor?.(a);
+    return !!enc && enc.has(viewer) && enc.enemiesOf(viewer).includes(a);
+}
+function actorGlyph(a, viewer, isOtherPlayer, isTableAlly, isHostile) {
     // Still an actor, so still alive -- the dead are Room.bodies, drawn
     // separately as skulls. This is someone face-down and revivable.
     if (a.isIncapacitated())
@@ -313,7 +339,7 @@ function actorGlyph(a, viewer, isOtherPlayer, isTableAlly) {
     if (isTableAlly?.(a) ?? a.allyOf === viewer.name) {
         return { ch: CREW_GLYPH, color: 'green' };
     }
-    if (a.inExchange && !a.surrendered)
+    if (isHostile?.(a) ?? hostileByStance(a))
         return { ch: HOSTILE_GLYPH, color: 'red' };
     return { ch: NEUTRAL_GLYPH, color: 'white' };
 }
@@ -321,18 +347,18 @@ function actorGlyph(a, viewer, isOtherPlayer, isTableAlly) {
  * The glyph for one cell, in priority order: people, then terrain, then
  * vertical links, then exits, then the spot itself.
  */
-function glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly) {
+function glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly, isHostile) {
     const k = key(c);
     const occ = maps.occupants.get(k);
     if (occ && occ.length > 0) {
         if (occ.includes(viewer))
-            return actorGlyph(viewer, viewer, isOtherPlayer, isTableAlly);
+            return actorGlyph(viewer, viewer, isOtherPlayer, isTableAlly, isHostile);
         if (occ.length === 1)
-            return actorGlyph(occ[0], viewer, isOtherPlayer, isTableAlly);
+            return actorGlyph(occ[0], viewer, isOtherPlayer, isTableAlly, isHostile);
         // A crowded cell shows the most urgent icon standing in it: a fight
         // outranks a runner outranks a bystander, and a body never hides
         // someone still upright.
-        const glyphs = occ.map(a => actorGlyph(a, viewer, isOtherPlayer, isTableAlly));
+        const glyphs = occ.map(a => actorGlyph(a, viewer, isOtherPlayer, isTableAlly, isHostile));
         return glyphs.find(g => g.ch === HOSTILE_GLYPH)
             ?? glyphs.find(g => g.ch === PLAYER_GLYPH)
             // A fellow runner outranks a bystander for the same reason you
@@ -398,7 +424,7 @@ function levelPlansFor(room) {
  * glyph used. Returns [] for a spotless room (no grid ever synthesizes
  * -- see Room.ensureGrid).
  */
-export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly) {
+export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHostile) {
     const grid = room.ensureGrid();
     if (!grid)
         return [];
@@ -419,7 +445,7 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly) {
             let row = '';
             for (let x = x0; x <= x1; x++) {
                 const c = { x, y, z: lvl.z };
-                row += exists.has(key(c)) ? cell(glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly)) : '  ';
+                row += exists.has(key(c)) ? cell(glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly, isHostile)) : '  ';
             }
             rows.push(row.trimEnd());
         }
@@ -483,7 +509,7 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly) {
     }
     // People, once, only for the icons actually standing in the room --
     // a key to four kinds of person in an empty bar is just noise.
-    const present = new Set(visibleActorsIn(room, viewer).map(a => actorGlyph(a, viewer, isOtherPlayer, isTableAlly).ch));
+    const present = new Set(visibleActorsIn(room, viewer).map(a => actorGlyph(a, viewer, isOtherPlayer, isTableAlly, isHostile).ch));
     const who = [
         // "you" leads the key: on a party job it is the answer to the
         // question that sent the player to the legend in the first place.
@@ -508,7 +534,7 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly) {
         present.has(OTHER_PLAYER_GLYPH) ? `{${OTHER_PLAYER_COLOR}-fg}${OTHER_PLAYER_GLYPH}{/${OTHER_PLAYER_COLOR}-fg} runner` : '',
         present.has(CREW_GLYPH) ? `{green-fg}${CREW_GLYPH}{/green-fg} yours` : '',
         present.has(NEUTRAL_GLYPH) ? `{white-fg}${NEUTRAL_GLYPH}{/white-fg} local` : '',
-        present.has(HOSTILE_GLYPH) ? `{red-fg}${HOSTILE_GLYPH}{/red-fg} fighting` : '',
+        present.has(HOSTILE_GLYPH) ? `{red-fg}${HOSTILE_GLYPH}{/red-fg} hostile` : '',
         // The knocked-out mark was missing from this key entirely -- the one
         // glyph on the map a player is most likely to need explained.
         present.has(DOWNED_GLYPH) ? `{yellow-fg}${DOWNED_GLYPH}{/yellow-fg} out cold` : '',
@@ -712,7 +738,7 @@ function renderShellCompact(room, viewer, availW, viewH, boxWidth) {
 export function renderRoomLayoutCompact(room, viewer, opts = {}) {
     // Default to the TALLEST room class, not a fixed 9 -- see
     // room-grid.ts tallestRoomRows for why that number is derived.
-    const { viewH = tallestRoomRows(), boxWidth, isOtherPlayer, isTableAlly } = opts;
+    const { viewH = tallestRoomRows(), boxWidth, isOtherPlayer, isTableAlly, isHostile } = opts;
     // Width left for the grid once the right-justified elevation bar and
     // its gap are reserved.
     const availW = Math.max(6, (boxWidth ?? 27) - ELEVATION_WIDTH - 1);
@@ -735,7 +761,7 @@ export function renderRoomLayoutCompact(room, viewer, opts = {}) {
         const row = [];
         for (let x = x0; x <= x1; x++) {
             const c = { x, y, z };
-            row.push(exists.has(key(c)) ? glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly) : undefined);
+            row.push(exists.has(key(c)) ? glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly, isHostile) : undefined);
         }
         cells.push(row);
     }

package/package.json

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