@maka/maka-cli 5.139.0 → 5.141.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.139.0",
+  "version": "5.141.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/env/prompt-for-env.js

@@ -4,15 +4,10 @@ import { Log } from '../../tools/log/log.class.js';
  * Prompts for which environment to target when --env wasn't given.
  */
 export async function promptForEnv(cfg, opts = {}) {
-    const { message = 'Which environment?', excludeLocal = false } = opts;
-    let configs = cfg.getAppProjectConfigs();
-    if (excludeLocal) {
-        configs = configs.filter(config => config !== 'local');
-    }
+    const { message = 'Which environment?' } = opts;
+    const configs = cfg.getAppProjectConfigs();
     if (configs.length === 0) {
-        Log.error(excludeLocal
-            ? 'No configuration other than local found. Consider running "maka g:config production" first.'
-            : 'No configurations found. Consider running "maka g:config local" first.');
+        Log.error('No configurations found. Consider running "maka g:config local" first.');
         process.exit(1);
     }
     if (configs.length === 1) {

package/bundle/typescript/src/commands/env/set.sub.cmd.js

@@ -34,7 +34,7 @@ Command.create({
     ]
 }, async function (args, opts) {
     try {
-        const env = opts.env ? this.cfg.getEnvFromShorthand(opts.env) : await promptForEnv(this.cfg, { excludeLocal: true });
+        const env = opts.env ? this.cfg.getEnvFromShorthand(opts.env) : await promptForEnv(this.cfg);
         if (!this.cfg.checkConfigExists(env)) {
             Log.error(`No configuration: ${env}, consider running "maka g:config ${env}"`);
             process.exit(1);

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

@@ -388,5 +388,9 @@
 //   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.
-export const ENGINE_VERSION = '1.43.0';
+// 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';
@@ -5623,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));

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

@@ -84,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;
@@ -106,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
@@ -141,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();
     }
@@ -624,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.139.0",
+  "version": "5.141.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.",