@maka/maka-cli 5.134.0 → 5.136.0

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

@@ -1,6 +1,7 @@
 import { Command } from './command.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { hint } from '../utilities/hints.js';
+import { billAction } from '../utilities/action-cost.js';
 /**
  * Conjuring (SR5e p.300-303): "summon <force>" calls a spirit -- an
  * opposed Magic + conjuring test against the spirit's Force dice. NET
@@ -50,6 +51,10 @@ export class SummonCommand extends Command {
             return `A Force ${force} spirit would wear YOU as the vessel -- twice your Magic (${actor.magic * 2}) is the hard ceiling.`;
         }
         const overcast = force > actor.magic;
+        // SUMMONING IS A COMPLEX ACTION (SR5 p.167) inside a Combat Turn.
+        const bill = billAction(this.scene, actor, 'complex', 'Summoning');
+        if (bill)
+            return bill;
         // The opposed test (p.300): Magic + conjuring vs the spirit's Force.
         const conjuring = actor.skillRating('conjuring');
         const mine = rollPool(Math.max(1, actor.magic + (conjuring > 0 ? conjuring : -1) + actor.woundModifier - actor.sustainingPenalty));

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

@@ -1,10 +1,12 @@
 import { Command } from './command.js';
+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).
@@ -27,6 +29,11 @@ export class SurrenderCommand extends Command {
         if (actor.inExchange) {
             return `Lead is flying -- wait for the exchange to resolve, then surrender in the lull.`;
         }
+        // Hands up is a gesture and a phrase -- a Free Action (SR5 p.164
+        // Gesture / Speak) in a Combat Turn.
+        const bill = billAction(this.scene, actor, 'free', 'Surrender');
+        if (bill)
+            return bill;
         actor.surrendered = true;
         // Break the fight both ways: no parting shot for walking away from a
         // surrender, and the opponent's own combat memory of you clears too.

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

@@ -5,6 +5,7 @@ import { fileReach } from '../utilities/planes.js';
 import { canReach, ensureAtSpot, sealedRouteTo } from '../utilities/spots.js';
 import { hint } from '../utilities/hints.js';
 import { Category } from '../types/shared/item-enum.js';
+import { billAction } from '../utilities/action-cost.js';
 export class TakeCommand extends Command {
     static verb = 'take';
     static description = 'Pick up an item. "take all" sweeps everything here -- but only after you have searched the room.';
@@ -25,6 +26,10 @@ export class TakeCommand extends Command {
                 screen: this.screen, game: this.game,
             }).execute();
         }
+        // PICK UP OBJECT (SR5 p.165): a Simple Action in a Combat Turn.
+        const bill = billAction(this.scene, this.actor, 'simple', 'Pick Up Object');
+        if (bill)
+            return bill;
         if (wanted === 'all' || wanted === 'everything') {
             return this.takeAll();
         }

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

@@ -1,9 +1,15 @@
 import { Command } from './command.js';
 import { dropActiveCall, CALL_ICON, CALL_COLOR } from '../utilities/comm-style.js';
+import { billAction } from '../utilities/action-cost.js';
 export class UnequipCommand extends Command {
     static verb = 'unequip';
     static description = 'Unequip an item.';
     async execute(args) {
+        // Taking gear off is a Simple Action's worth of hands (SR5 p.165
+        // Pick Up/Put Down Object) inside a Combat Turn.
+        const bill = billAction(this.scene, this.actor, 'simple', 'Unequip');
+        if (bill)
+            return bill;
         const slotName = args.join(' ').toLowerCase();
         // TAKING THE LINK OFF HANGS UP THE CALL (MgrjzDYTzY8sJdvkT: "when I
         // unequipped my commlink, I went offline, but the call with deditri

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

@@ -6,6 +6,7 @@ import { ensureAtSpot, ensureAtExit } from '../utilities/spots.js';
 import { applyDeviceOpened } from '../utilities/devices.js';
 import { hint } from '../utilities/hints.js';
 import { FIRST_AID_THRESHOLD, firstAidCap, firstAidRefusal, performFirstAid, } from '../utilities/first-aid.js';
+import { billAction } from '../utilities/action-cost.js';
 export class UseCommand extends Command {
     static verb = 'use';
     static description = 'Use a thing: an item from your pack (a medkit, a stim patch), or a device in the room -- "use keypad 4471" offers a code, "use safe" tries it with what you are carrying. With one device here, a bare code works too.';
@@ -16,6 +17,13 @@ export class UseCommand extends Command {
     preferredCategory;
     verbNoun = 'use';
     async execute(args) {
+        // USE SIMPLE DEVICE (SR5 p.166-167): a Simple Action in a Combat
+        // Turn -- a medkit's first aid is the Complex Action heal.ts charges,
+        // but the thing this verb does with one is "use the kit", which the
+        // book prices as a Simple Action of the device.
+        const bill = billAction(this.scene, this.actor, 'simple', 'Use Simple Device');
+        if (bill)
+            return bill;
         return this.use(args);
     }
     /**

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

@@ -359,5 +359,22 @@
 //   beside you (companion-heel.ts trailMaster) -- they used to heel only on
 //   a room change and sat in the doorway while you paced. "recall" judges
 //   "already at your side" by cells, not spot names.
-export const ENGINE_VERSION = '1.39.0';
+// 1.40.0 (2026-09-06): THE COMBAT TURN (SR5 p.158-168). Physical-plane
+//   combat is a turn/pass loop per room (utilities/combat-turn.ts):
+//   initiative for everyone, Action Phases in order, -10 per pass, fresh
+//   rolls per Combat Turn. COMMAND SEMANTICS in shared scenes: "attack"
+//   is one strike on your own phase (no retaliation, no auto-draw); new
+//   verbs end-turn/done/pass, initiative, aim, defend, delay; draw,
+//   holster, cover, stand, reload, take, drop, equip, use, search,
+//   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.
+// 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

@@ -74,6 +74,11 @@ import { GiveCommand } from './commands/give.js';
 import { ReadCommand } from './commands/read.js';
 import { KillCommand } from './commands/kill.js';
 import { AttackCommand } from './commands/attack.js';
+import { EndTurnCommand } from './commands/end-turn.js';
+import { InitiativeCommand } from './commands/initiative.js';
+import { AimCommand } from './commands/aim.js';
+import { DefendCommand } from './commands/defend.js';
+import { DelayCommand } from './commands/delay.js';
 import { SpellsCommand } from './commands/spells.js';
 import { InventoryCommand } from './commands/inv.js';
 import { EquipmentCommand } from './commands/equipment.js';
@@ -174,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';
@@ -190,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
@@ -2528,6 +2529,18 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // wanted to end a call -- the intent is unambiguous mid-call.
         CommandFactory.registerCommand('end', EndCallCommand);
         CommandFactory.registerCommand('hangup', EndCallCommand);
+        // THE COMBAT TURN (utilities/combat-turn.ts). "end turn" arrives
+        // through EndCallCommand ("end" is the hangup) and is handed here.
+        CommandFactory.registerCommand('end-turn', EndTurnCommand);
+        CommandFactory.registerCommand('endturn', EndTurnCommand);
+        CommandFactory.registerCommand('done', EndTurnCommand);
+        CommandFactory.registerCommand('pass', EndTurnCommand);
+        CommandFactory.registerCommand('initiative', InitiativeCommand);
+        CommandFactory.registerCommand('tracker', InitiativeCommand);
+        CommandFactory.registerCommand('turn', InitiativeCommand);
+        CommandFactory.registerCommand('aim', AimCommand);
+        CommandFactory.registerCommand('defend', DefendCommand);
+        CommandFactory.registerCommand('delay', DelayCommand);
         // 'train' used to alias advance; it belongs to crew instruction now
         // (commands/crew.ts) -- self-training is "advance".
         CommandFactory.registerCommand('advance', AdvanceCommand);
@@ -3645,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. */
     /**
@@ -3768,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());
@@ -4600,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);
@@ -5220,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,
@@ -5235,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.
@@ -5245,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
@@ -5305,6 +5316,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // throws, least of all on the panel a dying player is reading.
         const docwagon = this.docwagonSlot(this.docwagonByPlayer?.get(player.name) ?? (player === this.player ? this.docwagon : undefined));
         lines.push(`${armorNote}${arSlot}  |  ${link}  |  ${docwagon}`);
+        // THE COMBAT TURN (utilities/combat-turn.ts): whose phase it is, the
+        // score, and what this player has left to spend -- present only
+        // while a fight is on, like every transient line below.
+        const combatLine = this.scene?.encounterFor?.(player)?.hudLine(player);
+        if (combatLine)
+            lines.push(combatLine);
         // Lines 4+: transient states, present only while active. Future
         // contexts (astral projection, VR hot-sim) join here the same way.
         // THE COST IS THE ENGINE'S. Every one of these lines printed a
@@ -5988,7 +6005,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     static HELP_CATEGORIES = [
         { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
         { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['loot'], ['drop'], ['give'], ['store'], ['open'], ['close'], ['put'], ['equip'], ['unequip'], ['fit'], ['unfit'], ['brandish', 'draw'], ['holster'], ['reload'], ['use'], ['read']] },
-        { title: 'combat', entries: [['attack'], ['kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['stance'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
+        { title: 'combat', entries: [['attack'], ['kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['stance'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
         // The party layer: everyone who walks (or flies, or manifests) at
         // your side answers to these.
         // "players" folded back under crew after playtesting ("crew

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

@@ -82,7 +82,7 @@ export function savedPlayer(name, overrides = {}) {
         },
         edgeRemaining: 3,
         haggledThisJob: false,
-        autoStance: 'manual',
+        autoStance: 'lethal',
         visitedRooms: [],
         inventory: [],
         equipment: {},
@@ -244,6 +244,8 @@ export function paritySeed(overrides = {}) {
 export async function bootSession(opts = {}) {
     process.env.MAKA_NO_DDP = '1';
     process.env.MAKA_NO_LORE = '1';
+    // Combat narration beats are pacing for a person; a harness has none.
+    process.env.MAKA_NO_BEATS = '1';
     process.env.MAKA_NO_TELEMETRY = '1';
     const events = opts.events;
     const session = await createHeadlessSession({

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

@@ -95,12 +95,29 @@ export class Item extends AbstractItem {
                     break;
             }
         }
-        // Firearms track ammunition: a flat magazine, starting full. Melee
-        // weapons never touch it. See fireRound()/reload() and combat-exchange.
+        // Firearms track ammunition: the row's magazine when it has one,
+        // the flat default otherwise, starting full. Melee weapons never
+        // touch it. See fireRound()/reload() and combat-exchange.
         if (this.isFirearm()) {
-            this.ammo = Item.MAGAZINE_CAPACITY;
+            this.ammo = this.magazineCapacity;
         }
     }
+    /**
+     * ROUNDS IN A FULL MAGAZINE: the catalog row's "ammo" (p.421-431 --
+     * 15(c) for a Predator, 6(cy) for a revolver) when the row carries
+     * one, else the engine's flat default for generated gear.
+     */
+    get magazineCapacity() {
+        const rounds = this.row?.weapon?.ammo?.rounds;
+        return rounds && rounds > 0 ? rounds : Item.MAGAZINE_CAPACITY;
+    }
+    /** How it reloads (p.163 Reloading Weapons): 'c' clip, 'cy' cylinder,
+     *  'm' internal magazine, 'b' break action, 'd' drum, 'belt', 'ml'
+     *  muzzle loader. A clip is two Simple Actions; everything else a
+     *  Complex. Unknown gear reloads like a clip. */
+    get reloadFeed() {
+        return this.row?.weapon?.ammo?.feed ?? 'c';
+    }
     // ======================== Stacking ========================
     /**
      * WHAT FUNGIBLE MEANS HERE (user ruling): only CONSUMABLES stack.
@@ -200,7 +217,7 @@ export class Item extends AbstractItem {
     loadedAmmo;
     reload(ammoName) {
         if (this.isFirearm()) {
-            this.ammo = Item.MAGAZINE_CAPACITY;
+            this.ammo = this.magazineCapacity;
             if (ammoName !== undefined)
                 this.loadedAmmo = ammoName;
         }

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

@@ -909,6 +909,38 @@ description text.`;
             this.logger.write(`AI fallback for appearance (${this.name}): ${err}`);
         }
     }
+    /**
+     * IN A FIGHT, THE TURN LOOP OWNS THIS SHELL (utilities/combat-turn.ts).
+     * While this NPC is a participant in a running encounter, its LLM
+     * chain -- act, respondTo, recursiveReflect -- is suspended: the
+     * deterministic brain (utilities/npc-combat-brain.ts) plays its Action
+     * Phases in initiative order, and a model answering on its own clock
+     * would only be refused by the phase gate and grind to a halt on the
+     * refusals. Perception (see/hear) still records history, so the shell
+     * knows what happened when the chain resumes after the fight.
+     */
+    combatPhaseLocked() {
+        return !!this._scene?.encounterFor?.(this);
+    }
+    /**
+     * One verb, executed now, no reflection -- the brain's way of acting
+     * inside an Action Phase. Returns the command's own result so the
+     * brain can read a refusal, and files it into history like any act.
+     */
+    async actInCombat(commandString) {
+        if (this.deathClaimed)
+            return '';
+        const parsed = await this.commandRegistry.parse(commandString, this);
+        if (!parsed) {
+            this.logger.error(`${this.name} (combat) tried to perform unknown command: ${commandString}`);
+            return '';
+        }
+        const result = await parsed.command.execute(parsed.args);
+        if (result)
+            this._addToHistory(result);
+        this.relayToMaster(commandString, result);
+        return result ?? '';
+    }
     async act(commandString) {
         // A removed actor must STOP: dismissal/death happens while an AI
         // burst is still in flight, and without this latch a real session's
@@ -918,6 +950,10 @@ description text.`;
             this.logger.write(`${this.name} is gone from the world -- dropping queued action "${commandString}".`);
             return;
         }
+        if (this.combatPhaseLocked()) {
+            this.logger.write(`${this.name} is in a Combat Turn -- the turn loop acts for them; dropping "${commandString}".`);
+            return;
+        }
         const parsed = await this.commandRegistry.parse(commandString, this);
         if (parsed) {
             // Capture the result of the command
@@ -1361,6 +1397,10 @@ description text.`;
             this.logger.write(`${this.name} is gone from the world -- reflect chain ends.`);
             return;
         }
+        if (this.combatPhaseLocked()) {
+            this.logger.write(`${this.name} is in a Combat Turn -- reflect chain yields to the turn loop.`);
+            return;
+        }
         // THE GRIND BREAKER. Record what just happened, then refuse to keep
         // going round on it. Deterministic on purpose: the prompt already
         // asks for honesty about failure and got it -- what it lacked was
@@ -1538,6 +1578,10 @@ ${worldEventsSummary}
             : [];
     }
     async respondTo(actor, message) {
+        if (this.combatPhaseLocked()) {
+            this.logger.write(`${this.name} is in a Combat Turn -- no AI reaction to "${message.slice(0, 40)}".`);
+            return;
+        }
         this.logger.write('Attempting to respond');
         // A fresh stimulus earns at most one fresh speech (see the field doc)
         // -- and a clean slate of attempts. Something new has happened, so

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)
@@ -229,6 +233,39 @@ export class Player extends AbstractPlayer {
     rallyInitBonus = 0;
     directedDice = 0;
     inspiredGuardDice = 0;
+    // ==================== THE ACTION PHASE (utilities/combat-turn.ts) ====
+    //
+    // TAKE AIM (SR5 p.166): +1 die per Simple Action spent aiming, up to
+    // half Willpower rounded up, on the NEXT attack -- and lost the moment
+    // "any other kind of action (including a Free Action)" is taken first.
+    // Cleared by action-cost.ts on every non-aim spend, by the encounter
+    // at every phase boundary, and consumed by the strike that uses it.
+    aimBonus = 0;
+    aimTarget;
+    clearAim() {
+        this.aimBonus = 0;
+        this.aimTarget = undefined;
+    }
+    /** p.166: the cap on sequential Take Aim bonuses. */
+    get aimCap() {
+        return Math.max(1, Math.ceil(this.willpower / 2));
+    }
+    // PROGRESSIVE RECOIL (p.175-176): the rounds fired keep counting across
+    // Action Phases and Combat Turns until a phase goes by without a shot.
+    // firedThisPhase is the encounter's evidence for that reset.
+    recoilRoundsFired = 0;
+    firedThisPhase = false;
+    /**
+     * THE STANDING ANSWER TO "SOMEONE IS SHOOTING AT YOU" (p.168, p.191).
+     * Interrupt actions are declared in response to an attack, outside
+     * the defender's own phase. A terminal cannot prompt mid-pass -- and
+     * a hosted table cannot wait on one player's keystroke -- so the
+     * player sets a policy ("defend dodge") that the engine applies when
+     * an attack comes in and the Initiative Score can pay for it. Full
+     * Defense is different: declared once, -10, and it lasts the turn
+     * (CombatEncounter.declareFullDefense).
+     */
+    defensePolicy = 'none';
     // Set by the "surrender" command: this actor has thrown their hands up.
     // Cleared the moment they initiate violence again (see
     // CombatExchange.beginExchange). Guarded auto-fight honors it;

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

@@ -6,6 +6,7 @@ import { hint } from '../utilities/hints.js';
 import { Category, Size, Rating } from '../types/shared/item-enum.js';
 import { AbstractScene } from '../types/shared/abstracts.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
+import { CombatEncounter } from '../utilities/combat-turn.js';
 export class Scene extends AbstractScene {
     story;
     // SYMMETRIC PLAYERS: the scene holds a LIST of human players --
@@ -129,6 +130,95 @@ export class Scene extends AbstractScene {
     // meaning -- begin/end act on the primary player, the query asks
     // "is ANY human's exchange live".
     _playerExchangesActive = new Set();
+    // ==================== COMBAT ENCOUNTERS (utilities/combat-turn.ts) ====
+    //
+    // One Combat Turn structure per ROOM: the fight in the loading bay and
+    // the fight in the office are two initiative orders, as they would be
+    // at a table. An encounter holds the participants, their scores and
+    // whose Action Phase is live; the scene only owns the map.
+    encounters = new Map();
+    /** The live fight in a room, if any. */
+    encounterIn(room) {
+        if (!room)
+            return undefined;
+        const enc = this.encounters.get(room);
+        return enc && !enc.ended ? enc : undefined;
+    }
+    /** The fight this actor is a participant in, if any. */
+    encounterFor(actor) {
+        const enc = this.encounterIn(actor.currentLocation);
+        return enc?.has(actor) ? enc : undefined;
+    }
+    /**
+     * Who is in the fight when `aggressor` opens on `target`: the two of
+     * them, every human and bound shell in the room (the party fights as
+     * one), every NPC flagged hostile, and anyone already engaged with
+     * either. A bystander is scenery; a bartender is not opposition until
+     * someone makes them so (noteAttack pulls them in then).
+     */
+    encounterMembers(room, aggressor, target) {
+        const out = new Set([aggressor]);
+        if (target)
+            out.add(target);
+        for (const a of room.getActors()) {
+            if (a === aggressor || a === target)
+                continue;
+            if (!a.sharesCombatPlane(aggressor) || a.isIncapacitated())
+                continue;
+            const npc = a;
+            if (npc.ephemeral?.kind === 'bystander')
+                continue;
+            const party = this.isHumanControlled(a) || !!npc.allyOf;
+            const hostile = !this.isHumanControlled(a) && npc.hostile === true && !npc.allyOf;
+            const engaged = !!a.combatOpponent && (a.combatOpponent === aggressor || a.combatOpponent === target);
+            if (party || hostile || engaged)
+                out.add(a);
+        }
+        return [...out];
+    }
+    /**
+     * Opens a fight in a room -- or renews the one already running there.
+     * Resolves once the first pass has run up to a human's Action Phase
+     * (or the fight has already ended).
+     */
+    async startEncounter(room, opts) {
+        const existing = this.encounterIn(room);
+        if (existing) {
+            if (opts.target)
+                existing.noteAttack(opts.aggressor, opts.target);
+            else if (!existing.has(opts.aggressor))
+                existing.join(opts.aggressor);
+            return existing;
+        }
+        const enc = new CombatEncounter(this, this.logger, room);
+        this.encounters.set(room, enc);
+        await enc.start(this.encounterMembers(room, opts.aggressor, opts.target), opts);
+        return enc;
+    }
+    /** The encounter is over (called by the encounter itself). */
+    endEncounter(enc) {
+        if (this.encounters.get(enc.room) === enc)
+            this.encounters.delete(enc.room);
+    }
+    /**
+     * Someone walks into a room where a fight is on (p.160 entering
+     * combat late): the party and the hostile join it; anyone else stays
+     * out until they act.
+     */
+    admitToEncounter(actor) {
+        const enc = this.encounterIn(actor.currentLocation);
+        if (!enc || enc.has(actor) || actor.isIncapacitated())
+            return undefined;
+        const npc = actor;
+        const party = this.isHumanControlled(actor) || !!npc.allyOf;
+        const hostile = !this.isHumanControlled(actor) && npc.hostile === true && !npc.allyOf;
+        if (!party && !hostile)
+            return undefined;
+        if (!enc.participants.some(p => p.actor.sharesCombatPlane(actor)))
+            return undefined;
+        enc.join(actor);
+        return enc;
+    }
     beginPlayerExchange(playerName) {
         this._playerExchangesActive.add(playerName ?? this.player.name);
     }
@@ -141,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).
@@ -491,6 +581,13 @@ export class Scene extends AbstractScene {
         // map was never cleaned on removal, leaving a dead Room reference.
         this.characterLocations.delete(name);
         this.logger.write(`Removed actor: ${name}`);
+        // A fallen participant's Action Phase, if it was live, moves on;
+        // the encounter itself re-checks who is still standing on its next
+        // step (utilities/combat-turn.ts run).
+        const enc = room ? this.encounterIn(room) : undefined;
+        if (enc && enc.phaseActor === actor) {
+            void enc.dropPhaseActor(actor);
+        }
         // Tell the Game an actor left the world -- the companion roster
         // (Game.onActorRemoved) prunes shells and settles their bound
         // devices (a wrecked frame, a bricked deck).