@maka/maka-cli 5.3.16 → 5.4.0

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

@@ -1,6 +1,8 @@
 import blessed from 'blessed';
 import { capitalCase } from 'change-case';
-import { Door } from './models/_index.js';
+import { Room } from './models/_index.js';
+import { Direction } from './types/shared/direction-enum.js';
+import { Logger } from './utilities/logger.js';
 import { LookCommand } from './commands/look.js';
 import { TakeCommand } from './commands/take.js';
 import { GoCommand } from './commands/go.js';
@@ -18,20 +20,72 @@ import { StoreCommand } from './commands/store.js';
 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 { SpellsCommand } from './commands/spells.js';
+import { InventoryCommand } from './commands/inv.js';
+import { EquipmentCommand } from './commands/equipment.js';
+import { MapCommand } from './commands/map.js';
+import { SilentCommand } from './commands/silent.js';
+import { RestCommand } from './commands/rest.js';
+import { ReloadCommand } from './commands/reload.js';
+import { SubdueCommand } from './commands/subdue.js';
+import { EdgeCommand } from './commands/edge.js';
+import { SheetCommand } from './commands/sheet.js';
+import { CallCommand } from './commands/call.js';
+import { EndCallCommand } from './commands/end-call.js';
+import { PickCommand } from './commands/pick.js';
+import { HackCommand } from './commands/hack.js';
+import { CastCommand } from './commands/cast.js';
+import { StanceCommand } from './commands/stance.js';
+import { SurrenderCommand } from './commands/surrender.js';
+import { JackCommand } from './commands/jack.js';
+import { ProjectCommand, ReturnCommand } from './commands/project.js';
+import { AssenseCommand } from './commands/assense.js';
+import { DroneCommand } from './commands/drone.js';
+import { PanCommand } from './commands/pan.js';
+import { RebootCommand } from './commands/reboot.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 } from './factories/scene-seed-generator.js';
+import { CALL_ICON, CALL_COLOR } from './utilities/comm-style.js';
 export default class Game {
     initialized;
     static instance;
     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
+    // give the log the whole screen.
     _screen;
-    _exitsBox;
-    _inventoryBox;
     _logBox;
+    _statusBox;
     _inputBox;
-    _equipmentBox;
+    _useAi = false;
+    _logFilePath = '';
+    _tier = 1;
+    // Guards against two overlapping continueToNextScene() calls -- found via
+    // a real session where calling the fixer twice in a row (nothing stopped
+    // it, and a 20-40+ second draft invites a second, impatient call) fired
+    // two independent drafts at once. Both read the same starting _tier
+    // before either finished, both generated a "tier 2" job, and whichever
+    // one finished last silently overwrote the first one's scene, room, and
+    // player-location state out from under whatever the player was already
+    // doing in it.
+    _draftInProgress = false;
+    // A single fixed room, created once and never torn down across job
+    // transitions -- the player's own place, unlike every job's generated
+    // rooms which get discarded wholesale when the next job replaces them.
+    _homeRoom;
+    _homeRoomExitDirection;
+    static HOME_DIRECTION_PRIORITY = [
+        Direction.DOWN, Direction.UP, Direction.SOUTH, Direction.NORTH, Direction.EAST, Direction.WEST,
+    ];
     constructor(player, sceneSeed) {
         this.player = player;
         this.sceneSeed = sceneSeed;
@@ -55,10 +109,65 @@ export default class Game {
         CommandFactory.registerCommand('give', GiveCommand);
         CommandFactory.registerCommand('read', ReadCommand);
         CommandFactory.registerCommand('kill', KillCommand);
+        CommandFactory.registerCommand('attack', AttackCommand);
+        CommandFactory.registerCommand('spells', SpellsCommand);
+        CommandFactory.registerCommand('inv', InventoryCommand);
+        CommandFactory.registerCommand('inventory', InventoryCommand);
+        CommandFactory.registerCommand('equipment', EquipmentCommand);
+        CommandFactory.registerCommand('eq', EquipmentCommand);
+        CommandFactory.registerCommand('map', MapCommand);
+        CommandFactory.registerCommand('exits', MapCommand);
+        CommandFactory.registerCommand('silent', SilentCommand);
+        CommandFactory.registerCommand('rest', RestCommand);
+        CommandFactory.registerCommand('reload', ReloadCommand);
+        CommandFactory.registerCommand('subdue', SubdueCommand);
+        CommandFactory.registerCommand('edge', EdgeCommand);
+        CommandFactory.registerCommand('sheet', SheetCommand);
+        CommandFactory.registerCommand('stats', SheetCommand);
+        CommandFactory.registerCommand('call', CallCommand);
+        CommandFactory.registerCommand('end-call', EndCallCommand);
+        CommandFactory.registerCommand('pick', PickCommand);
+        CommandFactory.registerCommand('hack', HackCommand);
+        CommandFactory.registerCommand('cast', CastCommand);
+        CommandFactory.registerCommand('stance', StanceCommand);
+        CommandFactory.registerCommand('surrender', SurrenderCommand);
+        CommandFactory.registerCommand('jack', JackCommand);
+        CommandFactory.registerCommand('project', ProjectCommand);
+        CommandFactory.registerCommand('return', ReturnCommand);
+        CommandFactory.registerCommand('assense', AssenseCommand);
+        CommandFactory.registerCommand('drone', DroneCommand);
+        CommandFactory.registerCommand('pan', PanCommand);
+        CommandFactory.registerCommand('reboot', RebootCommand);
     }
     determineStartRoom() {
         return this.scene.determineStartRoom();
     }
+    /**
+     * Wires a fresh, always-unlocked path between the persistent home base
+     * and wherever the player is starting the current job from. Clears the
+     * previous job's connection first (if any) so the home base never keeps
+     * a stale door into an abandoned scene's now-orphaned rooms -- only ever
+     * one way out at a time, pointing at whichever job is actually current.
+     */
+    connectHomeRoom(jobStartRoom) {
+        if (this._homeRoomExitDirection) {
+            this._homeRoom.exits.delete(this._homeRoomExitDirection);
+        }
+        const direction = Game.HOME_DIRECTION_PRIORITY.find(d => !jobStartRoom.exits.has(d));
+        if (!direction) {
+            // Every direction is already spoken for on this job's start room --
+            // rare (most generated start rooms use 1-2 exits), but leave the
+            // player without a home-base link this job rather than clobbering
+            // one of the job's own exits.
+            this._homeRoomExitDirection = undefined;
+            return;
+        }
+        jobStartRoom.addExit(direction, this._homeRoom);
+        // Tracked from the HOME room's own side (the opposite of `direction`,
+        // which is the job room's side) -- that's the key actually stored on
+        // this._homeRoom.exits, and what gets cleared above next time around.
+        this._homeRoomExitDirection = jobStartRoom.getOppositeDirection(direction);
+    }
     get logBox() {
         return this._logBox;
     }
@@ -66,11 +175,11 @@ export default class Game {
         return this._inputBox;
     }
     async init(options, screen) {
-        this.initMap(screen);
+        this._useAi = options.useAi;
+        this._logFilePath = options.logFilePath;
         this.initInputBox(screen);
         this.initLogBox(screen);
-        this.initEquipmentBox(screen);
-        this.initInventoryBox(screen);
+        this.initStatusBox(screen);
         // Create a loading box
         const loadingBox = blessed.box({
             parent: screen,
@@ -101,8 +210,139 @@ export default class Game {
         this.player.currentLocation = this.determineStartRoom();
         this.registerCommands();
         this._screen = screen;
+        this._homeRoom = new Room({
+            name: 'Your Hideout',
+            description: `A cramped, windowless room you can actually call your own -- a cot, a locker, and a door that locks from the inside. Whatever you leave here stays here, no matter where the next job takes you.`,
+            roomType: 'Residence',
+        });
+        this.scene.addRoom(this._homeRoom);
+        this.connectHomeRoom(this.player.currentLocation);
         this.initialized = true;
-        return `Welcome, ${this.player.name}\n ${this.scene.story}`;
+        // Nudge the player toward "call" up front -- the fixer convention means
+        // the story deliberately doesn't narrate a completed briefing, so
+        // without this hint there'd be no in-game indication that "call" is how
+        // you actually get your orders.
+        const wc = this.scene.getWinCondition();
+        const callHint = (wc?.type === 'give' && wc.toNpc)
+            ? `\n\nYour commlink is quiet for now, but ${wc.toNpc} is expecting to hear from you -- try "call ${wc.toNpc}" when you're ready to check in.`
+            : '';
+        return `Welcome, ${this.player.name}\n ${this.scene.story}${callHint}`;
+    }
+    /**
+     * Synchronous readiness check for continueToNextScene() -- lets callers
+     * give instant feedback for the "not ready yet" cases (job not done, no
+     * AI configured) without waiting on anything async.
+     */
+    canDraftNextScene() {
+        if (this._draftInProgress) {
+            return { allowed: false, message: `Already drafting the next job -- give it a moment, he'll call back.` };
+        }
+        if (!this.scene.isCompleted()) {
+            return { allowed: false, message: `This job isn't finished yet.` };
+        }
+        if (!this._useAi) {
+            return { allowed: false, message: `Continuing needs an AI-generated job, which requires an AI provider to be configured (OPENAI_API_KEY or ANTHROPIC_API_KEY).` };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Fires continueToNextScene() without waiting on it -- job generation can
+     * take 20-40+ seconds, and neither "continue" nor calling the fixer
+     * should freeze the rest of the session behind that. Self-announces the
+     * result once it resolves, styled the same as any other comms exchange,
+     * since by design nothing else is holding a reference to display it.
+     * Public: called directly by call.ts when the player calls the fixer
+     * after a job's done, not just from "continue" here in game.ts.
+     */
+    draftNextSceneInBackground() {
+        void this.continueToNextScene()
+            .then(nextJobText => {
+            if (nextJobText) {
+                Logger.getInstance().logWithColor(`${CALL_ICON} ${nextJobText}`, CALL_COLOR);
+            }
+        })
+            .catch(err => {
+            Logger.getInstance().error(`Failed to draft the next job: ${err}`);
+        });
+    }
+    /**
+     * Drafts and loads the next job once the current scene's win condition
+     * has been met. Reuses the same long-lived Player (and its inventory),
+     * so gear compounds across the session -- nothing is persisted to disk,
+     * it just carries forward for the life of this process. Re-checks
+     * canDraftNextScene() itself (callers are expected to check it first for
+     * instant feedback, but this stays safe to call directly too).
+     */
+    async continueToNextScene() {
+        const gate = this.canDraftNextScene();
+        if (!gate.allowed) {
+            return gate.message ?? `This job isn't finished yet.`;
+        }
+        this._draftInProgress = true;
+        try {
+            return await this.draftNextScene();
+        }
+        finally {
+            this._draftInProgress = false;
+        }
+    }
+    /**
+     * The actual drafting work, split out from continueToNextScene() purely
+     * so that method can wrap it in the try/finally that clears
+     * _draftInProgress -- every return path below (including the early
+     * "couldn't draft" one) needs that cleanup to run.
+     */
+    async draftNextScene() {
+        const nextTier = this._tier + 1;
+        // Carry the current fixer's identity forward -- without this, each
+        // "continue" generates a scene with zero knowledge of the last one, so
+        // the AI just invents a brand new job-giver every time. Looked up by
+        // identity (is there an actor actually named FIXER_NAME?), not via the
+        // win condition's toNpc -- that's often a one-off contact the fixer
+        // pointed the runner toward, not the fixer himself (see the "broker,
+        // not always the destination" convention).
+        const fixerStillInScene = this.scene.allActors.some(a => a.name === FIXER_NAME);
+        const previousFixerName = fixerStillInScene ? FIXER_NAME : undefined;
+        // Append, don't replace -- this used to be setContent(), which wiped
+        // the whole log box (including the JOB COMPLETE banner and everything
+        // before it) for the entire generation wait, which can run 20-40+
+        // seconds for a tiered scene with AI flavor enabled. Framed as the
+        // fixer's own line when he's actually in this scene, rather than a
+        // bare system message -- he's the one drumming up the next gig.
+        const waitingLine = fixerStillInScene
+            ? `\n${CALL_ICON} ${FIXER_NAME}: "I'll call you back when I've got something lined up." (drafting the next job...)`
+            : '\nDrafting the next job... please wait.';
+        this.logBox.pushLine(waitingLine);
+        this.logBox.scrollTo(this.logBox.getScrollHeight());
+        this._screen.render();
+        const nextSeed = await SceneSeedGenerator.generate(this._logFilePath, nextTier, previousFixerName);
+        if (!nextSeed) {
+            return `Couldn't draft a new job this time. Type "continue" to try again, or "quit" to stop here.`;
+        }
+        this._tier = nextTier;
+        this.sceneSeed = nextSeed;
+        // A call partner from the old scene wouldn't exist in the new one --
+        // hang up before moving on, rather than leave a dangling reference.
+        if (this.player.activeCallPartner) {
+            this.player.activeCallPartner = undefined;
+        }
+        // false: this is a continuation, not a fresh game -- the player already
+        // has gear from prior jobs, so don't dump another starter kit on top.
+        this.scene = await SceneSynthesizer.synthesizeFromJson(nextSeed, this.player, this._useAi, false);
+        this.scene.initialize(this);
+        this.player.currentLocation = this.determineStartRoom();
+        // New job, fresh luck (see commands/edge.ts).
+        this.player.refreshEdge();
+        // The home base is owned by Game, not any one Scene -- re-inject it and
+        // rewire its one exit to point at this job's start room instead of the
+        // just-abandoned one.
+        this.scene.addRoom(this._homeRoom);
+        this.connectHomeRoom(this.player.currentLocation);
+        this.updateEquipment(this.player.equipment);
+        this.updateInventory(this.player.inventory, capitalCase(this.scene.getCurrencyType()));
+        this.updateExits(this.player.currentLocation);
+        this.updateStatus();
+        return `\n=== JOB #${this._tier}: ${nextSeed.name} ===\n${this.scene.story}`;
     }
     async close() {
         this._inputBox.removeAllListeners(); // removes all event listeners
@@ -113,42 +353,13 @@ export default class Game {
             process.exit(2);
         });
     }
-    initMap(screen) {
-        // Map
-        const exitsBox = blessed.box({
-            top: '70%',
-            left: '75%',
-            width: '25%',
-            height: '20%',
-            border: {
-                type: 'line'
-            },
-            label: ' Map ',
-            content: 'Available exits will be shown here...',
-            tags: true,
-            scrollable: true,
-            scrollbar: {
-                ch: ' ',
-                track: {
-                    bg: 'yellow'
-                },
-                style: {
-                    inverse: true
-                }
-            },
-            keys: true,
-            mouse: true,
-        });
-        screen.append(exitsBox);
-        this._exitsBox = exitsBox;
-    }
     initInputBox(screen) {
         // Create an input box for user commands
         const inputBox = blessed.textbox({
             bottom: 0,
             left: 0,
             width: '100%',
-            height: '10%',
+            height: 3,
             tags: true,
             border: { type: 'line' },
             style: { fg: 'white', border: { fg: 'cyan' } },
@@ -161,8 +372,21 @@ export default class Game {
         screen.append(inputBox);
         // Key bindings
         screen.key(['escape', 'C-c'], () => process.exit(0));
-        // Focus on the input box by default
-        inputBox.focus();
+        // Focus on the input box by default -- but ONLY if it isn't already
+        // focused. screen.append() auto-focuses the first keyable element
+        // (Node.insert), and since the sidebar boxes were removed this textbox
+        // IS the first one, so it arrives here already focused with its input
+        // reader mid-setup. Blessed's _focus() has no same-element guard:
+        // focusing an already-focused textbox fires a self-blur that cancels
+        // that reader BEFORE its keypress listener finishes attaching (the
+        // attach rides a delayed tick), so the cancel removes nothing, a
+        // second reader starts, both listeners land -- and every keystroke
+        // doubles, from startup ("exit" arrived as "eexxiitt" in a real
+        // session). Previously the Map box was appended first and soaked up
+        // the auto-focus, which is the only reason this never fired before.
+        if (screen.focused !== inputBox) {
+            inputBox.focus();
+        }
         // Render the screen
         screen.render();
     }
@@ -172,8 +396,9 @@ export default class Game {
             id: 'logBox',
             top: '0%',
             left: '0%',
-            width: '75%',
-            height: '90%',
+            width: '100%',
+            // Fixed-row footer: 8 rows of HUD (status box) + 3 rows of input.
+            height: '100%-11',
             border: {
                 type: 'line'
             },
@@ -197,139 +422,138 @@ export default class Game {
         logBox.removeAllListeners('mousemove');
         screen.append(logBox);
     }
-    initEquipmentBox(screen) {
-        const equipmentBox = blessed.box({
-            top: '45%',
-            left: '75%',
-            width: '25%',
-            height: '25%',
+    /**
+     * The HUD: a fixed strip between the log and the input box for the
+     * important real-time state -- condition tracks, armed/link status,
+     * sustained spells, active call. Anything that changes moment to moment
+     * and shouldn't need a command to check lives here; everything slower
+     * (full inventory, slot-by-slot equipment, the map) is an on-demand
+     * command instead. Future contexts (astral projection, VR hot-sim) get
+     * their own line here the same way the call line did: small explicit
+     * pieces, not a status framework built ahead of need.
+     */
+    initStatusBox(screen) {
+        const statusBox = blessed.box({
+            id: 'statusBox',
+            bottom: 3, // sits directly on the input box
+            left: '0%',
+            width: '100%',
+            height: 8, // 6 content rows inside the border: location, tracks,
+            // readiness, and up to two transient lines (sustained, call)
             border: {
                 type: 'line'
             },
-            label: ' Equipment ',
-            content: 'Your equipped items will be listed here...',
             tags: true,
-            scrollable: true,
-            scrollbar: {
-                ch: ' ',
-                track: {
-                    bg: 'yellow'
-                },
-                style: {
-                    inverse: true
-                }
-            },
-            keys: true,
-            mouse: true,
-        });
-        this._equipmentBox = equipmentBox;
-        // Append the equipment box to the screen
-        screen.append(equipmentBox);
-    }
-    initInventoryBox(screen) {
-        const inventoryBox = blessed.box({
-            top: '0%',
-            left: '75%',
-            width: '25%',
-            height: '45%',
-            border: {
-                type: 'line'
-            },
-            label: ' Inventory ',
-            content: 'Your items will be listed here...',
-            tags: true, // Enable formatting tags in content
-            scrollable: true, // Enable scrolling if the content overflows
-            scrollbar: {
-                ch: ' ',
-                track: {
-                    bg: 'yellow'
-                },
-                style: {
-                    inverse: true
-                }
-            },
-            keys: true,
-            mouse: true,
+            content: '',
         });
-        // Append the inventory box to the screen
-        screen.append(inventoryBox);
-        this._inventoryBox = inventoryBox;
+        this._statusBox = statusBox;
+        screen.append(statusBox);
     }
-    updateEquipment(playerEquipment) {
-        const sections = [];
-        const renderSlotGroup = (label, group) => {
-            if (!group) {
-                sections.push(`{bold}${label}:{/bold} None`);
-                return;
-            }
-            const equipped = Object.entries(group)
-                .filter(([_, item]) => item !== null)
-                .map(([slot, item]) => `  ${slot}: ${item.name}`);
-            if (equipped.length > 0) {
-                sections.push(`{bold}${label}:{/bold}`);
-                sections.push(...equipped);
-            }
-            else {
-                sections.push(`{bold}${label}:{/bold} None`);
-            }
-        };
-        renderSlotGroup("Head", playerEquipment.head);
-        renderSlotGroup("Torso", playerEquipment.torso);
-        renderSlotGroup("Legs", playerEquipment.legs);
-        renderSlotGroup("Feet", playerEquipment.feet);
-        renderSlotGroup("Arms", playerEquipment.arms);
-        renderSlotGroup("Gloves", playerEquipment.gloves);
-        renderSlotGroup("Left Hand", playerEquipment.leftHand);
-        renderSlotGroup("Right Hand", playerEquipment.rightHand);
-        this._equipmentBox.setContent(sections.join('\n'));
-        this._screen.render();
-    }
-    ;
-    updateExits(room) {
-        let description = `Currently in: ${room.name}\n\n`;
-        description += `----- Exits ------\n`;
-        if (room.exits.size > 0) {
-            room.exits.forEach((exit, key) => {
-                if (exit instanceof Door) {
-                    const nextRoom = exit.getOtherSideToName(room);
-                    description += `${capitalCase(key)}: ${nextRoom}`;
-                    if (exit.checkIfLocked()) {
-                        description += " (Locked)";
-                    }
-                    else if (exit.checkIfLockable()) {
-                        description += ' (Unlocked)';
-                    }
-                    description += '\n';
-                }
-                else {
-                    description += `${capitalCase(key)}\n`; // Example: "NORTH"
-                }
-            });
+    /**
+     * Refreshes the status box from current player state. Called after any
+     * command that can change what belongs there (currently "call"/"end-call")
+     * and once on load/job transition.
+     */
+    updateStatus() {
+        // updateInventory/updateEquipment route here now, and those hooks can
+        // fire from synthesis paths before the blessed UI exists.
+        if (!this._statusBox)
+            return;
+        const player = this.player;
+        const lines = [];
+        // Line 1: where you are, and the fight autopilot mode. The stance
+        // 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.
+        const stanceColor = player.autoStance === 'aggressive' ? 'red' : player.autoStance === 'guarded' ? 'yellow' : 'white';
+        const stance = `{${stanceColor}-fg}⚔ ${player.autoStance.toUpperCase()}{/${stanceColor}-fg}`;
+        if (player.currentLocation) {
+            lines.push(`{bold}📍 ${player.currentLocation.name}{/bold}  |  ${stance}`);
         }
         else {
-            description += '\nThere are no exits here.';
+            lines.push(stance);
         }
-        this._exitsBox.setContent(description);
-        this._screen.render();
-    }
-    // Function to update the inventory
-    updateInventory(playerInventory, currencyName = 'currency') {
-        const items = playerInventory.getAllItems();
-        let currencyTotal = 0;
-        const itemLines = [];
-        for (const item of items) {
-            let line = item.name;
-            if (item.isCurrencyCarrier?.() && item.currencyAmount > 0) {
-                line += ` [${item.currencyAmount}]`;
-                currencyTotal += item.currencyAmount;
-            }
-            itemLines.push(line);
+        // Line 2: both condition monitors -- in a game where a fight can kill
+        // you and casting can knock you out, current damage on either track is
+        // never something a player should have to ask for. Colors shift as
+        // each track fills; the stacked wound modifier from both tracks shows
+        // once.
+        const trackColor = (taken, max) => taken === 0 ? 'green' : taken >= max - 3 ? 'red' : 'yellow';
+        const wound = player.woundModifier;
+        const woundNote = wound < 0 ? ` {red-fg}(${wound} dice){/red-fg}` : '';
+        const physColor = trackColor(player.damageTaken, player.maxConditionBoxes);
+        const stunColor = trackColor(player.stunTaken, player.maxStunBoxes);
+        lines.push(`{${physColor}-fg}Physical ${player.conditionSummary()}{/${physColor}-fg}  ` +
+            `{${stunColor}-fg}Stun ${player.stunSummary()}{/${stunColor}-fg}${woundNote}`);
+        // Line 3: readiness -- armed state, armor, and whether the commlink is
+        // actually live (equipped), the recurring "why can't I call anyone"
+        // friction surfaced at a glance.
+        const weapon = player.getWeaponProfile();
+        const weaponItem = player.equipment.rightHand?.weapon ?? player.equipment.leftHand?.weapon;
+        const ammoNote = weaponItem?.isFirearm()
+            ? (weaponItem.jammed
+                ? ` {red-fg}[JAMMED -- reboot]{/red-fg}`
+                : weaponItem.ammo === 0 ? ` {red-fg}[DRY]{/red-fg}` : ` [${weaponItem.ammo} rds]`)
+            : '';
+        const armed = weapon.name === 'bare fists'
+            ? `{gray-fg}Unarmed{/gray-fg}`
+            : `Armed: ${weapon.name} (DV ${weapon.damage}${weapon.poolBonus > 0 ? `, +${weapon.poolBonus} dice` : ''})${ammoNote}`;
+        const armorNote = `Armor +${player.getArmorValue()}`;
+        const hasLink = player.equipment.head?.commlink != null;
+        const link = !hasLink
+            ? `{gray-fg}Link offline{/gray-fg}`
+            : player.runningSilent
+                ? `{magenta-fg}Link SILENT{/magenta-fg}`
+                : player.arOffline
+                    ? `{red-fg}AR CUT -- reboot{/red-fg}`
+                    : `{${CALL_COLOR}-fg}Link online{/${CALL_COLOR}-fg}`;
+        lines.push(`${armed}  |  ${armorNote}  |  ${link}`);
+        // Lines 4+: transient states, present only while active. Future
+        // contexts (astral projection, VR hot-sim) join here the same way.
+        if (player.sustainedArmor > 0) {
+            lines.push(`{magenta-fg}Sustained: armor +${player.sustainedArmor} soak (-2 dice to everything else){/magenta-fg}`);
+        }
+        if (player.activeCallPartner) {
+            lines.push(`{${CALL_COLOR}-fg}${CALL_ICON} On a call with ${player.activeCallPartner.name}{/${CALL_COLOR}-fg}`);
+        }
+        // Off-plane context: which reality you're in, your persona's Matrix
+        // track (cold-sim damage lands there), and where your empty body lies.
+        if (player.plane === 'matrix') {
+            // Matrix damage is hardware damage: show the DECK's track. A
+            // technomancer has no deck -- their stun track (already on line 2)
+            // is what the ice chews on.
+            const track = player.activeDeck
+                ? `  Deck ${player.activeDeck.deckSummary()}${player.simMode === 'hot' ? ' +biofeedback' : ''}`
+                : `  (living persona -- damage is REAL stun)`;
+            lines.push(`{cyan-fg}▣ MATRIX ${(player.simMode ?? 'cold').toUpperCase()}-SIM${track} -- body at ${player.bodyRoom?.name ?? '???'}{/cyan-fg}`);
+        }
+        else if (player.plane === 'astral') {
+            lines.push(`{magenta-fg}✧ ASTRAL -- ${player.astralTicks} move${player.astralTicks === 1 ? '' : 's'} out -- body at ${player.bodyRoom?.name ?? '???'}{/magenta-fg}`);
         }
-        itemLines.unshift(`{bold}Total ${currencyName}:{/bold} ${currencyTotal}\n`);
-        this._inventoryBox.setContent(itemLines.join('\n'));
+        this._statusBox.setContent(lines.join('\n'));
         this._screen.render();
     }
-    ;
+    // The three methods below were the render paths for the old always-on
+    // sidebar boxes. Those boxes are gone (the log owns the whole screen; see
+    // commands/inv.ts, equipment.ts, map.ts for the on-demand replacements),
+    // but the methods stay as no-ops: dozens of call sites across commands,
+    // scene proxies, and ui.ts still ping them after inventory/equipment/exit
+    // changes, and keeping the hooks alive means a future HUD element can tap
+    // those same signals without re-plumbing. Each refreshes the HUD, since
+    // several HUD fields (armed, armor, link) derive from equipment state.
+    updateEquipment(_playerEquipment) {
+        this.updateStatus();
+    }
+    updateExits(_room) {
+        // Nothing to render -- the "map" command reads live room state.
+    }
+    updateInventory(_playerInventory, _currencyName = 'currency') {
+        this.updateStatus();
+    }
     // Public method to get the instance of the Game class
     static async getInstance(player, sceneSeed) {
         if (!Game.instance) {
@@ -341,12 +565,24 @@ export default class Game {
         const parts = input.trim().split(' ');
         const verb = parts[0].toLowerCase();
         const args = parts.slice(1);
-        if (verb === 'quit') {
+        if (verb === 'quit' || verb === 'exit') {
             return null;
         }
         if (verb === 'maka') {
             return 'You are still in the game, type "quit" to exit';
         }
+        if (verb === 'continue') {
+            // Instant feedback for "not ready yet" (job not done, no AI
+            // configured); otherwise kicks off drafting in the background rather
+            // than freezing this command (and everything after it) behind a
+            // 20-40+ second generation call -- same as calling the fixer does.
+            const gate = this.canDraftNextScene();
+            if (!gate.allowed) {
+                return gate.message ?? `This job isn't finished yet.`;
+            }
+            this.draftNextSceneInBackground();
+            return `Understood -- drafting the next job now. Feel free to keep exploring in the meantime.`;
+        }
         if (verb === 'help') {
             return this.getHelpMessage();
         }
@@ -357,6 +593,8 @@ export default class Game {
             actor: this.player,
             rooms: this.scene.getRooms(),
             scene: this.scene,
+            screen: this._screen,
+            game: this,
         };
         const command = CommandFactory.createCommand(verb, context);
         if (command) {
@@ -375,6 +613,7 @@ export default class Game {
             }
         }
         helpText += `- clear: Clear the screen.\n`;
+        helpText += `- continue: Take on a new, tougher job once you've completed the current one.\n`;
         helpText += `- quit: Exit the game.\n`;
         return helpText;
     }