@maka/maka-cli 5.136.0 → 5.137.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.136.0",
+  "version": "5.137.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/bluff.js

@@ -1,3 +1,4 @@
+import { standDown } from '../utilities/hostile-contact.js';
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { sameSpot, spotOf, sealedRouteTo } from '../utilities/spots.js';
@@ -152,7 +153,11 @@ export class BluffCommand extends Command {
             return `${who.name} lets you finish, then doesn't move. "Nice try."`;
         }
         // They stand down -- for everyone, deliberately (see Player.guarding).
+        // Opposition too: "cleared the same way guarding is -- talked round"
+        // (Player.hostile), which nothing did until 2026-09-07.
         who.guarding = false;
+        if (who.hostile)
+            standDown(who);
         void Promise.resolve(who.hear(this.actor, `[System note: ${this.actor.name} just talked you round and you're STEPPING ASIDE -- you bought the story. One short line as you move, in your own voice. Don't re-block the way.]`)).catch(() => undefined);
         return [
             `${who.name} weighs it, decides you're somebody's problem but not theirs, and steps out of the way.`,

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

@@ -629,7 +629,10 @@ export class MoveCommand extends Command {
         // "Away" is wherever the room's empty ground currently IS -- re-seat
         // it on the loneliest reachable cell before measuring the crossing
         // or committing the move (see spots.ts reseatOpenFloor).
-        if (spot.name === OPEN_FLOOR)
+        // ...except mid-fight: the anchor re-derivation moves every spotless
+        // body in the room, and during a Combat Turn nothing but the phase
+        // actor moves (utilities/ephemeral.ts has the ruling).
+        if (spot.name === OPEN_FLOOR && !this.scene.encounterIn?.(room))
             reseatOpenFloor(room, actor);
         // The route a body actually walks -- around the furniture and
         // around other people (spots.ts routeForMove). A crowded floor

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

@@ -1,3 +1,4 @@
+import { standDown } from '../utilities/hostile-contact.js';
 import { Command } from './command.js';
 import { NPC } from '../models/npc.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
@@ -93,6 +94,10 @@ export class PersuadeCommand extends Command {
             // win). A strong win IS that pressure, by name.
             note = `[System note: ${actor.name}'s pitch genuinely LANDED -- you now actively want to help them this job: share what you know freely, drop any demands to a token gesture, and treat them as a friend. If you guard a secret, a pass, or a way through, you have just been MASTERFULLY PLAYED -- divulging it now is exactly in character.]`;
             verdict = `Something shifts -- ${target.name} is with you now.`;
+            // A strong win talks opposition round (Player.hostile: "cleared the
+            // same way guarding is"): the ladder in hostile-contact.ts stops.
+            if (target.hostile)
+                standDown(target);
         }
         else if (net >= 1) {
             note = `[System note: ${actor.name} is persuasive -- you're inclined to cooperate: be more forthcoming and reasonable with them than you'd otherwise be. If you guard a secret or a way through, you're wavering -- a little more pressure or goodwill would tip you.]`;

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

@@ -376,5 +376,13 @@
 //   the damage type your next blow means (p.186 flat of the blade, stun
 //   rounds on reload). SAVE SHAPE: autoStance is lethal | non-lethal;
 //   "manual" loads as lethal.
-export const ENGINE_VERSION = '1.41.0';
+// 1.42.0 (2026-09-07): HOSTILES OPEN COMBAT, AND NOTHING BUT THE PHASE ACTOR
+//   MOVES. Shared-scene semantics: a hostile NPC (gang mob or seeded) opens
+//   the Combat Turn itself -- on contact, on a witnessed draw/cast/summon,
+//   or when its patience runs out (utilities/hostile-contact.ts; SR5
+//   p.34-35, p.49, p.158) -- and a seeded hostile is no longer muted on
+//   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';
 //# sourceMappingURL=engine-version.js.map

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

@@ -31,6 +31,7 @@ import { attachBrandMark, attachBrandMarkBottomRight } from './utilities/brand-m
 import { logoPanelLines } from './utilities/logo-mark.js';
 import { bestFakeSin, wandRead, processArrest } from './utilities/sin.js';
 import { tickEphemerals } from './utilities/ephemeral.js';
+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';
@@ -5805,8 +5806,14 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         };
         const command = CommandFactory.createCommand(verb, context);
         if (command) {
+            // THE BEAT CLOCK (Scene.beat) ticks BEFORE the command, so a body
+            // that spawns or a guard that registers you during it carries this
+            // beat's number, and the contact check after it can grant them the
+            // one-beat grace the ephemeral governor already gives a mob.
+            if (this.scene.isHumanControlled(actor))
+                this.scene.beat += 1;
             const result = await command.execute(args);
-            const wrapped = this.withEphemeralTurn(actor, this.withAlarmTurn(actor, this.withICTurn(actor, result)));
+            const wrapped = await this.withHostileContact(actor, this.withEphemeralTurn(actor, this.withAlarmTurn(actor, this.withICTurn(actor, result))));
             // The IC turn above may have filled a track -- settle it now, not
             // on the next keystroke.
             const settled = await settleUnresolvedHarm(this.scene, actor);
@@ -5923,6 +5930,23 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const lines = tickEphemerals(this, actor);
         return lines.length === 0 ? result : `${result}\n\n${lines.join('\n')}`;
     }
+    /**
+     * HOSTILES OPEN COMBAT (utilities/hostile-contact.ts): after every
+     * human command, every hostile in that human's room gets its beat --
+     * contact, a provocation they witnessed, or patience run out opens
+     * the Combat Turn with THEM as aggressor. Runs AFTER the ephemeral
+     * tick so the step a mob just took toward you counts this beat. Any
+     * human, not only the primary: a second runner on the table can be
+     * the one a ganger is standing over.
+     */
+    async withHostileContact(actor, result) {
+        if (result === null)
+            return null;
+        if (!this.scene.isHumanControlled(actor))
+            return result;
+        const lines = await hostileContactBeat(this.scene, actor, this.scene.beat);
+        return lines.length === 0 ? result : `${result}\n\n${lines.join('\n')}`;
+    }
     withICTurn(actor, result) {
         if (result === null)
             return null;

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

@@ -1,3 +1,4 @@
+import { registerNotice, registerProvocation, PROVOCATION } from '../utilities/hostile-contact.js';
 import { capitalCase } from 'change-case';
 import { tableCrewNote, tableDeliveryNote } from '../utilities/table-notes.js';
 import { Player } from './player.js';
@@ -673,6 +674,15 @@ export class NPC extends Player {
      * none of the three.
      */
     ephemeral;
+    /**
+     * WHERE THIS HOSTILE IS ON THE LADDER that opens a fight
+     * (utilities/hostile-contact.ts, 2026-09-07): the beat they registered
+     * the player, the beat they watched a provocation, and why the fight
+     * opened once it has. Transient and never saved -- a hostile you left
+     * behind starts over when you come back. Written only by that module
+     * and by see() below (the witness); read only by that module.
+     */
+    hostileContact;
     /**
      * Every human seated at this scene's table. utilities/table-notes.ts
      * turns it into what a companion is told; in solo play it is just
@@ -1174,6 +1184,18 @@ description text.`;
                     this.logger.logWithColor(`${this.name} clocks you slipping in -- so much for quiet.`, 'yellow');
                 }
             }
+            // HOSTILE CONTACT (utilities/hostile-contact.ts): a hostile who
+            // just registered a human -- or watched them draw, cast, or call
+            // a spirit -- is on the ladder that opens the fight. Marks only;
+            // the beat after the command decides. Past the sneak contest on
+            // purpose: a sneaking player who won it never reaches this line.
+            if (this.hostile && !(actor instanceof NPC)) {
+                const beat = this._scene?.beat ?? 0;
+                if (PROVOCATION.test(verb))
+                    registerProvocation(this, beat);
+                else
+                    registerNotice(this, beat);
+            }
             // A jumped-in arrival is a MACHINE arriving -- the history should
             // say so, or the AI greets a rotor drone like the person's face.
             const form = actor.plane === 'drone'
@@ -1280,7 +1302,13 @@ description text.`;
                         blendFailed = true;
                     }
                 }
-                if (spotsActive(this.currentLocation)
+                // A HOSTILE IS NEVER "NOT WARM ENOUGH TO HAIL" (2026-09-07): the
+                // warmth gate is about greetings, and opposition has something
+                // to say to a stranger on its ground -- the challenge that
+                // canon puts before the fight (p.34-35). Muting it here was why
+                // a seeded guard in a spotted room watched you walk in and said
+                // nothing until you drew.
+                if (spotsActive(this.currentLocation) && !this.hostile
                     && !(rel && rel.loyalty >= 3) && !knownByRep && !arrivedAtMySpot) {
                     this.logger.write(`[DEBUG] ${this.name} quietly notes the arrival -- not warm enough to hail (loyalty ${rel?.loyalty ?? 'none'}).`);
                     return;

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

@@ -144,6 +144,15 @@ export class Scene extends AbstractScene {
         const enc = this.encounters.get(room);
         return enc && !enc.ended ? enc : undefined;
     }
+    /**
+     * THE BEAT CLOCK: which human command the world is on. Game bumps it
+     * before each human command runs, so anything that happens DURING a
+     * command (a gang spawning, a guard registering you) carries that
+     * command's number, and the hostile-contact beat that runs after it
+     * can tell "noticed you this action" from "has been watching you for
+     * three". Transient; never saved.
+     */
+    beat = 0;
     /** The fight this actor is a participant in, if any. */
     encounterFor(actor) {
         const enc = this.encounterIn(actor.currentLocation);

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

@@ -173,11 +173,19 @@ function walkCells(npc) {
  * room, and each kind spends it differently.
  *
  * WHY THIS HANGS OFF THE COMMAND DISPATCH, which is the same choice
- * withICTurn made and for the same reason: an ephemeral is not a combat
- * actor, so there is no turn loop to live in, and hooking one verb
- * would give a mob permission to close only while you happened to be
- * walking. It closes while you look, while you talk, while you check
- * your gear. That is what makes it opposition rather than furniture.
+ * withICTurn made and for the same reason: OUTSIDE A FIGHT there is no
+ * turn loop to live in, and hooking one verb would give a mob
+ * permission to close only while you happened to be walking. It closes
+ * while you look, while you talk, while you check your gear. That is
+ * what makes it opposition rather than furniture.
+ *
+ * INSIDE A FIGHT THE GOVERNOR IS SILENT (playtest 2026-09-07: "if I
+ * move, they move -- not respecting the combat turn, which is mine").
+ * Since the Combat Turn (combat-turn.ts, engine 1.40.0) a room with a
+ * live encounter IS a turn loop, every hostile in it is a participant,
+ * and a participant moves on its own Action Phase through the verbs
+ * (npc-combat-brain.ts: "move to <spot>", then the swing) and never on
+ * the player's keystrokes. Nothing but the phase actor moves.
  *
  * WHAT THIS IS NOT: it is NOT what made the NPC seem to follow the
  * player. Nothing here existed when that was reported -- an ephemeral
@@ -198,10 +206,17 @@ export function tickEphemerals(host, player) {
     const room = player.currentLocation;
     if (!room)
         return lines;
+    // A Combat Turn is running here: initiative owns every body in the
+    // room, and the beat clock (mark.ticks) stops with it -- a mob's
+    // patience does not run out while the dice are rolling.
+    if (host.scene.encounterIn?.(room))
+        return lines;
     for (const [name, mark] of host.ephemerals) {
         const npc = host.scene.getActor(name);
         if (!(npc instanceof NPC) || npc.isIncapacitated())
             continue;
+        if (host.scene.encounterFor?.(npc))
+            continue;
         // A BODY IN ANOTHER ROOM IS NOT YOUR PROBLEM AND YOU ARE NOT ITS
         // BUSINESS. This is the line the report was really about: a mob you
         // left behind holds the block it was holding, and nothing here can

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

@@ -0,0 +1,104 @@
+import { actorDistanceMeters, ADJACENT_METERS, wouldNotice } from './spots.js';
+import { Logger } from './logger.js';
+/**
+ * Beats after notice before a hostile stops waiting for you to leave.
+ * Three player actions is the length of a challenge and an answer;
+ * canon gives no number (the GM decides when "fighting breaks out"), so
+ * this is a documented ruling, kept short enough that "they were hostile
+ * and nothing happened" cannot recur.
+ */
+export const PATIENCE_BEATS = 3;
+/** What a hostile watching you do it will not let pass (performAction verbs). */
+export const PROVOCATION = /^(draws\b|casts\b|chants a summoning)/;
+/** The hostiles in `room` who could open on `player` -- structural, no LLM. */
+export function hostilesIn(scene, room, player) {
+    const out = [];
+    for (const a of room.getActors()) {
+        if (a === player || scene.isHumanControlled(a))
+            continue;
+        const npc = a;
+        if (npc.hostile !== true || npc.allyOf || npc.surrendered)
+            continue;
+        if (npc.isIncapacitated() || !npc.sharesCombatPlane(player))
+            continue;
+        out.push(npc);
+    }
+    return out;
+}
+/** A hostile has registered the player (idempotent; the first beat wins). */
+export function registerNotice(npc, beat) {
+    if (npc.hostile !== true)
+        return;
+    npc.hostileContact ??= { noticedBeat: beat };
+}
+/** A hostile watched the player do something it cannot ignore. */
+export function registerProvocation(npc, beat) {
+    if (npc.hostile !== true)
+        return;
+    registerNotice(npc, beat);
+    npc.hostileContact.provokedBeat ??= beat;
+}
+/** Talked round, or beaten: opposition stands down. */
+export function standDown(npc) {
+    npc.hostile = false;
+    npc.hostileContact = undefined;
+}
+function onPhysicalPlane(player) {
+    return player.plane === 'meat' || player.plane === 'drone';
+}
+/**
+ * One beat of every hostile in the player's room. Runs after every
+ * human command (Game.withHostileContact) and once on arrival after the
+ * ephemerals have spawned (go.ts describeArrival) -- the reported case
+ * is a gang that did not exist when the arrival stimulus fanned out.
+ * Returns narration; the encounter announces its own initiative.
+ */
+export async function hostileContactBeat(scene, player, beat) {
+    const room = player.currentLocation;
+    if (!room || !onPhysicalPlane(player) || player.isIncapacitated())
+        return [];
+    if (scene.encounterIn?.(room))
+        return [];
+    for (const npc of hostilesIn(scene, room, player)) {
+        const c = npc.hostileContact;
+        if (!c) {
+            // A sneaking player is the arrival contest's call, not ours.
+            if (!player.sneaking && wouldNotice(npc, player))
+                registerNotice(npc, beat);
+            continue;
+        }
+        // NOBODY OPENS ON THE BEAT THEY NOTICED YOU -- the same grace the
+        // ephemeral governor gives a mob its first beat: a gang that squares
+        // up and swings in one breath is the ambush street-gang.ts says it
+        // is not. A provocation is the exception: you drew on them.
+        const provoked = c.provokedBeat !== undefined;
+        if (!provoked && beat <= c.noticedBeat)
+            continue;
+        const inReach = actorDistanceMeters(room, npc, player) <= ADJACENT_METERS;
+        const patienceOut = beat - c.noticedBeat >= PATIENCE_BEATS;
+        const why = provoked ? 'provocation' : inReach ? 'contact' : patienceOut ? 'patience' : undefined;
+        if (!why)
+            continue;
+        return open(scene, room, npc, player, why);
+    }
+    return [];
+}
+/** The commit line, then the Combat Turn, with the hostile as aggressor. */
+async function open(scene, room, npc, player, why) {
+    npc.hostileContact.openedBy = why;
+    // The predicate go.ts's despawn and resolvePartingShot read for "a
+    // fight is on": a mob that opened on you stays with it through the
+    // doorway; one you walked away from before this beat let you go.
+    const now = Date.now();
+    npc.lastExchangeAt = now;
+    player.lastExchangeAt = now;
+    Logger.getInstance().write(`Hostile contact: ${npc.name} opens on ${player.name} in ${room.name} (${why}).`);
+    const line = why === 'provocation'
+        ? `{yellow-fg}${npc.name} saw that -- and that settles it.{/yellow-fg}`
+        : why === 'contact'
+            ? `{yellow-fg}${npc.name} is done looking at you.{/yellow-fg}`
+            : `{yellow-fg}${npc.name} has waited long enough.{/yellow-fg}`;
+    await scene.startEncounter(room, { aggressor: npc, target: player, ambush: false });
+    return [line];
+}
+//# sourceMappingURL=hostile-contact.js.map

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

@@ -367,7 +367,12 @@ function holdsGround(other, mover) {
     if (other.allyOf === mover.name)
         return false;
     const guarding = other.guarding === true;
-    return (other.inExchange || guarding) && !other.surrendered;
+    // Two fight engines, one rule: the old exchange flag OR a place in a
+    // running Combat Turn (combat-turn.ts). A ganger in the doorway you
+    // back through holds it while the fight is on.
+    const fighting = other.inExchange
+        || other.combatPhaseLocked?.() === true;
+    return (fighting || guarding) && !other.surrendered;
 }
 /**
  * Move a non-hostile body off an exit so the way opens, returning their

package/bundle/typescript/src/commands/game/sideQuest/utilities/street-gang.js

@@ -1,3 +1,4 @@
+import { registerNotice } from './hostile-contact.js';
 import { Logger } from './logger.js';
 import { isOutdoorsPlace } from './outdoors.js';
 import { spawnEphemeral, claimEphemeralName } from './ephemeral.js';
@@ -25,11 +26,16 @@ import { AI } from '../../../../tools/ai/ai.class.js';
  * Splintered State p.11 "law enforcement will not show up at any point
  * -- this is the Barrens"; Run Faster p.220 on Zone 0).
  *
- * THEY DO NOT ATTACK ON SIGHT. They are spawned `hostile`, which per
- * Player.hostile adds a REASON to the brief and nothing else -- the AI
- * still chooses, and challenging, shaking down, or sizing you up are
- * all likelier openings than shooting. That keeps the governor's
- * founding property intact: an ephemeral voices, it does not rule.
+ * THEY DO NOT ATTACK ON SIGHT. They are spawned `hostile`, and the
+ * spawn line is the challenge canon puts before the fight (p.34-35).
+ * WHERE THE CHALLENGE GOES (2026-09-07, playtest "the combat turn never
+ * started until I attacked"): utilities/hostile-contact.ts. A ganger
+ * closes on the beat clock (ephemeral.ts closeOn); when it reaches you,
+ * when it watches you draw, or when its patience runs out, the Combat
+ * Turn opens with the ganger as aggressor. Walk away first and it lets
+ * you go; talk it round ("bluff", "persuade") and it stands down. The
+ * governor's founding property holds: the engine computes the ladder,
+ * the ephemeral never decides anything.
  */
 /**
  * PROFESSIONAL RATING 1 GANGER, canon stats (SR5 p.382, "Gangers &
@@ -114,9 +120,12 @@ export function maybeStreetGang(host, actor, room) {
         });
         if (!npc)
             continue;
-        // OPPOSITION, not an ambush (Player.hostile): this gives them a
-        // reason, and the AI still chooses what to do with it.
+        // OPPOSITION, not an ambush (Player.hostile). A body that peeled
+        // off the wall watching you has, by definition, noticed you: it is
+        // on the contact ladder from this beat (hostile-contact.ts), with
+        // the one-beat grace every mob gets before it moves.
         npc.hostile = true;
+        registerNotice(npc, host.scene.beat ?? 0);
         spawned.push(npc.name);
     }
     if (spawned.length === 0)

package/package.json

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