@maka/maka-cli 5.138.0 → 5.139.0

package/bundle/typescript/package.json

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

@@ -0,0 +1,88 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { NUDGES_TO_SKIP } from '../utilities/combat-turn.js';
+/**
+ * NUDGE -- the table's answer to a runner who is holding the Action
+ * Phase and has gone quiet (project owner, 2026-09-07: "three nudges
+ * skips the player being nudged").
+ *
+ * Since the Combat Turn (utilities/combat-turn.ts) a human's phase
+ * waits for "end turn", and since the autopilot went (v5.136.0)
+ * nothing plays a phase for anyone. On a shared run that leaves one
+ * hole: a human who walks away mid-phase stalls the whole table. There
+ * is deliberately no clock -- a timer skips the player who was reading
+ * the rules -- so the escape is the table's: every nudge tells the
+ * nudged runner, in their own log, that people are waiting; the third
+ * nudge on one phase ends it for them, whatever they had left forfeit,
+ * exactly as "end turn" with nothing spent (SR5 p.158-159; the book
+ * gives no refund). The count is the phase's (CombatEncounter.noteNudge)
+ * and starts over the next time they act.
+ *
+ * Off the phase, or out of a fight, a nudge is a tap on the shoulder
+ * only the nudged runner sees. Human-only: an NPC acts by rule on its
+ * own phase and must never be able to skip a human's.
+ */
+export class NudgeCommand extends Command {
+    static verb = 'nudge';
+    static humanOnly = true;
+    static description = 'Prod another runner on a shared run: "nudge <name>". If they are holding the Action Phase, that tells them the table is waiting -- the third nudge on one phase ends it for them, whatever is unspent forfeit, the same as "end turn" with nothing spent. Off the phase, or out of a fight, it is a tap on the shoulder only they see. "initiative" names who is holding the phase.';
+    /** The scene's other humans -- the only legal targets. */
+    others() {
+        return this.scene.getPlayers().filter(p => p !== this.actor);
+    }
+    async execute(args = []) {
+        if (!this.scene.isHumanControlled(this.actor))
+            return '';
+        const me = this.actor;
+        const query = (args ?? []).join(' ').trim();
+        const others = this.others();
+        if (others.length === 0) {
+            return `You're running this one alone -- there's nobody to nudge.${hint(` (Seat a table with "crew hire"; "nudge" is for a shared run.)`)}`;
+        }
+        if (!query) {
+            return `Nudge who? ${others.map(p => p.name).join(', ')}.  Usage: "nudge <runner>".`;
+        }
+        if (query.toLowerCase() === me.name.toLowerCase()) {
+            return `Nudging yourself moves nothing. If it's your phase, act -- or "end turn".`;
+        }
+        const picked = fuzzyPickName(query, others.map(p => p.name));
+        const target = picked ? others.find(p => p.name === picked) : undefined;
+        if (!target) {
+            return `No runner on this job answers to "${query}". Out here with you: ${others.map(p => p.name).join(', ')}. (An NPC acts by rule on its own phase -- nothing to nudge there.)`;
+        }
+        if (this.scene.getKnockout?.(target.name)) {
+            return `${target.name} is out cold -- no nudge reaches them.`;
+        }
+        const enc = this.scene.encounterFor?.(target);
+        const count = enc?.noteNudge(target);
+        if (count === undefined) {
+            // A TAP ON THE SHOULDER, seen by them alone -- the same per-human
+            // scope beginPhase uses for the cyan "your Action Phase" line.
+            this.logger.log(`{yellow-fg}${me.name} nudges you.{/yellow-fg}`, { actor: target.name });
+            this.logger.write(`${me.name} nudged ${target.name} (no phase to count against).`);
+            const holder = enc?.phaseActor;
+            const aside = enc && holder && holder !== target
+                ? ` It isn't ${target.name}'s Action Phase -- ${holder === me ? `it's yours` : `${holder.name} is holding it`}.`
+                : '';
+            return `You nudge ${target.name}.${aside}`;
+        }
+        const room = target.currentLocation;
+        if (count >= NUDGES_TO_SKIP) {
+            // THE SKIP. Logged, not returned: the phases that follow announce
+            // themselves while this command is still running (end-turn.ts has
+            // the same note), and a return value would land under them.
+            this.logger.log(`{yellow-fg}${target.name}'s Action Phase is skipped -- nudged ${NUDGES_TO_SKIP} times; whatever they had left is forfeit.{/yellow-fg}`, { room: room.name });
+            this.logger.write(`${me.name}'s nudge #${count} skips ${target.name}'s Action Phase.`);
+            await enc.endPhase(target);
+            return '';
+        }
+        this.logger.log(`{yellow-fg}${me.name} nudges you -- the table is waiting on your Action Phase (${count}/${NUDGES_TO_SKIP}; ${NUDGES_TO_SKIP} and it is skipped). "end turn" when you're done.{/yellow-fg}`, { actor: target.name });
+        this.logger.log(`${me.name} nudges ${target.name} (${count}/${NUDGES_TO_SKIP}).`, { room: room.name });
+        this.logger.write(`${me.name} nudged ${target.name} (${count}/${NUDGES_TO_SKIP}).`);
+        // The room line above already reached the nudger when they share the
+        // room; from elsewhere they get the summary instead.
+        return me.currentLocation === room ? '' : `You nudge ${target.name} (${count}/${NUDGES_TO_SKIP}).`;
+    }
+}
+//# sourceMappingURL=nudge.js.map

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

@@ -384,5 +384,9 @@
 //   arrival. During a live encounter the ephemeral governor, open-floor
 //   re-seating and doorway yielding are frozen: nobody moves off the
 //   player's keystrokes. bluff/persuade wins clear the hostile flag.
-export const ENGINE_VERSION = '1.42.0';
+// 1.43.0 (2026-09-07): NUDGE. New verb in shared scenes: "nudge <runner>"
+//   tells a human holding the Action Phase that the table is waiting; the
+//   third nudge on one phase ends it for them (forfeit, as "end turn" with
+//   nothing spent). Off the phase it is a private tap on the shoulder.
+export const ENGINE_VERSION = '1.43.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -80,6 +80,7 @@ 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 { NudgeCommand } from './commands/nudge.js';
 import { SpellsCommand } from './commands/spells.js';
 import { InventoryCommand } from './commands/inv.js';
 import { EquipmentCommand } from './commands/equipment.js';
@@ -2553,6 +2554,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('aim', AimCommand);
         CommandFactory.registerCommand('defend', DefendCommand);
         CommandFactory.registerCommand('delay', DelayCommand);
+        CommandFactory.registerCommand('nudge', NudgeCommand);
         // 'train' used to alias advance; it belongs to crew instruction now
         // (commands/crew.ts) -- self-training is "advance".
         CommandFactory.registerCommand('advance', AdvanceCommand);
@@ -6040,7 +6042,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'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['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'], ['nudge'], ['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/utilities/combat-turn.js

@@ -1,6 +1,71 @@
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
 import { runNpcActionPhase } from './npc-combat-brain.js';
+/**
+ * THE COMBAT TURN (SR5 p.158-161, RAG-checked 2026-09-06).
+ *
+ * This engine used to resolve a fight as EXCHANGES: one typed "attack"
+ * rolled a two-actor initiative, both sides struck, and a >10 gap bought
+ * one extra strike. That was the closest thing it had to the book's
+ * turn, and combat-exchange.ts said so. What it could never express was
+ * the thing the book is built on -- a sequence of Action Phases in
+ * which every participant spends a budget of actions, in an order the
+ * dice decided, until nobody has Initiative Score left.
+ *
+ * The sequence, as the book gives it:
+ *   1. ROLL INITIATIVE: Initiative attribute + Initiative Dice, summed
+ *      (p.159). Highest acts first; ties break Edge, Reaction,
+ *      Intuition, coin (p.159 "ERIC").
+ *   2-4. INITIATIVE PASS: each participant, highest score first, takes
+ *      an ACTION PHASE -- two Simple Actions or one Complex, plus one
+ *      Free (p.158). When everyone has acted, EVERY score drops by 10
+ *      (p.159), and anyone still above zero goes again.
+ *   5. When nobody is above zero the Combat Turn ends and a new one
+ *      begins at step 1 (p.159).
+ *
+ * Also carried here because the score lives here:
+ *   - INTERRUPT ACTIONS (p.167-168) spend Initiative Score: Full
+ *     Defense -10 for the Combat Turn, Block/Dodge/Parry -5 each for
+ *     one test. Only affordable "if he has enough Initiative Score
+ *     left" -- a score already at or below zero buys nothing (the p.191
+ *     worked example).
+ *   - WOUND MODIFIERS CHANGE THE SCORE AS THEY LAND (p.160 Changing
+ *     Initiative): the difference is applied immediately, and it can
+ *     reorder the pass. It never grants an extra action.
+ *   - ENTERING LATE (p.160): roll as normal, then subtract 10 for every
+ *     pass already gone.
+ *   - DELAYING (p.161): an actor may hold their Action Phase and take
+ *     it later in the same pass. Modelled as "act after everyone else
+ *     this pass, keeping your score"; the pass-end -10 still applies.
+ *   - SURPRISE (p.192): a fight opened on the unaware makes every other
+ *     participant roll Reaction + Intuition (3); failure is -10 and no
+ *     defense against, nor action against, the surprising side until
+ *     their next Action Phase. +3 for anyone already alert.
+ *   - MOVEMENT is a WHOLE-TURN total (p.161-162, Player.movedMetersThisTurn)
+ *     and comes back at step 5, not per pass.
+ *
+ * SCOPE: one encounter per ROOM, on the physical planes (meat and a
+ * jumped-in drone). The Matrix keeps its own initiative structure
+ * (utilities/ic.ts maps IC to Combat Turns per player action) and
+ * astral combat still rides the exchange engine -- both are noted as
+ * gaps rather than folded in half-right.
+ *
+ * WHO DRIVES IT: a human's Action Phase waits for them to type actions
+ * and then "end turn" (commands/end-turn.ts). An NPC's phase is played
+ * by a deterministic brain (utilities/npc-combat-brain.ts) -- the LLM
+ * reflect chain is suspended for participants while the encounter runs,
+ * because a model answering "what next?" in a second or two cannot be
+ * sequenced against a dice-ordered pass, and was the reason NPCs used
+ * to shoot from between the beats of the player's own exchange.
+ */
+/**
+ * Nudges on one Action Phase before the table ends it for the holder
+ * (commands/nudge.ts, owner ruling 2026-09-07). A ruling, not canon --
+ * the book has no idle player -- kept as a count rather than a clock so
+ * that a runner reading the rules is never skipped by a timer, only by
+ * three people saying so.
+ */
+export const NUDGES_TO_SKIP = 3;
 export class CombatEncounter {
     scene;
     logger;
@@ -317,6 +382,7 @@ export class CombatEncounter {
         this.budget = new ActionBudget();
         p.surprised = false;
         p.delayed = false;
+        p.nudges = 0;
         p.actor.clearAim();
         // Recoil resets the moment an Action Phase passes without firing --
         // tracked by the phase, settled by attack.ts (p.175-176).
@@ -342,6 +408,19 @@ export class CombatEncounter {
         const walkLeft = Math.max(0, actor.walkRateMeters - actor.movedMetersThisTurn);
         return `${left} m of movement left this turn (${walkLeft} m at a walk)`;
     }
+    /**
+     * Another human nudged the phase holder (commands/nudge.ts): the
+     * running count for this phase, or undefined when `target` is not
+     * the one holding it. Bookkeeping only -- the verb owns the wording
+     * and calls endPhase() itself at NUDGES_TO_SKIP.
+     */
+    noteNudge(target) {
+        const p = this.participantOf(target);
+        if (!p || this.ended || this.phaseActor !== target)
+            return undefined;
+        p.nudges = (p.nudges ?? 0) + 1;
+        return p.nudges;
+    }
     /** The human typed "end turn" (or lost the phase -- fled, dropped). */
     async endPhase(actor) {
         const p = this.participantOf(actor);

package/package.json

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