@maka/maka-cli 5.13.0 → 5.14.0

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

@@ -5,13 +5,17 @@ import { Item } from './models/item.js';
 import { Room } from './models/_index.js';
 import { Door } from './models/door.js';
 import { SAVE_VERSION } from './types/save-file.js';
-import { serializePlayer, restorePlayer, captureHubOverlay, applyHubOverlay, writeSaveAtomic, deleteSave, restoreItem, readSave, } from './utilities/persistence.js';
+import { serializePlayer, restorePlayer, captureHubOverlay, applyHubOverlay, writeSaveAtomic, deleteSave, restoreItem, readSave, serializeItem, saveSlug, } from './utilities/persistence.js';
+import { appendCrewLedger } from './utilities/crew-ledger.js';
+import { heartbeatPresence, ghostHireable, syncCrewLedger, claimGhostEarnings } from './utilities/social.js';
 import { pushSave, burnCloudSaveFor } from './utilities/cloud-saves.js';
 import { DOCWAGON_TIERS, RESUSC_FEE, DEATH_COMP } from './utilities/docwagon.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 { CommandQueue } from './utilities/command-queue.js';
+import { currentSession } from './utilities/session-context.js';
 import { LookCommand } from './commands/look.js';
 import { TakeCommand } from './commands/take.js';
 import { GoCommand } from './commands/go.js';
@@ -43,6 +47,7 @@ import { AcceptCommand, DeclineCommand } from './commands/job-offer.js';
 import { SourceCommand } from './commands/source.js';
 import { DocwagonCommand } from './commands/docwagon.js';
 import { LeadCommand, RecruitCommand } from './commands/lead.js';
+import { CrewCommand, HireCommand, DismissCommand, TrainCommand } from './commands/crew.js';
 import { PalmCommand } from './commands/palm.js';
 import { CatalogCommand } from './commands/catalog.js';
 import { refreshCatalog } from './utilities/catalog.js';
@@ -87,7 +92,7 @@ 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 { equipIntoEmptySlots, ARCHETYPES, createArchetypeGear } from './archetypes.js';
 import { NPC } from './models/npc.js';
 import { CommandRegistry } from './commands/command-registry.js';
 import { HaggleCommand } from './commands/haggle.js';
@@ -97,7 +102,7 @@ import { BluffCommand } from './commands/bluff.js';
 import { AutoFight } from './utilities/auto-fight.js';
 import { CommandFactory } from './factories/command-factory.js';
 import { SceneSynthesizer } from './factories/scene-factory.js';
-import { SceneSeedGenerator, FIXER_NAME } from './factories/scene-seed-generator.js';
+import { SceneSeedGenerator, FIXER_NAME, isFixerName } 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';
@@ -162,6 +167,9 @@ export default class Game {
     // 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).
+    // `note` is the relationship's one-line memory -- a client's grudge
+    // ("walked out on their job") or a sloppy wrap-up -- rendered as a
+    // compact marker on the roster (contacts.ts) and carried by the save.
     contacts = new Map();
     // SWAG orders in flight (SR5e p.387/418, commands/source.ts): a
     // contact shopping the black market for you. Paid up front on a won
@@ -172,33 +180,232 @@ export default class Game {
     // DOCWAGON (SR5e p.450, utilities/docwagon.ts): the wristband between
     // a runner and the morgue. Rides the save; ticks down at homecomings.
     docwagon;
-    // LEADERSHIP's Command action (SR5e p.141-142, commands/lead.ts): a
-    // recruited contact rides the NEXT run as an 'ally' companion shell
-    // (spawned at activateRunScene, released at homecoming). RAW's teeth:
-    // a refusal stands until Loyalty deepens past the level it happened
-    // at. Both ride the save.
-    enlistedAlly;
+    // ==================== THE CREW (the party system) ====================
+    // Persistent teammates who ride EVERY run (player vision: the hub
+    // stays solo housekeeping; the party is for the job). A slot holds an
+    // NPC hire, a deep-loyalty contact (Leadership's Command action,
+    // p.141-142), or -- Phase B -- another PLAYER's character riding as a
+    // ghost (source 'ghost', their cut credited home via the ledger).
+    // Live shells spawn per run (spawnCrew) and are disposable; the
+    // roster below is the persistent state and rides the save. Changing
+    // the crew SCRAPS any pending job (player ruling: the quote was for a
+    // different team -- Mr. Krow needs a fresh call).
+    crew = [];
+    // RAW's teeth on the Command recruit: a refusal stands until Loyalty
+    // deepens past the level it happened at. Rides the save.
     commandRefusals = {};
+    // DEPRECATED one-slot predecessor -- read once by applyResumeState to
+    // migrate old saves into `crew`, never written again.
+    enlistedAlly;
+    /** Leadership fields the table: anyone runs with a partner, a leader
+     *  runs a team. Ceiling 5 -- the size of the future multiplayer table. */
+    get crewCap() {
+        return Math.min(5, 1 + this.player.skillRating('leadership'));
+    }
+    /** The crew-change rule (player ruling): any roster change voids the
+     *  standing quote. Returns the line to show, or ''. */
+    scrapPendingRunForCrewChange() {
+        if (!this._pendingRunSeed)
+            return '';
+        this.clearPendingRun();
+        return `\nThe standing job was quoted for a different crew -- ${FIXER_NAME} needs a fresh call.`;
+    }
     // PERFORMANCE's busking gate (commands/perform.ts): one set per job
     // cycle, reset at homecoming like a contact's legwork. Deliberately
     // NOT saved -- a relaunch is as good as a homecoming for new material.
     performedThisCycle = false;
-    /** The recruited contact joins at the jobsite curb ("takes their own
-     *  ride and meets you there" -- the companion convention). */
-    spawnEnlistedAlly() {
-        const ally = this.enlistedAlly;
-        if (!ally)
-            return [];
-        const shell = this.spawnCompanionShell({
-            name: ally.name,
-            description: `${ally.description} Right now they run as ${this.player.name}'s crew: they fight beside them, follow their lead, and expect to be home by morning.`,
-            kind: 'ally',
-            combat: ally.combat,
-            room: this.player.currentLocation,
-            plane: 'meat',
-            force: Number(ally.combat.body ?? 3),
+    // THE FOR-HIRE BOARD: archetype-built candidates, fresh faces each
+    // homecoming (the gig-pool rotation school). Not saved -- the street's
+    // talent pool churns; whoever you HIRED is the persistent part.
+    crewForHire = [];
+    // PRESENCE (social layer, Phase B): a hub heartbeat announces this
+    // runner to the street's player list on maka-cli.com -- and carries
+    // the "hireable while away" ghost opt-in. Only beats while the scene
+    // IS the hub (the run is nobody's business); silent no-op logged out.
+    _presenceTimer;
+    static PRESENCE_TICK_MS = 60_000;
+    beatPresence() {
+        if (!this.hasHub || this.scene !== this._hubScene)
+            return;
+        void heartbeatPresence({
+            playerName: this.player.name,
+            slug: saveSlug(this.player.name),
+            hubName: this._hubName,
+            ghostHireable: ghostHireable(),
+            summary: {
+                archetypeName: this.player.archetypeName,
+                karma: this.player.careerKarma,
+                streetCred: this.player.streetCred,
+            },
         });
-        return shell ? [`${ally.name} is already leaning on the wall when you arrive -- "Took my own ride. Let's work."`] : [];
+    }
+    startPresenceHeartbeat() {
+        if (this._presenceTimer)
+            return;
+        this.beatPresence();
+        this._presenceTimer = setInterval(() => this.beatPresence(), Game.PRESENCE_TICK_MS);
+        this._presenceTimer.unref();
+    }
+    /** Ghost earnings home delivery: what YOUR runner made riding in
+     *  other players' crews since last time. Fire-and-forget from hub
+     *  arrival beats; pays onto the job credstick when anything landed. */
+    async collectGhostEarnings() {
+        try {
+            const claimed = await claimGhostEarnings(saveSlug(this.player.name));
+            if (!claimed || this.scene !== this._hubScene)
+                return;
+            const paid = this.scene.payRunner(claimed.total, 'ghost earnings');
+            if (!paid)
+                return;
+            const jobs = claimed.entries.map(e => `"${e.job}" with ${e.hiredBy} (${e.amount}¥)`).join(', ');
+            Logger.getInstance().logWithColor(`While you were gone, your runner rode other crews: ${jobs}. ${paid.net}¥ certified lands on your stick.`, 'green');
+            this.updateStatus();
+        }
+        catch { /* offline -- next homecoming */ }
+    }
+    static HIRE_NAMES = [
+        'Jax', 'Sable', 'Vex', 'Rook', 'Nyx', 'Cinder', 'Halo', 'Grifter',
+        'Static', 'Mercy', 'Tinder', 'Chrome Marie', 'Deacon', 'Fetch', 'Loa',
+    ];
+    /** Deal 2-3 fresh candidates. Names dodge the live cast and roster. */
+    rollHireCandidates() {
+        const taken = new Set([
+            ...this.crew.map(m => m.name),
+            ...(this._hubScene?.allActors ?? []).map(a => a.name),
+        ]);
+        const names = Game.HIRE_NAMES.filter(n => !taken.has(n)).sort(() => Math.random() - 0.5);
+        const count = 2 + Math.floor(Math.random() * 2);
+        this.crewForHire = [];
+        for (let i = 0; i < count && i < names.length; i++) {
+            const archetype = ARCHETYPES[Math.floor(Math.random() * ARCHETYPES.length)];
+            // Asking cut scales with muscle: sum of the offensive statline.
+            const c = archetype.combat;
+            const power = (c.body ?? 3) + (c.agility ?? 3) + (c.logic ?? 3) + (c.magic ?? 0);
+            const asking = Math.min(30, 12 + Math.floor(power / 2) + Math.floor(Math.random() * 5));
+            this.crewForHire.push({
+                name: names[i],
+                source: 'hired',
+                archetypeName: archetype.name,
+                description: `${names[i]}, a ${archetype.name.toLowerCase()} for hire off the Purple Haze boards. ${archetype.description}`,
+                combat: { ...archetype.combat },
+                gear: createArchetypeGear(archetype).map(item => serializeItem(item)),
+                cutPct: asking,
+                jobsRun: 0,
+            });
+        }
+    }
+    /** The crew joins at the jobsite curb ("took their own ride" -- the
+     *  companion convention): one 'ally' shell per member, carrying and
+     *  wearing their own gear. */
+    spawnCrew() {
+        const lines = [];
+        for (const member of this.crew) {
+            const shell = this.spawnCompanionShell({
+                name: member.name,
+                description: `${member.description} Right now they run as ${this.player.name}'s crew: they fight beside them, follow their lead, and expect their ${member.cutPct}% of the take.`,
+                kind: 'ally',
+                combat: member.combat,
+                room: this.player.currentLocation,
+                plane: 'meat',
+                force: Number(member.combat.body ?? 3),
+            });
+            if (!shell)
+                continue;
+            // Their kit comes with them -- weapons/armor worn, the rest carried
+            // (the scene-factory auto-equip convention).
+            for (const g of member.gear) {
+                try {
+                    const item = restoreItem(g);
+                    // Carried gear has no "at" spot -- a stale one from the room
+                    // it was once shelved in haunts search hints scenes later.
+                    item.atSpot = undefined;
+                    shell.addInventory(item);
+                    // Category enum VALUES are lowercase ('ranged weapon') --
+                    // match case-insensitively or the crew arrives unarmed.
+                    if (/weapon|armor|helmet|shield|clothing|boots|gloves/i.test(String(item.category))) {
+                        shell.equip(item); // refusals return strings; extras stay carried
+                    }
+                }
+                catch {
+                    Logger.getInstance().write(`spawnCrew: could not restore "${g.name}" for ${member.name} (carry cap?).`);
+                }
+            }
+            lines.push(`${member.name} is already leaning on the wall when you arrive -- "Took my own ride. Let's work."`);
+        }
+        return lines;
+    }
+    /**
+     * Homecoming settlement for the crew (returnToHub, BEFORE the fold --
+     * dismissCompanion sends shell cargo to the PLAYER, and crew gear is
+     * THEIRS): write each survivor's inventory+equipment back into the
+     * roster (loot they picked up stays with them), heal them (the cot
+     * convention), and bury the fallen -- crew death is PERMANENT, like
+     * everything else on this street. Returns homecoming lines.
+     */
+    settleCrewAfterRun() {
+        if (this.crew.length === 0)
+            return [];
+        const lines = [];
+        const fallen = [];
+        for (const member of this.crew) {
+            const entry = this.companions.find(c => c.kind === 'ally' && c.npc.name === member.name);
+            if (!entry || entry.npc.deathClaimed) {
+                fallen.push(member.name);
+                lines.push(`${member.name} didn't make it home. The crew pours one out; the street keeps the rest.`);
+                continue;
+            }
+            // Out cold is NOT dead (a real session's KO'd Jax -- "breathing"
+            // -- got an obituary and fell off the roster): the crew drags
+            // their own to the cab. Gear they dropped in the scene stays
+            // dropped unless somebody picked it up.
+            if (entry.npc.isDown() || entry.npc.isUnconscious()) {
+                lines.push(`${member.name} gets dragged to the cab, breathing. They'll wake up mean, but they'll wake up.`);
+            }
+            // Gear write-back: everything carried or worn rides the roster.
+            const shell = entry.npc;
+            const kit = shell.inventory.getAllItems().map(i => serializeItem(i));
+            for (const group of Object.values(shell.equipment)) {
+                if (!group)
+                    continue;
+                for (const item of Object.values(group)) {
+                    if (item)
+                        kit.push(serializeItem(item));
+                }
+            }
+            member.gear = kit;
+            // Empty the shell so the fold's cargo-transfer moves nothing.
+            for (const i of [...shell.inventory.getAllItems()])
+                shell.inventory.removeItem(i.name);
+        }
+        for (const name of fallen) {
+            this.crew = this.crew.filter(m => m.name !== name);
+        }
+        return lines;
+    }
+    /**
+     * The team's split, taken at every pay moment (canon: the crew shares
+     * the take; in multiplayer each player literally receives their
+     * share). Total cut capped at 60% -- the wheelman never out-earns the
+     * one holding the job. Ghost members' shares land on the local ledger
+     * for Phase B to sync home. Returns the player's share + the itemized
+     * line (empty crew: full amount, no line).
+     */
+    applyCrewCut(gross) {
+        if (this.crew.length === 0 || gross <= 0)
+            return { share: gross, line: '' };
+        const totalPct = Math.min(60, this.crew.reduce((s, m) => s + m.cutPct, 0));
+        const scale = totalPct / this.crew.reduce((s, m) => s + m.cutPct, 0);
+        const parts = [];
+        let taken = 0;
+        for (const member of this.crew) {
+            const cut = Math.floor(gross * (member.cutPct * scale) / 100);
+            taken += cut;
+            parts.push(`${member.name} ${member.cutPct}% (${cut}¥)`);
+            if (member.ghost) {
+                appendCrewLedger({ slug: member.ghost.slug, owner: member.ghost.owner, amount: cut, job: this.currentJobName ?? 'a job', when: new Date().toISOString() });
+            }
+        }
+        return { share: gross - taken, line: `Crew cut: ${parts.join(', ')}.` };
     }
     /** Bills a DocWagon fee: cred first, shortfall onto the rent tab (the
      *  street's one universal collections agency). Returns the line. */
@@ -314,14 +521,15 @@ export default class Game {
      */
     static roleOf(npc) {
         const hay = `${npc.description ?? ''} ${npc.name}`.toLowerCase();
-        // Mr. Johnson is NOT the fixer (player ruling: don't overload his
-        // role). Canon splits them: a Johnson is the anonymous CLIENT who
-        // commissions the run; a fixer is the street middleman (scene1's
-        // Mr. Krow, e.g.). He gets his own archetype label.
-        if (npc.name === FIXER_NAME || /job broker|johnson/.test(hay))
-            return 'Job Broker';
-        if (/fixer/.test(hay))
+        // Canon roles (p.390-392, player ruling): Mr. Krow is the FIXER --
+        // the broker who sets up the meets. A JOHNSON is a per-run client's
+        // deniable face; those join the roster from finished runs
+        // (returnToHub's client upsert), tagged by the /johnson|client rep/
+        // text their generated descriptions carry.
+        if (isFixerName(npc.name) || /fixer|job broker/.test(hay))
             return 'Fixer';
+        if (/johnson|client rep|deniable/.test(hay))
+            return 'Johnson';
         // "charms" deliberately absent: a market kid hawking LUCKY charms is
         // a Vendor, not a talismonger (Skitter proved it).
         if (/talismonger|magical goods|foci|spell formula/.test(hay))
@@ -350,7 +558,7 @@ export default class Game {
     }
     static connectionFor(npc) {
         const hay = `${npc.description ?? ''} ${npc.name}`.toLowerCase();
-        if (npc.name === FIXER_NAME || /fixer|johnson/.test(hay))
+        if (isFixerName(npc.name) || /fixer|johnson/.test(hay))
             return 5;
         if (/fence|pawn|launder|smuggl|no questions/.test(hay))
             return 4;
@@ -488,6 +696,19 @@ export default class Game {
      * damage), a spirit is banished outright.
      */
     onActorRemoved(name) {
+        // KILLING YOUR OWN JOHNSON (player ruling: it must FAIL the job; a
+        // real session shot Ms. Veil over a maglock code and the run kept
+        // pretending she'd pay). The paymaster's death zeroes the payout,
+        // charges the p.368 notoriety, and marks the client dead so the
+        // homecoming files a corpse, not a contact.
+        if (this.currentClient && !this.currentClient.dead && name === this.currentClient.name) {
+            this.currentClient.dead = true;
+            const wc = this.scene?.getWinCondition?.();
+            if (wc)
+                wc.payout = 0;
+            const stained = this.player.addNotoriety(`killed their own Johnson on "${this.currentJobName ?? 'a job'}"`);
+            Logger.getInstance().logWithColor(`\n=== JOB DEAD === You just killed your paymaster. Whatever this was worth, nobody's left to pay it${stained ? ` -- and word WILL travel (+1 Notoriety, now ${this.player.notoriety})` : ''}.`, 'red');
+        }
         const entry = this.companions.find(c => c.npc.name === name);
         if (!entry)
             return;
@@ -849,6 +1070,134 @@ export default class Game {
     get pendingRunTier() {
         return this._pendingRunTier;
     }
+    // ==================== The run's CLIENT (canon p.27-29) ====================
+    // Every generated run carries its own Johnson (seed.client) -- the
+    // employer's deniable face who holds THE MEET. The fixer brokered the
+    // introduction and is out of the loop from here. Not saved: mid-run
+    // state never is (runs are disposable); reconstructed fresh by
+    // activateRunScene, settled into the roster by returnToHub.
+    currentClient;
+    // Taxi warn-once (player ruling): leaving with the remainder unclaimed
+    // arms this; the second "call taxi" forfeits. Mirrors _quitArmed.
+    forfeitArmed = 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).
+     * Returns the beat's text (advance/remainder lines) or null when this
+     * NPC isn't the client / nothing new happens. Canon p.28-29: half up
+     * front at the meet, the remainder on delivering proof. Completing the
+     * objective BEFORE ever meeting them collapses both beats into one.
+     */
+    onClientInteraction(npcName) {
+        const client = this.currentClient;
+        if (!client || !this.scene || this.scene === this._hubScene)
+            return null;
+        if (npcName !== client.name)
+            return null;
+        if (client.dead)
+            return null;
+        const payout = this.scene.getWinCondition()?.payout ?? 0;
+        const lines = [];
+        if (!client.met) {
+            client.met = true;
+            const advance = Math.floor(payout / 2);
+            // The team's split comes off the top of every payment (canon: the
+            // crew shares the take) -- the player banks their share only.
+            const split = this.applyCrewCut(advance);
+            const paid = this.scene.payRunner(split.share, 'meet advance');
+            client.advancePaid = advance;
+            if (paid) {
+                lines.push(`THE MEET: ${client.name} slides half across up front -- ${paid.net}¥ certified${paid.tax > 0 ? ` (${paid.tax}¥ skimmed: SIN on file)` : ''}. The other half on delivery.${hint(` (Canon terms, p.28 -- and the rate is negotiable exactly once: "haggle" while you have them.)`)}`);
+                if (split.line)
+                    lines.push(`  ${split.line}`);
+            }
+            Logger.getInstance().write(`Client meet: ${this.player.name} met ${client.name}, advance ${advance} (gross, crew took ${advance - split.share}).`);
+        }
+        if (this.scene.isCompleted() && !client.reported) {
+            client.reported = true;
+            const remainder = payout - client.advancePaid;
+            const split = this.applyCrewCut(remainder);
+            const paid = this.scene.payRunner(split.share, 'wrap-up remainder');
+            if (paid) {
+                lines.push(`WRAP-UP: ${client.name} settles the balance -- ${paid.net}¥ certified${paid.tax > 0 ? ` (${paid.tax}¥ skimmed: SIN on file)` : ''}. Clean work; the name will remember yours.`);
+                if (split.line)
+                    lines.push(`  ${split.line}`);
+            }
+            Logger.getInstance().write(`Client wrap-up: ${this.player.name} reported to ${client.name}, remainder ${remainder} (gross, crew took ${remainder - split.share}).`);
+            // JOHNSONS DON'T LINGER (real session: a settled Ms. Slate paced
+            // in and out of rooms and tailed the runner around the scene).
+            // After the settlement beat lands, the client walks -- their AI
+            // gets no say in staying, because deniable faces leave. Guarded
+            // against the scene having ended or swapped by the time it fires.
+            const sceneAtWrap = this.scene;
+            const clientName = client.name;
+            setTimeout(() => {
+                try {
+                    if (this.scene !== sceneAtWrap)
+                        return;
+                    const actor = sceneAtWrap.allActors.find(a => a.name === clientName);
+                    if (!actor || actor.inExchange || actor.deathClaimed)
+                        return;
+                    Logger.getInstance().logWithColor(`${clientName} settles the tab, turns up a collar, and is gone -- Johnsons don't linger.`, 'cyan');
+                    sceneAtWrap.removeActorQuietly(clientName);
+                    this.updateStatus();
+                }
+                catch { /* the exit must never crash a scene */ }
+            }, 8000);
+        }
+        return lines.length > 0 ? lines.join('\n') : null;
+    }
+    /**
+     * The client's verdict, filed at homecoming (returnToHub): whatever
+     * happened, their name joins the roster -- clean work opens a
+     * relationship (role 'Johnson', repeat clients deepen like gigs), a
+     * forfeited remainder or a walked-out job files a note the roster
+     * shows (p.368 already charged the walkout's notoriety at the curb).
+     * Clears currentClient; returns the homecoming line.
+     */
+    settleClientReputation(wrappedRun) {
+        const client = this.currentClient;
+        this.currentClient = undefined;
+        this.forfeitArmed = false;
+        if (!client)
+            return '';
+        // Dead Johnsons don't take calls (player ruling: a killed client
+        // must not appear in contacts) -- the notoriety was charged at the
+        // kill; homecoming just states the arithmetic.
+        if (client.dead) {
+            this.contacts.delete(client.name);
+            Logger.getInstance().write(`Client reputation settled: ${client.name} (dead -- no contact).`);
+            return `
+${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and their friends ask questions.`;
+        }
+        const existing = this.contacts.get(client.name);
+        let line;
+        if (wrappedRun && client.reported) {
+            if (existing) {
+                existing.gigs += 1;
+                existing.loyalty = Math.min(6, existing.loyalty + 1);
+                existing.note = undefined;
+            }
+            else {
+                this.contacts.set(client.name, { connection: 4, loyalty: 2, spent: 0, gigs: 1, asked: false, role: 'Johnson' });
+            }
+            line = `\nWord gets around: ${client.name} is good for it -- and so are you. (CONTACT: Johnson, Loyalty ${this.contacts.get(client.name).loyalty})`;
+        }
+        else if (wrappedRun && !client.reported) {
+            const entry = existing ?? { connection: 4, loyalty: 1, spent: 0, gigs: 0, asked: false, role: 'Johnson' };
+            entry.note = 'sloppy wrap-up';
+            this.contacts.set(client.name, entry);
+            line = `\nThe job got done, but you never settled with ${client.name} -- the remainder stays theirs, and that's how they'll tell it.`;
+        }
+        else {
+            const entry = existing ?? { connection: 4, loyalty: 1, spent: 0, gigs: 0, asked: false, role: 'Johnson' };
+            entry.note = 'grudge -- walked out on their job';
+            this.contacts.set(client.name, entry);
+            line = `\n${client.name} will remember this one. Not fondly.`;
+        }
+        Logger.getInstance().write(`Client reputation settled: ${client.name} (${wrappedRun ? (client.reported ? 'clean' : 'unsettled') : 'walked'}).`);
+        return line;
+    }
     /**
      * The cab that answers "call taxi" varies per job (player request: not
      * always a van) -- picked once when the pending run lands, so the
@@ -957,6 +1306,10 @@ export default class Game {
         // LEADERSHIP (commands/lead.ts): rally/direct/inspire + Command recruiting.
         CommandFactory.registerCommand('lead', LeadCommand);
         CommandFactory.registerCommand('command', RecruitCommand);
+        CommandFactory.registerCommand('crew', CrewCommand);
+        CommandFactory.registerCommand('hire', HireCommand);
+        CommandFactory.registerCommand('dismiss', DismissCommand);
+        CommandFactory.registerCommand('train', TrainCommand);
         // DOCWAGON (commands/docwagon.ts): the wristband between you and the morgue.
         CommandFactory.registerCommand('docwagon', DocwagonCommand);
         // SWAG (commands/source.ts): contacts shop the black market for you.
@@ -998,8 +1351,9 @@ export default class Game {
         // wanted to end a call -- the intent is unambiguous mid-call.
         CommandFactory.registerCommand('end', EndCallCommand);
         CommandFactory.registerCommand('hangup', EndCallCommand);
+        // 'train' used to alias advance; it belongs to crew instruction now
+        // (commands/crew.ts) -- self-training is "advance".
         CommandFactory.registerCommand('advance', AdvanceCommand);
-        CommandFactory.registerCommand('train', AdvanceCommand);
         CommandFactory.registerCommand('qualities', QualityTradeCommand);
         CommandFactory.registerCommand('quality', QualityTradeCommand);
         CommandFactory.registerCommand('ask', AskCommand);
@@ -1097,16 +1451,28 @@ export default class Game {
         return this._inputBox;
     }
     async init(options, screen) {
+        this.initUi(screen);
+        return this.initEngine(options);
+    }
+    /** The blessed half of startup -- widgets only. Headless sessions
+     *  (Phase C) never call this; everything below survives without it
+     *  (updateStatus/refreshLogLabel/close are all screen-guarded). */
+    initUi(screen) {
+        this.initInputBox(screen);
+        this.initLogBox(screen);
+        this.initMetaBox(screen);
+        this.initStatusBox(screen);
+        this._screen = screen;
+    }
+    /** The engine half of startup: scene synthesis, command registration,
+     *  hub seeding, resume overlay -- no widget contact. */
+    async initEngine(options) {
         this._useAi = options.useAi;
         this._logFilePath = options.logFilePath;
         this._saveFilePath = options.saveFilePath;
         // The swag catalog warms from maka-cli.com in the background
         // (utilities/catalog.ts): live list > local cache > baked-in floor.
         void refreshCatalog();
-        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
         // generated scenes), so the old blocking AI-redressing pass -- 30-60
@@ -1123,7 +1489,6 @@ export default class Game {
         this.scene.initialize(this);
         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.
@@ -1164,6 +1529,14 @@ export default class Game {
             // Home turf knows its own (see seedHomeTurfContacts). On resume the
             // saved contacts overwrite these loyalty-1 seeds a few lines down.
             this.seedHomeTurfContacts();
+            // First deal of the for-hire board (rotates each homecoming).
+            this.rollHireCandidates();
+            // The street learns you're home (social layer): presence beats,
+            // unsynced ghost earnings go up, and anything YOUR runner earned
+            // riding other crews comes down. All fire-and-forget.
+            this.startPresenceHeartbeat();
+            void syncCrewLedger();
+            void this.collectGhostEarnings();
             // 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 --
@@ -1192,6 +1565,15 @@ export default class Game {
         // above, so the save is authoritative everywhere they overlap.
         if (this._resume && this._hubScene) {
             this.applyResumeState(this._resume);
+            // The fixer reaches out on resume TOO (player report: "Krow
+            // doesn't kick off a new job when I load in"). The init-time
+            // draft above stays gated on resume because the overlay hadn't
+            // landed yet -- HERE we know whether a pendingRun actually
+            // survived the save, so an empty docket starts cooking now and
+            // Krow's "1 new message" ping lands mid-session as usual.
+            if (!this._pendingRunSeed && this.canDraftNextScene().allowed) {
+                this.draftNextSceneInBackground();
+            }
         }
         this.initialized = true;
         if (this._resume) {
@@ -1256,7 +1638,23 @@ export default class Game {
         }
         this.pendingProcurements = [...(save.game.procurements ?? [])];
         this.docwagon = save.game.docwagon ? { ...save.game.docwagon } : undefined;
-        this.enlistedAlly = save.game.enlistedAlly ? { ...save.game.enlistedAlly } : undefined;
+        // THE CREW rides the save; the deprecated one-slot enlistedAlly
+        // migrates in once (old saves) and is never written again.
+        this.crew = (save.game.crew ?? []).map(m => ({ ...m, gear: [...m.gear] }));
+        if (this.crew.length === 0 && save.game.enlistedAlly) {
+            const legacy = save.game.enlistedAlly;
+            this.crew.push({
+                name: legacy.name,
+                source: 'contact',
+                description: legacy.description,
+                combat: { ...legacy.combat },
+                gear: [],
+                cutPct: 10,
+                jobsRun: 0,
+            });
+            Logger.getInstance().write(`Migrated legacy enlistedAlly "${legacy.name}" into the crew roster.`);
+        }
+        this.enlistedAlly = undefined;
         this.commandRefusals = { ...(save.game.commandRefusals ?? {}) };
         this.fencedCategories = new Set(save.game.fencedCategories);
         this._rumorIndex = save.game.rumorIndex;
@@ -1340,7 +1738,7 @@ export default class Game {
                 contacts: [...this.contacts.entries()],
                 procurements: [...this.pendingProcurements],
                 docwagon: this.docwagon ? { ...this.docwagon } : undefined,
-                enlistedAlly: this.enlistedAlly ? { ...this.enlistedAlly } : undefined,
+                crew: this.crew.map(m => ({ ...m, gear: [...m.gear] })),
                 commandRefusals: { ...this.commandRefusals },
                 fencedCategories: [...this.fencedCategories],
                 rumorIndex: this._rumorIndex,
@@ -1443,6 +1841,18 @@ 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();
+        // THE CLIENT REMEMBERS (player ruling: the run's outcome is
+        // reputation with the CLIENT, not the fixer).
+        const clientLine = this.scene !== hub ? this.settleClientReputation(wrappedRun) : '';
+        // CREW settlement BEFORE the fold (gear write-back + obituaries --
+        // dismissCompanion would ship their kit to the player otherwise),
+        // then the wrapped-run tally and the training window reset.
+        const crewLines = this.scene !== hub ? this.settleCrewAfterRun() : [];
+        for (const member of this.crew) {
+            if (wrappedRun)
+                member.jobsRun += 1;
+            member.trainedThisCycle = false;
+        }
         // 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
@@ -1523,11 +1933,16 @@ export default class Game {
         const companionBlock = [...companionFoldLines, ...companionArrivalLines];
         // The commanded ally's tour ends with the run (RAW's Command lasts
         // turns; ours lasts the job): the crew disbands at the curb.
-        let allyLine = '';
-        if (this.enlistedAlly) {
-            allyLine = `\n${this.enlistedAlly.name} peels off at the curb -- "Call it even, chummer." The crew's back to just you.`;
-            this.enlistedAlly = undefined;
-        }
+        // The crew stays hired between jobs (the roster persists); their
+        // homecoming lines (obituaries, write-back) rode in above. Fresh
+        // faces on the for-hire board each homecoming.
+        this.rollHireCandidates();
+        // Social settlement: presence resumes, ghost cuts sync up, earnings
+        // come home.
+        this.beatPresence();
+        void syncCrewLedger();
+        void this.collectGhostEarnings();
+        const allyLine = crewLines.length > 0 ? `\n${crewLines.join('\n')}` : '';
         // DOCWAGON's year ticks in homecomings (12 = a street year, player
         // ruling): the contract lapses quietly unless renewed at Doc's.
         let docwagonLine = '';
@@ -1570,7 +1985,7 @@ export default class Game {
         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}.${hint(` Call ${FIXER_NAME} when you're hungry for the next job.`)}\n${rentLine}${comfortLine}${restockLine}${deliveryLine}${docwagonLine}${allyLine}${companionBlock.length > 0 ? `\n${companionBlock.join('\n')}` : ''}`;
+        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.`)}${clientLine}\n${rentLine}${comfortLine}${restockLine}${deliveryLine}${docwagonLine}${allyLine}${companionBlock.length > 0 ? `\n${companionBlock.join('\n')}` : ''}`;
     }
     /**
      * The actual drafting work, split out from continueToNextScene() purely
@@ -1580,15 +1995,9 @@ export default class Game {
      */
     async draftNextScene() {
         const nextTier = this._tier + 1;
-        // Carry the current fixer's identity forward -- without this, each
-        // "continue" generates a scene with zero knowledge of the last one, so
-        // the AI just invents a brand new job-giver every time. Looked up by
-        // identity (is there an actor actually named FIXER_NAME?), not via the
-        // win condition's toNpc -- that's often a one-off contact the fixer
-        // pointed the runner toward, not the fixer himself (see the "broker,
-        // not always the destination" convention).
-        const fixerStillInScene = this.scene.allActors.some(a => a.name === FIXER_NAME);
-        const previousFixerName = fixerStillInScene ? FIXER_NAME : undefined;
+        // Each run invents its OWN client Johnson (canon roles: the fixer
+        // brokers from the hub and never appears in run scenes) -- the old
+        // fixer-identity carryforward is gone with him.
         // Append, don't replace -- this used to be setContent(), which wiped
         // the whole log box (including the JOB COMPLETE banner and everything
         // before it) for the entire generation wait, which can run 20-40+
@@ -1602,7 +2011,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, this.activeRumor);
+        const nextSeed = await SceneSeedGenerator.generate(this._logFilePath, nextTier, this.player, this.activeRumor, this.crew);
         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."`;
         }
@@ -1669,14 +2078,26 @@ export default class Game {
         // Deployed drones spin back up at the curb -- BEFORE appearance
         // warming so re-shelled companions get warmed with the cast.
         const arrivalLines = this.unfoldCompanionsOnArrival();
-        // A commanded ally meets you at the jobsite (commands/lead.ts).
-        const allyLines = this.spawnEnlistedAlly();
+        // The crew meets you at the jobsite (commands/crew.ts, lead.ts).
+        const allyLines = this.spawnCrew();
         this.warmNpcAppearancesInBackground();
         this.refreshLogLabel();
+        // THE MEET opens the job (canon p.28): the seed's client is this
+        // run's Johnson -- track them, and point the arrival at the meet.
+        this.currentClient = seed.client
+            ? { name: seed.client, met: false, advancePaid: 0, reported: false }
+            : undefined;
+        this.forfeitArmed = false;
+        const clientRoom = seed.client
+            ? this.scene.allActors.find(a => a.name === seed.client)?.currentLocation?.name
+            : undefined;
+        const meetLine = seed.client
+            ? `\nYour contact on this one goes by ${seed.client}${clientRoom ? ` -- holding the meet at ${clientRoom}` : ''}. Half up front when you sit down; the rest on delivery.${hint(` (Find them and talk, or "call ${seed.client}" -- the rate is negotiable at the meet, once.)`)}`
+            : '';
         // No "=== JOB #n ===" banner on entry (player request) -- the Game
         // Log window's own title carries the job name now.
         const companionBlock = [...companionLines, ...arrivalLines, ...allyLines];
-        return `\n${this.scene.story}${needsLines.length > 0 ? `\n${needsLines.join('\n')}` : ''}${companionBlock.length > 0 ? `\n${companionBlock.join('\n')}` : ''}`;
+        return `\n${this.scene.story}${meetLine}${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
@@ -1789,13 +2210,41 @@ export default class Game {
             Logger.getInstance().write(`Permadeath: save deleted (${this._saveFilePath}).`);
         }
         this.stopPursuitHeartbeat();
-        this._inputBox.removeAllListeners(); // removes all event listeners
-        this._inputBox.cancel(); // cancels any active input session
-        this._inputBox.detach(); // optionally remove from screen
-        this._screen.render(); // re-render if needed
-        this._screen.key(['C-c'], () => {
-            process.exit(2);
-        });
+        // Widget teardown only where widgets exist -- endGame() reaches here
+        // from headless sessions too (Phase C), where there is no screen.
+        if (this._inputBox) {
+            this._inputBox.removeAllListeners(); // removes all event listeners
+            this._inputBox.cancel(); // cancels any active input session
+            this._inputBox.detach(); // optionally remove from screen
+        }
+        if (this._screen) {
+            this._screen.render(); // re-render if needed
+            this._screen.key(['C-c'], () => {
+                process.exit(2);
+            });
+        }
+    }
+    stopPresenceHeartbeat() {
+        if (this._presenceTimer) {
+            clearInterval(this._presenceTimer);
+            this._presenceTimer = undefined;
+        }
+    }
+    /**
+     * Full per-session teardown (Phase C): everything init/play armed that
+     * outlives a turn -- for the hosting server's idle eviction and
+     * session close. Solo play never calls this (process exit does it).
+     */
+    async dispose() {
+        this.stopPresenceHeartbeat();
+        this.stopPursuitHeartbeat();
+        this.autoFight.cancelPending();
+        for (const ko of this.scene?.playerKnockouts.values() ?? []) {
+            if (ko.timer)
+                clearTimeout(ko.timer);
+        }
+        this.scene?.playerKnockouts.clear();
+        await this.commandQueue.drain();
     }
     initInputBox(screen) {
         // Create an input box for user commands
@@ -2052,7 +2501,15 @@ export default class Game {
         // fire from synthesis paths before the blessed UI exists.
         if (!this._statusBox)
             return;
-        const player = this.player;
+        this._statusBox.setContent(this.statusLinesFor(this.player).join('\n'));
+        this._screen.render();
+    }
+    /**
+     * The HUD as data: every status line for `player`, pure state reads --
+     * no widgets. updateStatus paints it for the local player; a shared-run
+     * server ships it per player as status events (Phase C).
+     */
+    statusLinesFor(player) {
         const lines = [];
         // Line 1: where you are, and the fight autopilot mode. The stance
         // lives HERE -- the shortest HUD line -- because appended to the long
@@ -2189,8 +2646,7 @@ export default class Game {
             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();
+        return lines;
     }
     // The three methods below were the render paths for the old always-on
     // sidebar boxes. Those boxes are gone (the log owns the whole screen; see
@@ -2225,7 +2681,50 @@ export default class Game {
      * correction call overwrites it with the corrected verb.
      */
     lastResolvedVerb = '';
+    /**
+     * Serializes every inbound command (see utilities/command-queue.ts):
+     * the engine's await points assume one command in flight, and a second
+     * human on a DDP connection must wait its turn, not interleave.
+     */
+    commandQueue = new CommandQueue();
+    /**
+     * Shared-run hook (Phase C): fires when a NON-primary human player
+     * dies in this scene, so the server can burn their save. The primary
+     * player's death keeps the solo path (Scene.endGame -> close(),
+     * permadeath).
+     */
+    onPlayerDeath;
     async handleInput(input) {
+        return (await this.handleInputAs(this.player.name, input)).text;
+    }
+    /**
+     * Runs `input` AS the named human player -- the symmetric-multiplayer
+     * command entry: every human gets the same full privileged context the
+     * solo player always had. Queued; internal re-entries (typo
+     * correction, say.ts's speech-accept) run inline via the queue's
+     * re-entrancy guard.
+     */
+    async handleInputAs(actorName, input) {
+        return this.commandQueue.enqueue(() => {
+            // Ambient event scoping (see emitter.ts): while this command runs,
+            // the session context knows WHOSE command it is -- headless
+            // emitters default its output to that player's room/eyes. Solo
+            // play has no session context; this is a no-op there.
+            const ctx = currentSession();
+            const prev = ctx?.dispatch;
+            if (ctx)
+                ctx.dispatch = { actorName };
+            return Promise.resolve(this.runInputAs(actorName, input)).finally(() => {
+                if (ctx)
+                    ctx.dispatch = prev;
+            });
+        });
+    }
+    async runInputAs(actorName, input) {
+        const actor = this.scene.getPlayerByName(actorName);
+        if (!actor) {
+            return { text: `No runner named "${actorName}" is in this scene.`, verb: '' };
+        }
         // "jack-in"/"jack-out" read naturally but parse as unknown verbs (a
         // real session typed "jack-in" and bounced) -- normalize the hyphen.
         const normalized = input.replace(/^\s*jack-(in|out)\b/i, 'jack $1');
@@ -2233,43 +2732,48 @@ export default class Game {
         const verb = parts[0].toLowerCase();
         const args = parts.slice(1);
         this.lastResolvedVerb = verb;
+        const out = (text) => ({ text, verb: this.lastResolvedVerb });
+        // Empty input is a nervous Enter, not a command (a real session's
+        // triple keystroke printed three 'I don't understand ""' lines).
+        if (!verb)
+            return out('');
         // 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;
+                return out(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.)`;
+            return out(`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 (actor.isUnconscious() && this.scene.getKnockout(actor.name)) {
+            return out(`You're out cold -- the world moves without you.`);
         }
         if (verb === 'maka') {
-            return 'You are still in the game, type "quit" to exit';
+            return out('You are still in the game, type "quit" to exit');
         }
         if (verb === 'continue') {
             // RETIRED verb, kept only as a redirect: jobs flow through the
             // fixer ("call Mr. Johnson"), and a finished run ends by walking
             // home to your hideout -- no system command in the loop.
-            return `That's not how the street works anymore, chummer: "call ${FIXER_NAME}" when you want work. When a run's wrapped, head home to your hideout -- the door knows the way.`;
+            return out(`That's not how the street works anymore, chummer: "call ${FIXER_NAME}" when you want work. When a run's wrapped, head home to your hideout -- the door knows the way.`);
         }
         if (verb === 'help') {
-            return this.getHelpMessage(args);
+            return out(this.getHelpMessage(args));
         }
         if (verb === 'clear') {
-            return '';
+            return out('');
         }
         const context = {
-            actor: this.player,
+            actor,
             rooms: this.scene.getRooms(),
             scene: this.scene,
             screen: this._screen,
@@ -2278,7 +2782,7 @@ export default class Game {
         const command = CommandFactory.createCommand(verb, context);
         if (command) {
             const result = await command.execute(args);
-            return result;
+            return out(result);
         }
         // Typo tolerance: two straight sessions bounced on slips like "searh"
         // and "maop". Reuse the same fuzzy matcher item/NPC names go through
@@ -2297,17 +2801,19 @@ export default class Game {
         }
         if (guess && guess !== verb) {
             if (guess === 'quit' || guess === 'exit') {
-                return `I don't understand "${verb}" -- did you mean "${guess}"?`;
+                return out(`I don't understand "${verb}" -- did you mean "${guess}"?`);
             }
-            const corrected = await this.handleInput([guess, ...args].join(' '));
+            const corrected = await this.runInputAs(actorName, [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 corrected.text === null
+                ? out(null)
+                : out(`(read "${verb}" as "${guess}")\n${corrected.text ?? ''}`);
         }
-        return `I don't understand the command "${verb}".`;
+        return out(`I don't understand the command "${verb}".`);
     }
     /**
      * The help taxonomy: every entry is [primary, ...aliases], grouped the
@@ -2324,13 +2830,13 @@ export default class Game {
         { title: 'combat', entries: [['attack', 'kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['stance'], ['surrender'], ['edge'], ['rest']] },
         // The party layer: everyone who walks (or flies, or manifests) at
         // your side answers to these.
-        { title: 'party', entries: [['order'], ['lead'], ['command'], ['deploy'], ['recall']] },
+        { title: 'party', entries: [['crew'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall']] },
         { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project'], ['return'], ['assense']] },
         { title: 'matrix', entries: [['jack'], ['deck'], ['load'], ['unload'], ['hack'], ['pan'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
         { title: 'social', entries: [['say'], ['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'], ['perform'], ['palm'], ['docwagon'], ['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: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['initiate', 'submerge'], ['install', 'chrome']] },
         { title: 'session', entries: [['help'], ['hints'], ['clear'], ['quit', 'exit']] },
     ];
     /** Descriptions for the verbs handled inline in handleInput() rather than registered. */