@maka/maka-cli 5.5.0 → 5.7.0

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

@@ -1,6 +1,10 @@
 import blessed from 'blessed';
 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 { isFence, LIFESTYLE_TIERS } from './utilities/commerce.js';
+import { rollPool, formatRoll } from './utilities/dice.js';
 import { Direction } from './types/shared/direction-enum.js';
 import { Logger } from './utilities/logger.js';
 import { LookCommand } from './commands/look.js';
@@ -47,6 +51,20 @@ 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 { QualityTradeCommand } from './commands/quality-trade.js';
+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 { InstallCommand } from './commands/install.js';
+import { BuyCommand } from './commands/buy.js';
+import { SellCommand } from './commands/sell.js';
+import { PayCommand } from './commands/pay.js';
+import { LifestyleCommand } from './commands/lifestyle.js';
+import { TreatCommand } from './commands/treat.js';
+import { WorkCommand } from './commands/work.js';
+import { EatCommand } from './commands/eat.js';
+import { DrinkCommand } from './commands/drink.js';
 import { equipIntoEmptySlots } from './archetypes.js';
 import { NPC } from './models/npc.js';
 import { HaggleCommand } from './commands/haggle.js';
@@ -99,6 +117,255 @@ export default class Game {
     get hasHub() {
         return this._hubScene !== undefined;
     }
+    /** The active job's name (seed name) -- notoriety incidents cite it. */
+    get currentJobName() {
+        return this.sceneSeed?.name;
+    }
+    // ==================== CONTACTS (SR5e p.386-389) ====================
+    // Earned, never bought: a hub NPC becomes a contact through a real
+    // transaction (a sale, a bowl served, stitches, a fenced score), and
+    // the relationship deepens through gigs (to Loyalty 6) or patronage
+    // (money alone caps at Loyalty 3 -- cred buys familiarity, not
+    // friendship). CONNECTION is the contact's reach (role heuristic,
+    // same duck-typing school as commerce.isFence); LOYALTY is yours to
+    // grow. "ask" (commands/ask.ts) is what the roster is FOR: legwork
+    // against the real pending-run seed. One pull per contact per
+    // homecoming (asked resets in returnToHub).
+    contacts = new Map();
+    /** How much juice the name carries, read off the role. */
+    static connectionFor(npc) {
+        const hay = `${npc.description ?? ''} ${npc.name}`.toLowerCase();
+        if (npc.name === FIXER_NAME || /fixer|johnson/.test(hay))
+            return 5;
+        if (/fence|pawn|launder|smuggl|no questions/.test(hay))
+            return 4;
+        if (/talismonger|street doc|clinic|surgeon|decker|information/.test(hay))
+            return 3;
+        if (/bartender|barkeep|vendor|noodle|shop|stall|merchant|dealer|market/.test(hay))
+            return 2;
+        return 1;
+    }
+    /**
+     * HOME TURF: the hub is where the runner LIVES -- everyone in the
+     * district already knows them (player request: "all NPCs there should
+     * already know them"). Called at hub capture: the whole meat-plane
+     * cast opens at Loyalty 1 ("knows your name"), so legwork works from
+     * day one and only run-scene faces are ever strangers. Depth is still
+     * earned -- trade, gigs, patronage -- exactly as before. Ice and
+     * spirits don't do noodles: non-meat actors stay off the roster.
+     */
+    seedHomeTurfContacts() {
+        for (const actor of this._hubScene?.allActors ?? []) {
+            if (actor === this.player || actor.plane !== 'meat')
+                continue;
+            if (this.contacts.has(actor.name))
+                continue;
+            this.contacts.set(actor.name, { connection: Game.connectionFor(actor), loyalty: 1, spent: 0, gigs: 0, asked: false });
+        }
+        Logger.getInstance().write(`Home turf: ${this.contacts.size} contacts seeded from the hub cast.`);
+    }
+    /**
+     * Records a real transaction with a hub NPC: first contact opens the
+     * relationship at Loyalty 1 (a safeguard -- the hub cast is pre-seeded
+     * by seedHomeTurfContacts); gigs raise it a point each (cap 6);
+     * cumulative spend raises it at each full 1,000 nuyen (cap 3).
+     * Returns a player-facing line when something changed, else null.
+     */
+    touchContact(name, kind, spent = 0) {
+        if (!this.hasHub)
+            return null;
+        const npc = this._hubScene?.allActors?.find(a => a.name === name && a !== this.player);
+        if (!npc)
+            return null;
+        let c = this.contacts.get(name);
+        if (!c) {
+            c = { connection: Game.connectionFor(npc), loyalty: 1, spent: 0, gigs: 0, asked: false };
+            this.contacts.set(name, c);
+            if (kind === 'trade')
+                c.spent += spent;
+            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.)`;
+        }
+        if (kind === 'gig') {
+            c.gigs += 1;
+            if (c.loyalty < 6) {
+                c.loyalty += 1;
+                return `${name} remembers who made that hand-off happen. (Loyalty ${c.loyalty}.)`;
+            }
+            return null;
+        }
+        const thousandsBefore = Math.floor(c.spent / 1000);
+        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 null;
+    }
+    // ==================== Downtime economy (hub life) ====================
+    // A fence's standing quote (see commands/sell.ts / haggle.ts): one at a
+    // time, replaced by any new quote, dead the moment the fence isn't at
+    // the counter. Lives here because sell and haggle are separate commands
+    // negotiating the same number.
+    pendingSale;
+    // LIFESTYLE (SR5e p.369, monthly costs scaled to per-job-cycle): the
+    // hideout has a tier, upkeep is charged on every homecoming
+    // (returnToHub), and the tier buys real mechanics -- rest quality at
+    // home (rest.ts) and, higher up, a bonus edge every job. Can't cover
+    // the upkeep? You slide DOWN a tier and the shortfall becomes debt --
+    // and while the tab stands, rest at the hideout recovers half (rest.ts;
+    // "pay" squares it, pay.ts; "lifestyle" views and moves tiers).
+    lifestyleTier = 'Squatter';
+    rentDebt = 0;
+    /** The active lifestyle tier's row (falls back to Squatter). */
+    get lifestyle() {
+        return LIFESTYLE_TIERS.find(t => t.name === this.lifestyleTier) ?? LIFESTYLE_TIERS[1];
+    }
+    /**
+     * Makes the hideout LOOK like what the rent buys: the room's description
+     * follows the active tier (player request -- an upgraded lifestyle read
+     * as the same windowless squat). Called wherever the tier moves: the
+     * lifestyle command, and the shortfall slide in returnToHub.
+     */
+    syncHomeToLifestyle() {
+        if (this._homeRoom)
+            this._homeRoom.description = this.lifestyle.homeDescription;
+    }
+    // RESTOCK (see returnToHub): consumable shop stock -- food, drink,
+    // ammo, patches -- snapshotted at hub capture and restored to any shelf
+    // found empty on each homecoming. Durable one-offs are deliberately NOT
+    // in the category set: the pawnshop's lockpicks, once sold, stay sold.
+    static RESTOCK_CATEGORIES = new Set([
+        Category.Food, Category.Drink, Category.Ammunition, Category.StimPatch, Category.Medical, Category.SlapPatch,
+    ]);
+    _restockSnapshot = [];
+    /** Captures every restockable shelf item's blueprint (hub capture time). */
+    snapshotVendorStock() {
+        this._restockSnapshot = [];
+        for (const room of Object.values(this.scene.getRooms())) {
+            for (const item of room.inventory.getAllItems()) {
+                if (!item.owner || !Game.RESTOCK_CATEGORIES.has(item.category))
+                    continue;
+                this._restockSnapshot.push({
+                    room: room.name,
+                    owner: item.owner,
+                    config: {
+                        name: item.name, description: item.description, size: item.size,
+                        category: item.category, shape: item.shape, color: item.color,
+                        texture: item.texture, rating: item.rating, weight: item.weight,
+                        details: item.details, price: item.price,
+                    },
+                });
+            }
+        }
+    }
+    /** Refills empty shelves from the snapshot; returns how many came back. */
+    restockVendorShelves() {
+        let restocked = 0;
+        const rooms = this.scene.getRooms();
+        for (const entry of this._restockSnapshot) {
+            const room = Object.values(rooms).find(r => r.name === entry.room);
+            if (!room || room.inventory.hasItem(entry.config.name))
+                continue;
+            const fresh = new Item(entry.config);
+            fresh.owner = entry.owner;
+            room.inventory.addItem(fresh);
+            restocked += 1;
+        }
+        return restocked;
+    }
+    /** The fence moves merchandise: anything sold to a fence is sold ON. */
+    fenceSellsOn() {
+        for (const actor of this.scene.allActors) {
+            if (actor === this.player || !isFence(actor, actor.currentLocation))
+                continue;
+            for (const item of [...actor.inventory.getAllItems()]) {
+                if (item.transferable && item.category !== Category.Commlink) {
+                    actor.inventory.removeItem(item.name);
+                }
+            }
+        }
+    }
+    // SIDE GIGS (see commands/work.ts / give.ts): one small favor on offer
+    // at a time, rotating each homecoming like the rumor. Take it with
+    // "work" in front of the giver; deliver the package with "give"; the
+    // pay lands on delivery.
+    gigAvailable;
+    activeGig;
+    _gigPool = [];
+    _gigIndex = 0;
+    /** Rotates the gig on offer (skipped while one is already in hand). */
+    advanceGig() {
+        if (this._gigPool.length === 0 || this.activeGig)
+            return;
+        this.gigAvailable = this._gigPool[this._gigIndex % this._gigPool.length];
+        this._gigIndex += 1;
+    }
+    /**
+     * WORK FROM A RELATIONSHIP (see commands/ask.ts): a contact puts THEIR
+     * errand on the table. Their seeded gigs get first claim -- spliced
+     * out of the rotating pool, so work handed to you personally never
+     * reappears on the ambient board -- and when the pool holds nothing of
+     * theirs, the relationship synthesizes one: a sealed parcel to another
+     * hub local, priced off Connection (their reach IS the stakes) with a
+     * Loyalty kicker. Loyalty 5+ pays the family rate (+25%). The offer
+     * lands as gigAvailable: the existing "work" pickup and "give"
+     * delivery handle the rest unchanged.
+     */
+    offerGigFrom(contactName) {
+        const contact = this.contacts.get(contactName);
+        if (!contact || !this.hasHub || this.activeGig)
+            return null;
+        let gig = undefined;
+        const seeded = this._gigPool.findIndex(g => g.from === contactName);
+        if (seeded >= 0) {
+            gig = this._gigPool.splice(seeded, 1)[0];
+        }
+        else {
+            const locals = (this._hubScene?.allActors ?? [])
+                .filter(a => a !== this.player && a.name !== contactName && a.plane === 'meat' && !a.isIncapacitated())
+                .map(a => a.name);
+            if (locals.length === 0)
+                return null;
+            const to = locals[Math.floor(Math.random() * locals.length)];
+            const pay = 60 + contact.connection * 40 + contact.loyalty * 10;
+            gig = {
+                from: contactName,
+                to,
+                itemName: `${contactName}'s Sealed Parcel`,
+                itemDescription: `A tight-wrapped parcel, taped past curiosity. Whatever it is, ${contactName} trusts you to not ask.`,
+                pay,
+                brief: `Quiet job, no questions asked: this needs to reach ${to}, today, unopened. ${pay} nuyen on delivery.`,
+            };
+        }
+        const familyRate = contact.loyalty >= 5;
+        if (familyRate)
+            gig = { ...gig, pay: Math.round(gig.pay * 1.25) };
+        this.gigAvailable = gig;
+        Logger.getInstance().write(`Contact gig offered by ${contactName}: "${gig.itemName}" -> ${gig.to}, ${gig.pay}${familyRate ? ' (family rate)' : ''}.`);
+        return { ...gig, familyRate };
+    }
+    // FIRST-OF-ITS-KIND bounty (see commands/sell.ts): the fence pays a
+    // 50% premium on the first item of each category to cross her counter.
+    fencedCategories = new Set();
+    // Street rumors: the hub seed ships a pool (scene2.json "rumors"); one
+    // is ACTIVE at a time, rotating each time a run wraps. The active rumor
+    // is planted in the world-event mesh (every hub NPC's prompt reads it,
+    // so Mama Wu can actually gossip) and handed to the next job's skeleton
+    // prompt as its backdrop -- the street foreshadows the work.
+    _rumorPool = [];
+    _rumorIndex = 0;
+    activeRumor;
+    /** Rotates to the next rumor and plants it where NPCs will hear it. */
+    advanceRumor() {
+        if (this._rumorPool.length === 0)
+            return;
+        this.activeRumor = this._rumorPool[this._rumorIndex % this._rumorPool.length];
+        this._rumorIndex += 1;
+        this._hubScene?.addWorldEvent(`Word around the district: ${this.activeRumor}`);
+    }
     /** The persistent hideout room -- go.ts's walk-home trigger checks it. */
     get homeRoom() {
         return this._homeRoom;
@@ -242,6 +509,26 @@ export default class Game {
         CommandFactory.registerCommand('hangup', EndCallCommand);
         CommandFactory.registerCommand('advance', AdvanceCommand);
         CommandFactory.registerCommand('train', AdvanceCommand);
+        CommandFactory.registerCommand('qualities', QualityTradeCommand);
+        CommandFactory.registerCommand('quality', QualityTradeCommand);
+        CommandFactory.registerCommand('ask', AskCommand);
+        CommandFactory.registerCommand('contacts', ContactsCommand);
+        CommandFactory.registerCommand('jump', JumpCommand);
+        CommandFactory.registerCommand('rig', JumpCommand);
+        CommandFactory.registerCommand('initiate', InitiateCommand);
+        CommandFactory.registerCommand('submerge', InitiateCommand);
+        CommandFactory.registerCommand('install', InstallCommand);
+        CommandFactory.registerCommand('chrome', InstallCommand);
+        CommandFactory.registerCommand('buy', BuyCommand);
+        CommandFactory.registerCommand('browse', BuyCommand);
+        CommandFactory.registerCommand('sell', SellCommand);
+        CommandFactory.registerCommand('pay', PayCommand);
+        CommandFactory.registerCommand('eat', EatCommand);
+        CommandFactory.registerCommand('drink', DrinkCommand);
+        CommandFactory.registerCommand('lifestyle', LifestyleCommand);
+        CommandFactory.registerCommand('treat', TreatCommand);
+        CommandFactory.registerCommand('work', WorkCommand);
+        CommandFactory.registerCommand('gig', WorkCommand);
         CommandFactory.registerCommand('haggle', HaggleCommand);
         CommandFactory.registerCommand('negotiate', HaggleCommand);
         CommandFactory.registerCommand('sneak', SneakCommand);
@@ -307,9 +594,12 @@ export default class Game {
         this.player.currentLocation = this.determineStartRoom();
         this.registerCommands();
         this._screen = screen;
+        // The description follows the rent from day one (see
+        // syncHomeToLifestyle) -- a fresh session at the default Squatter tier
+        // reads exactly as the hideout always has.
         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.`,
+            description: this.lifestyle.homeDescription,
             roomType: 'Residence',
         });
         this.scene.addRoom(this._homeRoom);
@@ -325,6 +615,17 @@ export default class Game {
         if (this.scene.isHub) {
             this._hubScene = this.scene;
             this._hubName = this.sceneSeed?.name ?? 'home';
+            // The street starts talking from minute one.
+            this._rumorPool = this.sceneSeed?.rumors ?? [];
+            this.advanceRumor();
+            // The economy wakes up with it: shelf blueprints for restocking,
+            // the first odd job on offer, and the lifestyle's edge perk.
+            this.snapshotVendorStock();
+            this._gigPool = this.sceneSeed?.gigs ?? [];
+            this.advanceGig();
+            this.player.lifestyleEdgeBonus = this.lifestyle.edgeBonus;
+            // Home turf knows its own (see seedHomeTurfContacts).
+            this.seedHomeTurfContacts();
         }
         // Gear up automatically: wearables (and the commlink) slot into any
         // EMPTY slots at load -- no "equip all" ritual to start a session
@@ -394,11 +695,13 @@ export default class Game {
      * 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()) {
+        // Hub sessions: a RUN doesn't chain into the next draft -- going
+        // home is going home, and the next run is commissioned from there
+        // (call the fixer). Deliberately NOT gated on completion: the taxi
+        // will carry a runner away from a job gone sideways (see call.ts) --
+        // walking away just means the payout never landed. Classic sessions
+        // skip this and keep the old continue->draft loop.
+        if (this._hubScene && this.scene !== this._hubScene) {
             return this.returnToHub();
         }
         const gate = this.canDraftNextScene();
@@ -425,6 +728,9 @@ export default class Game {
         const hub = this._hubScene;
         if (!hub)
             return `There's no home to go back to.`;
+        // 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();
         // 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).
@@ -433,6 +739,7 @@ export default class Game {
         this.player.simMode = undefined;
         this.player.astralTicks = 0;
         this.player.activeDeck = undefined;
+        this.player.riggedDrone = undefined;
         this.player.astralPerceiving = false;
         this.player.sneaking = false;
         this.player.inExchange = false;
@@ -444,12 +751,60 @@ export default class Game {
         this.connectHomeRoom(hub.determineStartRoom());
         this.player.currentLocation = this._homeRoom;
         this.player.cameFrom = undefined;
+        this.pendingSale = undefined;
+        // Contacts have had time to work their networks again -- one legwork
+        // pull each per homecoming (see commands/ask.ts).
+        for (const contact of this.contacts.values())
+            contact.asked = false;
+        // LIFESTYLE upkeep comes due with the homecoming: this tier's share
+        // plus any standing debt, paid from carried cred as far as it goes.
+        // Coming up short SLIDES YOU DOWN a tier (the district notices) and
+        // the shortfall becomes the tab -- rest.ts halves recovery while you
+        // owe; "pay" squares it; "lifestyle" climbs back up.
+        const tier = this.lifestyle;
+        const due = tier.upkeep + this.rentDebt;
+        const paid = Math.min(this.player.currency, due);
+        if (paid > 0)
+            this.player.adjustCurrency(-paid);
+        this.rentDebt = due - paid;
+        let rentLine;
+        if (this.rentDebt > 0) {
+            const tierIndex = LIFESTYLE_TIERS.findIndex(t => t.name === tier.name);
+            if (tierIndex > 0) {
+                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.)`;
+            }
+            else {
+                rentLine = `Even the doorway costs something: ${this.rentDebt} nuyen on the tab. ("pay" when you're flush.)`;
+            }
+        }
+        else {
+            rentLine = `The landlord's drone takes its ${paid} nuyen (${tier.name} upkeep) at the door and buzzes off satisfied.`;
+        }
+        this.player.lifestyleEdgeBonus = this.lifestyle.edgeBonus;
+        // A High lifestyle erases the run: hot shower, real bed, full reset.
+        let comfortLine = '';
+        if (this.lifestyle.clearStunOnReturn && this.player.stunTaken > 0) {
+            const cleared = this.player.healStun(this.player.stunTaken);
+            comfortLine = `\nThe shower runs hot until the run is a rumor -- ${cleared} stun gone before your head hits the pillow.`;
+        }
+        // Fresh streets, fresh gossip, restocked shelves, new work.
+        this.advanceRumor();
+        this.fenceSellsOn();
+        const restocked = this.restockVendorShelves();
+        const restockLine = restocked > 0 ? `\nThe district has restocked around you -- the wok steams, the bar's shelf is full, the market stalls are loud again.` : '';
+        this.advanceGig();
         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.`;
+        Logger.getInstance().write(`Returned to hub "${this._hubName}". Lifestyle ${this.lifestyleTier}: ${paid} paid, ${this.rentDebt} owed. Restocked ${restocked}. Rumor: ${this.activeRumor ?? '(none)'}`);
+        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}`;
     }
     /**
      * The actual drafting work, split out from continueToNextScene() purely
@@ -481,7 +836,7 @@ export default class Game {
         //
         // 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);
+        const nextSeed = await SceneSeedGenerator.generate(this._logFilePath, nextTier, previousFixerName, this.player, this.activeRumor);
         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."`;
         }
@@ -519,14 +874,21 @@ export default class Game {
         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;
+        // New job -- and the needs come due at the door (see
+        // applyDepartureNeeds): edge only refills fed-and-slept, and ignored
+        // needs land as locked fatigue. Lines ride the JOB banner below.
+        const needsLines = this.applyDepartureNeeds();
+        // The home base is owned by Game, not any one Scene. HUB sessions
+        // leave it OUT of run scenes (player request): your cot is across
+        // town, not stapled to the jobsite -- the taxi ("call taxi", fare on
+        // the tab if you're broke) is the road home. Classic sessions keep
+        // the hideout adjacent as always: it's the only home they have.
+        if (!this.hasHub) {
+            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()));
@@ -535,7 +897,67 @@ export default class Game {
         // 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}`;
+        return `\n=== JOB #${this._tier}: ${seed.name} ===\n${this.scene.story}${needsLines.length > 0 ? `\n${needsLines.join('\n')}` : ''}`;
+    }
+    /**
+     * The needs check at every job departure (SR5e p.56 / p.172, scaled to
+     * job-cycle "days"). Fed AND slept since the last departure: edge
+     * refills and you head out sharp. Skip either: edge stays at whatever's
+     * left. Keep skipping: escalating fatigue (1S, 2S, 3S... per cycle),
+     * resisted Body + Willpower, landing as LOCKED stun no recovery touches
+     * until the need is met (Player.healStun / markFed / markSlept). A
+     * Sleep Regulator (augmentations.ts) halves the effective sleep debt.
+     * Fatigue is capped one box short of a knockout -- RAW would drop you,
+     * but collapsing INSIDE the departure transition would strand the
+     * session between scenes; "running on fumes" carries the spirit.
+     */
+    applyDepartureNeeds() {
+        const p = this.player;
+        const fed = p.ateThisCycle;
+        const slept = p.sleptThisCycle;
+        const lines = [];
+        p.hungerStreak = fed ? 0 : p.hungerStreak + 1;
+        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}.)`);
+        }
+        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.`);
+        }
+        // Escalating, resisted, LOCKED fatigue per ignored need.
+        const events = [];
+        if (p.hungerStreak > 0) {
+            events.push({ kind: 'hunger', label: 'Hunger', dmg: p.hungerStreak });
+        }
+        const effectiveSleepDebt = p.hasAug('sleep-regulator') ? Math.floor(p.sleepStreak / 2) : p.sleepStreak;
+        if (effectiveSleepDebt > 0) {
+            events.push({ kind: 'sleep', label: 'Sleep deprivation', dmg: effectiveSleepDebt });
+        }
+        for (const event of events) {
+            const resist = rollPool(Math.max(1, p.body + p.willpower));
+            const taken = Math.max(0, event.dmg - resist.hits);
+            const headroom = Math.max(0, p.maxStunBoxes - p.stunTaken - 1);
+            const applied = Math.min(taken, headroom);
+            if (applied > 0) {
+                p.takeStun(applied);
+                p.addLockedFatigue(event.kind, applied);
+                lines.push(`${event.label} (${event.dmg}S): resist ${formatRoll(resist)} -- ${applied} stun, and it will NOT heal until you ${event.kind === 'hunger' ? 'eat' : 'sleep'}: ${p.stunSummary()}`);
+            }
+            else if (taken > 0) {
+                lines.push(`${event.label} (${event.dmg}S): resist ${formatRoll(resist)} -- you're running on fumes; there's barely anything left to take.`);
+            }
+            else {
+                lines.push(`${event.label} (${event.dmg}S): resist ${formatRoll(resist)} -- you shake it off. For now.`);
+            }
+            Logger.getInstance().write(`Departure needs: ${event.label} ${event.dmg}S, resisted ${resist.hits}, applied ${applied} (locked).`);
+        }
+        // The new cycle starts unfed and unslept -- Wu's counter and your own
+        // cot are how these flip back (use.ts eat / rest.ts at a Residence).
+        p.ateThisCycle = false;
+        p.sleptThisCycle = false;
+        return lines;
     }
     /**
      * "travel": takes the arranged transport to the pending job (see
@@ -588,8 +1010,13 @@ export default class Game {
             border: { type: 'line' },
             style: { fg: 'white', border: { fg: 'cyan' } },
             keys: true, // Enable keyboard input
-            mouse: true, // Enable mouse input
-            inputOnFocus: true, // Focus the text input when clicked,
+            // NO mouse -- deliberately. Any widget with mouse:true makes
+            // blessed arm xterm mouse tracking (?1000h/?1002h/?1003h/?1005h),
+            // and three real sessions ended with the whole process tree dying
+            // hard (no JS cleanup possible) and the shell flooded by raw mouse
+            // reports on every cursor move. The input box is auto-focused and
+            // keyboard-driven; click-to-focus bought nothing worth that risk.
+            inputOnFocus: true,
             vi: true
         });
         this._inputBox = inputBox;
@@ -639,11 +1066,13 @@ export default class Game {
                 }
             },
             keys: true, // Enable keyboard input
-            mouse: true, // Enable mouse input
+            // NO mouse (see initInputBox): never arm mouse tracking. The log
+            // auto-scrolls (alwaysScroll) and keys/vi still scroll it when
+            // focused -- wheel-scroll wasn't worth shells full of coordinate
+            // bytes every time a session died hard.
             tags: true // Intercept tags
         });
         this._logBox = logBox;
-        logBox.removeAllListeners('mousemove');
         screen.append(logBox);
     }
     /**
@@ -776,6 +1205,15 @@ export default class Game {
         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}`);
         }
+        else if (player.plane === 'drone') {
+            // Jumped-in: the HULL is the track that matters (attacks land there,
+            // half bleeding through the link), so it lives on the HUD alongside
+            // where the empty body was left.
+            const drone = player.riggedDrone;
+            const hull = drone ? `  Hull ${drone.droneSummary()}` : '';
+            const mount = player.droneArmed ? ' ⌖ armed' : ' (recon -- no mounts)';
+            lines.push(`{yellow-fg}✈ JUMPED IN: ${drone?.name ?? 'drone'} ${(player.simMode ?? 'cold').toUpperCase()}-SIM${mount}${hull} -- body at ${player.bodyRoom?.name ?? '???'}{/yellow-fg}`);
+        }
         this._statusBox.setContent(lines.join('\n'));
         this._screen.render();
     }
@@ -878,10 +1316,11 @@ export default class Game {
         { 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: 'matrix', entries: [['jack'], ['hack'], ['pan'], ['silent'], ['reboot'], ['drone'], ['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']] },
+        { title: 'character', entries: [['sheet', 'stats'], ['advance', 'train'], ['qualities', 'quality'], ['initiate', 'submerge'], ['install', 'chrome']] },
         { title: 'session', entries: [['help'], ['clear'], ['quit', 'exit']] },
     ];
     /** Descriptions for the verbs handled inline in handleInput() rather than registered. */