@maka/maka-cli 5.67.0 → 5.69.0

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

@@ -96,14 +96,20 @@ 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 { CompileCommand, SPRITE_TYPES } from './commands/compile.js';
+import { CompileCommand, SPRITE_TYPES, uniqueSpriteName } from './commands/compile.js';
+import { DecompileCommand } from './commands/decompile.js';
 import { ThreadCommand } from './commands/thread.js';
 import { RegisterCommand } from './commands/register.js';
+import { SpritesCommand } from './commands/sprites.js';
+import { StandbyCommand } from './commands/standby.js';
+import { AbandonCommand } from './commands/abandon.js';
+import { UnravelCommand } from './commands/unravel.js';
 import { OrderCommand } from './commands/order.js';
 import { DeployCommand, AgentCommand, RecallCommand } from './commands/companions.js';
 import { DeckCommand, LoadProgramCommand, UnloadProgramCommand } from './commands/deck.js';
 import { getProgram } from './utilities/programs.js';
 import { MoveCommand, RunCommand, SprintCommand } from './commands/move.js';
+import { ClimbCommand, DescendCommand } from './commands/climb.js';
 import { HintsCommand } from './commands/hints.js';
 import { hint } from './utilities/hints.js';
 import { camerasLive } from './utilities/surveillance.js';
@@ -947,9 +953,133 @@ export default class Game {
     // death both remove the entry; persistent state (the frame, the deck)
     // lives on Items in the player's possession, never here.
     companions = [];
-    /** A registered sprite folded for travel, waiting to re-shell at the
-     *  destination (the drone _pendingRedeploys school). */
-    _pendingSpriteRedeploy;
+    /** REGISTERED SPRITES WAITING IN THE RESONANCE (SR5 p.254-256):
+     *  folded for travel, or staged from a resumed save, waiting to
+     *  re-shell (the drone _pendingRedeploys school).
+     *
+     *  An ARRAY since 2026-08-28. It was a single slot back when one
+     *  sprite was the hard maximum; the canon cap is one COMPILED sprite
+     *  with registered ones exempt, up to LOGIC of them (register.ts), so
+     *  a single slot would have quietly dropped every registered sprite
+     *  but one at the next save or journey -- the same "your permanent
+     *  companion vanished" the fix is for, moved one step downstream. */
+    _pendingSpriteRedeploy = [];
+    /** How many registrations are spent: the ones standing here plus the
+     *  ones waiting in the Resonance. register.ts bills this against
+     *  Logic. */
+    registeredSpriteCount() {
+        return this.companions.filter(c => c.kind === 'sprite' && c.registered).length
+            + this._pendingSpriteRedeploy.length;
+    }
+    // THE STASH AND THE LIVE ROSTER ARE DISJOINT, and every mover below
+    // must keep them that way: a registered sprite is EITHER standing in
+    // `companions` OR waiting here, never both and never neither.
+    // foldCompanionsForTravel pushes here and dismisses the shell in the
+    // same pass; both drains splice(0); dismissSpriteToResonance and
+    // callSpriteFromResonance are the two halves of Call/Dismiss and move
+    // a sprite across in one step each.
+    //
+    // This is why decompile.ts needs no "forget this registration" call,
+    // and why one written there could not be made to fail under mutation:
+    // decompile only reaches actors in the room, and a sprite waiting
+    // HERE is not in the room. That stays true now that Call/Dismiss can
+    // put one here mid-run -- dismissing does not make it decompilable,
+    // it makes it absent.
+    /** Registered sprites waiting in the Resonance, for the surfaces that
+     *  have to tell a player what they still have. A copy: the stash is
+     *  maintained by the movers above and nowhere else. */
+    registeredSpritesWaiting() {
+        return this._pendingSpriteRedeploy.map(s => ({ ...s }));
+    }
+    /**
+     * DISMISS half of Call/Dismiss Sprite (SR5 p.250, Simple Action):
+     * "send a sprite back to the Resonance, releasing it from any tasks it
+     * still owes you."
+     *
+     * The task release is canon and it is the expensive part -- p.256
+     * offers STANDBY (costs 1 task, keeps the rest) precisely because
+     * dismissing burns them all. So tasks go to 0 here rather than being
+     * carried, and the command that calls this says so out loud before a
+     * player spends a companion's usefulness to tidy the grid.
+     *
+     * Only a REGISTERED sprite has anywhere to go. A compiled one that is
+     * sent away is simply gone, which is decompile's job, not this one --
+     * so this refuses it rather than quietly destroying it.
+     */
+    dismissSpriteToResonance(entry) {
+        if (entry.kind !== 'sprite' || !entry.registered || !entry.spriteType)
+            return false;
+        this._pendingSpriteRedeploy.push({
+            spriteType: entry.spriteType,
+            level: entry.force,
+            tasks: 0,
+            name: entry.npc.name,
+        });
+        this.dismissCompanion(entry, 'dismissed to the Resonance');
+        return true;
+    }
+    /**
+     * STANDBY (SR5 p.256, a registered sprite TASK): "tells the sprite to
+     * return to the Resonance but come when you call it. This keeps the
+     * sprite from giving away your presence or getting in harm's way."
+     * Costs ONE task.
+     *
+     * The middle option dismissal made visible. Dismissing is free at the
+     * door and costs everything the sprite owes you (p.250); standby
+     * costs one and keeps the rest, which is the whole reason the book
+     * sells it. Without this the only way to park a sprite was to spend
+     * its entire usefulness, and a player who wanted it out of sight for
+     * one room paid for that with every favour it had left.
+     *
+     * Returns false when there is no task to spend with. A registered
+     * sprite that owes you nothing cannot pay for standby -- and does not
+     * need to, because dismissing it releases nothing it still had. The
+     * caller says that out loud rather than silently doing the other one.
+     */
+    standbySpriteToResonance(entry) {
+        if (entry.kind !== 'sprite' || !entry.registered || !entry.spriteType)
+            return false;
+        const owed = entry.services ?? 0;
+        if (owed < 1)
+            return false;
+        this._pendingSpriteRedeploy.push({
+            spriteType: entry.spriteType,
+            level: entry.force,
+            // The task it spends going quiet. The REST survive, which is the
+            // entire difference between this and dismissal.
+            tasks: owed - 1,
+            name: entry.npc.name,
+        });
+        this.dismissCompanion(entry, 'sent to standby');
+        return true;
+    }
+    /**
+     * CALL half of Call/Dismiss Sprite (p.250): "You call a registered
+     * sprite you have waiting in the Resonance."
+     *
+     * `name` picks one when several wait; without it, the first. Returns
+     * the arrival line, or undefined when nothing answered -- the caller
+     * owns the refusal wording, because "you have none" and "you have
+     * some but not that one" are different things to be told.
+     */
+    callSpriteFromResonance(name) {
+        const idx = name === undefined
+            ? (this._pendingSpriteRedeploy.length > 0 ? 0 : -1)
+            : this._pendingSpriteRedeploy.findIndex(s => s.name === name);
+        if (idx < 0)
+            return undefined;
+        // Removed BEFORE the re-shell, so a failed spawn cannot leave the
+        // same sprite both waiting and standing.
+        const [spec] = this._pendingSpriteRedeploy.splice(idx, 1);
+        const line = this.respawnRegisteredSprite(spec);
+        if (line === undefined) {
+            // It could not land. Put it back rather than losing it: the
+            // registration is the player's property, not this call's.
+            this._pendingSpriteRedeploy.splice(idx, 0, spec);
+            return undefined;
+        }
+        return line;
+    }
     // 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 = [];
@@ -1228,7 +1358,7 @@ export default class Game {
                 // A REGISTERED sprite persists (register.ts): it folds into
                 // your PAN for the ride and re-shells at the curb.
                 if (entry.registered && entry.spriteType) {
-                    this._pendingSpriteRedeploy = { spriteType: entry.spriteType, level: entry.force, tasks: entry.services ?? 0 };
+                    this._pendingSpriteRedeploy.push({ spriteType: entry.spriteType, level: entry.force, tasks: entry.services ?? 0, name: entry.npc.name });
                     lines.push(`${entry.npc.name} folds into your PAN for the ride -- registered code travels with you.`);
                 }
                 else {
@@ -1260,10 +1390,11 @@ export default class Game {
             if (shell)
                 lines.push(`The ${item.name}'s rotors spin back up at the curb.`);
         }
-        // A REGISTERED sprite re-shells from the PAN (register.ts).
-        if (this._pendingSpriteRedeploy) {
-            const spec = this._pendingSpriteRedeploy;
-            this._pendingSpriteRedeploy = undefined;
+        // EVERY registered sprite re-shells from the PAN (register.ts).
+        // splice(0) drains the stash exactly once, the way the drone loop
+        // above does -- a sprite that fails to land is not left staged to
+        // try again at the next curb.
+        for (const spec of this._pendingSpriteRedeploy.splice(0)) {
             const line = this.respawnRegisteredSprite(spec);
             if (line)
                 lines.push(line);
@@ -1278,7 +1409,11 @@ export default class Game {
         if (!type)
             return undefined;
         const shell = this.spawnCompanionShell({
-            name: `${type.name} Sprite (Level ${spec.level})`,
+            // The name it left with, so "order <name>" still works after the
+            // ride -- but never on top of a live actor, which is how two
+            // registered sprites of the same type and Level used to collide
+            // and silently lose the second one.
+            name: this.scene.getActor(spec.name) ? uniqueSpriteName(this.scene, type.name, spec.level) : spec.name,
             description: `A registered ${type.name.toLowerCase()} sprite riding ${this.player.name}'s PAN -- ${type.blurb}. It serves until its ${spec.tasks} task${spec.tasks === 1 ? '' : 's'} are spent.`,
             kind: 'sprite',
             combat: type.combat(spec.level),
@@ -1673,6 +1808,12 @@ export default class Game {
     // Taxi warn-once (player ruling): leaving with the pay unclaimed
     // arms this; the second "call taxi" forfeits. Mirrors _quitArmed.
     forfeitArmed = false;
+    /** Set by "abandon": the next taxi WALKS OUT instead of running an
+     *  errand (mYTCzJbsdZxYsTsZo). The reversible trip is the default and
+     *  the irreversible one is asked for -- Notoriety, a forfeited payout
+     *  and a destroyed scene should require the deliberate word, and a
+     *  round trip you can undo by getting back in the cab should not. */
+    walkOutArmed = false;
     /**
      * The meet and the wrap-up, triggered by the player's first/next real
      * interaction with the client (talk-to, a connected call, a give).
@@ -1976,15 +2117,27 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('summon', SummonCommand);
         CommandFactory.registerCommand('conjure', SummonCommand);
         CommandFactory.registerCommand('compile', CompileCommand);
-        CommandFactory.registerCommand('decompile', CompileCommand);
+        CommandFactory.registerCommand('decompile', DecompileCommand);
         CommandFactory.registerCommand('thread', ThreadCommand);
         CommandFactory.registerCommand('register', RegisterCommand);
+        // The sprite database (p.256-259) -- reference, the way "spells" is.
+        CommandFactory.registerCommand('sprites', SpritesCommand);
+        // STANDBY (p.256): the registered-sprite task that parks one for 1.
+        CommandFactory.registerCommand('standby', StandbyCommand);
+        // Walk out for good -- the taxi's irreversible half (mYTCzJbs...).
+        CommandFactory.registerCommand('abandon', AbandonCommand);
+        // Kill Complex Form (p.250) -- the Resonance counterpart to dispel.
+        CommandFactory.registerCommand('unravel', UnravelCommand);
         // "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);
+        // Vertical travel by name (commands/climb.ts) -- shortcuts over
+        // move, which already crosses levels.
+        CommandFactory.registerCommand('climb', ClimbCommand);
+        CommandFactory.registerCommand('descend', DescendCommand);
         CommandFactory.registerCommand('run', RunCommand);
         CommandFactory.registerCommand('sprint', SprintCommand);
         CommandFactory.registerCommand('hints', HintsCommand);
@@ -2314,12 +2467,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         }
         // A REGISTERED sprite from the save re-shells at the cot (the
         // technomancer's persistent companion -- register.ts).
-        if (this._pendingSpriteRedeploy && this.scene === this._hubScene) {
-            const spec = this._pendingSpriteRedeploy;
-            this._pendingSpriteRedeploy = undefined;
-            const line = this.respawnRegisteredSprite(spec);
-            if (line)
-                Logger.getInstance().logWithColor(line, 'cyan');
+        if (this._pendingSpriteRedeploy.length > 0 && this.scene === this._hubScene) {
+            for (const spec of this._pendingSpriteRedeploy.splice(0)) {
+                const line = this.respawnRegisteredSprite(spec);
+                if (line)
+                    Logger.getInstance().logWithColor(line, 'cyan');
+            }
         }
         if (this._resume) {
             const pendingNote = this._pendingRunSeed
@@ -2403,9 +2556,22 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         if (this.crew.length > 0 && this.crewForHire.some(c => this.crew.some(m => m.name === c.name))) {
             this.rollHireCandidates();
         }
-        // The registered sprite stages for its re-shell at hub arrival.
-        if (save.game.registeredSprite) {
-            this._pendingSpriteRedeploy = { ...save.game.registeredSprite };
+        // Registered sprites stage for their re-shell at hub arrival. The
+        // array is the live field; the singular `registeredSprite` is only
+        // read when it is absent, which is exactly the pre-2026-08-28 saves
+        // written before a technomancer could hold more than one. Reading
+        // BOTH would double a sprite on the first save that carries each.
+        if (save.game.registeredSprites && save.game.registeredSprites.length > 0) {
+            this._pendingSpriteRedeploy = save.game.registeredSprites.map(s => ({ ...s }));
+        }
+        else if (save.game.registeredSprite) {
+            const legacy = save.game.registeredSprite;
+            const type = SPRITE_TYPES[legacy.spriteType];
+            this._pendingSpriteRedeploy = [{
+                    ...legacy,
+                    // Old saves carry no name; rebuild the one it would have had.
+                    name: `${type?.name ?? 'Courier'} Sprite (Level ${legacy.level})`,
+                }];
         }
         if (this.crew.length === 0 && save.game.enlistedAlly) {
             const legacy = save.game.enlistedAlly;
@@ -2514,13 +2680,19 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 contacts: [...this.contacts.entries()],
                 procurements: [...this.pendingProcurements],
                 docwagon: this.docwagon ? { ...this.docwagon } : undefined,
-                registeredSprite: (() => {
-                    // A live registered sprite rides the save; a travel-folded one
-                    // is in the redeploy stash. Either way it survives the session.
-                    const live = this.companions.find(c => c.kind === 'sprite' && c.registered && c.spriteType);
-                    if (live)
-                        return { spriteType: live.spriteType, level: live.force, tasks: live.services ?? 0 };
-                    return this._pendingSpriteRedeploy ? { ...this._pendingSpriteRedeploy } : undefined;
+                registeredSprites: (() => {
+                    // Registered sprites ride the save from wherever they are:
+                    // STANDING here (a live companion, whose services are the
+                    // truth for its task count) or WAITING in the redeploy stash
+                    // after a fold. Both sources, because a technomancer can have
+                    // some of each -- taking only one of the two lists is how a
+                    // sprite that happened to be manifest at save time would
+                    // survive while its folded sibling silently did not.
+                    const live = this.companions
+                        .filter(c => c.kind === 'sprite' && c.registered && c.spriteType)
+                        .map(c => ({ spriteType: c.spriteType, level: c.force, tasks: c.services ?? 0, name: c.npc.name }));
+                    const all = [...live, ...this._pendingSpriteRedeploy.map(s => ({ ...s }))];
+                    return all.length > 0 ? all : undefined;
                 })(),
                 crew: this.crew.map(m => ({ ...m, gear: [...m.gear] })),
                 commandRefusals: { ...this.commandRefusals },
@@ -2634,6 +2806,124 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * state (a persona still jacked in, an astral projection, a sneak,
      * open combat bookkeeping) is settled on the way home.
      */
+    /**
+     * THE JOB YOU LEFT STANDING (mYTCzJbsdZxYsTsZo: "I'd like it to not
+     * fail the run -- I should be able to come and go to the job as I
+     * need (to get new gear)").
+     *
+     * Held in memory only, and deliberately NOT saved. Mid-run state
+     * never is -- "runs are disposable, a quit resumes to the hub with
+     * the job back on offer" -- so an errand is SESSION-SCOPED and needs
+     * no save-schema change. Quit mid-errand and you get exactly today's
+     * behaviour rather than a half-restored scene from a save that was
+     * never designed to hold one.
+     *
+     * The rooms survive because something finally holds them: returnToHub
+     * orphans a run "wholesale" only because nothing kept a reference.
+     */
+    _openRun;
+    /** Is there a job waiting for the runner to come back to it? */
+    get hasOpenRun() {
+        return this._openRun !== undefined;
+    }
+    /** The room an open run is waiting in, for the surfaces that say so. */
+    get openRunSceneName() {
+        return this._openRun?.room.name;
+    }
+    /**
+     * AN ERRAND IS NOT A HOMECOMING, and that is the whole design.
+     *
+     * returnToHub is a RITUAL, not a journey. Walking its full length
+     * twice per gear run would hand a player, free and on demand: a full
+     * stun heal at High lifestyle ("the shower runs hot until the run is
+     * a rumor"), every vendor's shelves restocked, a fresh legwork pull
+     * from every contact, the busking cycle reset, and a rerolled
+     * for-hire board -- while ALSO charging rent again and burning a
+     * twelfth of the DocWagon contract, whose year "ticks in homecomings".
+     * Wrong in both directions at once: the exploit and the punishment
+     * are the same line of code.
+     *
+     * So this is its own path rather than a flag on that one. Written as
+     * a separate method ON PURPOSE: parameterising the ritual would mean
+     * every future line added to it silently joins the errand too, and
+     * the failure would be invisible -- a restock nobody notices is not a
+     * crash. Here, anything an errand should do has to be written here.
+     *
+     * WHAT IT DOES: state hygiene the cab demands (a persona cannot ride
+     * in a taxi), companions fold and unfold as on any trip, and the
+     * scene swaps. Nothing else.
+     *
+     * WHAT IT DOES NOT DO, all of it deliberate: no client settlement, no
+     * crew settlement or disband, no jobsRun tally, no lifestyle upkeep,
+     * no restock, no rumor, no gig advance, no hire reroll, no DocWagon
+     * tick, no legwork refresh -- and NO per-job reset. A RETURN LEG IS
+     * NOT A NEW JOB: Edge does not refill, haggledThisJob does not clear,
+     * First Impression does not re-arm. You come back as you left, which
+     * is the difference between fetching a gun and starting over.
+     */
+    leaveRunForErrand() {
+        const hub = this._hubScene;
+        if (!hub || this.scene === hub)
+            return undefined;
+        this._openRun = {
+            scene: this.scene,
+            room: this.player.currentLocation,
+            spot: this.player.atSpot,
+        };
+        const foldLines = this.foldCompanionsForTravel();
+        this.settleTravelState();
+        this.scene = hub;
+        this.scene.addRoom(this._homeRoom);
+        this.connectHomeRoom(hub.determineStartRoom());
+        this.player.currentLocation = this._homeRoom;
+        this.player.cameFrom = undefined;
+        const arrivalLines = this.unfoldCompanionsOnArrival();
+        this.refreshHubUi();
+        return [...foldLines, ...arrivalLines].join('\n');
+    }
+    /** Back to the job you left standing. */
+    resumeOpenRun() {
+        const open = this._openRun;
+        if (!open)
+            return undefined;
+        const foldLines = this.foldCompanionsForTravel();
+        this.settleTravelState();
+        this.scene = open.scene;
+        this.player.currentLocation = open.room;
+        // AFTER currentLocation: its setter clears atSpot on every room
+        // change, so the order here is load-bearing (same trap as
+        // scene-factory's stationing).
+        this.player.atSpot = open.spot;
+        this.player.cameFrom = undefined;
+        this._openRun = undefined;
+        const arrivalLines = this.unfoldCompanionsOnArrival();
+        this.refreshHubUi();
+        return [...foldLines, ...arrivalLines].join('\n');
+    }
+    /** Cross-plane and combat state that must not ride in a cab, shared
+     *  by both legs of an errand. A persona has no body to put in a taxi
+     *  and a fight does not travel. */
+    settleTravelState() {
+        this.player.plane = 'meat';
+        this.player.bodyRoom = undefined;
+        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;
+        this.player.combatOpponent = undefined;
+        this.player.activeCallPartner = undefined;
+        this.autoFight.cancelPending();
+    }
+    /** The panel refresh both errand legs need. */
+    refreshHubUi() {
+        this.updateEquipment(this.player.equipment);
+        this.updateInventory(this.player.inventory, capitalCase(this.scene.getCurrencyType()));
+        this.updateExits(this.player.currentLocation);
+        this.updateStatus();
+    }
     returnToHub() {
         const hub = this._hubScene;
         if (!hub)
@@ -2665,6 +2955,25 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.player.astralTicks = 0;
         this.player.activeDeck = undefined;
         this.player.riggedDrone = undefined;
+        // THE JOB'S NEGOTIATION ENDS WITH THE JOB (d4yoYPcRAtWpLtm9y).
+        //
+        // haggledThisJob is per-JOB and was only ever cleared on DEPARTURE
+        // (applyDepartureNeeds -> refreshEdge). Coming home cleared nothing,
+        // so a runner who pushed on the number at this job's meet carried
+        // the flag back to the hub -- and launchPendingRun's offer-window
+        // capture then restored that stale true over the next job's fresh
+        // clear, refusing their first real haggle with "you already pushed
+        // on the number once this job."
+        //
+        // Cleared HERE rather than papering over it at the capture, because
+        // the flag's meaning is "this job", and the moment the job ends is
+        // when that stops being true. Anything set afterwards belongs to
+        // the next offer, which is exactly what the capture wants to keep.
+        //
+        // Deliberately NOT refreshEdge(): Edge refills on departure, fed
+        // and slept (SR5e p.56), and refilling it on arrival home would
+        // hand back a resource the next run is supposed to start without.
+        this.player.haggledThisJob = false;
         this.player.astralPerceiving = false;
         this.player.sneaking = false;
         this.player.inExchange = false;
@@ -3215,6 +3524,28 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // The departure save: hub state with the job still on offer -- what
         // a mid-run quit resumes to (the "runs are disposable" ruling).
         this.requestSave('job-accept');
+        // CARRY THE OFFER'S HAGGLE ACROSS THE TRAVEL, BUT ONLY THIS
+        // OFFER'S (d4yoYPcRAtWpLtm9y: "I got a notice that I've already
+        // pushed the number once, however I haven't").
+        //
+        // activateRunScene below refreshes per-job state, which clears
+        // haggledThisJob -- correct, a new job is a new negotiation. This
+        // capture/restore exists because the offer itself has a haggle
+        // window at the hub ("call <fixer>" delivers it), and a push made
+        // there must not be forgotten by the drive over.
+        //
+        // THE BUG WAS THAT THE CAPTURE COULD NOT TELL WHOSE HAGGLE IT WAS.
+        // haggledThisJob survives a finished run -- returnToHub clears
+        // neither it nor Edge -- so a runner who haggled at LAST job's meet
+        // came back to the hub still flagged, accepted a new job, and this
+        // line captured that stale true and faithfully restored it over the
+        // fresh clear. Their first haggle of the new job was then refused
+        // with "you already pushed on the number once this job", which was
+        // false, and the meet had just told them the rate was negotiable.
+        //
+        // Fixed at the source rather than here: returnToHub now ends the
+        // job's negotiation with the job, so anything still set when a ride
+        // is called genuinely belongs to the offer in hand.
         const haggledAtOffer = this.player.haggledThisJob;
         try {
             const banner = await this.activateRunScene(seed, tier, { startInHideout: false });
@@ -4235,7 +4566,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * future command can't silently fall out of help.
      */
     static HELP_CATEGORIES = [
-        { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach', 'run', 'sprint'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow', 'unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
+        { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach', 'run', 'sprint'], ['climb', 'descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow', 'unfollow'], ['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'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['stance'], ['surrender'], ['edge'], ['rest']] },
         // The party layer: everyone who walks (or flies, or manifests) at
@@ -4247,9 +4578,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         { title: 'matrix', entries: [['jack'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['snoop'], ['overwatch', 'os'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
         // The Emerged get their own shelf (player request: "there MUST be
         // resonance" -- matrix is the place, Resonance is the talent).
-        { title: 'resonance', entries: [['compile', 'decompile'], ['thread'], ['register']] },
+        { title: 'resonance', entries: [['compile', 'decompile'], ['thread'], ['unravel'], ['register'], ['standby'], ['sprites']] },
         { title: 'social', entries: [['say'], ['emote', 'me'], ['talk-to'], ['call'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
-        { title: 'street', entries: [['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['pay']] },
+        { title: 'street', entries: [['abandon'], ['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['pay']] },
         { title: 'barriers', entries: [['pick'], ['breach'], ['dispel', 'dispell'], ['bluff'], ['unlock'], ['lock']] },
         { title: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['sin', 'sins', 'papers'], ['initiate', 'submerge'], ['install', 'chrome']] },
         { title: 'session', entries: [['help'], ['hints'], ['time', 'clock'], ['note'], ['backlog'], ['roles'], ['clear'], ['quit', 'exit']] },