@maka/maka-cli 5.49.0 → 5.51.0

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

@@ -12,6 +12,7 @@ import { DOCWAGON_TIERS, RESUSC_FEE, DEATH_COMP } from './utilities/docwagon.js'
 import { isFence, LIFESTYLE_TIERS } from './utilities/commerce.js';
 import { bestFakeSin, wandRead, processArrest } from './utilities/sin.js';
 import { renderMapViewport } from './utilities/map-view.js';
+import { renderRoomLayoutCompact } from './utilities/room-view.js';
 import { getPref } from './utilities/prefs.js';
 import { rollPool, formatRoll } from './utilities/dice.js';
 import { Direction } from './types/shared/direction-enum.js';
@@ -21,6 +22,8 @@ import { currentSession } from './utilities/session-context.js';
 import { PlayersCommand } from './commands/players.js';
 import { LookCommand } from './commands/look.js';
 import { TakeCommand } from './commands/take.js';
+import { LootCommand } from './commands/loot.js';
+import { NoteCommand } from './commands/note.js';
 import { GoCommand } from './commands/go.js';
 import { UseCommand } from './commands/use.js';
 import { EquipCommand } from './commands/equip.js';
@@ -146,6 +149,9 @@ export default class Game {
     /** The floating icon-minimap (map-overlay wave 2026-08-24). Optional:
      *  headless sessions never build widgets. */
     _mapBox;
+    /** Its twin, docked to its right: the current room's own layout
+     *  (spatial-viz follow-up 2026-08-25). See utilities/room-view.ts. */
+    _roomMapBox;
     _useAi = false;
     _aiRefusalAnnounced = false;
     // ACCOUNT BINDING (ruling 2026-08-23): who this runner belongs to,
@@ -1081,9 +1087,13 @@ export default class Game {
      * Returns a player-facing line when something changed, else null.
      */
     /** A hub-cast member by name, for roster displays that need the live
-     *  actor (contacts.ts reads their commlink to show reachability). */
+     *  actor (contacts.ts reads their commlink to show reachability).
+     *  ROOM GRIDS wave (2026-08-25): falls back to the CURRENT run scene
+     *  so a live client (not yet a hub contact -- see onClientInteraction)
+     *  resolves too; call.ts already reaches them the same way. */
     hubActor(name) {
-        return this._hubScene?.allActors?.find(a => a.name === name && a !== this.player);
+        return this._hubScene?.allActors?.find(a => a.name === name && a !== this.player)
+            ?? (this.scene !== this._hubScene ? this.scene?.allActors?.find(a => a.name === name && a !== this.player) : undefined);
     }
     /** The whole hub cast -- call.ts merges these into its candidates so
      *  a linked contact answers from ANYWHERE (a real mid-run session:
@@ -1415,16 +1425,18 @@ export default class Game {
     // 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
+    // Taxi warn-once (player ruling): leaving with the pay 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.
+     * Returns the beat's text or null when this NPC isn't the client /
+     * nothing new happens. LUMP SUM (player ruling 2026-08-25, replacing
+     * canon p.28's half-up-front: the advance beat kept misfiring in
+     * play): the meet sets the terms, the wrap-up pays the WHOLE number.
+     * Completing the objective before ever meeting them still collapses
+     * cleanly -- the wrap-up is the only beat that moves money.
      */
     onClientInteraction(npcName) {
         const client = this.currentClient;
@@ -1438,30 +1450,22 @@ export default class Game {
         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}).`);
+            lines.push(`THE MEET: ${client.name} lays out the terms -- ${payout}¥ certified, in full, on delivery.${hint(` (The rate is negotiable exactly once: "haggle" while you have them.)`)}`);
+            Logger.getInstance().write(`Client meet: ${this.player.name} met ${client.name}, terms ${payout} lump sum on delivery.`);
         }
         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');
+            // The team's split comes off the top (canon: the crew shares the
+            // take) -- the player banks their share only. Payout read LIVE so
+            // a haggle at any point before delivery moves the real number.
+            const split = this.applyCrewCut(payout);
+            const paid = this.scene.payRunner(split.share, 'wrap-up settlement');
             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.`);
+                lines.push(`WRAP-UP: ${client.name} pays out in full -- ${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}).`);
+            Logger.getInstance().write(`Client wrap-up: ${this.player.name} reported to ${client.name}, settlement ${payout} (gross, crew took ${payout - 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
@@ -1611,6 +1615,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('look', LookCommand);
         CommandFactory.registerCommand('go', GoCommand);
         CommandFactory.registerCommand('take', TakeCommand);
+        CommandFactory.registerCommand('loot', LootCommand);
+        CommandFactory.registerCommand('note', NoteCommand);
         CommandFactory.registerCommand('use', UseCommand);
         CommandFactory.registerCommand('equip', EquipCommand);
         CommandFactory.registerCommand('unequip', UnequipCommand);
@@ -1830,6 +1836,29 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.initStatusBox(screen);
         this.initMapBox(screen); // docked atop the Mechanics column
         this._screen = screen;
+        // Paint the meat-plane border up front rather than leaving blessed's
+        // default until the first status refresh.
+        this.paintPlaneBorder();
+        // RESIZE REDRAWS (player request 2026-08-25). blessed re-solves its
+        // own percentage geometry on a resize, but the docked panels are
+        // drawn CONTENT, not layout: the district viewport's width and the
+        // room box's elevation justification are both computed from
+        // screen.width at paint time (see updateExits), so after a resize
+        // they kept the old terminal's dimensions until the next command
+        // happened to repaint them -- a map sized for a window that no
+        // longer exists, which is exactly how content spills a border.
+        screen.on('resize', () => {
+            try {
+                this.updateStatus();
+                const here = this.player?.currentLocation;
+                if (here)
+                    this.updateExits(here);
+                screen.render();
+            }
+            catch (err) {
+                Logger.getInstance().write(`resize redraw failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
     }
     /** The engine half of startup: scene synthesis, command registration,
      *  hub seeding, resume overlay -- no widget contact. */
@@ -2717,7 +2746,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // 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 }
+            ? { name: seed.client, met: false, reported: false }
             : undefined;
         this.forfeitArmed = false;
         // THE CLIENT REACHES OUT (ruling 2026-08-24, friction pass): the
@@ -2729,7 +2758,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const clientRoom = clientActor?.currentLocation?.name;
         const clientSpot = clientActor ? spotOf(clientActor) : undefined;
         const meetLine = seed.client
-            ? `\n📞 Your link chirps -- {bold}{underline}${seed.client}{/underline}{/bold}: "${clientRoom ? `I'm at ${clientRoom}${clientSpot ? `, the ${clientSpot}` : ''}` : `I'm on-site`} -- waiting on you. Come sit down before somebody else does." Half up front at the table; the rest on delivery.${hint(` (Find them and talk, or "call ${seed.client}" -- the rate is negotiable at the meet, once.)`)}`
+            ? `\n📞 Your link chirps -- {bold}{underline}${seed.client}{/underline}{/bold}: "${clientRoom ? `I'm at ${clientRoom}${clientSpot ? `, the ${clientSpot}` : ''}` : `I'm on-site`} -- waiting on you. Come sit down before somebody else does." Payment in full 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.
@@ -3159,22 +3188,32 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         screen.append(statusBox);
     }
     /**
-     * THE MINIMAP (map-overlay wave 2026-08-24): a small icon viewport
-     * DOCKED at the top of the Mechanics column -- not floated over the
-     * log (a float occluded log text and, being numerically anchored,
-     * drifted on terminal resize; percentage geometry re-solves both).
-     * The Mechanics pane shifts down while the map is shown and takes the
-     * space back when it hides. keys:false -- a keyable box appended
-     * after the input steals focus (the "eexxiitt" bug, see initInputBox).
-     * Hidden until the first setMapOverlay with content.
+     * THE MINIMAP (map-overlay wave 2026-08-24; split into a pair
+     * 2026-08-25 -- player ask: "ample space to split the existing map in
+     * two, one for the area, one for the room"): two small icon
+     * viewports DOCKED side by side at the top of the Mechanics column --
+     * not floated over the log (a float occluded log text and, being
+     * numerically anchored, drifted on terminal resize; percentage
+     * geometry re-solves both). The Mechanics pane shifts down while
+     * EITHER is shown and takes the space back only once both hide.
+     * keys:false -- a keyable box appended after the input steals focus
+     * (the "eexxiitt" bug, see initInputBox). Hidden until the first
+     * setMapOverlay/setRoomOverlay with content.
      */
-    static MAP_DOCK_ROWS = 11; // 9 viewport rows + border
+    // 9 viewport rows + a caption row (the room name / "@ spot", moved off
+    // the HUD 2026-08-25) + border.
+    static MAP_DOCK_ROWS = 12;
+    /** Must track the roomMapBox's `width` below -- updateExits derives
+     *  the inner width from it to right-justify the elevation bar. */
+    static ROOM_DOCK_PCT = 0.23;
+    /** Must track the mapBox's `width` below -- used to trim its caption. */
+    static MAP_DOCK_PCT = 0.12;
     initMapBox(screen) {
         const mapBox = blessed.box({
             id: 'mapBox',
             top: 0,
             left: '65%',
-            width: '35%',
+            width: '12%',
             height: Game.MAP_DOCK_ROWS,
             border: { type: 'line' },
             style: { border: { fg: 'blue' } },
@@ -3186,19 +3225,48 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         });
         this._mapBox = mapBox;
         screen.append(mapBox);
+        const roomMapBox = blessed.box({
+            id: 'roomMapBox',
+            top: 0,
+            // Much wider than its district twin: this box carries the grid,
+            // the elevation bar down its right side, AND (since the
+            // 2026-08-25 room resize) a `large` room's full 12 cells at two
+            // columns each -- the district view needs only its fixed 15-wide
+            // viewport, so the space is better spent here.
+            left: '77%',
+            width: '23%',
+            height: Game.MAP_DOCK_ROWS,
+            border: { type: 'line' },
+            style: { border: { fg: 'blue' } },
+            label: ' Room ',
+            tags: true,
+            keys: false,
+            content: '',
+            hidden: true,
+        });
+        this._roomMapBox = roomMapBox;
+        screen.append(roomMapBox);
     }
-    /** Shifts the Mechanics pane down (map shown) or back up (hidden). */
+    /** Shifts the Mechanics pane down (a map box is shown) or back up
+     *  (neither is). Driven by syncMapDock, never called directly. */
     dockMap(shown) {
         if (!this._metaBox)
             return;
         this._metaBox.top = shown ? Game.MAP_DOCK_ROWS : 0;
         this._metaBox.height = shown ? `100%-${11 + Game.MAP_DOCK_ROWS}` : '100%-11';
     }
+    /** Keeps the Mechanics pane's dock offset in sync with whichever
+     *  docked box(es) -- district, room, or both -- are currently shown. */
+    syncMapDock() {
+        const anyShown = (this._mapBox !== undefined && !this._mapBox.hidden)
+            || (this._roomMapBox !== undefined && !this._roomMapBox.hidden);
+        this.dockMap(anyShown);
+    }
     /**
-     * Paints (or hides) the docked minimap. Solo: updateExits feeds it
-     * from the local scene; shared runs: SharedRunSession.route feeds it
-     * from the server's per-player kind:'map' events. The preference
-     * gates both paths in one place.
+     * Paints (or hides) the docked DISTRICT minimap. Solo: updateExits
+     * feeds it from the local scene; shared runs: SharedRunSession.route
+     * feeds it from the server's per-player kind:'map' events. The
+     * preference gates both this and setRoomOverlay in one place.
      */
     setMapOverlay(lines) {
         if (!this._mapBox)
@@ -3208,15 +3276,41 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             return;
         }
         this._mapBox.setContent(lines.join('\n'));
-        this.dockMap(true);
         this._mapBox.show();
+        this.syncMapDock();
         this._screen?.render();
     }
     hideMapOverlay() {
         if (!this._mapBox)
             return;
         this._mapBox.hide();
-        this.dockMap(false);
+        this.syncMapDock();
+        this._screen?.render();
+    }
+    /**
+     * Paints (or hides) the docked ROOM minimap -- the district box's
+     * twin, fed by updateExits from utilities/room-view.ts. Empty
+     * whenever the current room has no synthesized grid (spotless --
+     * THE COMPAT RULE) or the player is circulating in it (nothing fixed
+     * to center on): both read as "hide", same as an empty district.
+     */
+    setRoomOverlay(lines) {
+        if (!this._roomMapBox)
+            return;
+        if (lines.length === 0 || !getPref('mapOverlay', true)) {
+            this.hideRoomOverlay();
+            return;
+        }
+        this._roomMapBox.setContent(lines.join('\n'));
+        this._roomMapBox.show();
+        this.syncMapDock();
+        this._screen?.render();
+    }
+    hideRoomOverlay() {
+        if (!this._roomMapBox)
+            return;
+        this._roomMapBox.hide();
+        this.syncMapDock();
         this._screen?.render();
     }
     /**
@@ -3234,6 +3328,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         if (this.remoteSession)
             return;
         this._statusBox.setContent(this.statusLinesFor(this.player).join('\n'));
+        // The log's border tracks the plane -- updateStatus is the one hook
+        // every plane transition already funnels through.
+        this.paintPlaneBorder();
         this._screen.render();
     }
     /** ui plumbing for session mode (utilities/shared-run.ts). */
@@ -3248,32 +3345,75 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * no widgets. updateStatus paints it for the local player; a shared-run
      * server ships it per player as status events (Phase C).
      */
+    /**
+     * What's in your hands, in one phrase. Three armed states on the meat
+     * plane: drawn, HOLSTERED (carried but riding leather -- "brandish"
+     * puts it in hand; combat auto-draws, so this is posture rather than
+     * readiness), or nothing at all. Off-plane the profile is attack
+     * programs / astral will and reads as Armed. White, not gray, for the
+     * same legibility reason as the stance it now sits beside.
+     */
+    armedLine(player) {
+        const weapon = player.getWeaponProfile();
+        const weaponItem = player.getCarriedWeapon();
+        const ammoNote = weaponItem?.isFirearm()
+            ? (weaponItem.jammed
+                ? ` {red-fg}[JAMMED -- reboot]{/red-fg}`
+                : weaponItem.ammo === 0 ? ` {red-fg}[DRY]{/red-fg}` : ` [${weaponItem.ammo} rds]`)
+            : '';
+        if (player.plane === 'meat' && weaponItem && !player.weaponDrawn) {
+            return `{white-fg}Holstered: ${weaponItem.name}${ammoNote}${hint(' -- "brandish"')}{/white-fg}`;
+        }
+        if (weapon.name === 'bare fists')
+            return `{gray-fg}Unarmed{/gray-fg}`;
+        return `Armed: ${weapon.name} (DV ${weapon.damage}${weapon.poolBonus > 0 ? `, +${weapon.poolBonus} dice` : ''})${ammoNote}`;
+    }
+    /**
+     * THE LOG WEARS THE PLANE (player request 2026-08-25). Jacking in or
+     * stepping out of your body changes what every line in that log even
+     * MEANS, and the only marker was a HUD row well below it. The border
+     * takes the plane's own established colour -- cyan for the Matrix,
+     * magenta for astral, yellow for a jumped-in drone, matching the
+     * tints those planes already use throughout the prose.
+     */
+    planeBorderColor(player) {
+        switch (player.plane) {
+            case 'matrix': return 'cyan';
+            case 'astral': return 'magenta';
+            case 'drone': return 'yellow';
+            default: return 'white';
+        }
+    }
+    paintPlaneBorder() {
+        if (!this._logBox)
+            return;
+        const style = this._logBox.style;
+        style.border = { ...(style.border ?? {}), fg: this.planeBorderColor(this.player) };
+    }
     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
-        // readiness line it wrapped out of the box on narrower terminals and
-        // effectively only ever showed in the Tab announcement. Always shown,
-        // even MANUAL: the HUD is how players discover Tab cycles it at all
-        // (see utilities/auto-fight.ts). MANUAL is white, not gray -- blessed's
+        // Line 1: the fight autopilot mode. The stance lives HERE -- the
+        // shortest HUD line -- because appended to the long readiness line it
+        // wrapped out of the box on narrower terminals and effectively only
+        // ever showed in the Tab announcement. Always shown, even MANUAL: the
+        // HUD is how players discover Tab cycles it at all (see
+        // utilities/auto-fight.ts). MANUAL is white, not gray -- blessed's
         // gray is ANSI "bright black", which on a stock dark terminal palette
         // is illegible enough that the stance looked absent entirely.
+        //
+        // WHERE YOU ARE MOVED OUT (player ruling 2026-08-25): the room name
+        // now captions the Map box and the "@ spot" captions the Room box,
+        // each under the picture it belongs to, so the HUD stops repeating
+        // what two panels already show. The breadcrumb went with it -- the
+        // district map draws the way you came far better than a text trail.
         const stanceColor = player.autoStance === 'aggressive' ? 'red' : player.autoStance === 'guarded' ? 'yellow' : 'white';
-        const stance = `{${stanceColor}-fg}⚔ ${player.autoStance.toUpperCase()}{/${stanceColor}-fg}`;
-        // The breadcrumb, reading chronologically into the current location:
-        // "Neon Strip (west) > Night Market" -- origin first, the direction
-        // BACK to it in parens. An 18-room hub made "which way did I come in"
-        // a real question.
-        const crumb = player.cameFrom ? `${player.cameFrom.room} (${player.cameFrom.back}) > ` : '';
-        if (player.currentLocation) {
-            // "At" spots: where you stand WITHIN the room, when it has places
-            // to stand (see utilities/spots.ts).
-            const atNote = spotOf(player) ? ` @ ${player.atSpot}` : '';
-            lines.push(`${crumb}{bold}📍 ${player.currentLocation.name}${atNote}{/bold}  |  ${stance}`);
-        }
-        else {
-            lines.push(stance);
-        }
+        // WHAT'S IN YOUR HANDS rides alongside the stance (player ruling
+        // 2026-08-25). The two answer the same question -- how ready are you
+        // -- and the stance line was left short and lonely once the location
+        // moved out to the map captions, while the readiness line below ran
+        // long. armedLine is built further down with the rest of the gear
+        // read; only its placement moved.
+        lines.push(`{${stanceColor}-fg}⚔ ${player.autoStance.toUpperCase()}{/${stanceColor}-fg}  ${this.armedLine(player)}`);
         // Line 2: both condition monitors -- in a game where a fight can kill
         // you and casting can knock you out, current damage on either track is
         // never something a player should have to ask for. Colors shift as
@@ -3292,26 +3432,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const heat = this.heatBand();
         if (heat && player === this.player)
             lines.push(heat);
-        // Line 3: readiness -- armed state, armor, and whether the commlink is
-        // actually live (equipped), the recurring "why can't I call anyone"
-        // friction surfaced at a glance.
-        const weapon = player.getWeaponProfile();
-        const weaponItem = player.getCarriedWeapon();
-        const ammoNote = weaponItem?.isFirearm()
-            ? (weaponItem.jammed
-                ? ` {red-fg}[JAMMED -- reboot]{/red-fg}`
-                : weaponItem.ammo === 0 ? ` {red-fg}[DRY]{/red-fg}` : ` [${weaponItem.ammo} rds]`)
-            : '';
-        // Three armed states on the meat plane: drawn, holstered (weapon
-        // carried but riding leather -- "brandish" puts it in hand; combat
-        // auto-draws so this is posture, not readiness), or nothing at all.
-        // Off-plane the profile is attack programs / astral will and reads as
-        // Armed. White, not gray, for the same legibility reason as the stance.
-        const armed = player.plane === 'meat' && weaponItem && !player.weaponDrawn
-            ? `{white-fg}Holstered: ${weaponItem.name}${ammoNote}${hint(' -- "brandish"')}{/white-fg}`
-            : weapon.name === 'bare fists'
-                ? `{gray-fg}Unarmed{/gray-fg}`
-                : `Armed: ${weapon.name} (DV ${weapon.damage}${weapon.poolBonus > 0 ? `, +${weapon.poolBonus} dice` : ''})${ammoNote}`;
+        // Line 3: the rest of the readiness read -- armor, and whether the
+        // commlink is actually live (equipped), the recurring "why can't I
+        // call anyone" friction surfaced at a glance. The armed state used
+        // to lead this line; it now rides with the stance on line 1.
         const armorNote = `Armor +${player.getArmorValue()}`;
         const hasLink = player.equipment.head?.commlink != null;
         const link = !hasLink
@@ -3321,7 +3445,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 : player.arOffline
                     ? `{red-fg}AR CUT -- reboot{/red-fg}`
                     : `{${CALL_COLOR}-fg}Link online{/${CALL_COLOR}-fg}`;
-        lines.push(`${armed}  |  ${armorNote}  |  ${link}`);
+        lines.push(`${armorNote}  |  ${link}`);
         // Lines 4+: transient states, present only while active. Future
         // contexts (astral projection, VR hot-sim) join here the same way.
         if (player.sustainedArmor > 0) {
@@ -3414,22 +3538,71 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.notePresenceAffectingChange();
     }
     updateExits(_room) {
-        // THE ICON OVERLAY (map-overlay wave 2026-08-24): this hook was
-        // kept as a no-op for exactly this -- it already fires on movement
-        // (go/lock/unlock, ui.ts), scene transitions, and barrier changes.
+        // THE ICON OVERLAYS (map-overlay wave 2026-08-24, split 2026-08-25):
+        // this hook was kept as a no-op for exactly this -- it already
+        // fires on movement (go/lock/unlock, move.ts, ui.ts), scene
+        // transitions, and barrier changes (solve/bypass/lock/unlock).
         // Session mode: the server's per-player kind:'map' events feed the
-        // overlay instead (SharedRunSession.route).
+        // district overlay instead (SharedRunSession.route); the room box
+        // has no server-pushed path yet, so it just stays hidden in a
+        // shared run, same as the district box did before that wiring.
         if (!this._mapBox || this.remoteSession)
             return;
         const here = this.player.currentLocation;
         if (!here || this.player.plane === 'matrix') {
             this.hideMapOverlay();
+            this.hideRoomOverlay();
             return;
         }
-        this.setMapOverlay(renderMapViewport(this.scene.getRooms(), here, (r, d) => this.scene.barrierSealing(r, d), {
+        const screenW = Number(this._screen?.width) || 0;
+        // Each box's inner width. Derived from the screen rather than read
+        // off the widget: blessed resolves percentage geometry at render
+        // time, so `.width` is still the raw '23%' here. Used to right-
+        // justify the elevation bar and to trim the caption rows.
+        const boxWidth = screenW > 0 ? Math.floor(screenW * Game.ROOM_DOCK_PCT) - 2 : undefined;
+        const mapWidth = screenW > 0 ? Math.floor(screenW * Game.MAP_DOCK_PCT) - 2 : undefined;
+        const caption = (text, width) => {
+            const w = width ?? text.length;
+            return `{bold}${text.length > w ? `${text.slice(0, Math.max(1, w - 1))}…` : text}{/bold}`;
+        };
+        // The district viewport must FIT ITS BOX. It was a hardcoded 15
+        // columns, which was fine while the Map box was 35% wide and
+        // silently overflowed into the Room box once it shrank to 12% --
+        // on a narrower terminal the spill landed inside the neighbouring
+        // border and smartCSR's partial redraws smeared it into stray
+        // characters (playtest 2026-08-25: "getting some artifacting 'g'";
+        // ui.ts documents this same smear from column drift). Odd widths
+        // keep the player marker exactly centred.
+        const mapInner = mapWidth ?? 15;
+        const mapView = Math.max(7, mapInner % 2 === 0 ? mapInner - 1 : mapInner);
+        const mapLines = renderMapViewport(this.scene.getRooms(), here, (r, d) => this.scene.barrierSealing(r, d), {
             visited: this.player.visitedRooms,
             arEyes: this.player.hasMatrixEyes(),
-        }));
+        }, mapView);
+        // The captions the HUD used to carry: where you are under the
+        // district, where you stand under the room.
+        if (mapLines.length > 0)
+            mapLines.push(caption(here.name, mapWidth));
+        this.setMapOverlay(mapLines);
+        // A DECORATION MUST NEVER KILL THE RUN. This panel is pure derived
+        // geometry -- if synthesis or rendering ever throws (a malformed
+        // seed, a room shape no one anticipated), the right outcome is a
+        // blank box and a log line, not a dead session mid-job.
+        try {
+            const roomLines = renderRoomLayoutCompact(here, this.player, {
+                boxWidth,
+                isOtherPlayer: a => this.scene.isHumanControlled(a),
+            });
+            if (roomLines.length > 0) {
+                const spot = spotOf(this.player);
+                roomLines.push(caption(spot ? `@ ${spot}` : '(moving through)', boxWidth));
+            }
+            this.setRoomOverlay(roomLines);
+        }
+        catch (err) {
+            Logger.getInstance().write(`Room overlay render failed in ${here.name}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+            this.hideRoomOverlay();
+        }
     }
     updateInventory(_playerInventory, _currencyName = 'currency') {
         this.updateStatus();