@maka/maka-cli 5.130.0 → 5.131.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.130.0",
+  "version": "5.131.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

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

@@ -72,6 +72,15 @@ export class CallCommand extends Command {
         // before NPC resolution ("taxi" is a service, not a person).
         const spoken = rawWords.map(w => w.toLowerCase()).filter(w => w !== 'a' && w !== 'the');
         if (this.game?.hasHub && (spoken[0] === 'taxi' || spoken[0] === 'cab')) {
+            // A CAB IS THE RUNNER'S CALL (rigger pass 2026-09-06: a deployed
+            // drone must never start a run). `call` itself stays open -- NPCs
+            // phone people (npc.ts advertises the verb) -- but the taxi branch
+            // launches the PLAYER's pending run off this.game, so only a
+            // person at the table may hail one. Latent until now because NPC
+            // command contexts carry no `game`; a rule now rather than luck.
+            if (!this.scene.isHumanControlled(this.actor)) {
+                return `The dispatcher's bored voice: "No fare on the books for ${this.actor.name}, chummer." A cab is the runner's call.`;
+            }
             if (this.actor.plane !== 'meat') {
                 return this.actor.plane === 'matrix'
                     ? `Cabs take bodies, not personas -- "jack out" first.`

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

@@ -5,14 +5,18 @@ import { agentRatingFromName } from '../utilities/programs.js';
 import { resonanceAction } from '../resonance-actions.js';
 import { FIREARM_SKILLS } from '../models/player.js';
 import { ownedDrones, droneListLines } from '../utilities/owned-drones.js';
+import { droneLaunchAction, droneLaunchLine, droneRecallLine, droneWreckFragment } from '../utilities/drone-prose.js';
 /**
  * The rigger's autonomous frames (SR5e p.269-271): "deploy <drone>" puts
  * a carried frame in the air under its own DOG-BRAIN -- no control rig
- * needed, Pilot (2 + quality) standing in for every attribute it lacks.
- * It follows you, watches, and (armed frames only) shoots what threatens
- * you; damage lands on the HULL and a wreck is a wreck (rest to repair).
- * "recall" folds it back to your hand, and "jump" (jump.ts) seizes the
- * stick from the dog-brain wherever the frame flies.
+ * needed, Pilot (the row's, else 2 + quality: Item.pilotRating) standing
+ * in for every attribute it lacks. It follows you, watches, and (armed
+ * frames only) shoots what threatens you; damage lands on the HULL and a
+ * wreck is a wreck (rest to repair). "recall" folds it back to your
+ * hand, and "jump" (jump.ts) seizes the stick from the dog-brain
+ * wherever the frame flies. Every word about the frame moving comes
+ * from utilities/drone-prose.ts, classed by how it actually moves: a
+ * Steel Lynx rolls, a Fly-Spy whines up off your palm.
  */
 export class DeployCommand extends Command {
     static verb = 'deploy';
@@ -45,23 +49,27 @@ export class DeployCommand extends Command {
         if (!drone)
             return [`Which frame? ("deploy <name>")`, ...droneListLines(owned)].join('\n');
         if (drone.isWrecked)
-            return `The ${drone.name} is a wreck -- it deploys nowhere until you rest and true the rotors.`;
+            return `The ${drone.name} is a wreck -- ${droneWreckFragment(drone)} -- it deploys nowhere until you rest and rebuild it.`;
         if (game.companions.some(c => c.boundDevice === drone)) {
             return `The ${drone.name} is already in the air.`;
         }
         const shell = game.deployDroneShell(drone, actor.currentLocation);
         if (!shell)
             return `The autopilot stutters -- something already answers to that designation here.`;
-        const fromGarage = owned.find(d => d.item === drone)?.where === 'garage';
-        actor.performAction('deploys', fromGarage ? `${drone.name} -- rolling out of the garage under its own power` : `${drone.name} -- rotors spinning up to a hover`);
+        const from = owned.find(d => d.item === drone)?.where === 'garage' ? 'garage' : 'hand';
+        actor.performAction('deploys', `${drone.name} -- ${droneLaunchAction(drone, from)}`);
         this.logger.write(`DeployCommand: ${actor.name} deployed ${drone.name} on autopilot.`);
         this.scene.updateStatus();
         // ANY firearm skill, not one of them. A drone's mount is a gun; after
         // the split there is no single `firearms` rating to ask for, and
         // picking one would call a shell with a shotgun rating unarmed.
         const armed = FIREARM_SKILLS.some(k => shell.skillRating(k) > 0);
+        // The Pilot printed is the Pilot the shell RUNS ON (deployDroneShell
+        // reads Item.pilotRating, the catalog row's): this line used to
+        // inline the price-tier fallback and disagreed with the HUD for
+        // every catalog frame.
         return [
-            `The ${drone.name} lifts off your hand and settles into a watchful hover -- dog-brain running, Pilot ${2 + drone.qualityBonus}.`,
+            `${droneLaunchLine(drone, from)} -- dog-brain running, Pilot ${drone.pilotRating}.`,
             `  It follows where you walk${armed ? ` and its mount tracks what threatens you` : ` -- cameras only; it will not fight`}. Hull ${drone.droneSummary()}.${hint(` ("order ${drone.name.toLowerCase()} ..." to direct it, "recall" to bring it home, "jump" to take the stick yourself, wherever it flies.)`)}`,
         ].join('\n');
     }
@@ -159,7 +167,7 @@ export class RecallCommand extends Command {
         game.dismissCompanion(entry, 'recalled');
         this.actor.performAction('recalls', name);
         this.scene.updateStatus();
-        return `The ${name} banks once and settles back onto your hand, rotors folding.${entry.boundDevice && entry.boundDevice.droneDamage > 0 ? ` The airframe carries its dents (${entry.boundDevice.droneSummary()})${hint(' -- rest repairs it')}.` : ''}`;
+        return entry.boundDevice ? droneRecallLine(entry.boundDevice) : `The ${name} comes back to hand.`;
     }
     /**
      * CALL/DISMISS SPRITE (SR5 p.250, Simple Action), on this verb rather

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { Door } from '../models/door.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { ownedDrones } from '../utilities/owned-drones.js';
+import { droneReconLaunchLine, droneReconNowhereLine, droneReconReturnLine, droneSlipsVents } from '../utilities/drone-prose.js';
 /**
  * The rigger's mechanic: launch a carried surveillance drone for a live
  * sweep of every room adjacent to this one -- who's there, what's locked,
@@ -32,7 +33,7 @@ export class DroneCommand extends Command {
         const room = actor.currentLocation;
         const exits = Array.from(room.exits.entries());
         if (exits.length === 0) {
-            return `The ${drone.name} lifts, circles once -- nowhere to go from here.`;
+            return droneReconNowhereLine(drone);
         }
         actor.performAction('launches a drone', drone.name);
         this.logger.write(`${actor.name} launched ${drone.name} from ${room.name}.`);
@@ -43,18 +44,26 @@ export class DroneCommand extends Command {
         const roll = rollPool(Math.max(1, actor.reaction + (piloting > 0 ? piloting : -1) + actor.bonus('piloting') + actor.woundModifier - actor.sustainingPenalty));
         if (roll.hits === 0) {
             return [
-                `The ${drone.name} whirs off your palm -- Piloting: ${formatRoll(roll)}`,
+                droneReconLaunchLine(drone, formatRoll(roll), false),
                 `  It clips a railing, spins, and the feed dissolves into static. It limps home with nothing.`,
             ].join('\n');
         }
-        const lines = [`The ${drone.name} whirs off your palm and threads the gaps -- Piloting: ${formatRoll(roll)}. Feed incoming:`];
+        const lines = [droneReconLaunchLine(drone, formatRoll(roll), true)];
         for (const [direction, exit] of exits) {
             let target;
             let lockNote = '';
             if (exit instanceof Door) {
                 target = exit.getOtherSide(room);
-                if (exit.checkIfLocked())
+                if (exit.checkIfLocked()) {
+                    // Only a palm-sized flier slips a vent (drone-prose.ts): a
+                    // locked door stops a Roto-Drone or a Steel Lynx like anyone,
+                    // and the sweep says so instead of reading through it.
+                    if (!droneSlipsVents(drone)) {
+                        lines.push(`  • ${direction}: ${target?.name ?? '?'} [door LOCKED -- no way through for a ${drone.name}]`);
+                        continue;
+                    }
                     lockNote = ' [door LOCKED -- it slipped a vent]';
+                }
             }
             else if (typeof exit === 'string') {
                 target = this.rooms?.[exit];
@@ -68,7 +77,7 @@ export class DroneCommand extends Command {
             const node = target.hasNode ? ' -- a Matrix host node hums here' : '';
             lines.push(`  • ${direction}: ${target.name}${lockNote} -- ${who}${node}`);
         }
-        lines.push(`The ${drone.name} loops home and folds back into your kit.`);
+        lines.push(droneReconReturnLine(drone));
         return lines.join('\n');
     }
 }

package/bundle/typescript/src/commands/game/sideQuest/commands/job-offer.js

@@ -16,6 +16,12 @@ import { meetLocationFor } from '../utilities/meet-location.js';
  * with AI off it resolves immediately and the click is instant).
  */
 class JobOfferCommand extends Command {
+    // THE JOB IS THE PLAYER'S TO TAKE OR REFUSE (rigger pass 2026-09-06).
+    // Both verbs mutate this.game -- the player's run -- not the actor,
+    // so a companion shell ordered to "accept" would lock in the player's
+    // job. Declared once here: statics inherit, and Command.isHumanOnly()
+    // reads it off the subclass constructor (command-registry.ts).
+    static humanOnly = true;
     /** Bare "accept"/"decline" with NO job on the table but a PARTY
      *  INVITE waiting obviously means the invite (real session typed
      *  "accept" first and got the job-offer refusal) -- route it to the

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

@@ -3,6 +3,14 @@ import { hint } from '../utilities/hints.js';
 import { optionMark } from '../utilities/log-style.js';
 export class JobsCommand extends Command {
     static verb = 'jobs';
+    // THE JOB IS THE PLAYER'S TO TAKE (rigger pass 2026-09-06: "can a
+    // deployed drone take a job on its own? I don't think it should").
+    // "jobs take" acts on this.game -- the player's run -- not on the
+    // actor, so an ordered or AI-driven companion shell running it would
+    // put a job on the player's table. Latent until now only because NPC
+    // command contexts carry no `game`; now a rule, enforced and logged
+    // at command-registry.ts.
+    static humanOnly = true;
     static description = 'The job board: what\'s on offer, CREW vs LOCAL. "jobs take <n>" puts one on the table, "jobs dismiss <n>" scraps it.';
     async execute(args = []) {
         const game = this.game;

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

@@ -3,6 +3,7 @@ import { hint } from '../utilities/hints.js';
 import { enterDrone, leaveDrone } from '../utilities/planes.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { ownedDrones, droneListLines } from '../utilities/owned-drones.js';
+import { droneWreckFragment } from '../utilities/drone-prose.js';
 /**
  * Jumped-in rigging (SR5e p.266): "jump" pours the rigger into a carried
  * drone -- full VR through an IMPLANTED CONTROL RIG (the book's hard
@@ -15,7 +16,7 @@ import { ownedDrones, droneListLines } from '../utilities/owned-drones.js';
  */
 export class JumpCommand extends Command {
     static verb = 'jump';
-    static description = 'Jump INTO a drone (control rig required): fly it, see through it, fight with its mount. A deployed frame is seized wherever it flies. "jump hot" for hot-sim; "jump" again returns to your body.';
+    static description = 'Jump INTO a drone (control rig required): fly it, see through it, fight with its mount. A deployed frame is seized wherever it flies. "jump hot" for hot-sim; "jump" again returns to your body and leaves the frame out on its dog-brain where you left it ("recall" brings it home).';
     async execute(args = []) {
         const actor = this.actor;
         // Already riding: this is the jump OUT.
@@ -58,7 +59,7 @@ export class JumpCommand extends Command {
             return [`Which airframe? ("jump <name>", add "hot" for hot-sim)`, ...droneListLines(owned)].join('\n');
         }
         if (drone.isWrecked) {
-            return `The ${drone.name} is a wreck -- bent rotors and dead boards jump nowhere. It repairs while you rest somewhere safe.`;
+            return `The ${drone.name} is a wreck -- ${droneWreckFragment(drone)} -- and a wreck jumps nowhere. It repairs while you rest somewhere safe.`;
         }
         // Jumping into a DEPLOYED frame seizes it WHEREVER it flies (player
         // request -- jumping in rides the link, not your hands): the
@@ -66,15 +67,25 @@ export class JumpCommand extends Command {
         // position, not your body's. Only a frame mid-exchange refuses --
         // combat holds live references to the shell.
         let seizedRoom;
+        let seizedSpot;
+        let seizedCell;
         const flying = this.game?.companions.find(c => c.boundDevice === drone);
         if (flying) {
             if (flying.npc.inExchange) {
                 return `The ${drone.name} is fighting for its life -- the link can't seize a bucking frame mid-exchange. Let it settle first.`;
             }
+            // The frame's CELL comes with its room (rigger pass 2026-09-06):
+            // seizing used to carry the room and drop the cell, so the rigger
+            // snapped into the frame's room at their body's cell -- across the
+            // room from where the frame actually hovered.
             seizedRoom = flying.npc.currentLocation;
+            seizedSpot = flying.npc.atSpot;
+            seizedCell = flying.npc.atCell;
             this.game.dismissCompanion(flying, 'jumped into -- dog-brain yields the stick');
         }
         this.logger.write(`JumpCommand: ${actor.name} jumping into ${drone.name} (${mode}-sim)${seizedRoom ? ` -- seizing the deployed frame in ${seizedRoom.name}` : ''}.`);
+        // enterDrone FIRST: it sets the body's spot and cell aside from the
+        // actor's current values, which must still be the body's.
         const lines = enterDrone(this.scene, actor, drone, mode);
         if (seizedRoom && seizedRoom !== actor.currentLocation) {
             actor.currentLocation = seizedRoom;
@@ -83,6 +94,10 @@ export class JumpCommand extends Command {
         else if (flying) {
             lines.push(`The dog-brain stands down -- the stick is yours.`);
         }
+        if (flying) {
+            actor.atSpot = seizedSpot;
+            actor.atCell = seizedCell;
+        }
         this.scene.updateStatus();
         return lines.join('\n');
     }

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { fuzzyPickName, significantWords, normalizeLoose, wordsAreCloseEnough } from '../utilities/fuzzy-match.js';
 import { AI } from '../../../../tools/ai/ai.class.js';
+import { DRONE_COLOUR, DRONE_ICON, droneRecallLine } from '../utilities/drone-prose.js';
 /**
  * What "you have nobody" says, one phrase per COMPANION KIND.
  *
@@ -93,7 +94,7 @@ export class OrderCommand extends Command {
         const cmd = commandWords.join(' ');
         // The feed wears its plane's colors (player request: what the
         // companion SEES should read as coming through its senses) -- the
-        // same visual language the HUD already speaks: yellow ✈ for a
+        // same visual language the HUD already speaks: amber ✈ for a
         // drone's sensor feed, magenta ✧ for a spirit's otherworldly report,
         // cyan ▣ for an agent on the grid.
         const feed = OrderCommand.FEED[entry.kind] ?? OrderCommand.FEED.ally;
@@ -137,7 +138,10 @@ export class OrderCommand extends Command {
             const foldLine = entry.kind === 'spirit'
                 ? `${feed.icon} You speak the release. The spirit inclines its head -- the bargain closes${(entry.services ?? 0) > 0 ? `, ${entry.services} unspent service${entry.services === 1 ? '' : 's'} forfeit` : ''} -- and it thins back to its own plane.`
                 : entry.kind === 'drone'
-                    ? `${feed.icon} The ${entry.boundDevice?.name ?? entry.npc.name} banks once and settles back onto your hand, rotors folding.${entry.boundDevice && entry.boundDevice.droneDamage > 0 ? ` The airframe carries its dents (${entry.boundDevice.droneSummary()})${hint(' -- rest repairs it')}.` : ''}`
+                    // The same words "recall" speaks (drone-prose.ts), classed by
+                    // how the frame moves -- this line used to be a verbatim copy
+                    // of companions.ts's, and both said rotors to a Steel Lynx.
+                    ? `${feed.icon} ${entry.boundDevice ? droneRecallLine(entry.boundDevice) : `The ${entry.npc.name} comes back to hand.`}`
                     : this.actor.plane === 'matrix'
                         ? `${feed.icon} Your agent's icon collapses back into your persona -- folded into the deck.`
                         : `${feed.icon} The deck spins its agent down -- the DECK IN AR light dies as the icon folds home.`;
@@ -211,7 +215,9 @@ export class OrderCommand extends Command {
     // kind fails the build here.
     static FEED = {
         spirit: { color: 'magenta', icon: '✧' },
-        drone: { color: 'yellow', icon: '✈' },
+        // The rigger's amber (drone-prose.ts): the same constant the HUD
+        // and the room map paint with.
+        drone: { color: DRONE_COLOUR, icon: DRONE_ICON },
         agent: { color: 'cyan', icon: '▣' },
         // A sprite is a Matrix construct and reads cyan like the agent.
         // Without a row of its own it fell through to `ally` and rendered

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -321,5 +321,20 @@
 //   blocks and is blocked like anyone, and the rigger's body keeps its own
 //   spot for jump-out. Two tables on different versions disagree about
 //   where a drone stands.
-export const ENGINE_VERSION = '1.35.0';
+// 1.36.0 (2026-09-06): JUMP-OUT LEAVES THE FRAME DEPLOYED. COMMAND SEMANTICS
+//   in shared scenes: "jump" (out) no longer autopilots the frame home -- it
+//   re-shells on its dog-brain where it was (SR5 p.266/p.268-269: the drone
+//   reverts to Pilot on jump-out; nothing flies it back), at the frame's
+//   cell, whether it was deployed first or jumped from the hand; "recall"
+//   brings it home. A WRECKED frame (forced dump) does not re-shell.
+//   Jumping into a deployed frame now lands you at the frame's cell, not
+//   your body's. The room map draws a jumped-in rigger as an amber ✈ at the
+//   frame and the slumped body as 👤; drone feed/HUD lines are amber
+//   (#ffbf00). "jobs", "accept", "decline" and "call taxi" refuse a
+//   non-human actor. Deploy reports the frame's real Pilot; very-large
+//   frames get their cargo cap; a frame you cannot carry follows the cab
+//   under its own power; a locked door stops every frame but a palm-flier
+//   on the recon sweep. Two tables on different versions disagree about
+//   where a frame is after a jump-out.
+export const ENGINE_VERSION = '1.36.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -182,6 +182,7 @@ import { CALL_ICON, CALL_COLOR, END_CALL_SENTINEL } from './utilities/comm-style
 import { AI } from '../../../tools/ai/ai.class.js';
 import { BULLET } from './utilities/log-style.js';
 import { spotOf, resolveSpot } from './utilities/spots.js';
+import { DRONE_COLOUR, DRONE_ICON, droneFoldForTravelLine, droneUnfoldAtCurbLine } from './utilities/drone-prose.js';
 export default class Game {
     initialized;
     static instance;
@@ -1413,13 +1414,18 @@ export default class Game {
     }
     /**
      * The autonomous-drone shell, shared by the deploy command and
-     * arrival re-shelling: the frame's dog-brain (Pilot = 2 + quality)
-     * stands in for every attribute it lacks (RAW p.269-271).
+     * arrival re-shelling: the frame's dog-brain (Pilot: the row's, else
+     * 2 + quality -- Item.pilotRating) stands in for every attribute it
+     * lacks (RAW p.269-271).
      */
     // Cargo sling by frame class (player request: capacity enforced -- a
-    // palm-sized Fly-Spy is not a mule). Keyed by the frame Item's size.
+    // palm-sized Fly-Spy is not a mule). Keyed by the frame Item's size --
+    // the enum VALUE, and by the enum itself so a size the table forgets
+    // fails the build: this was a string map keyed `huge`, which is not a
+    // Size, while `'very large'` was missing, so every VeryLarge frame
+    // (a 400 kg Kodiak) fell to the 2 kg default -- less than a Medium.
     static DRONE_CARGO_KG = {
-        tiny: 0.5, small: 2, medium: 8, large: 20, huge: 40,
+        [Size.Tiny]: 0.5, [Size.Small]: 2, [Size.Medium]: 8, [Size.Large]: 20, [Size.VeryLarge]: 40,
     };
     deployDroneShell(item, room) {
         // The drone's own Pilot, Body and mount (catalog v13 vehicle block; the
@@ -1436,7 +1442,7 @@ export default class Game {
         // Take-command weight checks (Player.addInventory) enforce this cap
         // for the shell exactly as they do for a runner.
         if (shell)
-            shell.maxCarryingWeight = Game.DRONE_CARGO_KG[String(item.size)] ?? 2;
+            shell.maxCarryingWeight = Game.DRONE_CARGO_KG[item.size] ?? 2;
         return shell;
     }
     /** Drops a companion's shell and its roster entry. */
@@ -1622,7 +1628,12 @@ export default class Game {
                 }
             }
             else if (entry.kind === 'drone') {
-                lines.push(`The ${entry.boundDevice?.name ?? 'drone'} autopilots home to your hand for the ride.`);
+                // A frame you can carry rides with you; one you cannot (a 120 kg
+                // Steel Lynx, a 400 kg Kodiak) follows the cab on its own
+                // dog-brain and meets you at the curb (user ruling 2026-09-06;
+                // SR5 p.269 the Pilot drives). Same stash either way -- the
+                // shell re-lands at the arrival room -- only the words differ.
+                lines.push(entry.boundDevice ? droneFoldForTravelLine(entry.boundDevice) : `The drone folds for the ride.`);
                 if (entry.boundDevice)
                     this._pendingRedeploys.push(entry.boundDevice);
             }
@@ -1644,7 +1655,7 @@ export default class Game {
                 continue;
             const shell = this.deployDroneShell(item, this.player.currentLocation);
             if (shell)
-                lines.push(`The ${item.name}'s rotors spin back up at the curb.`);
+                lines.push(droneUnfoldAtCurbLine(item));
         }
         // EVERY registered sprite re-shells from the PAN (register.ts).
         // splice(0) drains the stash exactly once, the way the drone loop
@@ -3609,6 +3620,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         endPersona(this.player);
         this.player.astralTicks = 0;
         this.player.activeDeck = undefined;
+        // A frame ridden into the cab is an Item in the pack again, not a
+        // companion (foldCompanionsForTravel ran first and never saw it), so
+        // unlike planes.leaveDrone this path re-shells nothing: the curb
+        // loop only re-lands what was folded.
         this.player.riggedDrone = undefined;
         this.player.astralPerceiving = false;
         this.player.sneaking = false;
@@ -5443,7 +5458,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             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}`);
+            // Amber, the rigger's colour (drone-prose.ts): the same hex the
+            // room map paints the jumped-in icon with.
+            lines.push(`{${DRONE_COLOUR}-fg}${DRONE_ICON} JUMPED IN: ${drone?.name ?? 'drone'} ${(player.simMode ?? 'cold').toUpperCase()}-SIM${mount}${hull} -- body at ${player.bodyRoom?.name ?? '???'}{/${DRONE_COLOUR}-fg}`);
         }
         return lines;
     }

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

@@ -10,6 +10,7 @@ import { spotsActive, spotOf, describeSpotRoster, spotDistanceMeters, spotCoverB
 import { classifyWeapon, rangePenalty, rangeBracketName } from '../utilities/range.js';
 import { priceOf } from '../utilities/commerce.js';
 import { catalogGear, ROLE_DOMAINS } from '../utilities/catalog.js';
+import { DRONE_COLOUR, DRONE_ICON } from '../utilities/drone-prose.js';
 /**
  * BARRIERS AT YOUR POST (a real session: a beaten sentry announced he
  * was "unlocking" a spell-sealed hatch he could never open -- his AI had
@@ -703,7 +704,9 @@ export class NPC extends Player {
     // HUD and order.ts speak.
     static LINK_STYLE = {
         spirit: { color: 'magenta', icon: '✧' },
-        drone: { color: 'yellow', icon: '✈' },
+        // The rigger's amber (drone-prose.ts): one constant for the feed,
+        // the HUD and the room map, so "amber" means one thing everywhere.
+        drone: { color: DRONE_COLOUR, icon: DRONE_ICON },
         agent: { color: 'cyan', icon: '▣' },
         // A sprite is a Matrix construct and relays cyan like the agent.
         // With no arm of its own it fell through to `ally` and a sprite

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-exchange.js

@@ -3,6 +3,7 @@ import { crashIC } from './ic-actors.js';
 import { samePlace } from './matrix-roster.js';
 import { NPC } from '../models/npc.js';
 import { rollPool, formatRoll, rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP } from './dice.js';
+import { droneComesApartLine } from './drone-prose.js';
 import { leaveMatrix, leaveDrone } from './planes.js';
 import { spotOf, spotCell, seatingIn, actorCell, OPEN_FLOOR, isInCover, coverAvailableFor, takeCoverHere } from './spots.js';
 import { heldBy } from './grapple.js';
@@ -619,7 +620,7 @@ export class CombatExchange {
                 lines.push(`  ${defender.name} takes ${dealt} box${dealt === 1 ? '' : 'es'} to the airframe: ${device.droneSummary()}`);
                 if (device.isWrecked) {
                     defender.takeDamage(defender.maxConditionBoxes);
-                    lines.push(`  The frame comes apart -- rotors, casing, sparks.`);
+                    lines.push(`  ${droneComesApartLine(device)}`);
                 }
                 return { world: [...lines, ...dryWarning], meta };
             }
@@ -660,7 +661,7 @@ export class CombatExchange {
                 }
             }
             if (drone.isWrecked) {
-                lines.push(`  ${drone.name} comes apart mid-air -- rotors, casing, sparks --`);
+                lines.push(`  ${droneComesApartLine(drone)}`);
                 lines.push(...leaveDrone(this.scene, defender, { forced: true, reason: `The airframe dies around you.` }));
             }
             return { world: [...lines, ...dryWarning], meta };
@@ -830,7 +831,9 @@ export class CombatExchange {
                     : companionKind === 'agent'
                         ? `${fallen.name} DEREZZES -- its icon shears into static and rains out of the grid, gone with the deck that ran it.`
                         : companionKind === 'drone'
-                            ? `${fallen.name} comes apart -- rotors, plating, and sparks skidding across ${room.name}. The frame is wrecked.`
+                            ? (fallen instanceof NPC && fallen.boundDevice
+                                ? droneComesApartLine(fallen.boundDevice, room.name)
+                                : `${fallen.name} comes apart -- plating and sparks skidding across ${room.name}. The frame is wrecked.`)
                             : (opts?.fatal ?? true)
                                 ? `${fallen.name} goes down -- dead before they hit the floor. The body lies where it fell.`
                                 : `${fallen.name} collapses, out cold -- down for the count, but still breathing.`;

package/bundle/typescript/src/commands/game/sideQuest/utilities/drone-prose.js

@@ -0,0 +1,289 @@
+import { Size } from '../types/shared/item-enum.js';
+import { hint } from './hints.js';
+/**
+ * ONE VOICE FOR EVERY FRAME (rigger pass, 2026-09-06). Every drone verb
+ * used to speak rotorcraft: a 120 kg wheeled Steel Lynx "lifts off your
+ * hand and settles into a watchful hover", a 400 kg Kodiak "autopilots
+ * home to your hand for the ride" and "folds back into your kit". The
+ * catalog knows better -- every drone row carries `shape`, `size`,
+ * `weight` and a vehicle block -- so the words come from here, classed
+ * by how the frame actually moves, and every verb that says anything
+ * about a frame moving (deploy, recall, order home, travel fold and
+ * curb, jump in, jump out, the recon sweep, a wreck) says it through
+ * one of these. The same shape as comm-style.ts: icon, colour, and the
+ * wording, in one place.
+ *
+ * AMBER IS THE RIGGER'S COLOUR (player ruling 2026-09-06: "when jumped
+ * into the drone, I'd like the player icon to change to amber to match
+ * the color scheme"). The drone rows of the HUD and the order feed used
+ * plain yellow; this is the first named colour in the game tree, a hex
+ * blessed accepts in a tag ({#ffbf00-fg}, the same way logo-mark.ts
+ * paints the mark), so "amber" means one thing on the map, the HUD and
+ * the feed. ✈ is the drone icon the feed already spoke; it is a BMP
+ * dingbat, so unlike 👤 it actually takes a foreground colour.
+ */
+export const DRONE_COLOUR = '#ffbf00';
+export const DRONE_ICON = '✈';
+export function droneLocomotion(item) {
+    const shape = (item.row?.shape ?? item.shape ?? '').toLowerCase();
+    if (shape === 'insect' || shape === 'disc')
+        return 'flier-palm';
+    if (shape === 'rotary' || shape === 'vtol' || shape === 'vstol')
+        return 'flier';
+    if (shape === 'missile')
+        return 'missile';
+    if (shape === 'walker')
+        return 'walker';
+    if (shape === 'anthroform' || item.vehicle?.anthro)
+        return 'anthro';
+    if (shape === 'wheeled' || shape === 'tracked' || shape === 'hull')
+        return 'ground';
+    if (item.size === Size.Tiny)
+        return 'flier-palm';
+    if (item.size === Size.Small && item.weight <= 5)
+        return 'flier';
+    return 'ground';
+}
+/**
+ * Whether the frame rides in your hands (or pocket, or pack) when you
+ * travel. Everything Large or bigger answers no, whatever its shape;
+ * fliers, walkers and the palm-sized answer yes; an anthroform or a
+ * missile only when it is Tiny/Small; a ground frame never. The rest
+ * follow a cab under their own dog-brain (SR5 p.269: the Pilot program
+ * drives; Rigger 5.0 p.174: the autopilot obeys traffic law) and meet
+ * you at the curb -- which is what foldCompanionsForTravel always did,
+ * it just used to claim a Kodiak fit in your hand.
+ */
+export function droneHandHeld(item) {
+    if (item.size === Size.Large || item.size === Size.VeryLarge)
+        return false;
+    const loco = droneLocomotion(item);
+    if (loco === 'flier-palm' || loco === 'flier' || loco === 'walker')
+        return true;
+    if (loco === 'ground')
+        return false;
+    return item.size === Size.Tiny || item.size === Size.Small;
+}
+const big = (item) => item.size === Size.Large || item.size === Size.VeryLarge;
+const pick = (item, lines) => lines[droneLocomotion(item)];
+/** The third-person fragment after "<name> --" in the deploy broadcast. */
+export function droneLaunchAction(item, from) {
+    if (from === 'garage') {
+        return pick(item, {
+            'flier-palm': 'whirring up off the bench and out of the bay',
+            flier: 'lifting off the bench and out of the bay',
+            ground: 'rolling out of the garage under its own power',
+            walker: 'walking out of the bay on its own legs',
+            anthro: 'stepping out of the bay',
+            missile: 'kicking off its rack and circling the bay',
+        });
+    }
+    return pick(item, {
+        'flier-palm': 'micro-rotors whining up off their palm',
+        flier: 'rotors spinning up to a hover',
+        ground: 'rolling off under its own power',
+        walker: 'unfolding its legs',
+        anthro: 'standing up and squaring its shoulders',
+        missile: 'kicking off its rail',
+    });
+}
+/** The deploy line itself, second person; the caller adds the Pilot. */
+export function droneLaunchLine(item, from) {
+    const name = item.name;
+    if (from === 'garage') {
+        return pick(item, {
+            'flier-palm': `The ${name} whirs up off the bench and out of the bay to hang at eye level`,
+            flier: `The ${name} lifts off the bench and out of the bay into a watchful hover`,
+            ground: `The ${name} wakes in the bay and rolls out under its own power, idling beside you`,
+            walker: `The ${name} walks out of the bay on its own legs and settles at your feet`,
+            anthro: `The ${name} steps out of the bay, squares its shoulders, and waits`,
+            missile: `The ${name} kicks off its rack and holds a tight circle over the bay`,
+        });
+    }
+    return pick(item, {
+        'flier-palm': `The ${name} whines up off your palm and hangs at eye level`,
+        flier: `The ${name} lifts off your hand and settles into a watchful hover`,
+        ground: big(item)
+            ? `The ${name} wakes where it sits and rolls forward under its own power, idling beside you`
+            : `You set the ${name} down; it wakes and idles at your feet, motors ticking`,
+        walker: `The ${name} unfolds its legs off your hand and picks its way to the floor`,
+        anthro: big(item) || item.size === Size.Medium
+            ? `The ${name} stands up, squares its shoulders, and waits`
+            : `The ${name} climbs down off your pack and stands`,
+        missile: `The ${name} kicks off its rail and holds a tight circle overhead`,
+    });
+}
+/** Recall / "order <drone> home": the frame comes back to you. */
+export function droneRecallLine(item) {
+    const name = item.name;
+    const back = pick(item, {
+        'flier-palm': `The ${name} loops back and settles onto your palm, rotors stilling.`,
+        flier: `The ${name} banks once and settles back onto your hand, rotors folding.`,
+        ground: `The ${name} rolls back to your side and powers down.`,
+        walker: `The ${name} picks its way back and folds its legs into your hand.`,
+        anthro: `The ${name} walks back and powers down at your side.`,
+        missile: `The ${name} comes around and settles onto its rail, turbine spooling down.`,
+    });
+    const dents = item.droneDamage > 0
+        ? ` The frame carries its dents (${item.droneSummary()})${hint(' -- rest repairs it')}.`
+        : '';
+    return `${back}${dents}`;
+}
+/** Pre-travel: how the frame gets to the cab, or does not need one. */
+export function droneFoldForTravelLine(item) {
+    const name = item.name;
+    if (droneHandHeld(item)) {
+        return pick(item, {
+            'flier-palm': `The ${name} tucks into your pocket for the ride.`,
+            flier: `The ${name} autopilots home to your hand for the ride.`,
+            ground: `The ${name} rides in the pack.`,
+            walker: `The ${name} folds its legs and rides in the pack.`,
+            anthro: `The ${name} climbs into the pack for the ride.`,
+            missile: `The ${name} rides racked for the trip.`,
+        });
+    }
+    return pick(item, {
+        'flier-palm': `The ${name} flies alongside the cab -- it will meet you at the curb.`,
+        flier: `The ${name} flies alongside the cab on its own dog-brain -- it will meet you at the curb.`,
+        ground: `The ${name} falls in behind the cab on its own dog-brain -- it will meet you at the curb.`,
+        walker: `The ${name} takes its own way there on its own legs -- it will meet you at the curb.`,
+        anthro: `The ${name} takes its own way there on its own two legs -- it will meet you at the curb.`,
+        missile: `The ${name} shadows the cab from altitude -- it will meet you at the curb.`,
+    });
+}
+/** Post-arrival: the frame re-shells at the curb. */
+export function droneUnfoldAtCurbLine(item) {
+    const name = item.name;
+    if (droneHandHeld(item)) {
+        return pick(item, {
+            'flier-palm': `The ${name} whirs up off your palm at the curb.`,
+            flier: `The ${name}'s rotors spin back up at the curb.`,
+            ground: `The ${name} drops off its sling and idles at the curb.`,
+            walker: `The ${name} unfolds its legs at the curb.`,
+            anthro: `The ${name} hops down at the curb and stands.`,
+            missile: `The ${name} kicks off its rail at the curb.`,
+        });
+    }
+    return pick(item, {
+        'flier-palm': `The ${name} is already hanging at the curb when you step out.`,
+        flier: `The ${name} is already hovering at the curb when you step out.`,
+        ground: `The ${name} pulls up at the curb behind the cab, motors ticking.`,
+        walker: `The ${name} is already waiting at the curb, legs folded under it.`,
+        anthro: `The ${name} is already waiting at the curb.`,
+        missile: `The ${name} drops out of its circle and picks up station over the curb.`,
+    });
+}
+/** The "jumps into" broadcast fragment after the verb. */
+export function droneJumpInAction(item, mode) {
+    const wake = pick(item, {
+        'flier-palm': 'the micro-rotors whine up',
+        flier: 'the rotors spin up',
+        ground: 'the drive motors wake',
+        walker: 'the legs take the weight',
+        anthro: 'the frame\'s limbs answer theirs',
+        missile: 'the turbine spools',
+    });
+    return `${item.name} -- body going slack as ${wake} (${mode}-sim)`;
+}
+/** The sensor-sight slot in the jump-in line ("...you ARE the X now, <this>, your body slumped..."). */
+export function droneJumpInFragment(item) {
+    return pick(item, {
+        'flier-palm': 'micro-rotors whining',
+        flier: 'rotors humming',
+        ground: 'drive motors humming under you',
+        walker: 'legs ticking under you',
+        anthro: 'servos whining in your limbs',
+        missile: 'turbine screaming',
+    });
+}
+/**
+ * Jump-out: the frame STAYS where it is on its dog-brain (SR5 p.266,
+ * p.268-269: the drone reverts to its Pilot program when the rigger
+ * leaves; nothing flies it home). Same room or another, the line says
+ * where it was left.
+ */
+export function droneJumpOutLine(item, frameRoom, bodyRoom) {
+    const holds = pick(item, {
+        'flier-palm': 'holds its hover',
+        flier: 'holds its hover',
+        ground: 'sits where it stopped, motors idling',
+        walker: 'stands where it is',
+        anthro: 'stands where it is, holding the pose',
+        missile: 'holds its circle overhead',
+    });
+    const where = frameRoom === bodyRoom ? 'where you left it' : `in ${frameRoom.name}`;
+    return `You're back in your body in ${bodyRoom.name}; the ${item.name} ${holds} ${where} -- dog-brain on the stick.${hint(' ("recall" brings it home.)')}`;
+}
+/** The recon sweep ("drone"): nowhere to go, launch, and return. */
+export function droneReconNowhereLine(item) {
+    return pick(item, {
+        'flier-palm': `The ${item.name} lifts, circles once -- nowhere to go from here.`,
+        flier: `The ${item.name} lifts, circles once -- nowhere to go from here.`,
+        ground: `The ${item.name} rolls a slow loop -- nowhere to go from here.`,
+        walker: `The ${item.name} picks a circle around your feet -- nowhere to go from here.`,
+        anthro: `The ${item.name} looks around -- nowhere to go from here.`,
+        missile: `The ${item.name} climbs, circles once -- nowhere to go from here.`,
+    });
+}
+export function droneReconLaunchLine(item, rollText, ok) {
+    const off = pick(item, {
+        'flier-palm': `The ${item.name} whirs off your palm`,
+        flier: `The ${item.name} lifts off your hand`,
+        ground: `The ${item.name} rolls off`,
+        walker: `The ${item.name} scuttles off`,
+        anthro: `The ${item.name} walks off`,
+        missile: `The ${item.name} kicks off its rail`,
+    });
+    if (!ok)
+        return `${off} -- Piloting: ${rollText}`;
+    const threads = pick(item, {
+        'flier-palm': 'threads the gaps',
+        flier: 'threads the gaps',
+        ground: 'noses through the doorways',
+        walker: 'picks through the gaps',
+        anthro: 'goes to look',
+        missile: 'makes a fast pass',
+    });
+    return `${off} and ${threads} -- Piloting: ${rollText}. Feed incoming:`;
+}
+export function droneReconReturnLine(item) {
+    return pick(item, {
+        'flier-palm': `The ${item.name} loops home and folds back into your kit.`,
+        flier: `The ${item.name} banks home and folds onto your hand.`,
+        ground: `The ${item.name} rolls back and powers down at your feet.`,
+        walker: `The ${item.name} picks its way back into your hand.`,
+        anthro: `The ${item.name} walks back and powers down.`,
+        missile: `The ${item.name} comes around and settles onto its rail.`,
+    });
+}
+/** Can this frame get past a locked door on the recon sweep? Only the
+ *  palm-sized fliers slip a vent; everything else is stopped by a door
+ *  like anyone. */
+export function droneSlipsVents(item) {
+    return droneLocomotion(item) === 'flier-palm';
+}
+/** What a wreck of this frame looks like: "bent rotors, dead boards". */
+export function droneWreckFragment(item) {
+    return pick(item, {
+        'flier-palm': 'crushed rotors, dead boards',
+        flier: 'bent rotors, dead boards',
+        ground: 'buckled frame, dead boards',
+        walker: 'snapped legs, dead boards',
+        anthro: 'dead servos, dead boards',
+        missile: 'torn fins, dead boards',
+    });
+}
+/** The moment of wrecking, in a fight. */
+export function droneComesApartLine(item, roomName) {
+    const bits = pick(item, {
+        'flier-palm': 'rotors, casing, sparks',
+        flier: 'rotors, casing, sparks',
+        ground: 'plating, wheels, sparks',
+        walker: 'legs, casing, sparks',
+        anthro: 'limbs, plating, sparks',
+        missile: 'fins, casing, fire',
+    });
+    const where = roomName ? ` skidding across ${roomName}` : '';
+    return `${item.name} comes apart -- ${bits}${where}. The frame is wrecked.`;
+}
+//# sourceMappingURL=drone-prose.js.map

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

@@ -7,6 +7,7 @@ import { fuzzyPickName } from './fuzzy-match.js';
 import { resetOverwatch } from './overwatch.js';
 import { rebootWipe } from './marks.js';
 import { hint } from './hints.js';
+import { droneJumpInAction, droneJumpInFragment, droneJumpOutLine, droneWreckFragment } from './drone-prose.js';
 /**
  * Plane transitions and their tolls -- the one place that moves an actor
  * between meat, Matrix, and astral (see Player.plane for the model).
@@ -288,7 +289,7 @@ export function enterDrone(scene, actor, drone, mode) {
     actor.simMode = mode;
     actor.riggedDrone = drone;
     actor.sneaking = false;
-    actor.performAction('jumps into', `${drone.name} -- body going slack as the rotors spin up (${mode}-sim)`);
+    actor.performAction('jumps into', droneJumpInAction(drone, mode));
     scene.addWorldEvent(`${actor.name} jumped into ${drone.name} in ${actor.bodyRoom.name}.`);
     Logger.getInstance().write(`${actor.name} jumped into ${drone.name} (${mode}-sim, hull ${drone.droneSummary()}) from ${actor.bodyRoom.name}.`);
     const hullNote = drone.droneDamage > 0 ? ` The airframe is already scarred: ${drone.droneSummary()}.` : '';
@@ -296,8 +297,8 @@ export function enterDrone(scene, actor, drone, mode) {
         ? ` Hot-sim: the machine answers like your own skin -- and every hit it takes bleeds PHYSICAL into yours.`
         : ` Cold-sim: hits on the hull sting through the link as stun, half strength.`;
     return [
-        `The rig takes hold and the world snaps to sensor-sight -- you ARE the ${drone.name} now, rotors humming, your body slumped and empty in ${actor.bodyRoom.name}.${hotWarning}${hullNote}`,
-        hint(`Move with "go" (you fly the meat world; locked doors still stop an airframe), "look" through the sensors, "jump" again to drop back into your body.`),
+        `The rig takes hold and the world snaps to sensor-sight -- you ARE the ${drone.name} now, ${droneJumpInFragment(drone)}, your body slumped and empty in ${actor.bodyRoom.name}.${hotWarning}${hullNote}`,
+        hint(`Move with "go" (you fly the meat world; locked doors still stop an airframe), "look" through the sensors, "jump" again to drop back into your body -- the frame stays out on its dog-brain where you leave it; "recall" brings it home.`),
     ].filter(l => l.length > 0);
 }
 /**
@@ -308,11 +309,27 @@ export function enterDrone(scene, actor, drone, mode) {
  * Willpower-only resist -- the same softening the Matrix side had, minus
  * the Firewall term, plus the only correct half either copy had (the
  * p.229 disorientation, which the Matrix side was missing entirely).
+ *
+ * THE FRAME STAYS WHERE IT IS (user ruling 2026-09-06, and canon: SR5
+ * p.266 / p.268-269 -- when the rigger leaves, the drone reverts to its
+ * Pilot program at the next Combat Turn; nothing flies it home). This
+ * used to say the frame "autopilots home to your hand", which was both
+ * a deviation and a lie to a rigger who deployed a frame, seized it two
+ * rooms away and let go: the frame vanished. Now it re-shells on its
+ * dog-brain in the frame's room, at the frame's cell, whether you
+ * deployed it first or jumped straight from your hand, and "recall"
+ * brings it home. A WRECKED frame (the forced dump) never re-shells.
+ * Ordered AFTER the body is put back so seatingIn sees the rigger on
+ * bodyCell before the shell claims frameCell.
  */
 export function leaveDrone(scene, actor, opts) {
     const lines = [];
     const body = actor.bodyRoom;
     const drone = actor.riggedDrone;
+    // Where the FRAME is, captured before the body restore overwrites it.
+    const frameRoom = actor.currentLocation;
+    const frameSpot = actor.atSpot;
+    const frameCell = actor.atCell;
     if (opts?.forced) {
         lines.push(...applyDumpshock(actor, opts.reason ?? `The link dies with the airframe.`));
     }
@@ -320,7 +337,7 @@ export function leaveDrone(scene, actor, opts) {
         lines.push(`You let go of the machine and drop back down the link.`);
     }
     if (drone?.isWrecked) {
-        lines.push(`The ${drone.name} is WRECKED -- bent rotors, dead boards. It repairs while you rest somewhere safe.`);
+        lines.push(`The ${drone.name} is WRECKED -- ${droneWreckFragment(drone)}. It repairs while you rest somewhere safe.`);
     }
     actor.plane = 'meat';
     actor.simMode = undefined;
@@ -336,8 +353,18 @@ export function leaveDrone(scene, actor, opts) {
         actor.atCell = actor.bodyCell;
         actor.bodySpot = undefined;
         actor.bodyCell = undefined;
-        lines.push(drone && !drone.isWrecked
-            ? `You're back in your body in ${body.name}; the ${drone.name} autopilots home to your hand.`
+        // The dog-brain takes the stick where the frame is (see above).
+        const game = scene.ownerGame;
+        const shell = drone && !drone.isWrecked && game && frameRoom
+            ? game.deployDroneShell(drone, frameRoom)
+            : null;
+        if (shell) {
+            shell.atSpot = frameSpot;
+            shell.atCell = frameCell;
+            Logger.getInstance().write(`${drone.name} re-shelled on its dog-brain in ${frameRoom.name} after ${actor.name} jumped out.`);
+        }
+        lines.push(shell && drone
+            ? droneJumpOutLine(drone, frameRoom, body)
             : `You're back in your body in ${body.name}.`);
     }
     actor.performAction('jumps out', 'stirring awake as the rig releases');

package/bundle/typescript/src/commands/game/sideQuest/utilities/room-view.js

@@ -2,6 +2,7 @@ import { capitalCase } from 'change-case';
 import { Direction } from '../types/shared/direction-enum.js';
 import { OPEN_FLOOR, spotOf, visibleActorsIn, exitSpot, seatingIn, theSpot } from './spots.js';
 import { placeName } from './log-style.js';
+import { DRONE_COLOUR, DRONE_ICON } from './drone-prose.js';
 import { key, levelFootprint, dimsForSize, tallestRoomRows, METERS_PER_LEVEL, } from './room-grid.js';
 /**
  * THE ROOM LAYOUT (spatial-viz follow-up, 2026-08-25): an ASCII top-down
@@ -83,6 +84,24 @@ const HOSTILE_GLYPH = '⚔';
  *  A star reads as "yours" without pretending to be a person you can
  *  hand the controls to. */
 const CREW_GLYPH = '★';
+/**
+ * YOU, JUMPED INTO A DRONE (player ruling 2026-09-06: "when jumped into
+ * the drone, I'd like the player icon to change to amber to match the
+ * color scheme. Also, the player's neutral color icon (meat body)
+ * should remain").
+ *
+ * While rigged, the viewer's presence is the FRAME, and it drew as the
+ * same uncoloured 👤 as their body would -- and the body, slumped in
+ * bodyRoom, did not draw at all (seatingIn seats an actor once, at the
+ * frame). So a rigger looking at a room holding both saw one figure and
+ * could not say which. Now the frame is the drone icon the feed and the
+ * HUD already speak (✈, drone-prose.ts), in the rigger's amber -- a
+ * BMP dingbat, so unlike the emoji it really takes the colour -- and
+ * the body keeps the plain 👤 at the cell it was left in. Shape AND
+ * colour differ, as this panel's rulings require. An autopilot frame
+ * (a companion shell) is still the crew's ★: it is yours, not you.
+ */
+const RIGGED_GLYPH = DRONE_ICON;
 /** A CORPSE -- a body left where it fell, lootable (Room.bodies). */
 const DEAD_GLYPH = '💀';
 /**
@@ -203,7 +222,13 @@ function buildRenderMaps(grid, room, viewer) {
     const corpses = new Map();
     for (const b of room.bodies)
         corpses.set(key(b.cell), b.name);
-    return { cellToSpot, cellToExit, verticalAt, cellTerrain, occupants, corpses };
+    // The rigger's body, where it slumped (see RIGGED_GLYPH): seatingIn
+    // seats the viewer once, at the FRAME, so the body has to be placed
+    // from the cell enterDrone set aside.
+    const slumpedBody = viewer.plane !== 'meat' && viewer.bodyRoom === room && viewer.bodyCell
+        ? key(viewer.bodyCell)
+        : undefined;
+    return { cellToSpot, cellToExit, verticalAt, cellTerrain, occupants, corpses, slumpedBody };
 }
 function paint(g) {
     const body = g.inverse ? `{inverse}${g.ch}{/inverse}` : g.ch;
@@ -258,8 +283,13 @@ function actorGlyph(a, viewer, isOtherPlayer, isTableAlly) {
         return { ch: DOWNED_GLYPH, color: 'yellow' };
     // YOU keep the emoji; a fellow runner is the one who changes. Both
     // branches existed already and returned the identical icon.
-    if (a === viewer)
-        return { ch: PLAYER_GLYPH, wide: true };
+    // ...unless you are riding a frame: then this cell is the DRONE, in
+    // the rigger's amber, and the emoji is your body (see RIGGED_GLYPH).
+    if (a === viewer) {
+        return viewer.plane === 'drone'
+            ? { ch: RIGGED_GLYPH, color: DRONE_COLOUR }
+            : { ch: PLAYER_GLYPH, wide: true };
+    }
     if (isOtherPlayer?.(a))
         return { ch: OTHER_PLAYER_GLYPH, color: OTHER_PLAYER_COLOR };
     // Your own people read as yours even mid-fight -- knowing which of
@@ -311,7 +341,10 @@ function glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly) {
             ?? glyphs.find(g => g.ch === NEUTRAL_GLYPH)
             ?? glyphs[0];
     }
-    // Nobody standing here -- but something may be lying here.
+    // Nobody standing here -- but something may be lying here: your own
+    // slumped body first (it is what you are looking for), then the dead.
+    if (maps.slumpedBody === k)
+        return { ch: PLAYER_GLYPH, wide: true };
     if (maps.corpses.has(k))
         return { ch: DEAD_GLYPH, wide: true };
     const terrain = maps.cellTerrain.get(k);
@@ -465,6 +498,13 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly) {
         present.has(PLAYER_GLYPH)
             ? `${PLAYER_GLYPH} you (${NARROW_SUBSTITUTE[PLAYER_GLYPH]} in the side panel, where cells are one column)`
             : '',
+        // Jumped in: the amber frame is you, the plain figure is your body.
+        present.has(RIGGED_GLYPH)
+            ? `{${DRONE_COLOUR}-fg}${RIGGED_GLYPH}{/${DRONE_COLOUR}-fg} you, jumped in (${viewer.riggedDrone?.name ?? 'drone'})`
+            : '',
+        maps.slumpedBody !== undefined
+            ? `${PLAYER_GLYPH} your body, slumped (${NARROW_SUBSTITUTE[PLAYER_GLYPH]} in the side panel)`
+            : '',
         present.has(OTHER_PLAYER_GLYPH) ? `{${OTHER_PLAYER_COLOR}-fg}${OTHER_PLAYER_GLYPH}{/${OTHER_PLAYER_COLOR}-fg} runner` : '',
         present.has(CREW_GLYPH) ? `{green-fg}${CREW_GLYPH}{/green-fg} yours` : '',
         present.has(NEUTRAL_GLYPH) ? `{white-fg}${NEUTRAL_GLYPH}{/white-fg} local` : '',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.130.0",
+  "version": "5.131.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",