@maka/maka-cli 5.3.17 → 5.5.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,166 @@ 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 { fuzzyPickName, levenshteinDistance } from './utilities/fuzzy-match.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 { BrandishCommand, HolsterCommand } from './commands/brandish.js';
+import { AdvanceCommand } from './commands/advance.js';
+import { equipIntoEmptySlots } from './archetypes.js';
+import { NPC } from './models/npc.js';
+import { HaggleCommand } from './commands/haggle.js';
+import { SneakCommand } from './commands/sneak.js';
+import { PersuadeCommand } from './commands/persuade.js';
+import { BluffCommand } from './commands/bluff.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;
+    // The HUB scene, when this session started in one (a seed with
+    // "hub": true -- the persistent home base, e.g. Tacoma Purple Haze).
+    // Kept as the live Scene INSTANCE, same pattern as _homeRoom, so
+    // everything in it -- NPC state, shop stock, dropped loot -- persists
+    // untouched while runs play out, and returnToHub() just re-points the
+    // world at it. undefined for classic sessions (test scene, launch-
+    // generated runs), which keep the old continue->draft loop.
+    _hubScene;
+    _hubName = 'home';
+    get hasHub() {
+        return this._hubScene !== undefined;
+    }
+    /** The persistent hideout room -- go.ts's walk-home trigger checks it. */
+    get homeRoom() {
+        return this._homeRoom;
+    }
+    // A drafted run waiting for the player to take it (hub sessions only):
+    // generation finishing sends a MESSAGE instead of teleporting anyone --
+    // "call Mr. Johnson" hears the offer, "travel" goes.
+    _pendingRunSeed;
+    _pendingRunTier;
+    get pendingRun() {
+        return this._pendingRunSeed;
+    }
+    get pendingRunTier() {
+        return this._pendingRunTier;
+    }
+    /**
+     * The cab that answers "call taxi" varies per job (player request: not
+     * always a van) -- picked once when the pending run lands, so the
+     * arrival and the ride read as ONE vehicle.
+     */
+    static RIDE_POOL = [
+        {
+            arrive: `A matte-black step-van splashes to the curb in front of you, side door already sliding open.`,
+            board: `The door rattles shut and the Haze smears past the grimy windows.`,
+        },
+        {
+            arrive: `A pearl-gray Westwind glides up out of the rain, gullwing lifting -- somebody's billing this to the client.`,
+            board: `The gullwing sighs closed and the launch pins you into leather that costs more than your rent.`,
+        },
+        {
+            arrive: `A patchwork gypsy cab rattles around the corner and stops dead in front of you, meter torn out, driver watching the mirrors.`,
+            board: `The cabbie pulls off before the door's even latched, humming something older than the district.`,
+        },
+        {
+            arrive: `A rust-eaten GMC Bulldog bulls through traffic and mounts the curb beside you, panel doors ajar.`,
+            board: `The Bulldog coughs, catches, and shoves into traffic like it's owed something.`,
+        },
+        {
+            arrive: `An unmarked ambulance rolls up silent, lights dead, back doors swinging open -- nobody looks twice at it.`,
+            board: `You ride out flat on the gurney, ceiling lights strobing past the little windows.`,
+        },
+        {
+            arrive: `A growling Harley with a reinforced sidecar pulls a U-turn and stops at your boots, rider jerking a thumb at the car.`,
+            board: `You drop into the sidecar; the pipes drown the whole district out.`,
+        },
+    ];
+    _pendingRide;
+    /** The pending job's cab flavor -- "call taxi" narrates with it (see call.ts). */
+    get pendingRide() {
+        return this._pendingRide;
+    }
+    /**
+     * Generates NPC first-impression appearances ("look at <npc>") in the
+     * background, one at a time -- the only AI dressing still worth doing
+     * now that every scene arrives with real prose. Fire-and-forget: until
+     * an appearance lands, look-at just shows a bit less flavor.
+     */
+    warmNpcAppearancesInBackground() {
+        if (!this._useAi)
+            return;
+        const npcs = this.scene.allActors.filter((a) => a instanceof NPC);
+        const context = `${this.sceneSeed?.name ?? ''} -- ${this.scene.story}`;
+        void (async () => {
+            for (const npc of npcs) {
+                try {
+                    await npc.ensureAIAppearance(context);
+                }
+                catch {
+                    // Non-fatal: the next look-at simply has less flavor.
+                }
+            }
+        })();
+    }
+    // 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 +203,81 @@ 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);
+        CommandFactory.registerCommand('brandish', BrandishCommand);
+        CommandFactory.registerCommand('draw', BrandishCommand);
+        CommandFactory.registerCommand('holster', HolsterCommand);
+        CommandFactory.registerCommand('stow', HolsterCommand);
+        // "end" and "hangup" both bounced in real sessions when players
+        // wanted to end a call -- the intent is unambiguous mid-call.
+        CommandFactory.registerCommand('end', EndCallCommand);
+        CommandFactory.registerCommand('hangup', EndCallCommand);
+        CommandFactory.registerCommand('advance', AdvanceCommand);
+        CommandFactory.registerCommand('train', AdvanceCommand);
+        CommandFactory.registerCommand('haggle', HaggleCommand);
+        CommandFactory.registerCommand('negotiate', HaggleCommand);
+        CommandFactory.registerCommand('sneak', SneakCommand);
+        CommandFactory.registerCommand('persuade', PersuadeCommand);
+        CommandFactory.registerCommand('convince', PersuadeCommand);
+        CommandFactory.registerCommand('bluff', BluffCommand);
     }
     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,43 +285,288 @@ 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);
-        // Create a loading box
-        const loadingBox = blessed.box({
-            parent: screen,
-            top: 'center',
-            left: 'center',
-            width: '50%',
-            height: 'shrink',
-            content: 'Generating Scene... Please wait.',
-            border: { type: 'line' },
-            style: {
-                fg: 'white',
-                bg: 'black',
-                border: { fg: 'cyan' },
-            }
-        });
-        screen.append(loadingBox);
-        screen.render();
+        this.initStatusBox(screen);
+        // No "Generating Scene... Please wait." box anymore: every path now
+        // arrives with REAL prose (hand-authored static seeds, chunk-authored
+        // generated scenes), so the old blocking AI-redressing pass -- 30-60
+        // seconds rewriting text that was already good -- is skipped and the
+        // game opens instantly. The one thing still worth generating (NPC
+        // first-impression appearances for "look at") warms in the background
+        // below.
         try {
-            this.scene = await SceneSynthesizer.synthesizeFromJson(this.sceneSeed, this.player, options.useAi);
+            this.scene = await SceneSynthesizer.synthesizeFromJson(this.sceneSeed, this.player, false);
         }
         catch (err) {
             throw new Error(`Scene generation failed: ${err.message}`);
         }
-        // Remove loading box
-        screen.remove(loadingBox);
-        screen.render();
         this.scene.initialize(this);
         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);
+        // Every session starts AT HOME -- the hideout, one door from the job's
+        // start room (player request, left as an in-game note: "I'd like to
+        // always start in my hideout"). The scene's isStartRoom still anchors
+        // where the hideout's door leads; the runner just wakes up on their
+        // own cot instead of already standing in the job.
+        this.player.currentLocation = this._homeRoom;
+        // Starting in a hub makes this a hub SESSION: runs are commissioned
+        // by calling the fixer from here, and completing one returns here.
+        if (this.scene.isHub) {
+            this._hubScene = this.scene;
+            this._hubName = this.sceneSeed?.name ?? 'home';
+        }
+        // Gear up automatically: wearables (and the commlink) slot into any
+        // EMPTY slots at load -- no "equip all" ritual to start a session
+        // (player request). Occupied slots (archetype signature gear) are
+        // never swapped out.
+        equipIntoEmptySlots(this.player);
+        this.warmNpcAppearancesInBackground();
         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: `Still lining it up -- I'll ping you.` };
+        }
+        if (this._pendingRunSeed) {
+            return { allowed: false, message: `You've got my message already. Call a taxi when you're ready to roll.` };
+        }
+        // A hub is ALWAYS ready to commission the next run -- it has no win
+        // condition to complete; that's the whole point of home.
+        if (!this.scene.isHub && !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() {
+        // Hub sessions: a finished RUN doesn't chain into the next draft --
+        // "continue" takes you home instead, and the next run is commissioned
+        // from there (call the fixer). Classic sessions skip this and keep
+        // the old continue->draft loop.
+        if (this._hubScene && this.scene !== this._hubScene && this.scene.isCompleted()) {
+            return this.returnToHub();
+        }
+        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;
+        }
+    }
+    /**
+     * Re-points the world at the preserved hub scene after a run: the hub's
+     * whole state (NPCs, shop stock, anything dropped there) survived
+     * untouched because the INSTANCE survived. The player walks back in
+     * through their own hideout, firmly in the meat -- any lingering run
+     * state (a persona still jacked in, an astral projection, a sneak,
+     * open combat bookkeeping) is settled on the way home.
+     */
+    returnToHub() {
+        const hub = this._hubScene;
+        if (!hub)
+            return `There's no home to go back to.`;
+        // Settle cross-plane and combat state that must not leak into the hub
+        // (the run's rooms -- including a bodyRoom the player left behind --
+        // are about to be orphaned wholesale).
+        this.player.plane = 'meat';
+        this.player.bodyRoom = undefined;
+        this.player.simMode = undefined;
+        this.player.astralTicks = 0;
+        this.player.activeDeck = undefined;
+        this.player.astralPerceiving = false;
+        this.player.sneaking = false;
+        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());
+        this.player.currentLocation = this._homeRoom;
+        this.player.cameFrom = undefined;
+        this.updateEquipment(this.player.equipment);
+        this.updateInventory(this.player.inventory, capitalCase(this.scene.getCurrencyType()));
+        this.updateExits(this.player.currentLocation);
+        this.updateStatus();
+        Logger.getInstance().write(`Returned to hub "${this._hubName}".`);
+        return `\n=== ${this._hubName.toUpperCase()} ===\nThe run's wrapped and the street swallows you back up. You're home -- your hideout, one door off ${hub.determineStartRoom().name}. Call ${FIXER_NAME} when you're hungry for the next job.`;
+    }
+    /**
+     * 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.
+        // No system "drafting..." line -- the fixer's own one-ring commission
+        // (call.ts) already told the player he'll call back; anything more
+        // reads as machinery (real playtest note). The wait resolves as HIS
+        // callback either way, success or failure.
+        //
+        // The player object rides along so the job is drafted FOR this runner
+        // -- their archetype, stats, and toolkit (see buildPlayerDossier).
+        const nextSeed = await SceneSeedGenerator.generate(this._logFilePath, nextTier, previousFixerName, this.player);
+        if (!nextSeed) {
+            return `Incoming call -- ${FIXER_NAME}: "Job fell through, chummer. Client got cold feet before the ink dried. Give me another call in a bit -- I'll shake something loose."`;
+        }
+        // HUB sessions: the draft lands as a MESSAGE, never a teleport (real
+        // playtest note: being yanked into the run the instant generation
+        // finished was jarring). The player invokes it on their own time:
+        // "call Mr. Johnson" delivers the offer (haggle window included --
+        // see call.ts), and "travel" actually goes (launchPendingRun).
+        if (this.hasHub) {
+            this._pendingRunSeed = nextSeed;
+            this._pendingRunTier = nextTier;
+            this._pendingRide = Game.RIDE_POOL[Math.floor(Math.random() * Game.RIDE_POOL.length)];
+            return `Your link pings -- 1 new message: ${FIXER_NAME}. ("call ${FIXER_NAME}" to hear the job.)`;
+        }
+        // Classic sessions transition immediately, hideout-first, as always.
+        return await this.activateRunScene(nextSeed, nextTier, { startInHideout: true });
+    }
+    /**
+     * Installs a drafted run as the live scene. Shared by the classic
+     * immediate path (hideout start) and the hub's "travel" (start-room
+     * start -- you rode there, you arrive AT the job).
+     */
+    async activateRunScene(seed, tier, opts) {
+        this._tier = tier;
+        this.sceneSeed = seed;
+        // 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.activeCallPartner = undefined;
+            this.player.activeCallPartner = undefined;
+        }
+        // false, false: no starter kit (the player carries their own gear
+        // forward), and no blocking AI-redressing pass either -- the chunked
+        // rooms pass already wrote this scene's prose.
+        this.scene = await SceneSynthesizer.synthesizeFromJson(seed, this.player, false, 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.
+        this.scene.addRoom(this._homeRoom);
+        this.connectHomeRoom(this.player.currentLocation);
+        if (opts.startInHideout) {
+            this.player.currentLocation = this._homeRoom;
+        }
+        this.updateEquipment(this.player.equipment);
+        this.updateInventory(this.player.inventory, capitalCase(this.scene.getCurrencyType()));
+        this.updateExits(this.player.currentLocation);
+        this.updateStatus();
+        // Fresh streets, no trail yet (see Player.cameFrom / the HUD crumb).
+        this.player.cameFrom = undefined;
+        this.warmNpcAppearancesInBackground();
+        return `\n=== JOB #${this._tier}: ${seed.name} ===\n${this.scene.story}`;
+    }
+    /**
+     * "travel": takes the arranged transport to the pending job (see
+     * commands/travel.ts). The player arrives AT the run's start room --
+     * "You travel to <location>" -- not teleported onto their own cot.
+     * A haggle struck during the offer call already mutated the pending
+     * seed's payout, and stays spent across the transition (refreshEdge
+     * would otherwise re-arm it).
+     */
+    async launchPendingRun() {
+        const seed = this._pendingRunSeed;
+        const tier = this._pendingRunTier;
+        if (!seed || tier === undefined) {
+            return `There's no job waiting. "call ${FIXER_NAME}" to drum one up.`;
+        }
+        const haggledAtOffer = this.player.haggledThisJob;
+        try {
+            const banner = await this.activateRunScene(seed, tier, { startInHideout: false });
+            this._pendingRunSeed = undefined;
+            this._pendingRunTier = undefined;
+            this._pendingRide = undefined;
+            this.player.haggledThisJob = haggledAtOffer;
+            return `You travel to ${this.player.currentLocation.name}.\n${banner}`;
+        }
+        catch (err) {
+            this._pendingRunSeed = undefined;
+            this._pendingRunTier = undefined;
+            this._pendingRide = undefined;
+            Logger.getInstance().error(`launchPendingRun failed: ${err}`);
+            return `The ride never shows and the job address goes dead. ${FIXER_NAME} will not enjoy hearing this -- call him for another.`;
+        }
     }
     async close() {
         this._inputBox.removeAllListeners(); // removes all event listeners
@@ -113,42 +577,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 +596,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 +620,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 +646,156 @@ 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,
+            content: '',
         });
-        this._equipmentBox = equipmentBox;
-        // Append the equipment box to the screen
-        screen.append(equipmentBox);
+        this._statusBox = statusBox;
+        screen.append(statusBox);
     }
-    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,
-        });
-        // Append the inventory box to the screen
-        screen.append(inventoryBox);
-        this._inventoryBox = inventoryBox;
-    }
-    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}`;
+        // The breadcrumb, reading chronologically into the current location:
+        // "Neon Strip (west) > Night Market" -- origin first, the direction
+        // BACK to it in parens. An 18-room hub made "which way did I come in"
+        // a real question.
+        const crumb = player.cameFrom ? `${player.cameFrom.room} (${player.cameFrom.back}) > ` : '';
+        if (player.currentLocation) {
+            lines.push(`${crumb}{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.getCarriedWeapon();
+        const ammoNote = weaponItem?.isFirearm()
+            ? (weaponItem.jammed
+                ? ` {red-fg}[JAMMED -- reboot]{/red-fg}`
+                : weaponItem.ammo === 0 ? ` {red-fg}[DRY]{/red-fg}` : ` [${weaponItem.ammo} rds]`)
+            : '';
+        // Three armed states on the meat plane: drawn, holstered (weapon
+        // carried but riding leather -- "brandish" puts it in hand; combat
+        // auto-draws so this is posture, not readiness), or nothing at all.
+        // Off-plane the profile is attack programs / astral will and reads as
+        // Armed. White, not gray, for the same legibility reason as the stance.
+        const armed = player.plane === 'meat' && weaponItem && !player.weaponDrawn
+            ? `{white-fg}Holstered: ${weaponItem.name}${ammoNote} -- "brandish"{/white-fg}`
+            : 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.astralPerceiving) {
+            lines.push(`{magenta-fg}✧ ASTRAL SENSES OPEN (-2 dice sustained) -- "assense" to close{/magenta-fg}`);
+        }
+        if (player.sneaking) {
+            lines.push(`{white-fg}🐾 SNEAKING -- entries are opposed vs their perception; loud acts break it{/white-fg}`);
+        }
+        if (player.activeCallPartner) {
+            lines.push(`{${CALL_COLOR}-fg}${CALL_ICON} On a call with ${player.activeCallPartner.name}{/${CALL_COLOR}-fg}`);
         }
-        itemLines.unshift(`{bold}Total ${currencyName}:{/bold} ${currencyTotal}\n`);
-        this._inventoryBox.setContent(itemLines.join('\n'));
+        // 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}`);
+        }
+        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) {
@@ -338,17 +804,26 @@ export default class Game {
         return Game.instance;
     }
     async handleInput(input) {
-        const parts = input.trim().split(' ');
+        // "jack-in"/"jack-out" read naturally but parse as unknown verbs (a
+        // real session typed "jack-in" and bounced) -- normalize the hyphen.
+        const normalized = input.replace(/^\s*jack-(in|out)\b/i, 'jack $1');
+        const parts = normalized.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') {
+            // RETIRED verb, kept only as a redirect: jobs flow through the
+            // fixer ("call Mr. Johnson"), and a finished run ends by walking
+            // home to your hideout -- no system command in the loop.
+            return `That's not how the street works anymore, chummer: "call ${FIXER_NAME}" when you want work. When a run's wrapped, head home to your hideout -- the door knows the way.`;
+        }
         if (verb === 'help') {
-            return this.getHelpMessage();
+            return this.getHelpMessage(args);
         }
         if (verb === 'clear') {
             return '';
@@ -357,26 +832,111 @@ 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) {
             const result = await command.execute(args);
             return result;
         }
+        // Typo tolerance: two straight sessions bounced on slips like "searh"
+        // and "maop". Reuse the same fuzzy matcher item/NPC names go through
+        // (ambiguous guesses deliberately miss). A unique match auto-runs with
+        // a note -- EXCEPT anything that ends the session, which only ever
+        // gets a suggestion: a typo must never quit the game.
+        const knownVerbs = [...Object.keys(CommandFactory.getAllRegisteredCommands()), 'help', 'clear', 'quit', 'exit'];
+        let guess = fuzzyPickName(verb, knownVerbs);
+        // The shared matcher refuses typo tolerance on words <= 3 chars (too
+        // risky for item/NPC names) -- but the verb list is small and
+        // distinct, so a unique edit-distance-1 hit is safe ("maop" -> "map").
+        if (!guess && verb.length >= 3) {
+            const close = knownVerbs.filter(v => levenshteinDistance(verb, v) <= 1);
+            if (close.length === 1)
+                guess = close[0];
+        }
+        if (guess && guess !== verb) {
+            if (guess === 'quit' || guess === 'exit') {
+                return `I don't understand "${verb}" -- did you mean "${guess}"?`;
+            }
+            const corrected = await this.handleInput([guess, ...args].join(' '));
+            return corrected === null ? null : `(read "${verb}" as "${guess}")\n${corrected ?? ''}`;
+        }
         return `I don't understand the command "${verb}".`;
     }
-    getHelpMessage() {
-        const commands = CommandFactory.getAllRegisteredCommands();
-        let helpText = "Available Commands:\n";
-        for (const verb in commands) {
-            if (Object.hasOwn(commands, verb)) {
-                const CommandClass = commands[verb];
-                helpText += `- ${verb}: ${CommandClass.getDescription()}\n`;
+    /**
+     * The help taxonomy: every entry is [primary, ...aliases], grouped the
+     * way a player thinks, not the order commands were registered. The
+     * overview shows only verbs per category (the flat all-descriptions
+     * dump had grown past 45 lines); "help <category>" and "help <command>"
+     * drill into the real descriptions. Verbs registered but missing from
+     * this table surface in an "other" bucket rather than vanishing -- a
+     * future command can't silently fall out of help.
+     */
+    static HELP_CATEGORIES = [
+        { title: 'moving', entries: [['look'], ['go'], ['map', 'exits'], ['search'], ['sneak']] },
+        { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['drop'], ['give'], ['store'], ['equip'], ['unequip'], ['brandish', 'draw'], ['holster', 'stow'], ['reload'], ['use'], ['read']] },
+        { title: 'combat', entries: [['attack', 'kill'], ['subdue'], ['stance'], ['surrender'], ['edge'], ['rest']] },
+        { title: 'magic', entries: [['spells'], ['cast'], ['project'], ['return'], ['assense']] },
+        { title: 'matrix', entries: [['jack'], ['hack'], ['pan'], ['silent'], ['reboot'], ['drone']] },
+        { title: 'social', entries: [['say'], ['talk-to'], ['call'], ['end-call', 'end', 'hangup'], ['haggle', 'negotiate'], ['persuade', 'convince']] },
+        { title: 'barriers', entries: [['solve'], ['pick'], ['bluff'], ['unlock'], ['lock']] },
+        { title: 'character', entries: [['sheet', 'stats'], ['advance', 'train']] },
+        { title: 'session', entries: [['help'], ['clear'], ['quit', 'exit']] },
+    ];
+    /** Descriptions for the verbs handled inline in handleInput() rather than registered. */
+    static BUILTIN_DESCRIPTIONS = {
+        help: 'This overview. "help <category>" for one group with full descriptions; "help <command>" for one command.',
+        clear: 'Clear the screen.',
+        quit: 'Exit the game.',
+    };
+    describeVerb(verb) {
+        const builtin = Game.BUILTIN_DESCRIPTIONS[verb];
+        if (builtin)
+            return builtin;
+        const CommandClass = CommandFactory.getAllRegisteredCommands()[verb];
+        return CommandClass?.getDescription() ?? 'No description available.';
+    }
+    getHelpMessage(args = []) {
+        const registered = Object.keys(CommandFactory.getAllRegisteredCommands());
+        const covered = new Set(Game.HELP_CATEGORIES.flatMap(c => c.entries.flat()));
+        const uncategorized = registered.filter(v => !covered.has(v));
+        const query = args.join(' ').trim().toLowerCase();
+        // "help <category>": that group, with full descriptions.
+        if (query) {
+            const categoryNames = Game.HELP_CATEGORIES.map(c => c.title);
+            const pickedCategory = fuzzyPickName(query, categoryNames);
+            if (pickedCategory) {
+                const category = Game.HELP_CATEGORIES.find(c => c.title === pickedCategory);
+                const lines = [`=== ${category.title.toUpperCase()} ===`];
+                for (const [primary, ...aliases] of category.entries) {
+                    lines.push(`- ${primary}${aliases.length > 0 ? ` (${aliases.join(', ')})` : ''}: ${this.describeVerb(primary)}`);
+                }
+                return lines.join('\n');
             }
+            // "help <command>": one description, aliases resolved to their primary.
+            const allVerbs = [...covered, ...uncategorized];
+            const pickedVerb = fuzzyPickName(query, allVerbs);
+            if (pickedVerb) {
+                const entry = Game.HELP_CATEGORIES.flatMap(c => c.entries).find(e => e.includes(pickedVerb));
+                const primary = entry?.[0] ?? pickedVerb;
+                const aliases = entry?.slice(1) ?? [];
+                return `${primary}${aliases.length > 0 ? ` (${aliases.join(', ')})` : ''}: ${this.describeVerb(primary)}`;
+            }
+            return `No command or category called "${query}". Try plain "help".`;
+        }
+        // The overview: compact category lines, primaries only.
+        const lines = ['=== COMMANDS ==='];
+        const pad = Math.max(...Game.HELP_CATEGORIES.map(c => c.title.length));
+        for (const category of Game.HELP_CATEGORIES) {
+            lines.push(`${category.title.padEnd(pad)}  ${category.entries.map(e => e[0]).join(', ')}`);
+        }
+        if (uncategorized.length > 0) {
+            lines.push(`${'other'.padEnd(pad)}  ${uncategorized.join(', ')}`);
         }
-        helpText += `- clear: Clear the screen.\n`;
-        helpText += `- quit: Exit the game.\n`;
-        return helpText;
+        lines.push('');
+        lines.push(`"help <category>" for a group with descriptions ("help combat"); "help <command>" for one ("help haggle").`);
+        return lines.join('\n');
     }
 }
 //# sourceMappingURL=game.js.map