@maka/maka-cli 5.135.0 → 5.137.0

package/bundle/typescript/package.json

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

@@ -1,16 +1,19 @@
 import { Command } from './command.js';
-import { STANCE_CYCLE, STANCE_ALIASES, MATRIX_STANCE_CYCLE, MATRIX_STANCE_ALIASES, MATRIX_STANCE_ACTION } from '../models/player.js';
-import { AutoFight } from '../utilities/auto-fight.js';
+import { STANCE_CYCLE, STANCE_ALIASES, STANCE_DESCRIPTION, MATRIX_STANCE_CYCLE, MATRIX_STANCE_ALIASES, MATRIX_STANCE_ACTION } from '../models/player.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 /**
- * The typed twin of the Tab key: set (or inspect) the fight-or-flight
- * autopilot temperature. Tab cycles manual -> guarded -> aggressive in the
- * UI; this command jumps straight to one by name, typo-tolerant. The full
- * semantics live in utilities/auto-fight.ts.
+ * The typed twin of the Tab key: set (or inspect) the stance. On either
+ * plane the stance is what your next action DOES -- in the meat, the
+ * damage type your blow is meant to deal (lethal / non-lethal, see
+ * FightStance in models/player.ts); on the Matrix, which intrusion
+ * action a hack is (Brute Force / Hack on the Fly). It never decides
+ * whether you act: since the Combat Turn (2026-09-06) every phase is
+ * yours to play and "end turn" to commit, and the fight autopilot this
+ * verb used to set was retired with it (2026-09-07).
  */
 export class StanceCommand extends Command {
     static verb = 'stance';
-    static description = 'Set your stance. ON THE MATRIX it picks which intrusion action you use -- attack (Brute Force, p.238) or sleaze (Hack on the Fly, p.240); Tab flips it, and "deck config" still sets the array. IN THE MEAT it sets your fight autopilot. You ALWAYS counter when struck; the stance decides who presses: manual (you type it), non-lethal (auto, Stun where the gear allows, subdues, honors surrender), lethal (auto, to the death). Tab cycles.';
+    static description = 'Set your stance -- what your next action does, never whether you take it. ON THE MATRIX it picks the intrusion action: attack (Brute Force, p.238) or sleaze (Hack on the Fly, p.240); "deck config" still sets the array. IN THE MEAT it picks the damage type you mean: lethal (the gear as sold) or non-lethal (Stun wherever the gear allows -- stun rounds when you reload, the flat of the blade at Accuracy 3 per p.186, bare hands; a lethal gun with lethal rounds warns you it stays lethal). Tab flips it.';
     /**
      * ON THE MATRIX, TAB FLIPS THE INTRUSION ACTION instead of the fight
      * autopilot (mjmcee, uMQAhaAysgaKpWFkn). One verb and one key, two
@@ -40,11 +43,11 @@ export class StanceCommand extends Command {
             if (onMatrix)
                 return this.matrixLines(actor);
             const lines = [
-                `Stance: ${actor.autoStance.toUpperCase()} -- ${AutoFight.describe(actor.autoStance)}.`,
+                `Stance: ${actor.autoStance.toUpperCase()} -- ${STANCE_DESCRIPTION[actor.autoStance]}.`,
                 '',
-                ...STANCE_CYCLE.map(s => `  ${s.padEnd(10)} -- ${AutoFight.describe(s)}`),
+                ...STANCE_CYCLE.map(s => `  ${s.padEnd(10)} -- ${STANCE_DESCRIPTION[s]}`),
                 '',
-                `Set with "stance <name>", or Tab to cycle. Flight is never automated -- running is always your call.`,
+                `Set with "stance <name>", or Tab to flip. The stance is what a blow does, not who throws it -- every action is yours to type, and "end turn" commits the phase.`,
             ];
             return lines.join('\n');
         }
@@ -72,10 +75,9 @@ export class StanceCommand extends Command {
             const cur = STANCE_CYCLE.indexOf(actor.autoStance);
             const nextStance = STANCE_CYCLE[(cur + 1) % STANCE_CYCLE.length];
             actor.autoStance = nextStance;
-            this.game?.autoFight?.cancelPending();
             this.scene.updateStatus();
             this.logger.write(`${actor.name} cycled stance to ${nextStance}.`);
-            return `Stance: ${nextStance.toUpperCase()} -- ${AutoFight.describe(nextStance)}.`;
+            return `Stance: ${nextStance.toUpperCase()} -- ${STANCE_DESCRIPTION[nextStance]}.`;
         }
         // A Matrix route by name, from either plane's vocabulary -- so
         // "stance sleaze" works while jacked in and reads as a typo
@@ -100,13 +102,12 @@ export class StanceCommand extends Command {
         }
         const stance = picked;
         if (stance === actor.autoStance) {
-            return `Already ${stance.toUpperCase()} -- ${AutoFight.describe(stance)}.`;
+            return `Already ${stance.toUpperCase()} -- ${STANCE_DESCRIPTION[stance]}.`;
         }
         actor.autoStance = stance;
-        this.game?.autoFight?.cancelPending();
         this.scene.updateStatus();
         this.logger.write(`${actor.name} set stance to ${stance}.`);
-        return `Stance: ${stance.toUpperCase()} -- ${AutoFight.describe(stance)}.`;
+        return `Stance: ${stance.toUpperCase()} -- ${STANCE_DESCRIPTION[stance]}.`;
     }
 }
 //# sourceMappingURL=stance.js.map

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

@@ -3,9 +3,10 @@ import { billAction } from '../utilities/action-cost.js';
 /**
  * Throwing your hands up, as a real mechanical act instead of just talk.
  * The wound-aware AI guidance already nudges a losing NPC toward
- * surrender -- this gives that nudge teeth: the flag it sets is what a
- * GUARDED auto-fighter honors by holding fire (see utilities/auto-fight.ts;
- * an AGGRESSIVE one doesn't have to). Surrendering also breaks the fight:
+ * surrender -- this gives that nudge teeth: the flag it sets is what the
+ * Combat Turn reads to decide whether anyone is still hostile
+ * (CombatEncounter.stillHostile) and what "restrain" holds without a
+ * roll (p.195). Surrendering also breaks the fight:
  * both sides' combat memory clears, so walking away afterwards invites no
  * parting shot. The flag is revoked the moment the surrendered actor
  * initiates violence again (CombatExchange.beginExchange).

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

@@ -369,5 +369,20 @@
 //   grapple, struggle, release, cast, summon, dispel, heal and movement
 //   are refused outside your Action Phase and spend its Free/Simple/
 //   Complex budget. NPC participants act by rule, not by the LLM chain.
-export const ENGINE_VERSION = '1.40.0';
+// 1.41.0 (2026-09-07): THE STANCE IS INTENT, NOT AN AUTOPILOT. The fight
+//   autopilot (utilities/auto-fight.ts) is gone: a phase you commit with
+//   "end turn" is never played for you, in a hosted run or a local one.
+//   "stance" / Tab keep the half the rules read -- lethal or non-lethal,
+//   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.
+// 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';
@@ -179,7 +180,6 @@ import { TimeCommand } from './commands/time.js';
 // The HUD's clock -- read in the engine so a shared run reads the
 // host's wall clock, never each client's own (item B).
 import { clockTime, worldNow } from './utilities/world-clock.js';
-import { AutoFight } from './utilities/auto-fight.js';
 import { CommandFactory } from './factories/command-factory.js';
 import { SceneSynthesizer } from './factories/scene-factory.js';
 import { SceneSeedGenerator, FIXER_NAME, isFixerName } from './factories/scene-seed-generator.js';
@@ -195,9 +195,6 @@ export default class Game {
     sceneSeed;
     scene;
     player;
-    // The fight autopilot (Tab / "stance" command) -- created once, reads
-    // live game state at fire time so it survives scene transitions.
-    autoFight = new AutoFight(this);
     // Just three surfaces: a full-width log, a HUD strip, and the input box.
     // The old always-on Inventory/Equipment/Map sidebar boxes became the
     // on-demand inv/equipment/map commands (see commands/inv.ts et al.) to
@@ -3662,7 +3659,6 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.player.inExchange = false;
         this.player.combatOpponent = undefined;
         this.player.activeCallPartner = undefined;
-        this.autoFight.cancelPending();
     }
     /** The panel refresh both errand legs need. */
     /**
@@ -3785,7 +3781,6 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.player.inExchange = false;
         this.player.combatOpponent = undefined;
         this.player.activeCallPartner = undefined;
-        this.autoFight.cancelPending();
         this.scene = hub;
         this.scene.addRoom(this._homeRoom);
         this.connectHomeRoom(hub.determineStartRoom());
@@ -4617,7 +4612,6 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         if (this._presenceEquipTimer)
             clearTimeout(this._presenceEquipTimer);
         this.stopPursuitHeartbeat();
-        this.autoFight.cancelPending();
         for (const ko of this.scene?.playerKnockouts.values() ?? []) {
             if (ko.timer)
                 clearTimeout(ko.timer);
@@ -5237,14 +5231,15 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     }
     statusLinesFor(player) {
         const lines = [];
-        // Line 1: the fight autopilot mode. The stance lives HERE -- the
+        // Line 1: the stance -- lethal or non-lethal in the meat (the damage
+        // type your next blow means; models/player.ts FightStance), Brute
+        // Force or Hack on the Fly on the Matrix. It lives HERE -- the
         // shortest HUD line -- because appended to the long readiness line it
         // wrapped out of the box on narrower terminals and effectively only
-        // ever showed in the Tab announcement. Always shown, even MANUAL: the
-        // HUD is how players discover Tab cycles it at all (see
-        // utilities/auto-fight.ts). MANUAL is white, not gray -- blessed's
-        // gray is ANSI "bright black", which on a stock dark terminal palette
-        // is illegible enough that the stance looked absent entirely.
+        // ever showed in the Tab announcement. Always shown: the HUD is how
+        // players discover Tab flips it at all. Red for the lethal routes,
+        // yellow for the careful ones -- never gray, which is ANSI "bright
+        // black" and illegible on a stock dark palette.
         //
         // WHERE YOU ARE MOVED OUT (player ruling 2026-08-25): the room name
         // now captions the Map box and the "@ spot" captions the Room box,
@@ -5252,9 +5247,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // what two panels already show. The breadcrumb went with it -- the
         // district map draws the way you came far better than a text trail.
         // THE STANCE THE HUD SHOWS IS THE ONE IN FORCE (uMQAhaAysgaKpWFkn,
-        // 2026-09-03). Jacked in, the fight autopilot is not what Tab
-        // moves and not what your next action obeys -- the Matrix stance
-        // is (Brute Force or Hack on the Fly). Showing the meat stance to
+        // 2026-09-03). Jacked in, the fight stance is not what Tab moves
+        // and not what your next action obeys -- the Matrix stance is
+        // (Brute Force or Hack on the Fly). Showing the meat stance to
         // a persona would be the same class of bug as the 2026-08-27
         // report that the HUD did not follow Tab at all: a readout naming
         // a setting the player cannot currently change.
@@ -5262,7 +5257,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const stanceWord = onMatrix ? MATRIX_STANCE_ACTION[player.matrixStance] : player.autoStance;
         const stanceColor = onMatrix
             ? (player.matrixStance === 'attack' ? 'red' : 'yellow')
-            : player.autoStance === 'lethal' ? 'red' : player.autoStance === 'non-lethal' ? 'yellow' : 'white';
+            : player.autoStance === 'lethal' ? 'red' : 'yellow';
         // WHAT'S IN YOUR HANDS rides alongside the stance (player ruling
         // 2026-08-25). The two answer the same question -- how ready are you
         // -- and the stance line was left short and lonely once the location
@@ -5811,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);
@@ -5929,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/headless-harness.js

@@ -82,7 +82,7 @@ export function savedPlayer(name, overrides = {}) {
         },
         edgeRemaining: 3,
         haggledThisJob: false,
-        autoStance: 'manual',
+        autoStance: 'lethal',
         visitedRooms: [],
         inventory: [],
         equipment: {},

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/player.js

@@ -15,9 +15,17 @@ import { physicalLimit } from '../utilities/grapple.js';
 import { astralLimit } from '../utilities/limits.js';
 import { Inventory } from './inventory.js';
 import { AbstractPlayer } from '../types/shared/abstracts.js';
-export const STANCE_CYCLE = ['manual', 'non-lethal', 'lethal'];
+export const STANCE_CYCLE = ['lethal', 'non-lethal'];
 /** The old names, still accepted from saves and the stance command. */
-export const STANCE_ALIASES = { guarded: 'non-lethal', aggressive: 'lethal', nonlethal: 'non-lethal', 'non lethal': 'non-lethal' };
+export const STANCE_ALIASES = {
+    guarded: 'non-lethal', aggressive: 'lethal', manual: 'lethal',
+    nonlethal: 'non-lethal', 'non lethal': 'non-lethal', stun: 'non-lethal', kill: 'lethal',
+};
+/** What each stance means, in one line -- the HUD's and the verb's. */
+export const STANCE_DESCRIPTION = {
+    lethal: 'your weapons deal the damage they were sold to deal; "attack" and "kill" mean it',
+    'non-lethal': 'Stun wherever the gear allows -- stun rounds when you reload, the flat of the blade (p.186), bare hands -- and a lethal gun with lethal rounds says so before it fires',
+};
 export const MATRIX_STANCE_CYCLE = ['attack', 'sleaze'];
 /** What each stance is CALLED in the book -- printed everywhere the
  *  engine used to say "loud"/"quiet", so the vocabulary teaches the
@@ -36,8 +44,8 @@ export function normalizeMatrixStance(v) {
     return MATRIX_STANCE_ALIASES[k] ?? (MATRIX_STANCE_CYCLE.includes(k) ? k : 'attack');
 }
 export function normalizeStance(v) {
-    const k = (v ?? 'manual').toLowerCase();
-    return STANCE_ALIASES[k] ?? (STANCE_CYCLE.includes(k) ? k : 'manual');
+    const k = (v ?? 'lethal').toLowerCase();
+    return STANCE_ALIASES[k] ?? (STANCE_CYCLE.includes(k) ? k : 'lethal');
 }
 /** Meat and a jumped-in drone share the physical world. */
 export function isPhysicalPlane(plane) {
@@ -185,16 +193,12 @@ export class Player extends AbstractPlayer {
     // session where an NPC's overlapping AI loops fired two exchanges at
     // once and the target died TWICE (two kill events, two narrations).
     inExchange = false;
-    // Fight-or-flight autopilot (see utilities/auto-fight.ts): the FIGHT
-    // half runs automatically at the set temperature, the flight stays
-    // manual -- always. Tab cycles it in the UI; "stance" sets it by name.
-    //   manual     -- today's behavior, you type every swing
-    //   guarded    -- auto-fights, but finishes non-lethally (switches to
-    //                 subdue when the target is nearly down) and stands down
-    //                 if they surrender
-    //   aggressive -- fights until they're dead; surrender means nothing
+    // The fight stance (see FightStance above): lethal or non-lethal, the
+    // damage type your next blow is meant to deal. Tab cycles it in the UI;
+    // "stance" sets it by name. Every action is still yours to type -- the
+    // Combat Turn hands you the phase and waits for "end turn".
     // Accessor (live-sheet pass, 2026-09-01): stance is sheet-visible.
-    _autoStance = 'manual';
+    _autoStance = 'lethal';
     get autoStance() { return this._autoStance; }
     set autoStance(v) {
         if (this._autoStance === v)

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);
@@ -192,7 +201,6 @@ export class Scene extends AbstractScene {
         }
         const enc = new CombatEncounter(this, this.logger, room);
         this.encounters.set(room, enc);
-        enc.onHumanPhase = (p, e) => this.game?.autoFight?.onPhaseBegins?.(p, e);
         await enc.start(this.encounterMembers(room, opts.aggressor, opts.target), opts);
         return enc;
     }
@@ -232,13 +240,13 @@ export class Scene extends AbstractScene {
         return this._playerExchangesActive.size > 0;
     }
     /**
-     * CombatExchange.finishExchange() -> here -> the fight autopilot (see
-     * utilities/auto-fight.ts). Optional-chained like updateStatus: harmless
-     * before the Game reference is wired, or under a partial test stub, or
-     * for NPC-vs-NPC fights (the autopilot ignores those itself).
+     * CombatExchange.finishExchange() and CombatEncounter.closePhase() ->
+     * here. This used to arm the fight autopilot (utilities/auto-fight.ts,
+     * retired 2026-09-07 with the Combat Turn: a phase you commit with
+     * "end turn" is not one the game plays for you). What remains is the
+     * KO'd player's view of the fight still raging around them.
      */
     notifyExchangeSettled(combatants) {
-        this.game?.autoFight?.onExchangeSettled?.(combatants);
         // While a player lies KO'd, every settling exchange is a beat of
         // the fight still raging around them: learn its hostiles, then see
         // whether the room has settled (see maybeResolvePlayerKnockout).

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

@@ -290,9 +290,10 @@ export async function main(playerName, sceneSeed, options) {
         game.updateInventory(game.player.inventory, capitalCase(game.scene.getCurrencyType()));
         game.updateExits(game.player.currentLocation);
         game.updateStatus();
-        // Tab cycles the fight autopilot: manual -> guarded -> aggressive (see
-        // utilities/auto-fight.ts; "stance" is the typed twin). Bound on the
-        // input box because that's where focus lives during play.
+        // Tab flips the stance: lethal <-> non-lethal in the meat, Brute
+        // Force <-> Hack on the Fly on the Matrix (models/player.ts; "stance"
+        // is the typed twin). Bound on the input box because that's where
+        // focus lives during play.
         game.inputBox.key(['tab'], () => {
             // Blessed's textarea reader appends the literal '\t' to the box
             // value on this same keypress (listener order isn't guaranteed
@@ -318,7 +319,7 @@ export async function main(playerName, sceneSeed, options) {
             // bar"). game.player here is the LOCAL HUB player -- in a shared
             // run the runner on the table is a different object in a
             // different process, so cycling this one moved nothing the
-            // autopilot reads and nothing the HUD paints (updateStatus
+            // engine reads and nothing the HUD paints (updateStatus
             // early-returns on remoteSession; the status box belongs to the
             // server's events). Send the typed twin instead and let the
             // engine cycle from the ACTOR's real stance.
@@ -326,10 +327,10 @@ export async function main(playerName, sceneSeed, options) {
                 const res = await game.handleInput('stance next');
                 if (!res)
                     return;
-                // white for manual, not gray -- gray is ANSI bright-black,
-                // illegible on stock dark palettes (same fix as the HUD stance
-                // in game.ts). The Matrix routes borrow the same temperature:
-                // Brute Force is the loud one, Hack on the Fly the careful one.
+                // Red for the lethal routes, yellow for the careful ones (same
+                // palette as the HUD stance in game.ts): Brute Force is the loud
+                // one, Hack on the Fly the careful one. Never gray -- ANSI
+                // bright-black is illegible on stock dark palettes.
                 const named = res.match(/(?:Matrix s|S)tance:\s*([\w-]+)/i)?.[1]?.toLowerCase();
                 const c = named === 'lethal' || named === 'brute' ? 'red'
                     : named === 'non-lethal' || named === 'non' || named === 'hack' ? 'yellow'
@@ -369,10 +370,6 @@ export async function main(playerName, sceneSeed, options) {
                 // still a command you typed and will want to edit and retry.
                 if (opts.recordHistory !== false)
                     history.remember(input);
-                // Typing takes over: any submitted command cancels a pending
-                // auto-fight action (the interruptible beat -- see
-                // utilities/auto-fight.ts). The next settled exchange re-arms it.
-                game.autoFight.cancelPending();
                 // Clear the box the moment the command is submitted, not after
                 // it resolves -- a slow command (combat narration beats, an AI
                 // round trip on a call) used to leave the typed text sitting in

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

@@ -995,8 +995,8 @@ export class CombatExchange {
         this.releasePlayerLocks();
         this.releaseExchange();
         this.scene.updateStatus();
-        // The fight autopilot's trigger: a settled exchange involving the
-        // player schedules their next auto action (see utilities/auto-fight.ts).
+        // A settled exchange: the scene lets a KO'd player's watch learn who
+        // is still fighting around them (Scene.notifyExchangeSettled).
         this.scene.notifyExchangeSettled(this._combatants);
         // A spirit whose services ran out departs once the dust settles
         // (RAW p.302: the bargain is spent).

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

@@ -22,7 +22,10 @@ export class CombatEncounter {
     pairs = new Map();
     surrenderSeenAt = new Map();
     running = false;
-    /** Every human phase that began, for the autopilot hook. */
+    /** Every human phase that began -- a seam for tests and for any future
+     *  phase clock; nothing plays the phase for a human (the fight
+     *  autopilot was retired 2026-09-07: a phase you commit with "end
+     *  turn" is yours to play). */
     onHumanPhase;
     constructor(scene, logger, room) {
         this.scene = scene;

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.135.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/utilities/auto-fight.js

@@ -1,240 +0,0 @@
-import { Logger } from './logger.js';
-/**
- * Fight-or-flight autopilot -- the FIGHT half. The player sets a
- * temperature (Tab in the UI, or the "stance" command) and the game keeps
- * swinging for them; flight stays manual, always, because stopping YOUR
- * swings never stops THEIRS -- the only real defense is the door, and
- * that's the player's call.
- *
- *   manual     -- counters only. Struck, you strike back (the exchange
- *                 engine answers every swing in EVERY stance -- see
- *                 CombatExchange.resolveStrike's two-way resolution);
- *                 but pressing the fight, chasing, or finishing is yours
- *                 to type. (A real session read "manual" as fully
- *                 passive, saw the built-in counters, and concluded the
- *                 stances were redundant -- they never were; the old
- *                 descriptions were wrong.)
- *   guarded    -- keeps swinging FOR you between exchanges, with a
- *                 conscience: switches to subdue when the target is
- *                 nearly down, and stands down the moment they surrender
- *   aggressive -- keeps swinging until they're dead; surrender means
- *                 nothing
- *
- * Wiring: CombatExchange.finishExchange() -> Scene.notifyExchangeSettled()
- * -> onExchangeSettled() here. If the player was a combatant and the
- * stance says fight, the next action is scheduled a short, interruptible
- * beat later (REENGAGE_DELAY_MS). Submitting ANY command in the UI cancels
- * the pending action and takes over (see ui.ts) -- the beat exists exactly
- * so fleeing and healing stay possible mid-autofight. Everything is
- * revalidated at fire time: the fight may have ended, moved, or been
- * surrendered out of during the delay.
- *
- * Auto actions lead with whatever hits hardest: a caster whose manabolt
- * out-damages their equipped weapon throws the bolt (and eats the drain);
- * everyone else uses the gun/blade/fists they're holding. A dry gun's
- * refusal (reload prompt) is surfaced to the player and auto simply waits
- * for them to deal with it -- reloading is a decision, not a reflex.
- */
-export class AutoFight {
-    game;
-    static REENGAGE_DELAY_MS = 2000;
-    // One pending timer per HUMAN player (symmetric MP: each human's
-    // autopilot runs independently).
-    pending = new Map();
-    constructor(game) {
-        this.game = game;
-    }
-    /** Pending auto actions, dropped. No name = all of them (the local
-     *  player typed, or the stance changed -- ui.ts's call). */
-    cancelPending(playerName) {
-        if (playerName === undefined) {
-            for (const t of this.pending.values())
-                clearTimeout(t);
-            this.pending.clear();
-            return;
-        }
-        const t = this.pending.get(playerName);
-        if (t) {
-            clearTimeout(t);
-            this.pending.delete(playerName);
-        }
-    }
-    /**
-     * Called after every combat exchange resolves (player-involved or not).
-     * Schedules the next action for every HUMAN combatant whose stance
-     * says fight.
-     */
-    onExchangeSettled(combatants) {
-        for (const player of this.game.scene.getPlayers()) {
-            if (!combatants.includes(player))
-                continue;
-            if (player.autoStance === 'manual')
-                continue;
-            // A COMBAT TURN schedules from the phase (onPhaseBegins), never
-            // from a settled strike -- acting between phases is the thing the
-            // turn structure exists to stop.
-            if (this.game.scene.encounterFor?.(player))
-                continue;
-            const target = combatants.find(c => c !== player);
-            if (!target)
-                continue;
-            this.cancelPending(player.name);
-            const t = setTimeout(() => {
-                this.pending.delete(player.name);
-                void this.fire(player, target);
-            }, AutoFight.REENGAGE_DELAY_MS);
-            this.pending.set(player.name, t);
-        }
-    }
-    /**
-     * A COMBAT TURN handed this human their Action Phase
-     * (utilities/combat-turn.ts). At any stance but manual the autopilot
-     * plays the phase after the same interruptible beat: draw if
-     * holstered, the stance's strike, then "end turn". Typing anything
-     * cancels it and takes over, exactly as between exchanges.
-     */
-    onPhaseBegins(player, enc) {
-        if (player.autoStance === 'manual')
-            return;
-        this.cancelPending(player.name);
-        const t = setTimeout(() => {
-            this.pending.delete(player.name);
-            void this.playPhase(player, enc);
-        }, AutoFight.REENGAGE_DELAY_MS);
-        this.pending.set(player.name, t);
-    }
-    async playPhase(player, enc) {
-        const logger = Logger.getInstance();
-        if (player.autoStance === 'manual' || !enc.isPhaseOf(player) || player.isIncapacitated())
-            return;
-        const run = async (cmd) => {
-            if (!enc.isPhaseOf(player))
-                return;
-            logger.meta(`⚔ [${player.autoStance}] ${cmd}`, 'cyan');
-            const result = (await this.game.handleInputAs(player.name, cmd)).text;
-            if (result)
-                logger.log(result);
-        };
-        const target = enc.enemiesOf(player)[0];
-        if (!target) {
-            await run('end-turn');
-            return;
-        }
-        if (player.autoStance === 'non-lethal' && target.surrendered) {
-            if (player.plane === 'meat' && target.plane === 'meat'
-                && player.grappling !== target.name && !target.grappledBy) {
-                await run(`restrain ${target.name}`);
-            }
-            else {
-                logger.logWithColor(`⚔ ${target.name} has surrendered -- you hold fire. (non-lethal)`, 'yellow');
-            }
-            await run('end-turn');
-            this.game.updateStatus();
-            return;
-        }
-        const weapon = player.getCarriedWeapon();
-        if (weapon && !player.weaponDrawn && player.plane === 'meat')
-            await run('draw');
-        await run(this.chooseAction(player, target));
-        await run('end-turn');
-        this.game.updateStatus();
-    }
-    /**
-     * The beat elapsed uninterrupted -- act, if the fight still stands.
-     * Every guard here re-checks live state: the target may have died, fled,
-     * surrendered, or started another exchange during the delay.
-     */
-    async fire(player, target) {
-        const logger = Logger.getInstance();
-        if (player.autoStance === 'manual')
-            return;
-        if (player.isIncapacitated() || target.isIncapacitated())
-            return;
-        if (player.currentLocation !== target.currentLocation)
-            return;
-        // Cross-plane fights don't exist: a dump or a return mid-beat (see
-        // utilities/planes.ts) ends the engagement, autopilot included.
-        if (player.plane !== target.plane)
-            return;
-        // A fresh exchange is already in flight -- when IT settles,
-        // onExchangeSettled reschedules us. No waiting here.
-        if (player.inExchange || target.inExchange)
-            return;
-        // Guarded honors a surrender -- but doesn't trust it: the final
-        // action is a RESTRAIN (player request; SR5e Subduing p.195, the
-        // surrendered branch is an automatic no-roll hold). Hands-up
-        // prisoners get zip-tied, not taken at their word. One-shot: an
-        // already-held target (by anyone) means truly stand down, and off
-        // the meat plane there are no hands to hold with.
-        if (player.autoStance === 'non-lethal' && target.surrendered) {
-            if (player.plane === 'meat' && target.plane === 'meat'
-                && player.grappling !== target.name && !target.grappledBy) {
-                const cmd = `restrain ${target.name}`;
-                logger.meta(`⚔ [non-lethal] ${cmd}`, 'cyan');
-                const result = (await this.game.handleInputAs(player.name, cmd)).text;
-                if (result) {
-                    logger.log(result);
-                }
-                this.game.updateStatus();
-                return;
-            }
-            logger.logWithColor(`⚔ ${target.name} has surrendered -- you hold fire. (non-lethal)`, 'yellow');
-            this.game.updateStatus();
-            return;
-        }
-        const cmd = this.chooseAction(player, target);
-        // Cyan, not gray: the autopilot announcing it acted must be legible on
-        // stock dark palettes (gray = ANSI bright-black, near-invisible there).
-        // Mechanics ticker, not the narrative -- the strike it triggers tells
-        // the story in the world log (readability pass).
-        logger.meta(`⚔ [${player.autoStance}] ${cmd}`, 'cyan');
-        const result = (await this.game.handleInputAs(player.name, cmd)).text;
-        // Player-initiated exchanges self-announce ('' result); anything else
-        // (a dry-gun reload prompt, a refusal) is information the player needs.
-        if (result) {
-            logger.log(result);
-        }
-        this.game.updateStatus();
-    }
-    /**
-     * Lead with what hits hardest -- except Guarded near the end, which
-     * finishes non-lethally: when the target is within a few boxes of death,
-     * the next auto action is a subdue (stun damage, bare hands) instead of
-     * another killing blow.
-     */
-    chooseAction(player, target) {
-        // Subduing takes real hands (meat plane only); a guarded decker
-        // "killing" ice is just crashing a program, and astral entities go
-        // down by force -- no non-lethal switch off the meat plane.
-        if (player.autoStance === 'non-lethal' && player.plane === 'meat') {
-            if (target.maxConditionBoxes - target.damageTaken <= 3)
-                return `subdue ${target.name}`;
-            // A gun that can only kill is not what this stance reaches for:
-            // no stun rounds loaded means hands, not lead (p.434).
-            const gun = player.weaponDrawn ? player.getCarriedWeapon() : null;
-            if (gun?.isFirearm() && !gun.isStunWeapon() && !gun.stunAmmo())
-                return `subdue ${target.name}`;
-        }
-        // Magic doesn't compile in the Matrix (see cast.ts); everywhere else,
-        // lead with the harder hit. The autopilot casts at the mage's FULL
-        // safe Force (bolt damage = F - 2, drain billed, never overcast) --
-        // a bare "cast manabolt" would use the drain-neutral default (F3,
-        // damage 1: the Force pass silently gutted the old comparison).
-        // Same safe ceiling as cast.ts: a book-taught mundane works at 4.
-        const boltForce = player.magic > 0 ? player.magic : 4;
-        const boltDamage = Math.max(1, boltForce - 2);
-        if (player.plane !== 'matrix' && player.isCaster() && boltDamage > player.getWeaponProfile().damage) {
-            return `cast manabolt ${boltForce} at ${target.name}`;
-        }
-        return `attack ${target.name}`;
-    }
-    /** One-line HUD/announce description for a stance. */
-    static describe(stance) {
-        switch (stance) {
-            case 'manual': return 'counters when struck (every stance does) -- but pressing the fight is yours to type';
-            case 'non-lethal': return 'presses the fight for you with Stun wherever the gear allows (stun rounds, the flat of the blade, bare hands), subdues when they are nearly down, and RESTRAINS them when they surrender';
-            case 'lethal': return 'presses the fight to the death; surrender means nothing';
-        }
-    }
-}
-//# sourceMappingURL=auto-fight.js.map