@maka/maka-cli 5.7.0 → 5.9.0

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

@@ -3,6 +3,7 @@ import { capitalCase } from 'change-case';
 import { Category } from './types/shared/item-enum.js';
 import { Item } from './models/item.js';
 import { Room } from './models/_index.js';
+import { Door } from './models/door.js';
 import { isFence, LIFESTYLE_TIERS } from './utilities/commerce.js';
 import { rollPool, formatRoll } from './utilities/dice.js';
 import { Direction } from './types/shared/direction-enum.js';
@@ -33,6 +34,7 @@ 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 { GrappleCommand, ReleaseCommand, StruggleCommand } from './commands/grapple.js';
 import { EdgeCommand } from './commands/edge.js';
 import { SheetCommand } from './commands/sheet.js';
 import { CallCommand } from './commands/call.js';
@@ -56,6 +58,12 @@ import { AskCommand } from './commands/ask.js';
 import { ContactsCommand } from './commands/contacts.js';
 import { JumpCommand } from './commands/jump.js';
 import { InitiateCommand } from './commands/initiate.js';
+import { SummonCommand } from './commands/summon.js';
+import { OrderCommand } from './commands/order.js';
+import { DeployCommand, AgentCommand, RecallCommand } from './commands/companions.js';
+import { MoveCommand, RunCommand, SprintCommand } from './commands/move.js';
+import { HintsCommand } from './commands/hints.js';
+import { hint } from './utilities/hints.js';
 import { InstallCommand } from './commands/install.js';
 import { BuyCommand } from './commands/buy.js';
 import { SellCommand } from './commands/sell.js';
@@ -67,6 +75,7 @@ import { EatCommand } from './commands/eat.js';
 import { DrinkCommand } from './commands/drink.js';
 import { equipIntoEmptySlots } from './archetypes.js';
 import { NPC } from './models/npc.js';
+import { CommandRegistry } from './commands/command-registry.js';
 import { HaggleCommand } from './commands/haggle.js';
 import { SneakCommand } from './commands/sneak.js';
 import { PersuadeCommand } from './commands/persuade.js';
@@ -76,6 +85,9 @@ 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';
+import { AI } from '../../../tools/ai/ai.class.js';
+import { BULLET } from './utilities/log-style.js';
+import { spotOf } from './utilities/spots.js';
 export default class Game {
     initialized;
     static instance;
@@ -91,6 +103,11 @@ export default class Game {
     // give the log the whole screen.
     _screen;
     _logBox;
+    _metaBox;
+    // Quit confirmation state (see handleInput / initInputBox): armed by
+    // the first quit/exit or ESC, cleared by anything that isn't a yes.
+    _quitArmed = false;
+    _escArmedAt = 0;
     _statusBox;
     _inputBox;
     _useAi = false;
@@ -164,6 +181,227 @@ export default class Game {
         }
         Logger.getInstance().write(`Home turf: ${this.contacts.size} contacts seeded from the hub cast.`);
     }
+    // ==================== COMPANIONS: the party layer ====================
+    // Every companion is a per-scene NPC SHELL plus persistent STATE, and
+    // scene transitions are covered by narration, never instance rebinding
+    // (design decision with the player): spirits fade (RAW p.300: the
+    // summons doesn't outlast the ride), drones fold to the pack, agents
+    // into the deck -- damage lives on the bound Item and redeploys free.
+    // Tenants: summoned spirits (summon.ts), matrix agents (agent-cmd.ts),
+    // autonomous drones (deploy in drone-deploy.ts). Future tenants
+    // (enlisted allies, anthroform frames) ride the same rail with
+    // different words ("takes their own ride and meets you there").
+    // Roster invariant: entries are LIVE SHELLS only -- dismissal and
+    // death both remove the entry; persistent state (the frame, the deck)
+    // lives on Items in the player's possession, never here.
+    companions = [];
+    // Drones deployed at travel time re-shell on arrival ("the rotors spin
+    // back up at the curb") -- tracked as their items across the swap.
+    _pendingRedeploys = [];
+    /**
+     * The one correct runtime NPC spawn (mirrors scene-factory's seed
+     * path): construct with a scene-bound registry, add to the scene
+     * (names must be unique -- addActor throws), place via
+     * setCharacterLocation (the ONLY path that binds room observers), and
+     * hand it the scene for its AI context.
+     */
+    spawnCompanionShell(opts) {
+        if (this.scene.getActor(opts.name)) {
+            Logger.getInstance().write(`spawnCompanionShell: name "${opts.name}" already in scene -- refusing.`);
+            return null;
+        }
+        const npc = new NPC({
+            dialog: [],
+            description: opts.description,
+            playerConstructorConfig: { playerName: opts.name, startLocation: opts.room, combat: opts.combat },
+        }, new CommandRegistry(this.scene));
+        npc.plane = opts.plane;
+        npc.allyOf = this.player.name;
+        npc.companionKind = opts.kind;
+        npc.boundDevice = opts.boundDevice;
+        this.scene.addActor(npc);
+        this.scene.setCharacterLocation(npc, opts.room.name);
+        npc.scene = this.scene;
+        this.companions.push({ npc, kind: opts.kind, services: opts.services, force: opts.force, boundDevice: opts.boundDevice });
+        Logger.getInstance().write(`Companion spawned: ${opts.name} (${opts.kind}, force ${opts.force}) in ${opts.room.name}.`);
+        return npc;
+    }
+    /**
+     * The autonomous-drone shell, shared by the deploy command and
+     * arrival re-shelling: the frame's dog-brain (Pilot = 2 + quality)
+     * stands in for every attribute it lacks (RAW p.269-271).
+     */
+    // Cargo sling by frame class (player request: capacity enforced -- a
+    // palm-sized Fly-Spy is not a mule). Keyed by the frame Item's size.
+    static DRONE_CARGO_KG = {
+        tiny: 0.5, small: 2, medium: 8, large: 20, huge: 40,
+    };
+    deployDroneShell(item, room) {
+        const pilot = 2 + item.qualityBonus;
+        const armed = /armed|combat|gun|roto|assault|sentry|weapon/i.test(`${item.name} ${item.description ?? ''}`);
+        const shell = this.spawnCompanionShell({
+            name: `${item.name} (autopilot)`,
+            description: `${this.player.name}'s drone running its dog-brain autopilot: it follows them, watches, and ${armed ? 'shoots what threatens them' : 'has cameras where guns would go -- it never attacks'}.`,
+            kind: 'drone',
+            combat: { body: 2 + item.qualityBonus, agility: pilot, reaction: pilot, logic: pilot, intuition: pilot, willpower: pilot, strength: 1, charisma: 1, skills: { perception: pilot, ...(armed ? { firearms: pilot } : {}) } },
+            room, plane: 'meat', force: pilot, boundDevice: item,
+        });
+        // Take-command weight checks (Player.addInventory) enforce this cap
+        // for the shell exactly as they do for a runner.
+        if (shell)
+            shell.maxCarryingWeight = Game.DRONE_CARGO_KG[String(item.size)] ?? 2;
+        return shell;
+    }
+    /** Drops a companion's shell and its roster entry. */
+    dismissCompanion(entry, reason) {
+        if (this.scene.getActor(entry.npc.name) === entry.npc) {
+            // Cargo comes home with the shell (player request: fetch-and-carry
+            // runs -- a real session's drone took a credstick and had no way
+            // to hand it over). A deliberate dismissal passes whatever the
+            // shell carried to its master; without this, scene.removeActor
+            // dumps it on the floor wherever the shell happened to be.
+            const carried = entry.npc.inventory.getAllItems().map(i => i.name);
+            const delivered = carried.filter(n => entry.npc.inventory.transferItemTo(n, this.player.inventory));
+            if (delivered.length > 0) {
+                Logger.getInstance().logWithColor(`👥 From ${entry.npc.name}'s cargo, now yours: ${delivered.join(', ')}.`, 'green');
+            }
+            // Mark deliberate before removeActor fires onActorRemoved, so no
+            // wreckage is charged to a clean dismissal.
+            entry.npc.deathClaimed = true;
+            this.scene.removeActor(entry.npc.name);
+        }
+        const idx = this.companions.indexOf(entry);
+        if (idx >= 0)
+            this.companions.splice(idx, 1);
+        Logger.getInstance().write(`Companion dismissed: ${entry.npc.name} -- ${reason}`);
+    }
+    /**
+     * An actor left the world (Scene.removeActor). For a companion shell
+     * that DIED (not a deliberate dismissal -- those set deathClaimed
+     * first and prune themselves), settle the wreckage: a drone's frame is
+     * wrecked where it fell, an agent derezzes (the deck already ate the
+     * damage), a spirit is banished outright.
+     */
+    onActorRemoved(name) {
+        const entry = this.companions.find(c => c.npc.name === name);
+        if (!entry)
+            return;
+        const idx = this.companions.indexOf(entry);
+        if (idx >= 0)
+            this.companions.splice(idx, 1);
+        if (entry.kind === 'drone' && entry.boundDevice && !entry.npc.deathClaimed) {
+            entry.boundDevice.takeDroneDamage(entry.boundDevice.maxDroneBoxes);
+            Logger.getInstance().logWithColor(`👥 The ${entry.boundDevice.name} is WRECKED where it fell -- rest to repair the frame.`, 'yellow');
+        }
+        this.updateStatus();
+    }
+    /**
+     * Spirits with no services left depart once no exchange holds them
+     * (called from CombatExchange.finishExchange): the bargain is spent.
+     */
+    settleSpiritServices() {
+        for (const entry of [...this.companions]) {
+            if (entry.kind !== 'spirit' || (entry.services ?? 0) > 0)
+                continue;
+            if (entry.npc.inExchange)
+                continue;
+            // The paid fight is fought to the END. Between exchanges of the
+            // same fight inExchange is briefly false -- a real session's
+            // spirit spent its last service to join a fight and was dismissed
+            // 3ms later, before a single blow. Same freshness window as the
+            // per-fight billing in combat-exchange.
+            if (entry.npc.combatOpponent && Date.now() - entry.npc.lastExchangeAt < 60_000)
+                continue;
+            Logger.getInstance().logWithColor(`👥 ${entry.npc.name}'s bargain is spent -- it bows once and thins into nothing.`, 'green');
+            this.dismissCompanion(entry, 'services exhausted');
+            this.updateStatus();
+        }
+    }
+    // ==================== Pursuit heartbeat ====================
+    // Companions are stimulus-driven like every NPC: a directive burst ends
+    // at the reflect cap ("Max recursion reached") and a shell alone in a
+    // distant room then NEVER acts again -- a real session's drone was
+    // ordered to "find Mr. Krow", walked three rooms, and froze mid-hunt.
+    // The heartbeat re-spurs every shell with an open objective on a slow
+    // tick until it reports DONE/FAILED (which clears the objective -- see
+    // NPC.relayToMaster) or is dismissed.
+    _pursuitTimer;
+    _pursuitInFlight = new Set();
+    static PURSUIT_TICK_MS = 30_000;
+    startPursuitHeartbeat() {
+        if (this._pursuitTimer)
+            return;
+        this._pursuitTimer = setInterval(() => this.spurCompanionPursuits(), Game.PURSUIT_TICK_MS);
+        // Never hold the process open on our account.
+        this._pursuitTimer.unref?.();
+    }
+    stopPursuitHeartbeat() {
+        if (this._pursuitTimer)
+            clearInterval(this._pursuitTimer);
+        this._pursuitTimer = undefined;
+    }
+    spurCompanionPursuits() {
+        // The tick doubles as the spent-bargain sweep: finishExchange's own
+        // settle call now skips spirits whose fight is still warm (see
+        // settleSpiritServices), so without this a victorious spirit would
+        // linger at zero services forever.
+        this.settleSpiritServices();
+        if (!AI.isConfigured())
+            return;
+        for (const entry of this.companions) {
+            const npc = entry.npc;
+            if (!npc.objective)
+                continue;
+            if (npc.isIncapacitated() || npc.inExchange || npc.waitingForLull)
+                continue;
+            // A stale shell (already removed from the world) gets no spur.
+            if (this.scene.getActor(npc.name) !== npc)
+                continue;
+            // One spur in flight per shell -- a slow AI burst must not stack
+            // with the next tick.
+            if (this._pursuitInFlight.has(npc))
+                continue;
+            this._pursuitInFlight.add(npc);
+            Logger.getInstance().write(`Pursuit heartbeat: spurring ${npc.name} -- ${npc.objective}`);
+            void Promise.resolve(npc.hear(this.player, `[System note: HEARTBEAT -- your standing directive is still open: "${npc.objective}". Continue it NOW with [COMMAND] actions -- several steps if needed. If it is complete, say a line starting "DONE: <result>"; if it cannot be done, say a line starting "FAILED: <why>". Do not go quiet.]`, { viaLink: true }))
+                .catch(err => Logger.getInstance().error(`Pursuit heartbeat failed for ${npc.name}: ${err}`))
+                .finally(() => this._pursuitInFlight.delete(npc));
+        }
+    }
+    /** Pre-travel: every shell folds, each with its own goodbye. */
+    foldCompanionsForTravel() {
+        const lines = [];
+        for (const entry of [...this.companions]) {
+            if (entry.kind === 'spirit') {
+                lines.push(`Your bound spirit thins into the rain -- the summons doesn't outlast the ride.`);
+            }
+            else if (entry.kind === 'drone') {
+                lines.push(`The ${entry.boundDevice?.name ?? 'drone'} autopilots home to your hand for the ride.`);
+                if (entry.boundDevice)
+                    this._pendingRedeploys.push(entry.boundDevice);
+            }
+            else if (entry.kind === 'agent') {
+                lines.push(`Your agent folds back into the deck.`);
+            }
+            else {
+                lines.push(`${entry.npc.name} takes their own ride -- they'll meet you there.`);
+            }
+            this.dismissCompanion(entry, `travel: ${entry.kind} folds`);
+        }
+        return lines;
+    }
+    /** Post-arrival: re-shell what was deployed when you left (drones). */
+    unfoldCompanionsOnArrival() {
+        const lines = [];
+        for (const item of this._pendingRedeploys.splice(0)) {
+            if (item.isWrecked)
+                continue;
+            const shell = this.deployDroneShell(item, this.player.currentLocation);
+            if (shell)
+                lines.push(`The ${item.name}'s rotors spin back up at the curb.`);
+        }
+        return lines;
+    }
     /**
      * Records a real transaction with a hub NPC: first contact opens the
      * relationship at Loyalty 1 (a safeguard -- the hub cast is pre-seeded
@@ -186,7 +424,7 @@ export default class Game {
             if (kind === 'gig')
                 c.gigs += 1;
             Logger.getInstance().write(`Contact opened: ${name} (connection ${c.connection}).`);
-            return `${name} knows your name now -- a CONTACT (Connection ${c.connection}, Loyalty 1). ("contacts" for the roster, "ask ${name} about ..." for legwork.)`;
+            return `${name} knows your name now -- a CONTACT (Connection ${c.connection}, Loyalty 1).${hint(` ("contacts" for the roster, "ask ${name} about ..." for legwork.)`)}`;
         }
         if (kind === 'gig') {
             c.gigs += 1;
@@ -200,7 +438,7 @@ export default class Game {
         c.spent += spent;
         if (Math.floor(c.spent / 1000) > thousandsBefore && c.loyalty < 3) {
             c.loyalty += 1;
-            return `${name} has started keeping your usual ready. (Loyalty ${c.loyalty} -- patronage tops out at 3; run their errands to go deeper.)`;
+            return `${name} has started keeping your usual ready.${hint(` (Loyalty ${c.loyalty} -- patronage tops out at 3; run their errands to go deeper.)`)}`;
         }
         return null;
     }
@@ -482,6 +720,12 @@ export default class Game {
         CommandFactory.registerCommand('rest', RestCommand);
         CommandFactory.registerCommand('reload', ReloadCommand);
         CommandFactory.registerCommand('subdue', SubdueCommand);
+        // SUBDUING p.195 (see commands/grapple.ts): restrain without damage.
+        CommandFactory.registerCommand('grapple', GrappleCommand);
+        CommandFactory.registerCommand('restrain', GrappleCommand);
+        CommandFactory.registerCommand('clinch', GrappleCommand);
+        CommandFactory.registerCommand('release', ReleaseCommand);
+        CommandFactory.registerCommand('struggle', StruggleCommand);
         CommandFactory.registerCommand('edge', EdgeCommand);
         CommandFactory.registerCommand('sheet', SheetCommand);
         CommandFactory.registerCommand('stats', SheetCommand);
@@ -517,6 +761,21 @@ export default class Game {
         CommandFactory.registerCommand('rig', JumpCommand);
         CommandFactory.registerCommand('initiate', InitiateCommand);
         CommandFactory.registerCommand('submerge', InitiateCommand);
+        CommandFactory.registerCommand('summon', SummonCommand);
+        CommandFactory.registerCommand('conjure', SummonCommand);
+        // "At" spots (utilities/spots.ts): walk/move/approach are one
+        // crossing; run and sprint are the fast modes (combat semantics in
+        // the spot-move phase).
+        CommandFactory.registerCommand('walk', MoveCommand);
+        CommandFactory.registerCommand('move', MoveCommand);
+        CommandFactory.registerCommand('approach', MoveCommand);
+        CommandFactory.registerCommand('run', RunCommand);
+        CommandFactory.registerCommand('sprint', SprintCommand);
+        CommandFactory.registerCommand('hints', HintsCommand);
+        CommandFactory.registerCommand('order', OrderCommand);
+        CommandFactory.registerCommand('deploy', DeployCommand);
+        CommandFactory.registerCommand('recall', RecallCommand);
+        CommandFactory.registerCommand('agent', AgentCommand);
         CommandFactory.registerCommand('install', InstallCommand);
         CommandFactory.registerCommand('chrome', InstallCommand);
         CommandFactory.registerCommand('buy', BuyCommand);
@@ -550,6 +809,19 @@ export default class Game {
         if (this._homeRoomExitDirection) {
             this._homeRoom.exits.delete(this._homeRoomExitDirection);
         }
+        // The OTHER half of the previous link: sweep any exit on the anchor
+        // room that already leads home before choosing a direction. Without
+        // this, every homecoming re-ran the search against a room still
+        // holding last time's hideout door and stacked a second one on the
+        // next free direction (a real session's Neon Strip ended up with
+        // "up" AND "down" both reading "To Your Hideout").
+        for (const [dir, ex] of [...jobStartRoom.exits.entries()]) {
+            const leadsHome = ex instanceof Door
+                ? ex.getOtherSide(jobStartRoom) === this._homeRoom
+                : ex === this._homeRoom.name;
+            if (leadsHome)
+                jobStartRoom.exits.delete(dir);
+        }
         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 --
@@ -568,6 +840,9 @@ export default class Game {
     get logBox() {
         return this._logBox;
     }
+    get metaBox() {
+        return this._metaBox;
+    }
     get inputBox() {
         return this._inputBox;
     }
@@ -576,6 +851,7 @@ export default class Game {
         this._logFilePath = options.logFilePath;
         this.initInputBox(screen);
         this.initLogBox(screen);
+        this.initMetaBox(screen);
         this.initStatusBox(screen);
         // No "Generating Scene... Please wait." box anymore: every path now
         // arrives with REAL prose (hand-authored static seeds, chunk-authored
@@ -626,6 +902,15 @@ export default class Game {
             this.player.lifestyleEdgeBonus = this.lifestyle.edgeBonus;
             // Home turf knows its own (see seedHomeTurfContacts).
             this.seedHomeTurfContacts();
+            // The next run starts cooking the moment you're home (player
+            // request): generation takes 20-40s, and waiting for the player
+            // to CALL first meant "give me a bit" every time. Draft now --
+            // Mr. Johnson's "1 new message" ping lands mid-session, and the
+            // call finds work already waiting. The gate keeps this a no-op
+            // with AI off or a draft/pending seed somehow already in flight.
+            if (this.canDraftNextScene().allowed) {
+                this.draftNextSceneInBackground();
+            }
         }
         // Gear up automatically: wearables (and the commlink) slot into any
         // EMPTY slots at load -- no "equip all" ritual to start a session
@@ -633,6 +918,10 @@ export default class Game {
         // never swapped out.
         equipIntoEmptySlots(this.player);
         this.warmNpcAppearancesInBackground();
+        this.startPursuitHeartbeat();
+        // The banner learns where we are only after the hub/scene bookkeeping
+        // above settles.
+        this.refreshLogLabel();
         this.initialized = true;
         // Nudge the player toward "call" up front -- the fixer convention means
         // the story deliberately doesn't narrate a completed briefing, so
@@ -640,7 +929,7 @@ export default class Game {
         // 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.`
+            ? hint(`\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}`;
     }
@@ -731,6 +1020,8 @@ export default class Game {
         // Read the run's fate BEFORE the scene swap below discards it -- a
         // walked-away job gets a different homecoming line than a wrapped one.
         const wrappedRun = this.scene !== hub && this.scene.isCompleted();
+        // Companions fold for the ride home, same as the trip out.
+        const companionFoldLines = this.foldCompanionsForTravel();
         // 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).
@@ -774,10 +1065,10 @@ export default class Game {
                 this.lifestyleTier = LIFESTYLE_TIERS[tierIndex - 1].name;
                 // The downgrade is visible the moment you look around.
                 this.syncHomeToLifestyle();
-                rentLine = `The landlord's drone pings before the door even shuts: ${paid > 0 ? `${paid} paid, ` : ''}${this.rentDebt} nuyen still owed. Your ${tier.name} arrangement lapses -- you're living ${this.lifestyleTier} now. ("pay" the tab, "lifestyle" to climb back.)`;
+                rentLine = `The landlord's drone pings before the door even shuts: ${paid > 0 ? `${paid} paid, ` : ''}${this.rentDebt} nuyen still owed. Your ${tier.name} arrangement lapses -- you're living ${this.lifestyleTier} now.${hint(` ("pay" the tab, "lifestyle" to climb back.)`)}`;
             }
             else {
-                rentLine = `Even the doorway costs something: ${this.rentDebt} nuyen on the tab. ("pay" when you're flush.)`;
+                rentLine = `Even the doorway costs something: ${this.rentDebt} nuyen on the tab.${hint(` ("pay" when you're flush.)`)}`;
             }
         }
         else {
@@ -800,11 +1091,15 @@ export default class Game {
         this.updateInventory(this.player.inventory, capitalCase(this.scene.getCurrencyType()));
         this.updateExits(this.player.currentLocation);
         this.updateStatus();
+        this.refreshLogLabel();
         Logger.getInstance().write(`Returned to hub "${this._hubName}". Lifestyle ${this.lifestyleTier}: ${paid} paid, ${this.rentDebt} owed. Restocked ${restocked}. Rumor: ${this.activeRumor ?? '(none)'}`);
+        // Drones spin back up beside the cot.
+        const companionArrivalLines = this.unfoldCompanionsOnArrival();
+        const companionBlock = [...companionFoldLines, ...companionArrivalLines];
         const fateLine = wrappedRun
             ? `The run's wrapped and the street swallows you back up.`
             : `The run's behind you -- unfinished, unpaid, already someone else's problem. The street doesn't ask.`;
-        return `\n=== ${this._hubName.toUpperCase()} ===\n${fateLine} You're home -- your hideout, one door off ${hub.determineStartRoom().name}. Call ${FIXER_NAME} when you're hungry for the next job.\n${rentLine}${comfortLine}${restockLine}`;
+        return `\n=== ${this._hubName.toUpperCase()} ===\n${fateLine} You're home -- your hideout, one door off ${hub.determineStartRoom().name}.${hint(` Call ${FIXER_NAME} when you're hungry for the next job.`)}\n${rentLine}${comfortLine}${restockLine}${companionBlock.length > 0 ? `\n${companionBlock.join('\n')}` : ''}`;
     }
     /**
      * The actual drafting work, split out from continueToNextScene() purely
@@ -849,7 +1144,7 @@ export default class Game {
             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.)`;
+            return `Your link pings -- 1 new message: ${FIXER_NAME}.${hint(` ("call ${FIXER_NAME}" to hear the job.)`)}`;
         }
         // Classic sessions transition immediately, hideout-first, as always.
         return await this.activateRunScene(nextSeed, nextTier, { startInHideout: true });
@@ -868,6 +1163,9 @@ export default class Game {
             this.player.activeCallPartner.activeCallPartner = undefined;
             this.player.activeCallPartner = undefined;
         }
+        // Companions fold for the ride (spirits depart, drones to the pack,
+        // agents into the deck) -- their lines join the JOB banner below.
+        const companionLines = this.foldCompanionsForTravel();
         // 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.
@@ -896,8 +1194,15 @@ export default class Game {
         this.updateStatus();
         // Fresh streets, no trail yet (see Player.cameFrom / the HUD crumb).
         this.player.cameFrom = undefined;
+        // Deployed drones spin back up at the curb -- BEFORE appearance
+        // warming so re-shelled companions get warmed with the cast.
+        const arrivalLines = this.unfoldCompanionsOnArrival();
         this.warmNpcAppearancesInBackground();
-        return `\n=== JOB #${this._tier}: ${seed.name} ===\n${this.scene.story}${needsLines.length > 0 ? `\n${needsLines.join('\n')}` : ''}`;
+        this.refreshLogLabel();
+        // No "=== JOB #n ===" banner on entry (player request) -- the Game
+        // Log window's own title carries the job name now.
+        const companionBlock = [...companionLines, ...arrivalLines];
+        return `\n${this.scene.story}${needsLines.length > 0 ? `\n${needsLines.join('\n')}` : ''}${companionBlock.length > 0 ? `\n${companionBlock.join('\n')}` : ''}`;
     }
     /**
      * The needs check at every job departure (SR5e p.56 / p.172, scaled to
@@ -920,11 +1225,15 @@ export default class Game {
         p.sleepStreak = slept ? 0 : p.sleepStreak + 1;
         p.refreshEdge(fed && slept);
         if (fed && slept) {
-            lines.push(`Fed and slept -- you head out SHARP. (Edge ${p.edgeRemaining}/${p.edge + p.lifestyleEdgeBonus}.)`);
+            // Good-news status with a rules lesson inside -- hint-gated
+            // (player request); the HUD's edge count carries the number anyway.
+            const note = hint(`Fed and slept -- you head out SHARP. (Edge ${p.edgeRemaining}/${p.edge + p.lifestyleEdgeBonus}.)`);
+            if (note)
+                lines.push(note);
         }
         else {
             const missing = !fed && !slept ? 'meal and no sleep' : !fed ? 'meal' : 'sleep';
-            lines.push(`No ${missing} since the last job -- your edge doesn't come back (${p.edgeRemaining} left). A hot meal and a night in your own bed reset it.`);
+            lines.push(`No ${missing} since the last job -- your edge doesn't come back (${p.edgeRemaining} left).${hint(` A hot meal and a night in your own bed reset it.`)}`);
         }
         // Escalating, resisted, LOCKED fatigue per ignored need.
         const events = [];
@@ -991,6 +1300,7 @@ export default class Game {
         }
     }
     async close() {
+        this.stopPursuitHeartbeat();
         this._inputBox.removeAllListeners(); // removes all event listeners
         this._inputBox.cancel(); // cancels any active input session
         this._inputBox.detach(); // optionally remove from screen
@@ -1021,8 +1331,18 @@ export default class Game {
         });
         this._inputBox = inputBox;
         screen.append(inputBox);
-        // Key bindings
-        screen.key(['escape', 'C-c'], () => process.exit(0));
+        // Key bindings. ESC/Ctrl-C take a SECOND press within 3s to quit
+        // (player request: "I just exited by mistake") -- the first press
+        // warns; typing anything disarms nothing (the window just expires).
+        screen.key(['escape', 'C-c'], () => {
+            const now = Date.now();
+            if (now - this._escArmedAt < 3000) {
+                process.exit(0);
+            }
+            this._escArmedAt = now;
+            Logger.getInstance().logWithColor(`Press again within 3s to quit. (Or "quit" + "y".)`, 'yellow');
+            this._screen?.render();
+        });
         // 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
@@ -1047,13 +1367,17 @@ export default class Game {
             id: 'logBox',
             top: '0%',
             left: '0%',
-            width: '100%',
+            // COLUMNS, not rows (playtest note: a 3-row Mechanics strip made
+            // combat rolls "near impossible to read" -- they scrolled out as
+            // fast as they landed). The world log takes the left ~two-thirds;
+            // the Mechanics column stands full-height beside it.
+            width: '65%',
             // Fixed-row footer: 8 rows of HUD (status box) + 3 rows of input.
             height: '100%-11',
             border: {
                 type: 'line'
             },
-            label: ' Game Log ',
+            label: this.buildLogLabel(false),
             scrollable: true, // Enable scrolling
             alwaysScroll: true,
             scrollbar: {
@@ -1073,8 +1397,113 @@ export default class Game {
             tags: true // Intercept tags
         });
         this._logBox = logBox;
+        // Scrolling without focus (player report: "can't scroll the game log
+        // anymore"): focus lives in the input box on every path, so the
+        // box's own keys never fire, and the wheel died with mouse tracking.
+        // SCREEN-level PgUp/PgDn scroll the log while you keep typing; while
+        // you're up in history, followBottom stops every new line from
+        // yanking the view back down (Logger.log and ui.ts honor it).
+        // Paging back to the bottom -- or End -- re-engages the follow.
+        logBox.followBottom = true;
+        // CRITICAL: the input box is ALWAYS reading (focus never leaves it),
+        // and blessed's textarea.readInput sets screen.grabKeys = true --
+        // which mutes every screen-level key handler EXCEPT keys listed in
+        // screen.ignoreLocked (screen.js:591). Without this, the bindings
+        // below simply never fire (a real session: "PgUp/Dn don't work").
+        // The textbox itself ignores these keys, so nothing is stolen.
+        screen.ignoreLocked.push('pageup', 'pagedown', 'end');
+        const page = () => Math.max(1, (typeof logBox.height === 'number' ? logBox.height : 20) - 3);
+        const setFollow = (on) => {
+            logBox.followBottom = on;
+            logBox.setLabel(this.buildLogLabel(!on));
+        };
+        const atBottom = () => logBox.getScrollPerc() >= 100 || logBox.getScrollHeight() <= page() + 3;
+        screen.key(['pageup'], () => {
+            logBox.scroll(-page());
+            setFollow(false);
+            screen.render();
+        });
+        screen.key(['pagedown'], () => {
+            logBox.scroll(page());
+            if (atBottom())
+                setFollow(true);
+            screen.render();
+        });
+        screen.key(['end'], () => {
+            logBox.scrollTo(logBox.getScrollHeight());
+            setFollow(true);
+            screen.render();
+        });
         screen.append(logBox);
     }
+    /**
+     * The Game Log banner names WHERE you are in the campaign (player
+     * request): the hub by name at home, "JOB #n: <name>" on a run --
+     * plus the scroll state the label already carried.
+     */
+    buildLogLabel(scrolled) {
+        const onHub = this._hubScene !== undefined && this.scene === this._hubScene;
+        const name = onHub ? this._hubName : this.sceneSeed?.name;
+        const where = name ? ` -- ${name}` : '';
+        // The key coaching is hint-gated (player request); the SCROLLED
+        // state itself stays -- it's status, not teaching.
+        return scrolled
+            ? ` Game Log${where} -- SCROLLED${hint(' (End to follow)')} `
+            : ` Game Log${where}${hint(' (PgUp/PgDn to scroll)')} `;
+    }
+    /** Re-stamps the banner after a scene change (init, run start, home). */
+    refreshLogLabel() {
+        const box = this._logBox;
+        if (!box)
+            return;
+        box.setLabel(this.buildLogLabel(box.followBottom === false));
+        this._screen?.render();
+    }
+    /**
+     * Scroll the log to its tail -- unless the player has paged up to read
+     * history (followBottom off), in which case their place is left alone.
+     * Every "new line arrived" site goes through here.
+     */
+    followLog() {
+        const box = this._logBox;
+        if (!box || box.followBottom === false)
+            return;
+        box.scrollTo(box.getScrollHeight());
+    }
+    /**
+     * The MECHANICS column (readability pass, player request: the log was
+     * a "wall of text"): dice anatomy and resource arithmetic land here
+     * (via Logger.meta) instead of the world log, so the narrative stays
+     * prose. A full-height COLUMN beside the world log, not a bottom
+     * strip -- the first playtest's 3-row ticker scrolled combat rolls
+     * away faster than they could be read. De-emphasis is the BLUE border
+     * -- gray is banned (ANSI bright-black, illegible on stock dark
+     * palettes). Follow-only (no keys); the full interleaved record lives
+     * in session.log. Roll lines wrap at the column width -- fine in a
+     * tall column. NO mouse (see initInputBox): never arm mouse tracking.
+     */
+    initMetaBox(screen) {
+        const metaBox = blessed.box({
+            id: 'metaBox',
+            top: '0%',
+            left: '65%',
+            width: '35%',
+            // Same height as the world log: HUD (8) + input (3) below both.
+            height: '100%-11',
+            border: {
+                type: 'line'
+            },
+            style: {
+                border: { fg: 'blue' }
+            },
+            label: ' Mechanics ',
+            scrollable: true,
+            alwaysScroll: true,
+            tags: true,
+        });
+        this._metaBox = metaBox;
+        screen.append(metaBox);
+    }
     /**
      * The HUD: a fixed strip between the log and the input box for the
      * important real-time state -- condition tracks, armed/link status,
@@ -1130,7 +1559,10 @@ export default class Game {
         // 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}`);
+            // "At" spots: where you stand WITHIN the room, when it has places
+            // to stand (see utilities/spots.ts).
+            const atNote = spotOf(player) ? ` @ ${player.atSpot}` : '';
+            lines.push(`${crumb}{bold}📍 ${player.currentLocation.name}${atNote}{/bold}  |  ${stance}`);
         }
         else {
             lines.push(stance);
@@ -1191,6 +1623,30 @@ export default class Game {
         if (player.activeCallPartner) {
             lines.push(`{${CALL_COLOR}-fg}${CALL_ICON} On a call with ${player.activeCallPartner.name}{/${CALL_COLOR}-fg}`);
         }
+        // The party: one line per live companion shell, with the tracks that
+        // matter for its kind. A spirit shows its BODY too (it's a full
+        // Force-statted combatant and hits land on it -- player request:
+        // the track was real but invisible); drones show hull, agents deck.
+        for (const c of this.companions) {
+            const track = c.kind === 'spirit'
+                ? `${c.services ?? 0} service${(c.services ?? 0) === 1 ? '' : 's'}  ${c.npc.conditionSummary()}${c.npc.stunTaken > 0 ? `  stun ${c.npc.stunSummary()}` : ''}`
+                : c.kind === 'drone' && c.boundDevice ? `hull ${c.boundDevice.droneSummary()}`
+                    : c.kind === 'agent' && c.boundDevice ? `deck ${c.boundDevice.deckSummary()}`
+                        : c.npc.conditionSummary();
+            // Each kind speaks its own language (a real rigger session read a
+            // generic "(F3)" as spell Force on a Fly-Spy): drones fly on a
+            // PILOT rating, agents run at a RATING, and a spirit's Force is
+            // already in its name.
+            const grade = c.kind === 'drone' ? `Pilot ${c.force} -- ` : c.kind === 'agent' ? `Rating ${c.force} -- ` : '';
+            lines.push(`{green-fg}👥 ${c.npc.name} -- ${grade}${track}{/green-fg}`);
+        }
+        // DECK-AR INDICATOR (player request): "Link online" is the
+        // COMMLINK's AR overlay; this is the DECK's -- lit when an agent
+        // works the grid while you're back in the meat (the AR-drop exit).
+        const remoteAgent = this.companions.find(c => c.kind === 'agent');
+        if (remoteAgent && player.plane !== 'matrix') {
+            lines.push(`{cyan-fg}▣ DECK IN AR -- ${remoteAgent.npc.name} on the grid${remoteAgent.npc.objective ? ', working its directive' : ''}${hint(' ("jack in" to rejoin it, "recall" to fold it home)')}{/cyan-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') {
@@ -1248,8 +1704,25 @@ export default class Game {
         const parts = normalized.trim().split(' ');
         const verb = parts[0].toLowerCase();
         const args = parts.slice(1);
-        if (verb === 'quit' || verb === 'exit') {
-            return null;
+        // Quitting takes a CONFIRM (player request: "I just exited by
+        // mistake"): the first "quit" arms it, "y"/"yes" (or quit again)
+        // seals it, anything else disarms and runs as the command it is.
+        if (this._quitArmed) {
+            this._quitArmed = false;
+            if (/^(y|yes|quit|exit)$/i.test(verb)) {
+                return null;
+            }
+            // fall through -- the answer was a real command; play on.
+        }
+        else if (verb === 'quit' || verb === 'exit') {
+            this._quitArmed = true;
+            return `Really quit? ("y" to confirm -- anything else keeps playing.)`;
+        }
+        // Out cold with the fight settling around you (see
+        // Scene.beginPlayerKnockout): unconsciousness is not a prompt. Only
+        // quit (handled above) still answers.
+        if (this.player.isUnconscious() && this.scene.playerKnockout) {
+            return `You're out cold -- the world moves without you.`;
         }
         if (verb === 'maka') {
             return 'You are still in the game, type "quit" to exit';
@@ -1298,6 +1771,11 @@ export default class Game {
                 return `I don't understand "${verb}" -- did you mean "${guess}"?`;
             }
             const corrected = await this.handleInput([guess, ...args].join(' '));
+            // The correction note stays INLINE and always-on (player ruling:
+            // it briefly moved to the Mechanics ticker, and a conversational
+            // "well I'm here..." silently became a SELL with nothing in the
+            // world log explaining the refusal that came back). It's not dice
+            // noise -- it's the only receipt for a command you didn't type.
             return corrected === null ? null : `(read "${verb}" as "${guess}")\n${corrected ?? ''}`;
         }
         return `I don't understand the command "${verb}".`;
@@ -1312,16 +1790,16 @@ export default class Game {
      * future command can't silently fall out of help.
      */
     static HELP_CATEGORIES = [
-        { title: 'moving', entries: [['look'], ['go'], ['map', 'exits'], ['search'], ['sneak']] },
+        { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach', 'run', 'sprint'], ['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'], ['jump', 'rig']] },
+        { title: 'combat', entries: [['attack', 'kill'], ['subdue'], ['order'], ['stance'], ['surrender'], ['edge'], ['rest']] },
+        { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project'], ['return'], ['assense']] },
+        { title: 'matrix', entries: [['jack'], ['hack'], ['pan'], ['silent'], ['reboot'], ['agent'], ['drone'], ['deploy'], ['recall'], ['jump', 'rig']] },
         { title: 'social', entries: [['say'], ['talk-to'], ['call'], ['end-call', 'end', 'hangup'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
         { title: 'street', entries: [['browse', 'buy'], ['sell'], ['work', 'gig'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['pay']] },
         { title: 'barriers', entries: [['solve'], ['pick'], ['bluff'], ['unlock'], ['lock']] },
         { title: 'character', entries: [['sheet', 'stats'], ['advance', 'train'], ['qualities', 'quality'], ['initiate', 'submerge'], ['install', 'chrome']] },
-        { title: 'session', entries: [['help'], ['clear'], ['quit', 'exit']] },
+        { title: 'session', entries: [['help'], ['hints'], ['clear'], ['quit', 'exit']] },
     ];
     /** Descriptions for the verbs handled inline in handleInput() rather than registered. */
     static BUILTIN_DESCRIPTIONS = {
@@ -1349,7 +1827,7 @@ export default class Game {
                 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)}`);
+                    lines.push(`${BULLET}${primary}${aliases.length > 0 ? ` (${aliases.join(', ')})` : ''}: ${this.describeVerb(primary)}`);
                 }
                 return lines.join('\n');
             }