@maka/maka-cli 5.135.0 → 5.136.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.135.0",
+  "version": "5.136.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/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,12 @@
 //   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.
+export const ENGINE_VERSION = '1.41.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -179,7 +179,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 +194,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 +3658,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 +3780,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 +4611,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 +5230,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 +5246,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 +5256,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

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/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

@@ -192,7 +192,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 +231,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/package.json

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