@maka/maka-cli 5.134.0 → 5.136.0

package/bundle/typescript/package.json

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

@@ -0,0 +1,60 @@
+import { Command } from './command.js';
+import { billAction, phaseHint } from '../utilities/action-cost.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { hint } from '../utilities/hints.js';
+/**
+ * TAKE AIM (SR5 p.166, RAG-checked 2026-09-06): a Simple Action that
+ * adds +1 die to the next ranged attack, cumulative across Simple
+ * Actions and Action Phases, up to one-half Willpower rounded up -- and
+ * lost the moment "any other kind of action (including a Free Action)"
+ * comes before the shot. The bonus lands in combat-exchange.ts and is
+ * consumed by the strike; action-cost.ts clears it on every other spend.
+ *
+ * Only a READY ranged weapon can be aimed: a holstered pistol has nothing
+ * to line up, and a blade is not aimed.
+ */
+export class AimCommand extends Command {
+    static verb = 'aim';
+    static description = 'Take Aim (a Simple Action, SR5 p.166): +1 die on your next shot, stacking up to half your Willpower across aims -- lost if you do anything else first. "aim <name>" lines up on someone in particular.';
+    async execute(args = []) {
+        const actor = this.actor;
+        if (actor.plane !== 'meat' && actor.plane !== 'drone') {
+            return `Aiming is for a weapon in your hands -- there is nothing to line up from here.`;
+        }
+        const weapon = actor.getCarriedWeapon();
+        if (!weapon || !weapon.isFirearm()) {
+            return weapon
+                ? `The ${weapon.name} isn't aimed, it's swung.`
+                : `Nothing in hand to aim.`;
+        }
+        if (!actor.weaponDrawn) {
+            return `The ${weapon.name} is holstered -- "draw" it first (Ready Weapon, a Simple Action, p.165).`;
+        }
+        if (!this.scene.encounterFor?.(actor)) {
+            return `Nobody's shooting yet -- aiming only counts inside a Combat Turn.${hint(` (Attack someone to open one.)`)}`;
+        }
+        let targetName;
+        if (args.length > 0) {
+            const query = args.join(' ').replace(/^(at|on)\s+/i, '');
+            const candidates = this.scene.getActorsInRoom(actor.currentLocation)
+                .filter(a => a !== actor && a.sharesCombatPlane(actor));
+            targetName = fuzzyPickName(query, candidates.map(a => a.name)) ?? undefined;
+            if (!targetName)
+                return `Nobody named "${query}" here to aim at.`;
+        }
+        const cap = actor.aimCap;
+        if (actor.aimBonus >= cap) {
+            return `You're already lined up as well as you can be (+${actor.aimBonus}, the cap for Willpower ${actor.willpower}). Shoot.`;
+        }
+        const bill = billAction(this.scene, actor, 'simple', 'Take Aim', { aiming: true });
+        if (bill)
+            return bill;
+        actor.aimBonus += 1;
+        if (targetName)
+            actor.aimTarget = targetName;
+        actor.performAction('takes aim', targetName ? `at ${targetName}` : `down the ${weapon.name}`);
+        this.scene.updateStatus();
+        return `You settle the ${weapon.name}${targetName ? ` on ${targetName}` : ''} -- +${actor.aimBonus} on your next shot${actor.aimBonus >= cap ? ' (the cap)' : ''}.${hint(` Anything but another aim or the shot itself loses it.`)}${phaseHint(this.scene, actor)}`;
+    }
+}
+//# sourceMappingURL=aim.js.map

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

@@ -6,8 +6,10 @@ import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { describeFledTarget } from '../utilities/pursuit.js';
 import { shellsInRoom, resolveBodyAttack, crossPlaneRefusal } from '../utilities/planes.js';
 import { heldBy, holding } from '../utilities/grapple.js';
-import { spotOf, ensureAtSpot, ensureAtExit } from '../utilities/spots.js';
+import { spotOf, ensureAtSpot, ensureAtExit, canReach, spotDistanceMeters } from '../utilities/spots.js';
 import { resolveBarrierStrike } from '../utilities/barrier-combat.js';
+import { billAction, notYourPhase, phaseHint } from '../utilities/action-cost.js';
+import { spendMovementMeters } from '../utilities/movement-cost.js';
 /**
  * Shadowrun-style dice-pool combat, one full exchange per command:
  *
@@ -49,7 +51,10 @@ export class AttackCommand extends Command {
         if (gripHolder) {
             return `${gripHolder.name} has you locked down -- "struggle" free before you fight.`;
         }
-        // Violence is loud -- sneak mode ends the moment you swing.
+        // Violence is loud -- sneak mode ends the moment you swing. Whether
+        // you were sneaking WHEN you swung is what makes it an ambush (SR5
+        // p.192 Surprise), so that is read before it is cleared.
+        const ambush = this.actor.sneaking;
         this.actor.sneaking = false;
         // A recon frame has cameras, not guns (see Player.droneArmed) --
         // jumped-in combat needs an armed airframe.
@@ -115,7 +120,22 @@ export class AttackCommand extends Command {
                         : device.opensExit ? ensureAtExit(this.actor, device.opensExit) : {};
                     if (reach.refusal)
                         return reach.refusal;
-                    const drawn = this.actor.drawWeapon();
+                    // In a Combat Turn the shot is an action and the gun must
+                    // already be in hand (p.165); outside one it draws itself.
+                    let drawn = null;
+                    const barrierEnc = this.scene.encounterFor?.(this.actor);
+                    if (barrierEnc) {
+                        const held = this.actor.getCarriedWeapon();
+                        if (held && !this.actor.weaponDrawn) {
+                            return `The ${held.name} is holstered -- "draw" it first (Ready Weapon, a Simple Action, SR5 p.165).`;
+                        }
+                        const bill = billAction(this.scene, this.actor, held?.isFirearm() ? 'simple' : 'complex', 'Attack Barrier', { attack: true });
+                        if (bill)
+                            return bill;
+                    }
+                    else {
+                        drawn = this.actor.drawWeapon();
+                    }
                     const strike = resolveBarrierStrike(this.scene, this.logger, this.actor, device, room, {
                         heat: (amount, why) => this.game?.addHeat(amount, why),
                     });
@@ -199,6 +219,14 @@ export class AttackCommand extends Command {
         if (this.usesEquippedWeapon() && weaponItem?.isFirearm() && weaponItem.ammo <= 0) {
             return `Click -- the ${weaponItem.name} is dry. "reload" (needs ammunition), or go in swinging with something else.`;
         }
+        // THE COMBAT TURN (utilities/combat-turn.ts): on the physical planes
+        // a fight is a turn/pass loop and this attack is ONE action in the
+        // actor's own Action Phase. The Matrix and the astral keep the older
+        // exchange below -- the Matrix has its own initiative structure
+        // (utilities/ic.ts) and astral combat has not been swept yet.
+        if (this.actor.plane === 'meat' || this.actor.plane === 'drone') {
+            return await this.executeInEncounter(target, room, weaponItem ?? undefined, ambush);
+        }
         const report = [];
         // ROOM GRIDS (spatial wave 2026-08-25): MELEE (fists, or an
         // equipped weapon that isn't a firearm) needs adjacency -- the
@@ -287,6 +315,107 @@ export class AttackCommand extends Command {
             exchange.releaseExchange();
         }
     }
+    /**
+     * ONE STRIKE IN A COMBAT TURN (SR5 p.158-167, RAG-checked 2026-09-06).
+     *
+     * Opening a fight rolls initiative for everyone in the room who is in
+     * it (Scene.encounterMembers) and runs the passes up to this actor's
+     * own Action Phase -- a faster opponent acts BEFORE the shot that
+     * started it, which is the whole point of the score. Then:
+     *   - Ready Weapon is its own Simple Action (p.165): nothing draws for
+     *     you any more. A holstered gun is a refusal that names the verb.
+     *   - Melee needs reach, and ground costs metres from the whole-turn
+     *     budget (p.161, utilities/movement-cost.ts).
+     *   - The action: a melee attack is COMPLEX (p.167); firing a readied
+     *     gun is SIMPLE (p.165). One attack per phase (p.164).
+     *   - The strike resolves (combat-exchange.ts resolveStrike) with the
+     *     turn's own modifiers: aim, charge, surprise, active defense.
+     * No retaliation here: the target answers on THEIR phase.
+     */
+    async executeInEncounter(target, room, weaponItem, ambush) {
+        const actor = this.actor;
+        const human = this.scene.isHumanControlled(actor);
+        let enc = this.scene.encounterFor?.(actor);
+        if (!enc) {
+            enc = await this.scene.startEncounter(room, { aggressor: actor, target, ambush });
+            if (enc.ended) {
+                return human ? `` : `The fight was over before ${actor.name} got to act.`;
+            }
+            if (actor.isIncapacitated()) {
+                return human ? `You're down before you can act.` : `${actor.name} went down before acting.`;
+            }
+            if (!enc.isPhaseOf(actor)) {
+                // Someone faster is acting (a human's phase is waiting for its
+                // "end turn"); this attack becomes the next phase's business.
+                const who = enc.phaseActor?.name ?? 'the others';
+                return human
+                    ? `Initiative rolled -- ${who} ${enc.phaseActor ? 'acts' : 'act'} first. Your ${this.actionVerb() === 'attacks' ? 'attack' : 'move'} waits for your Action Phase.${hint(` ("initiative" shows the order.)`)}`
+                    : `${actor.name} squares up -- initiative rolled; ${who} first.`;
+            }
+            if (target.isIncapacitated() || target.currentLocation !== room) {
+                return human ? `${target.name} is no longer standing in front of you.` : `${target.name} is no longer a target.`;
+            }
+        }
+        else if (!enc.isPhaseOf(actor)) {
+            return notYourPhase(enc, actor);
+        }
+        enc.noteAttack(actor, target);
+        // READY WEAPON (p.165) is an action, not a beat.
+        if (this.usesEquippedWeapon() && weaponItem && !actor.weaponDrawn) {
+            return `The ${weaponItem.name} is holstered -- "draw" it first (Ready Weapon, a Simple Action, SR5 p.165).${phaseHint(this.scene, actor)}`;
+        }
+        const isMelee = !this.usesEquippedWeapon() || !weaponItem?.isFirearm();
+        const report = [];
+        // MELEE REACH: ground costs (p.161-162).
+        if (isMelee) {
+            const targetSpot = spotOf(target);
+            const mine = spotOf(actor);
+            if (targetSpot !== undefined && !canReach(actor, targetSpot)) {
+                const meters = mine !== undefined && room.ensureGrid() ? spotDistanceMeters(room, mine, targetSpot) : 0;
+                const spend = spendMovementMeters(this.scene, actor, meters, 'walk', this.logger);
+                if (spend)
+                    return `${target.name} is ${Math.round(meters)} m away. ${spend}`;
+                const reach = ensureAtSpot(actor, targetSpot);
+                if (reach.refusal)
+                    return reach.refusal;
+                if (reach.line)
+                    report.push(reach.line);
+            }
+        }
+        // THE ACTION.
+        const label = isMelee ? (this.usesEquippedWeapon() ? 'Melee Attack' : 'Subdue') : 'Fire Weapon';
+        const bill = billAction(this.scene, actor, isMelee ? 'complex' : 'simple', label, { attack: true });
+        if (bill)
+            return bill;
+        const exchange = new CombatExchange(this.scene, this.logger, actor);
+        actor.performAction(this.actionVerb(), target.name);
+        this.scene.addWorldEvent(`${actor.name} ${this.actionVerb()} ${target.name} in ${room.name}.`);
+        // The engagement memory pursuit and the parting shot key off.
+        const now = Date.now();
+        actor.combatOpponent = target;
+        actor.lastExchangeAt = now;
+        target.combatOpponent = target.combatOpponent ?? actor;
+        target.lastExchangeAt = now;
+        actor.surrendered = false;
+        if (!isMelee) {
+            actor.firedThisPhase = true;
+            actor.recoilRoundsFired += 1;
+        }
+        const profile = this.strikeProfile(exchange, target);
+        const strike = exchange.resolveStrike(actor, target, profile);
+        report.push(...strike.world, ...strike.meta);
+        await exchange.announce(strike.world, strike.meta);
+        enc.syncWounds();
+        const takedown = await this.resolveTakedown(exchange, target, actor);
+        if (takedown)
+            report.push(...takedown);
+        this.scene.updateStatus();
+        if (human) {
+            const tail = phaseHint(this.scene, actor).trim();
+            return tail;
+        }
+        return report.join('\n');
+    }
     /** subdue.ts overrides to false: its strike ignores the equipped gun entirely. */
     usesEquippedWeapon() {
         return true;

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

@@ -1,6 +1,7 @@
 import { Command } from './command.js';
 import { Category } from '../types/shared/item-enum.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
+import { billAction, phaseHint } from '../utilities/action-cost.js';
 /**
  * The two halves of the holster mechanic (see Player.weaponDrawn): an
  * equipped weapon rides holstered until "brandish" puts it in hand, and
@@ -38,6 +39,11 @@ export class BrandishCommand extends Command {
         if (actor.weaponDrawn) {
             return `The ${carried.name} is already in your hand.`;
         }
+        // READY WEAPON (SR5 p.165): a Simple Action. In a Combat Turn nothing
+        // draws for you any more -- the holster is a decision, not a beat.
+        const bill = billAction(this.scene, actor, 'simple', 'Ready Weapon');
+        if (bill)
+            return bill;
         actor.drawWeapon();
         // A threat display is the OPPOSITE of sneaking.
         actor.sneaking = false;
@@ -60,7 +66,7 @@ export class BrandishCommand extends Command {
         const ammoNote = carried.isFirearm()
             ? (carried.ammo === 0 ? ' The magazine is DRY -- "reload".' : ` ${carried.ammo} rounds ready.`)
             : '';
-        return `You draw the ${carried.name}.${ammoNote} Menace: ${formatRoll(menaceRoll)} -- everyone here just watched you do it.`;
+        return `You draw the ${carried.name}.${ammoNote} Menace: ${formatRoll(menaceRoll)} -- everyone here just watched you do it.${phaseHint(this.scene, actor)}`;
     }
 }
 export class HolsterCommand extends Command {
@@ -78,6 +84,11 @@ export class HolsterCommand extends Command {
         if (!actor.weaponDrawn) {
             return `The ${carried.name} is already holstered.`;
         }
+        // Putting a weapon away is the Simple Action's other half (p.165
+        // Pick Up/Put Down Object).
+        const bill = billAction(this.scene, actor, 'simple', 'Holster Weapon');
+        if (bill)
+            return bill;
         actor.stowWeapon();
         actor.performAction('holsters', carried.name);
         this.logger.write(`${actor.name} holsters ${carried.name}.`);

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

@@ -9,6 +9,7 @@ import { crossPlaneRefusal } from '../utilities/planes.js';
 import { spotOf, ensureAtSpot } from '../utilities/spots.js';
 import { NPC } from '../models/npc.js';
 import { spellFor, catalogSpells } from '../utilities/catalog.js';
+import { billAction, notYourPhase, phaseHint } from '../utilities/action-cost.js';
 /**
  * ISpell and SPELLS now live in `../spells.js` (imported above) -- the ONE
  * source shared with the chargen spell picker, so the cast mechanics and
@@ -530,6 +531,13 @@ export class CastCommand extends BypassCommand {
                     report.push(reach.line);
             }
         }
+        // THE COMBAT TURN (utilities/combat-turn.ts): on the physical planes
+        // a combat spell is one Complex Action in the caster's own Action
+        // Phase (p.167) -- the target answers on theirs. The astral keeps
+        // the exchange below.
+        if (this.actor.plane === 'meat' || this.actor.plane === 'drone') {
+            return await this.castInEncounter(exchange, spell, spellKey, force, overcast, target, room, flavor, report);
+        }
         // Movement locks while the exchange resolves, same as attack.ts. The
         // caster's hands are shaping mana, not clearing leather (no
         // aggressor draw) -- but the TARGET's counter is their weapon, so
@@ -669,6 +677,100 @@ export class CastCommand extends BypassCommand {
             exchange.releaseExchange();
         }
     }
+    /**
+     * ONE SPELL IN A COMBAT TURN (SR5 p.158-167). Opening a fight rolls
+     * initiative for the room and runs the passes up to the caster's own
+     * phase (a faster target acts BEFORE the incantation lands, which is
+     * what the old "moves before the incantation finishes" line was
+     * reaching for). Then the cast is the phase's Complex Action and its
+     * one attack; the bolt resolves with the turn's modifiers
+     * (combat-exchange.ts), the area splashes, and drain comes due. No
+     * counter here -- the target answers on THEIR phase.
+     */
+    async castInEncounter(exchange, spell, spellKey, force, overcast, target, room, flavor, report) {
+        const actor = this.actor;
+        const human = this.scene.isHumanControlled(actor);
+        let enc = this.scene.encounterFor?.(actor);
+        if (!enc) {
+            enc = await this.scene.startEncounter(room, { aggressor: actor, target, ambush: false });
+            if (enc.ended)
+                return human ? '' : `The fight was over before ${actor.name} could cast.`;
+            if (actor.isIncapacitated())
+                return human ? `You're down before you can cast.` : `${actor.name} went down before casting.`;
+            if (!enc.isPhaseOf(actor)) {
+                const who = enc.phaseActor?.name ?? 'the others';
+                return human
+                    ? `Initiative rolled -- ${who} ${enc.phaseActor ? 'acts' : 'act'} first. Your ${spellKey} waits for your Action Phase.${hint(` ("initiative" shows the order.)`)}`
+                    : `${actor.name} gathers mana -- initiative rolled; ${who} first.`;
+            }
+            if (target.isIncapacitated() || target.currentLocation !== room) {
+                return `${target.name} is no longer a target.`;
+            }
+        }
+        else if (!enc.isPhaseOf(actor)) {
+            return notYourPhase(enc, actor);
+        }
+        enc.noteAttack(actor, target);
+        // CAST SPELL is a Complex Action (p.167) and the phase's attack (p.164).
+        const bill = billAction(this.scene, actor, 'complex', `Cast ${spellKey}`, { attack: true });
+        if (bill)
+            return bill;
+        actor.performAction(`casts ${spellKey} at`, target.name);
+        this.scene.addWorldEvent(`${actor.name} ${flavor.act} ${target.name} in ${room.name}.`);
+        const now = Date.now();
+        actor.combatOpponent = target;
+        actor.lastExchangeAt = now;
+        target.combatOpponent = target.combatOpponent ?? actor;
+        target.lastExchangeAt = now;
+        actor.surrendered = false;
+        // The spell's own numbers -- identical to the exchange path below.
+        const spellAp = spell.soak === 'armor' ? Math.floor(force / 3) : 0;
+        const armorEaten = spellAp > 0
+            ? Math.min(spellAp, target.plane === 'meat' ? target.getArmorValue() : 0)
+            : 0;
+        const magicResistance = spell.soak === 'armor' ? 0 : target.qualityRating('magic-resistance');
+        const soakPool = (spell.soak === 'willpower' ? target.willpower
+            : spell.soak === 'body' ? target.body
+                : Math.max(0, target.getSoakPool() - armorEaten)) + magicResistance;
+        const damageBase = spell.soak === 'armor' ? force : Math.max(1, force - 2);
+        const strike = exchange.resolveStrike(actor, target, {
+            label: `with a Force ${force} ${spellKey}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}${armorEaten > 0 ? ` (AP -${armorEaten})` : ''}`,
+            pool: actor.getMagicPool() + actor.consumeEdgeBoost(),
+            damageBase,
+            soakPool,
+            dealStun: spell.stun,
+            isSpell: true,
+            limit: force,
+        });
+        report.push('', ...strike.world, ...strike.meta);
+        await exchange.announce(strike.world, strike.meta);
+        enc.syncWounds();
+        if (target.isDown()) {
+            report.push(...await exchange.resolveDeath(target, actor, {
+                fallLine: `${target.name} ${flavor.fall} Their gear scatters across ${room.name}.`,
+            }));
+        }
+        else if (target.isUnconscious()) {
+            report.push(...(this.scene.isHumanControlled(target)
+                ? await exchange.resolvePlayerKnockout(actor, target)
+                : await exchange.resolveDeath(target, actor, {
+                    fatal: false,
+                    fallLine: `${target.name} sags and drops -- out cold, breathing. Their gear scatters across ${room.name}.`,
+                })));
+        }
+        if (spell.area) {
+            report.push(...await this.splashArea(exchange, spellKey, spell, force, target, damageBase, spellAp));
+            enc.syncWounds();
+        }
+        const drain = this.applyDrain(spell, force, overcast);
+        report.push('', ...drain);
+        await exchange.announce(drain);
+        const collapse = await this.drainCollapse(exchange, target);
+        report.push(...collapse);
+        enc.syncWounds();
+        this.scene.updateStatus();
+        return human ? phaseHint(this.scene, actor).trim() : report.join('\n');
+    }
     /**
      * The rest of the room, for an AREA spell: every other hostile takes
      * the same damage, resisted with the same soak the primary target

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

@@ -1,6 +1,7 @@
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { coverAvailableFor, coverSpotsIn, isInCover, takeCoverHere, spotOf, sealedRouteTo, firstReachable } from '../utilities/spots.js';
+import { billAction, phaseHint, requirePhase } from '../utilities/action-cost.js';
 /**
  * TAKE COVER (player request 2026-08-27: "I should be able to 'Take
  * Cover' as a combat command").
@@ -20,10 +21,11 @@ import { coverAvailableFor, coverSpotsIn, isInCover, takeCoverHere, spotOf, seal
  * standing behind the crates is a position and taking cover is a
  * choice, and only the choice pays.
  *
- * NOT MODELLED, deliberately: p.166 also bars a SURPRISED character
- * from taking cover. This engine has no surprise state to read, and
- * inventing one to satisfy half a sentence would be worse than the
- * omission. Noted rather than faked.
+ * p.166 also bars a SURPRISED character from taking cover. Since the
+ * Combat Turn landed (utilities/combat-turn.ts, 2026-09-06) the engine
+ * has a surprise state to read -- the Surprise Test at an ambushed
+ * fight's open -- and this verb reads it. The action itself is billed
+ * through action-cost.ts like every other verb with a cost.
  */
 export class CoverCommand extends Command {
     static verb = 'cover';
@@ -35,6 +37,11 @@ export class CoverCommand extends Command {
                 ? `Cover is a meat-world idea -- there's nothing to hide behind on the grid.`
                 : `Nothing out here casts a shadow you can get behind.`;
         }
+        // Whose phase it is comes before where the cover is: the second
+        // answer is useless until the first is "yours".
+        const phase = requirePhase(this.scene, actor);
+        if (phase)
+            return phase;
         const room = actor.currentLocation;
         const available = coverAvailableFor(actor);
         if (!available) {
@@ -62,16 +69,27 @@ export class CoverCommand extends Command {
         if (isInCover(actor)) {
             return `You're already tucked in behind ${spotOf(actor) ? `the ${spotOf(actor)}` : 'it'} -- as small as this gets.`;
         }
+        // THE SIMPLE ACTION the class doc names (p.166) is now actually
+        // spent, inside a Combat Turn. p.166 also bars a SURPRISED character
+        // from taking cover -- the encounter knows who is surprised.
+        const enc = this.scene.encounterFor?.(actor);
+        if (enc?.isSurprised(actor)) {
+            return `You're caught flat-footed -- no cover until you get your bearings (SR5 p.166, p.192).`;
+        }
+        const bill = billAction(this.scene, actor, 'simple', 'Take Cover');
+        if (bill)
+            return bill;
         takeCoverHere(actor);
         const dice = available === 'good' ? 4 : 2;
         actor.performAction('takes cover', `at the ${spotOf(actor)}`);
         this.logger.write(`CoverCommand: ${actor.name} took ${available} cover at ${spotOf(actor)}.`);
         this.scene.updateStatus?.();
-        return available === 'good'
+        return (available === 'good'
             ? `You put ${spotOf(actor) ? `the ${spotOf(actor)}` : 'it'} between you and the room and fold down behind it -- most of you is gone.`
                 + `\n  {green-fg}GOOD COVER: +${dice} to defend.{/green-fg}${hint(` You keep it until you move.`)}`
             : `You drop in behind ${spotOf(actor) ? `the ${spotOf(actor)}` : 'it'} -- not all of you fits, but enough.`
-                + `\n  {green-fg}PARTIAL COVER: +${dice} to defend.{/green-fg}${hint(` You keep it until you move.`)}`;
+                + `\n  {green-fg}PARTIAL COVER: +${dice} to defend.{/green-fg}${hint(` You keep it until you move.`)}`)
+            + phaseHint(this.scene, actor);
     }
 }
 //# sourceMappingURL=cover.js.map

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

@@ -0,0 +1,74 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+/**
+ * ACTIVE DEFENSE (SR5 p.168, p.190-192, RAG-checked 2026-09-06).
+ *
+ * The book's four options all spend Initiative Score rather than actions:
+ *   FULL DEFENSE  -10, +Willpower to every Defense Test for the rest of
+ *                 the Combat Turn; declarable "at any point in a Combat
+ *                 Turn, even before the character's Action Phase" (p.191)
+ *   DODGE          -5, +Gymnastics on one Defense Test, any attack
+ *   BLOCK          -5, +Unarmed Combat on one test, melee only
+ *   PARRY          -5, +the melee weapon's skill on one test, melee
+ *                 only, weapon in hand
+ * "Only if he has enough Initiative Score left in the Combat Turn to pay
+ * the price" (p.167-168): a score at or below zero buys none of them.
+ *
+ * Full Defense is declared here and now. The other three answer an
+ * attack that has not happened yet, so they are set as a POLICY the
+ * engine applies when a shot or swing comes in and the score can pay
+ * (combat-exchange.ts) -- a terminal cannot ask mid-pass, and a hosted
+ * table cannot wait on one player's keystroke.
+ */
+export class DefendCommand extends Command {
+    static verb = 'defend';
+    static description = 'Active defense (SR5 p.191): "defend full" spends 10 Initiative for +Willpower on every defense this turn; "defend dodge", "defend block" or "defend parry" sets what you do when attacked (-5 Initiative each time it fires, +Gymnastics / +Unarmed / +weapon skill); "defend none" clears it.';
+    async execute(args = []) {
+        const actor = this.actor;
+        const word = (args[0] ?? '').toLowerCase();
+        const enc = this.scene.encounterFor?.(actor);
+        if (!word) {
+            const lines = [
+                `Defense policy: ${actor.defensePolicy.toUpperCase()}${enc?.fullDefenseActive(actor) ? ' -- FULL DEFENSE this turn' : ''}.`,
+                '',
+                `  full    -- -10 Initiative now, +Willpower (${actor.willpower}) on every defense this Combat Turn (p.191)`,
+                `  dodge   -- -5 when it fires, +Gymnastics (${actor.skillRating('gymnastics')}) against any attack (p.168)`,
+                `  block   -- -5 when it fires, +Unarmed Combat (${actor.skillRating('unarmed')}) against melee (p.168)`,
+                `  parry   -- -5 when it fires, +your melee weapon's skill against melee, weapon in hand (p.168)`,
+                `  none    -- plain Reaction + Intuition`,
+                '',
+                `Interrupts need Initiative Score left to pay for them${enc ? ` -- you have ${enc.scoreOf(actor)}` : ''}.`,
+            ];
+            return lines.join('\n');
+        }
+        if (/^(full|full-defense|fulldefense)$/.test(word) || (word === 'full' && args[1] === 'defense')) {
+            if (!enc)
+                return `You're not in a fight -- Full Defense is a Combat Turn thing.${hint(` ("defend dodge" and friends can be set any time.)`)}`;
+            if (actor.plane !== 'meat' && actor.plane !== 'drone')
+                return `Full Defense is a body's move.`;
+            const refusal = enc.declareFullDefense(actor);
+            if (refusal)
+                return refusal;
+            actor.performAction('goes on full defense', '');
+            this.scene.updateStatus();
+            return `You go on FULL DEFENSE -- -10 Initiative (now ${enc.scoreOf(actor)}), +${actor.willpower} to every defense for the rest of this Combat Turn (SR5 p.191).`;
+        }
+        const policy = ['dodge', 'block', 'parry', 'none'].find(p => p === word);
+        if (!policy) {
+            return `Defend how? "defend full", "defend dodge", "defend block", "defend parry" or "defend none".`;
+        }
+        actor.defensePolicy = policy;
+        this.scene.updateStatus();
+        switch (policy) {
+            case 'none':
+                return `Defense policy cleared -- plain Reaction + Intuition from here.`;
+            case 'dodge':
+                return `You'll DODGE what comes in: -5 Initiative each time, +${actor.skillRating('gymnastics')} (Gymnastics) on that Defense Test${actor.skillRating('gymnastics') === 0 ? ' -- which is nothing; the score would be spent for no dice' : ''}.`;
+            case 'block':
+                return `You'll BLOCK melee attacks: -5 Initiative each time, +${actor.skillRating('unarmed')} (Unarmed Combat) on that Defense Test.`;
+            case 'parry':
+                return `You'll PARRY melee attacks with your weapon: -5 Initiative each time, +your melee skill on that Defense Test${!actor.weaponDrawn || actor.getCarriedWeapon()?.isFirearm() ? ' -- once you have a melee weapon in hand' : ''}.`;
+        }
+    }
+}
+//# sourceMappingURL=defend.js.map

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

@@ -0,0 +1,34 @@
+import { Command } from './command.js';
+import { notYourPhase } from '../utilities/action-cost.js';
+/**
+ * DELAYING ACTIONS (SR5 p.161, RAG-checked 2026-09-06): "declared during
+ * Step 3A", before any action is taken; the character keeps their score
+ * and acts on a lower Initiative Score later in the same pass. If the
+ * pass ends first, the standard -10 applies like anyone else's.
+ *
+ * Modelled as "act after everyone else still owed a phase this pass"
+ * -- the engine cannot offer the book's interrupt-at-any-moment, so it
+ * gives the last word instead, which is what delaying is for.
+ */
+export class DelayCommand extends Command {
+    static verb = 'delay';
+    static description = 'Delay your Action Phase (SR5 p.161): keep your Initiative Score but act after the others this pass. Only before you have spent anything.';
+    async execute(_args = []) {
+        const actor = this.actor;
+        const enc = this.scene.encounterFor?.(actor);
+        if (!enc)
+            return `You're not in a fight -- nothing to delay.`;
+        if (!enc.isPhaseOf(actor))
+            return notYourPhase(enc, actor);
+        const budget = enc.budgetOf(actor);
+        if (budget && budget.spent.length > 0) {
+            return `Too late to delay -- you've already acted this phase (${budget.ledger()}). "end turn" instead.`;
+        }
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.log(`{cyan-fg}You hold your action, watching.{/cyan-fg}`, { actor: actor.name });
+        }
+        await enc.delayPhase(actor);
+        return this.scene.isHumanControlled(actor) ? '' : `${actor.name} holds their action.`;
+    }
+}
+//# sourceMappingURL=delay.js.map

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

@@ -2,6 +2,7 @@ import { CastCommand } from './cast.js';
 import { BypassCommand } from './bypass-command.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { billAction } from '../utilities/action-cost.js';
 /**
  * The magical barrier's OWN verb (player ruling: "solve" was too broad --
  * a ward wants "dispel", not a generic answer verb), and the second half
@@ -70,6 +71,10 @@ export class DispelCommand extends CastCommand {
         if (!this.actor.isCaster()) {
             return `Unweaving a ward takes talent you don't have -- you'd need to be Awakened, or have a spell formula, grimoire, or focus on you.`;
         }
+        // DISPELLING IS A COMPLEX ACTION (SR5 p.295) inside a Combat Turn.
+        const bill = billAction(this.scene, this.actor, 'complex', 'Dispel');
+        if (bill)
+            return bill;
         // An actor's name beats a barrier noun -- "dispel ghost" means the
         // mage, "dispel ward" falls through to the barrier route below.
         if (args && args.length > 0) {

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

@@ -1,4 +1,5 @@
 import { Command } from './command.js';
+import { billAction } from '../utilities/action-cost.js';
 export class DropCommand extends Command {
     static verb = 'drop';
     static description = 'Drop an item from your inventory.';
@@ -14,6 +15,10 @@ export class DropCommand extends Command {
                 ? `Your pack is streets away with your body -- the ${this.actor.riggedDrone?.name ?? 'drone'} carries nothing to drop.`
                 : `Your pack is with your body. Come back to it first.`;
         }
+        // DROP OBJECT (SR5 p.163): a Free Action in a Combat Turn.
+        const bill = billAction(this.scene, this.actor, 'free', 'Drop Object');
+        if (bill)
+            return bill;
         const itemName = args.join(' ').toLowerCase(); // Assuming the item name may contain spaces
         // Check if the item exists in the player's inventory
         if (!this.actor.inventory.hasItem(itemName)) {

package/bundle/typescript/src/commands/game/sideQuest/commands/end-call.js

@@ -3,8 +3,17 @@ import { NPC } from '../models/npc.js';
 import { CALL_ICON, CALL_COLOR } from '../utilities/comm-style.js';
 export class EndCallCommand extends Command {
     static verb = 'end-call';
-    static description = 'Hang up your current commlink call.';
-    async execute() {
+    static description = 'Hang up your current commlink call. ("end turn" commits your Action Phase in a fight -- see end-turn.)';
+    async execute(args = []) {
+        // "end turn" / "end phase" is the Combat Turn's commit, not a hangup
+        // (commands/end-turn.ts). The bare verb keeps its older meaning.
+        if (/^(turn|phase|round|action)s?$/i.test(args[0] ?? '')) {
+            const { EndTurnCommand } = await import('./end-turn.js');
+            return new EndTurnCommand({
+                actor: this.actor, scene: this.scene, rooms: this.rooms,
+                screen: this.screen, game: this.game,
+            }).execute();
+        }
         const partner = this.actor.activeCallPartner;
         if (!partner) {
             // A PLAYER call hangs up for EVERYONE (player ruling): the game