@maka/maka-cli 5.204.0 → 5.206.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.204.0",
+  "version": "5.206.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/breach.js

@@ -1,4 +1,6 @@
 import { BypassCommand } from './bypass-command.js';
+import { Door } from '../models/door.js';
+import { ensureAtExit } from '../utilities/spots.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 /**
  * The FORCEFUL route past a physical barrier (player ruling: "solve" was
@@ -35,8 +37,96 @@ export class BreachCommand extends BypassCommand {
         if (this.actor.plane === 'drone') {
             return `The drone weighs less than the door. "jump" back to a body with shoulders.`;
         }
+        // A DOOR IS A PHYSICAL BARRIER EVEN WHEN NO DEVICE HOLDS IT
+        // (Gfx5RFFpHJdKB87Bh: "I cant Breach East").
+        //
+        // Everything on BypassCommand is device-shaped: it lists
+        // room.openableDevices(), which knows only Device objects, and a
+        // plain keyed Door is not one. So a room whose east way out was a
+        // locked door and nothing else answered "There's nothing here to
+        // breach -- no physical barrier holds this room" while the map, one
+        // line above, printed "East: To Lucky Chummer (locked)". Two
+        // surfaces in the same room denying each other, and the player
+        // holding the verb that should work.
+        //
+        // Reproduced before fixing, in shipped scene1's Krow's Den: `map`
+        // advertised the locked east exit, `go east` named the key, and
+        // `breach east` said there was no barrier.
+        //
+        // A door HELD BY A DEVICE is left alone -- the maglock is the real
+        // thing standing in the way, it has its own prose and its own
+        // refusals, and the base class already routes it correctly.
+        const forced = await this.breachPlainDoor(args);
+        if (forced)
+            return forced;
         return super.execute(args);
     }
+    /**
+     * The muscle route at an ordinary locked door. Returns undefined when
+     * this isn't that case, so the device path runs untouched.
+     *
+     * SAME TEST AS THE DEVICE ROUTE, deliberately. Canon prices barriers
+     * by Structure and Armor (p.197-198, Destroying Barriers) and resolves
+     * them as an attack -- but that machinery reads the DV of a WEAPON,
+     * and by RAW it also says barriers ignore Stun, which is the only
+     * damage a shoulder deals. Modelling a door the book's way would
+     * therefore make an unarmed breach impossible rather than merely
+     * hard, which is not what the book means and not what this verb is
+     * for. The engine's existing Strength + Body muscle test is a
+     * standing ruling with its own comment above; extending the verb's
+     * REACH is this item's fix, and re-pricing it is a separate question
+     * that should be asked out loud rather than smuggled in here.
+     */
+    async breachPlainDoor(args) {
+        const room = this.actor.currentLocation;
+        if (!room)
+            return undefined;
+        // Only a bare "breach" or "breach <direction>" can mean a door --
+        // anything else is naming an object, which is the device path's job.
+        const raw = args.filter(w => !/^(at|the|a|an)$/i.test(w)).join(' ').trim().toLowerCase();
+        const plain = (dir) => {
+            const exit = room.exits.get(dir);
+            return exit instanceof Door && exit.isLocked && !exit.heldBy && !room.deviceOpening(dir)
+                ? exit
+                : undefined;
+        };
+        let direction;
+        if (raw && this.isValidDirection(raw)) {
+            direction = raw;
+        }
+        else if (!raw || /^(door|lock|barrier|gate|hatch|way)$/.test(raw)) {
+            // Unambiguous only: with two locked doors and no direction, fall
+            // through so the base class asks which -- guessing one would pick
+            // a door by map order and call it the player's intent.
+            const locked = [...room.exits.keys()].filter(d => plain(d));
+            if (locked.length !== 1)
+                return undefined;
+            direction = locked[0];
+        }
+        if (!direction)
+            return undefined;
+        const door = plain(direction);
+        if (!door)
+            return undefined;
+        const reach = ensureAtExit(this.actor, direction);
+        if (reach.refusal)
+            return reach.refusal;
+        const crossNote = reach.line ? `${reach.line}\n` : '';
+        const gave = await this.determineOutcome();
+        const where = String(direction).toLowerCase();
+        if (!gave) {
+            this.actor.performAction('throws a shoulder at', `the ${where} door, and it holds`);
+            return `${crossNote}${this.failureFlavor}`;
+        }
+        door.isLocked = false;
+        this.actor.sneaking = false;
+        this.logger.write(`BreachCommand: ${this.actor.name} forced the ${where} door in ${room.name}.`);
+        this.actor.performAction('breaches', `the ${where} door`);
+        this.scene.raiseAlarm(`${this.actor.name} breached the ${where} door in ${room.name} -- the crash carried`);
+        this.scene.addWorldEvent(`${this.actor.name} breached the ${where} door in ${room.name} -- the crash carried.`);
+        this.game?.addHeat(2, `breached the ${where} door`);
+        return `${crossNote}${this.successFlavor}\n  The crash CARRIES -- anyone nearby knows exactly where you are now.`;
+    }
     async determineOutcome() {
         // Raw muscle -- Strength + Body, 2 hits to give. No skill governs
         // hitting a door hard; wounds and sustained workings still bleed the

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

@@ -168,6 +168,33 @@ export class MoveCommand extends Command {
         // of metres -- METERS_PER_LEVEL is 3 -- so a single turn covers
         // any of them outright, and the honest translation is one test
         // that either lands you or does not. No clock invented to host it.
+        // THE LAST HALF-METRE IS A STEP, NOT A CLIMB (6SmvvRRtn9eEMZSbF,
+        // fifth rejection: "I would see the descend moved me towards the
+        // ground, but then I stopped ... 'the ground within reach' -- this
+        // is basically on the ground, I don't know why we have to split
+        // hairs").
+        //
+        // Unassisted UP is 1m per 2 hits, so a bank is typically half a
+        // metre. Descending that half metre with zero hits gained nothing,
+        // re-banked the identical figure, and printed the same two
+        // sentences -- a state byte-identical to the one before it, which
+        // is a loop with no exit but luck.
+        //
+        // CANON IS SILENT HERE and that silence is the ruling: p.134's
+        // Climbing Table prices metres per hit and has no row for a drop
+        // shorter than a person, and p.172 charges nothing for a fall of
+        // 3m or less (fallDamageDVMeters agrees -- it returns 0). So there
+        // is no test to run and no damage to deal. Inventing a roll to
+        // stand between a runner and a floor they can already touch is the
+        // deviation; letting go is not.
+        //
+        // Ahead of the rappel branch on purpose: nobody rigs a harness to
+        // get off a kerb either.
+        if (down && (meters - banked) < 1) {
+            actor.climbProgress = undefined;
+            this.actor.performAction('drops the last of the way down to', spotName);
+            return { arrived: true, note: `Under a metre left -- you let go and take it on your boots.` };
+        }
         if (down && assisted) {
             // Free-Fall in canon, and now in this engine too -- the comment
             // here used to end "...and has no Free-Fall skill", which was the
@@ -276,7 +303,15 @@ export class MoveCommand extends Command {
             // wall unclimbable rather than merely slow. Hanging on with
             // progress banked is the book's own shape: another Complex
             // Action, from where you got to.
-            actor.climbProgress = wall.progressFor(reached);
+            //
+            // ...BUT ONLY IF THERE ARE METRES (6SmvvRRtn9eEMZSbF). A first
+            // attempt that buys nothing used to bank ZERO and still count as
+            // being on the wall -- which is a real place to this engine, so
+            // the runner could not "move" until they "descend"ed off a floor
+            // they had never left, and descend then narrated letting go from
+            // no height at all. You are on a wall when you are up it.
+            const banked = wall.progressFor(reached);
+            actor.climbProgress = banked.meters > 0 ? banked : undefined;
             // THE TWO FIGURES HAVE TO ADD UP. Rounding each independently
             // printed "about 2m up" and "about 2m still above you" on a
             // 3m wall -- both are honest roundings of 1.5, and together
@@ -301,11 +336,36 @@ export class MoveCommand extends Command {
             // climbing it. Measured on a bench, descending a 3m ledge:
             //   "You get about 1m up ... about 2m still above you."
             // -- printed on the second of four `descend` commands.
+            // NEVER NARRATE A DISTANCE THAT WAS NOT TRAVELLED
+            // (6SmvvRRtn9eEMZSbF). `reached < 1` was true of ZERO, so a roll
+            // that bought nothing still announced "about a body length" --
+            // and the reporter, reasonably, read that as having moved. A
+            // failed climb makes no progress (p.134, Climbing Failures and
+            // Glitches); the prose has to say so instead of rounding nothing
+            // up into something.
+            const wentNowhere = reached <= 0;
+            const moved = reached < 1 ? 'a body length' : `${shownUp}m`;
+            const why = climb.glitch ? 'a hold shears away under your weight' : 'no purchase left within reach';
+            // AND NOBODY HANGS FROM THE FLOOR. With nothing banked the runner
+            // is standing in the yard with their hands on the wall, so
+            // "you hang on, boots wedged" is the same false picture the
+            // distance was painting. Off the wall entirely, say so.
+            const offTheWall = banked.meters <= 0;
+            const perch = down
+                ? (left < 1 ? 'the ground within reach' : `about ${left}m still below you`)
+                : (left < 1 ? 'the lip within reach' : `about ${left}m still above you`);
+            const rest = offTheWall
+                ? `, boots still on the ground.`
+                : `. You hang on, boots wedged, ${perch}.`;
             return {
                 arrived: false,
                 text: down
-                    ? `You get about ${reached < 1 ? 'a body length' : `${shownUp}m`} down and it stops going anywhere -- ${climb.glitch ? 'a hold shears away under your weight' : 'no purchase left within reach'}. You hang on, boots wedged, ${left < 1 ? 'the ground within reach' : `about ${left}m still below you`}.${hint(` (Descend again to keep going${assisted ? '' : '; rope and a harness would let you rappel it'}.)`)}`
-                    : `You get about ${reached < 1 ? 'a body length' : `${shownUp}m`} up and it stops going anywhere -- ${climb.glitch ? 'a hold shears away under your weight' : 'no purchase left within reach'}. You hang on, boots wedged, ${left < 1 ? 'the lip within reach' : `about ${left}m still above you`}.${hint(` (Climb again to keep going${assisted ? '' : '; rope and a harness would double your rate'}.)`)}`,
+                    ? `${wentNowhere
+                        ? `You feel for the next hold and there isn't one -- you get no lower, ${why}`
+                        : `You get about ${moved} down and it stops going anywhere -- ${why}`}${rest}${hint(` (Descend again to keep going${assisted ? '' : '; rope and a harness would let you rappel it'}.)`)}`
+                    : `${wentNowhere
+                        ? `You feel for the next hold and there isn't one -- you get no higher, ${why}`
+                        : `You get about ${moved} up and it stops going anywhere -- ${why}`}${rest}${hint(` (Climb again to keep going${assisted ? '' : '; rope and a harness would double your rate'}.)`)}`,
             };
         }
         // THE SECOND CHANCE (p.134 Climbing Failures and Glitches;
@@ -344,11 +404,18 @@ export class MoveCommand extends Command {
         const heightNow = Math.max(0, wall.heightAtStart + (down ? -reached : reached));
         const shownHeight = heightNow < 1 ? 'a body length' : `${Math.round(heightNow)}m`;
         if (catchIt.hits >= 1) {
-            actor.climbProgress = wall.progressFor(reached);
+            // Same rule as the hold-on above (6SmvvRRtn9eEMZSbF): catching
+            // yourself with nothing banked is catching yourself ON THE FLOOR,
+            // and saying "you are still on the wall" about a runner standing
+            // in the yard is the sort of line that gets an item sent back.
+            const caught = wall.progressFor(reached);
+            actor.climbProgress = caught.meters > 0 ? caught : undefined;
             this.actor.performAction('slips on', `the ${spotName} climb, and catches themselves`);
             return {
                 arrived: false,
-                text: `You come off -- and catch yourself a body length down, fingers screaming. You are still on the wall, about ${shownHeight} up.${hint(` (${down ? 'Descend' : 'Climb'} again to keep going.)`)}`,
+                text: caught.meters > 0
+                    ? `You come off -- and catch yourself a body length down, fingers screaming. You are still on the wall, about ${shownHeight} up.${hint(` (${down ? 'Descend' : 'Climb'} again to keep going.)`)}`
+                    : `You come off almost as soon as you start -- and catch yourself, boots back on the ground, fingers screaming.${hint(` (${down ? 'Descend' : 'Climb'} again to try it.)`)}`,
             };
         }
         // The grip goes: the wall takes back everything it gave.

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

@@ -4,14 +4,21 @@ import { rollPool, formatRoll } from '../utilities/dice.js';
 import { ownedDrones } from '../utilities/owned-drones.js';
 /**
  * The free road to STUN recovery (stim patches are the fast, risky one --
- * see use.ts): catch your breath somewhere safe. "Safe" means a
- * Residence-type room (your Hideout qualifies) or a room with no one else
- * in it -- nobody naps in front of an audience in the sprawl. Each rest
- * rolls Body and recovers hits + 1 stun; repeat as needed. A night in a
- * bed that's yours is also the day of NATURAL RECOVERY for the physical
- * track (SR5 p.207, built 2026-09-12 for vFMhSGwLhsfpiY7bs): Body x 2,
- * each hit a box, only once the stun is gone. You can't rest
+ * see use.ts): catch your breath somewhere safe. "Safe" means somewhere
+ * that houses you -- a Residence-type room, or a room whose seed says it
+ * quarters your lifestyle tier -- or a room with no one else in it:
+ * nobody naps in front of an audience in the sprawl.
+ *
+ * Each rest is SR5 p.207's Stun half: Body + Willpower, one box per hit.
+ * A night in a bed that's yours is also the day of NATURAL RECOVERY for
+ * the physical track (p.207, built 2026-09-12 for vFMhSGwLhsfpiY7bs):
+ * Body x 2, each hit a box, only once the stun is gone. You can't rest
  * mid-combat-exchange.
+ *
+ * Both halves of the stun line were wrong until YxFKFqmXMgAvxwpce: the
+ * pool was Body alone, and it paid out `hits + 1`. The free box is why
+ * the missing attribute went unmeasured for so long -- rest always did
+ * something, so nobody checked how much.
  */
 export class RestCommand extends Command {
     static verb = 'rest';
@@ -19,7 +26,24 @@ export class RestCommand extends Command {
     async execute(_args = []) {
         const actor = this.actor;
         const room = actor.currentLocation;
-        if (actor.isIncapacitated()) {
+        // A FULL STUN TRACK IS THE REASON TO REST, NOT A BAR TO IT. This
+        // asked isIncapacitated(), which is isDown() || isUnconscious() --
+        // and isUnconscious() is exactly "the stun track is full", so the
+        // runner who most needed to sleep it off was the one who could not.
+        // Canon is the other way round: p.207 counts forced naps and
+        // unconsciousness AS rest.
+        //
+        // HONEST SCOPE (YxFKFqmXMgAvxwpce): this is a correction, not that
+        // item's fix, and it is defence in depth rather than a live path.
+        // A full stun track is claimed upstream long before any verb runs --
+        // settleUnresolvedHarm() opens every command and hands an
+        // unconscious runner to Scene.beginPlayerKnockout, which is what
+        // decides whether they come to. Measured, not assumed: with this
+        // gate opened, `rest` on a stun-full runner still answers "the world
+        // tilts and goes dark". Narrowed anyway, because a guard that
+        // refuses the one case canon explicitly permits is wrong whether or
+        // not anything currently reaches it.
+        if (actor.isDown()) {
             return `You're past resting.`;
         }
         if (this.scene.isHumanControlled(actor) && this.scene.isPlayerExchangeActive(actor.name)) {
@@ -36,7 +60,25 @@ export class RestCommand extends Command {
             .map(d => d.item)
             .filter(i => i.droneDamage > 0);
         const othersHere = this.scene.getActorsInRoom(room).filter(a => a !== actor);
-        const isResidence = room.roomType?.toLowerCase() === 'residence';
+        // WHERE THIS RUNNER SLEEPS, NOT WHERE THE ENGINE KEEPS ITS HOME ROOM
+        // (YxFKFqmXMgAvxwpce). 'Residence' is the roomType of Game._homeRoom
+        // and of nothing else -- and _homeRoom is only ever added to the
+        // scene on a SOLO boot (game.ts: `if (!options.sharedRun && ...)`).
+        // headless.ts hard-codes sharedRun: true, so every browser session,
+        // hub included, ran with no residence room in the world at all:
+        // isResidence was permanently false, markSlept() could never fire,
+        // the sleep-locked fatigue floor in Player.healStun never lifted,
+        // and rest printed a roll and "0 stun recovered" with nothing to
+        // explain it.
+        //
+        // The seed already says where a runner of a given tier beds down --
+        // supportedLifestyles.residenceTypes, which the hub's own start room
+        // carries ("Street", "Squatter"). A room that houses your lifestyle
+        // IS your doss, whoever is hosting the session.
+        const tier = this.game?.lifestyleTier;
+        const housesMe = !!tier && (room.supportedLifestyles?.residenceTypes ?? [])
+            .some(t => t.toLowerCase() === tier.toLowerCase());
+        const isResidence = room.roomType?.toLowerCase() === 'residence' || housesMe;
         if (actor.stunTaken === 0 && actor.damageTaken === 0 && damagedDecks.length === 0 && damagedDrones.length === 0) {
             // Nothing to heal -- but sleeping is its own point now (needs
             // system: edge refills only fed-and-slept, see Game.
@@ -90,18 +132,41 @@ export class RestCommand extends Command {
             // MEDICINE aids natural recovery (canon p.207-208: Medicine hits
             // add dice to healing tests) -- knowing what your body needs.
             const medicineDice = actor.skillRating('medicine');
-            const roll = rollPool(Math.max(1, actor.body + tierDice + healerDice + medicineDice));
-            let recovery = roll.hits + 1;
+            // BODY + WILLPOWER, EACH HIT A BOX (SR5 p.207, Stun Damage: "Make
+            // a Body + Willpower (1 hour) Extended Test ... Each hit heals 1
+            // box of Stun damage"). This rolled Body alone and then handed out
+            // `hits + 1`, so it was short a whole attribute and long a free
+            // box -- wrong in both directions at once, and the free box is
+            // what kept the shortfall from ever being noticed.
+            const roll = rollPool(Math.max(1, actor.body + actor.willpower + tierDice + healerDice + medicineDice));
+            let recovery = roll.hits;
             // Insomnia (p.81): the sleep that comes is thin -- half the boxes.
+            // Halving nothing is still nothing: the old Math.max(1, ...) floor
+            // handed a box to a roll that bought none, which is the same
+            // invented generosity as the +1 above.
+            const halve = (n) => (n > 0 ? Math.max(1, Math.ceil(n / 2)) : 0);
             const insomnia = actor.hasQuality('insomnia');
             if (insomnia)
-                recovery = Math.max(1, Math.ceil(recovery / 2));
+                recovery = halve(recovery);
             if (inDebtAtHome)
-                recovery = Math.max(1, Math.ceil(recovery / 2));
+                recovery = halve(recovery);
             const recovered = actor.healStun(recovery);
             this.logger.write(`RestCommand: ${actor.name} rested and recovered ${recovered} stun (${actor.stunTaken}/${actor.maxStunBoxes})${inDebtAtHome ? ' [halved: rent debt]' : ''}${insomnia ? ' [halved: insomnia]' : ''}${tierDice !== 0 ? ` [lifestyle ${tierDice > 0 ? '+' : ''}${tierDice}d]` : ''}${healerDice ? ` [quick healer +${healerDice}d]` : ''}.`);
             lines.push(`  Rest: ${formatRoll(roll)}${tierDice > 0 ? ` (+${tierDice} -- a real bed)` : tierDice < 0 ? ` (${tierDice} -- the Street sleeps badly)` : ''}${healerDice ? ` (+${healerDice} -- quick healer)` : ''}${insomnia ? ' (halved -- sleep never comes easy)' : ''}${inDebtAtHome ? ' (halved -- shivering is not sleeping)' : ''}`);
             lines.push(`  ${recovered} stun recovered: ${actor.stunSummary()}`);
+            // WHY NOTHING MOVED (YxFKFqmXMgAvxwpce). Fatigue boxes are locked
+            // to their need (p.172), so a runner whose stun IS hunger or sleep
+            // debt watched a roll happen and the track not budge, with no line
+            // anywhere connecting the two. Recovery that is refused has to say
+            // it is refused, and say what would lift it.
+            if (recovered < recovery && actor.lockedFatigue > 0) {
+                const needs = [];
+                if (actor.hungerFatigue > 0)
+                    needs.push(`a real meal`);
+                if (actor.sleepFatigue > 0)
+                    needs.push(`a real bed -- "rest" somewhere that houses you`);
+                lines.push(`  ${actor.lockedFatigue} of those boxes won't shift: that's not damage, it's ${actor.hungerFatigue > 0 && actor.sleepFatigue > 0 ? 'hunger and exhaustion' : actor.hungerFatigue > 0 ? 'hunger' : 'exhaustion'}. It takes ${needs.join(' and ')}.`);
+            }
         }
         // NATURAL RECOVERY, PHYSICAL (vFMhSGwLhsfpiY7bs, 2026-09-12: "when I
         // rest, my physical health track doesn't heal"). Until now rest said

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

@@ -227,7 +227,14 @@ export class TakeCommand extends Command {
         // AFTER the loop, so the witnesses' event names what actually left
         // the room (owners included) -- "everything in the room" gave a
         // robbed NPC nothing to recognize as theirs.
-        this.actor.performAction('take', taken.length > 0 ? taken.join(', ') : 'everything in the room');
+        // THIRD PERSON, because this line is read by somebody else
+        // (LHNMHKX5A95yeycbB: "Deditri take Trauma Patch Kit"). Player.see()
+        // prints `${actor.name} ${verb} ${details}` verbatim -- it conjugates
+        // nothing -- so the bare infinitive reads as broken prose on every
+        // other seat. Every sibling verb already passes third person,
+        // including this file's own container path above. NPC theft reactions
+        // match /take/i, so "takes" still trips them.
+        this.actor.performAction('takes', taken.length > 0 ? taken.join(', ') : 'everything in the room');
         if (!searched) {
             const note = hint(`  (just what was lying in the open -- "search" to case the rest of the place)`);
             if (note)
@@ -255,7 +262,13 @@ export class TakeCommand extends Command {
         // its AI history, where ordering doesn't matter.
         const isPlayer = this.scene.isHumanControlled(this.actor);
         if (isPlayer) {
-            this.logger.log(lines.join('\n'));
+            // SCOPED TO THE SWEEPER (LHNMHKX5A95yeycbB). Unscoped, this falls
+            // through to the ambient room scope -- so Deditri's first-person
+            // "You sweep Rattican Alley: took the Trauma Patch Kit" landed on
+            // Jynx's screen too, on top of the see() feed line she was already
+            // getting. A summary written in the second person belongs to the
+            // one person it is addressed to; everyone else has the feed.
+            this.logger.log(lines.join('\n'), { actor: this.actor.name });
         }
         if (!this.scene.isWinConditionTarget(this.actor.name)) {
             for (const name of taken) {
@@ -356,7 +369,7 @@ export class TakeCommand extends Command {
             // pocketed Mr. Krow's credstick AT HIS DESK and Krow's history
             // read only "Maka take credstick": nothing marked it as his
             // (NPC.see keys its theft reaction off this).
-            this.actor.performAction('take', item.owner && item.owner !== this.actor.name ? `${item.name} (${item.owner}'s)` : item.name);
+            this.actor.performAction('takes', item.owner && item.owner !== this.actor.name ? `${item.name} (${item.owner}'s)` : item.name);
             this.actor.addInventory(item);
             this.logger.write(`Successfully added "${itemName}" to ${this.actor.name}'s inventory during 'Take' command.`);
             // PAYDATA COMES HOME ON A CHIP (user ruling 2026-08-30, for the

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

@@ -780,5 +780,68 @@
 //   The name is still only a claim: the server verifies it against the
 //   account's seats and saves before stamping it, and an older client
 //   that sends none keeps the presence fallback.
-export const ENGINE_VERSION = '1.66.0';
+// 1.67.0 (2026-09-16): SEVEN OPEN REPORTS, AND FOUR OF THEM WERE THE
+//   SAME SHAPE -- a thing wired at one end, agreeing with nothing at the
+//   other.
+//   - THE MAP NEVER LEARNED ABOUT A DOOR ADDED AFTER IT WAS DRAWN
+//     (BDFAZgcjZrtbXRNdn, "the D down door is gone, I can still go down
+//     but I can't see it"). Room.ensureGrid() memoizes for the life of
+//     the room; Room.addExit() never told it. Every runtime exit is
+//     affected and the hideout door is always one, because
+//     connectHomeRoom wires it AFTER seating the player -- which is
+//     itself what forces the first synthesis. addExit now patches the
+//     grid (room-grid.ts attachExitCell) rather than rebuilding it: a
+//     re-synthesis would re-seat the furniture under everyone standing
+//     on it. removeExit is the other half, so a home door that moves
+//     direction between jobs leaves no ghost.
+//   - REST WAS SHORT AN ATTRIBUTE AND LONG A FREE BOX
+//     (YxFKFqmXMgAvxwpce). p.207's Stun half is Body + Willpower, one
+//     box per hit; this rolled Body alone and paid hits + 1. The free
+//     box is why nobody measured the missing attribute. And 'Residence'
+//     is the roomType of Game._homeRoom alone, which is only added to
+//     the scene on a SOLO boot -- headless.ts hard-codes sharedRun, so
+//     every browser session had no bed in the world at all: no sleep, no
+//     unlock for sleep-locked fatigue (p.172), a roll that moved
+//     nothing, and no line saying why. A room whose seed quarters your
+//     lifestyle tier is now your doss, and blocked recovery names what
+//     is blocking it.
+//   - BREACH COULD NOT REACH A DOOR (Gfx5RFFpHJdKB87Bh, "I cant Breach
+//     East"). BypassCommand lists room.openableDevices(), which knows
+//     only Device objects, so a plain keyed Door matched nothing and
+//     got "there's nothing here to breach" -- in a room whose own map
+//     printed "East: ... (locked)" one line above. Reproduced in
+//     shipped scene1 before touching it. The muscle test is unchanged
+//     (re-pricing it against p.197's barrier table is a separate
+//     question); what changed is that it can find the door, and that
+//     the locked-move hint advertises the route it always had.
+//   - THE LAST HALF-METRE OF A CLIMB (6SmvvRRtn9eEMZSbF, fifth
+//     rejection: "this is basically on the ground, I don't know why we
+//     have to split hairs"). Unassisted UP buys 1m per two hits, so a
+//     bank is habitually 0.5m; descending it on a zero-hit roll gained
+//     nothing, re-banked the same figure, and narrated "about a body
+//     length down" for a distance of zero -- a state identical to the
+//     one before it. Under a metre now lands you, no test: p.134 has no
+//     row for it and p.172 charges nothing, so the roll was the
+//     invention. And no line claims a distance that was not travelled.
+//   - AN NPC MAY NOT SAY IT IS SOMEWHERE IT IS NOT (KwiMKNMN2e8KBqTY7).
+//     The brief's only location line was third-person, and the
+//     geography pin lists every room that EXISTS and demands exact
+//     names -- so a real alley was a blessed string for a pawnbroker at
+//     his own counter. A second-person pin, plus a PLACE rule in
+//     judgeNarration on BOTH channels (the claim was spoken, not
+//     narrated). Directions and "meet me at" stay legal; only
+//     present-tense self-location is refused.
+//   - BACKGROUND ACTORS STOP TAKING THE SCREEN (WQhacGNGuqoDzdPyM).
+//     `say` has been capped at one line per reply for ages; exposition
+//     never was, at any count or length. Capped to one beat, trimmed to
+//     whole sentences -- and an NPC walking through a room no longer
+//     wakes every NPC in it, which is where "3 large blocks of text"
+//     came from.
+//   - A SWEEP SUMMARY IS ADDRESSED TO ONE PERSON (LHNMHKX5A95yeycbB).
+//     take.ts logged "You sweep <room>" unscoped, so it reached every
+//     human in the room -- the other seat read a first-person line
+//     about someone else's haul, on top of the feed line it already
+//     had. Scoped to the sweeper; and the two performAction calls that
+//     passed a bare "take" now pass "takes", like every sibling verb.
+export const ENGINE_VERSION = '1.67.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -3165,7 +3165,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      */
     connectHomeRoom(jobStartRoom) {
         if (this._homeRoomExitDirection) {
-            this._homeRoom.exits.delete(this._homeRoomExitDirection);
+            this._homeRoom.removeExit(this._homeRoomExitDirection);
         }
         // The OTHER half of the previous link: sweep any exit on the anchor
         // room that already leads home before choosing a direction. Without
@@ -3178,7 +3178,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 ? ex.getOtherSide(jobStartRoom) === this._homeRoom
                 : ex === this._homeRoom.name;
             if (leadsHome)
-                jobStartRoom.exits.delete(dir);
+                jobStartRoom.removeExit(dir);
         }
         const direction = Game.HOME_DIRECTION_PRIORITY.find(d => !jobStartRoom.exits.has(d));
         if (!direction) {

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

@@ -339,6 +339,38 @@ things you tell them afterwards.`;
  * throws when a pattern stops matching, the line just prints, and the
  * only detector is a player watching their fixer break character.
  */
+/**
+ * The longest a background beat may run before it is cut back to its
+ * first sentence (WQhacGNGuqoDzdPyM). Sized off the player's own emote
+ * cap (commands/emote.ts MAX_LENGTH = 200) and given a little room,
+ * because an NPC beat carries a name where an emote does not.
+ */
+export const MAX_BEAT_LENGTH = 240;
+/**
+ * Cuts an over-long NPC beat back to whole sentences.
+ *
+ * Keeps sentences while they fit, so a short two-sentence beat survives
+ * intact and only genuine paragraphs lose their tail. A single sentence
+ * longer than the cap is left ALONE rather than truncated: an ellipsis
+ * mid-clause reads as a bug to a player, where a slightly long line just
+ * reads as a long line. Exported and pure for the same reason
+ * isOutOfCharacter is -- the failure mode is silent.
+ */
+export function trimToBeat(line) {
+    const t = (line ?? '').trim();
+    if (t.length <= MAX_BEAT_LENGTH)
+        return t;
+    const sentences = t.match(/[^.!?]+[.!?]+(?:["'”’]?)\s*/g);
+    if (!sentences || sentences.length < 2)
+        return t;
+    let kept = '';
+    for (const s of sentences) {
+        if (kept.length > 0 && (kept + s).trim().length > MAX_BEAT_LENGTH)
+            break;
+        kept += s;
+    }
+    return kept.trim() || t;
+}
 export function isOutOfCharacter(line, npcName) {
     const t = line.replace(/^[\s│|>*-]+/, '').trim();
     if (t.length === 0)
@@ -1429,6 +1461,22 @@ description text.`;
             // below the warmth bar quietly NOTES the arrival (their history
             // keeps it for when you walk up) and never wakes. Unspotted rooms
             // keep the old everyone-greets behavior (compat).
+            // A PASSER-BY IS NOT AN ARRIVAL (WQhacGNGuqoDzdPyM: "there was an
+            // NPC moving around that had 3 large blocks of text"). The whole
+            // warmth ladder below is about who is worth hailing, and it was
+            // reached only when a HUMAN walked in -- an NPC crossing the room
+            // skipped it entirely, woke every non-bystander in earshot, and
+            // each of them answered with a beat. One background actor walking
+            // through a busy room was three blocks of prose about nothing.
+            //
+            // Their own crowd is not news to them: an NPC's arrival is noted
+            // in history (the stimulus still lands) and answered by nobody.
+            // A human's arrival is unchanged -- the ladder still runs, and
+            // hostiles still get their challenge.
+            if (/enter/i.test(verb) && actor instanceof NPC) {
+                this.logger.write(`[DEBUG] ${this.name} notes ${actor.name} passing through -- an NPC arrival is not a greeting.`);
+                return;
+            }
             let arrivalNote = '';
             if (/enter/i.test(verb) && !(actor instanceof NPC)) {
                 const rel = this._scene?.ownerGame?.contacts?.get(this.name);
@@ -1902,7 +1950,29 @@ ${worldEventsSummary}
             this.logger.error(`[ERROR][${this.name}] currentLocation is undefined in respondTo!`);
             return;
         }
-        const roomDesc = `They are currently in: "${room.name}" — ${room.description}`;
+        // WHERE YOU ARE, SAID TO YOU (KwiMKNMN2e8KBqTY7: "Whisper told me to
+        // go to Rain-Chewed Alley but Whisper is not in the rain chewed
+        // ally, he says he is").
+        //
+        // This was the ONLY location statement in the brief and it is in the
+        // third person -- "They are currently in" reads as the player's
+        // whereabouts, not the speaker's. Nothing anywhere told an NPC where
+        // IT was standing, and the geography pin below actively licensed the
+        // mistake: it lists every room that exists and demands the names be
+        // used exactly, so "Rain-Chewed Alley" was a valid, blessed string
+        // for a pawnbroker who has never left his counter.
+        //
+        // Telling someone where to go is fine and often the point; claiming
+        // to be there is the defect, so the pin forbids exactly that and
+        // nothing more. judgeNarration's PLACE rule catches what the prompt
+        // does not (utilities/narration-limits.ts) -- the prompt is the
+        // request, the judge is the gate, and this file has learned twice
+        // over that a request alone is not a gate.
+        const roomDesc = [
+            `YOU ARE IN: "${room.name}" — ${room.description}`,
+            `You are in that room and nowhere else. You may tell someone to go somewhere, meet you somewhere, or where a place is -- but NEVER say or imply you are currently at any location other than "${room.name}".`,
+            `They are currently in: "${room.name}" — ${room.description}`,
+        ].join('\n');
         // "At" spots (utilities/spots.ts): WHERE everyone stands inside this
         // room, so the AI greets an arrival at the door from across the room
         // (or walks over) instead of assuming the newcomer is at its elbow.
@@ -2433,6 +2503,23 @@ Your objective is to drive the story line.`}
                 // command string, because "say X" and "say X, rephrased" are
                 // different strings and the same beat.
                 const said = commandText.replace(/^say\s+/i, '');
+                // THE CLAIM WAS SPOKEN, NOT NARRATED (KwiMKNMN2e8KBqTY7:
+                // "Whisper ... says he is"). The place judge has to sit on this
+                // channel too, or it guards the one half of the reply the
+                // reporter did not read. Only the PLACE rule applies here --
+                // the agency rules are about narrating an act, and a line of
+                // dialogue asserts nothing by being said. Refused speech is
+                // dropped and corrected exactly like a refused beat; the NPC
+                // gets its say back on the next stimulus.
+                const placeVerdict = judgeNarration(said, this.name, [], {
+                    here: this.currentLocation?.name,
+                    worldRooms: Object.values(this._scene?.getRooms?.() ?? {}).map(r => r.name),
+                });
+                if (placeVerdict.refused) {
+                    this.logger.write(`${this.name} speech refused (claimed to be elsewhere): ${said.slice(0, 160)}`);
+                    if (placeVerdict.note)
+                        this._addToHistory(placeVerdict.note);
+                }
                 // A COMPANION IS NEVER ECHO-GATED. Everything a bound shell says
                 // reaches its master over the link as a REPORT (the companion
                 // block in the brief: "work out loud... report what you find in
@@ -2443,11 +2530,15 @@ Your objective is to drive the story line.`}
                 const echo = this.allyOf
                     ? { echo: false }
                     : judgeEcho(this.currentLocation, this.name, said);
-                if (echo.echo) {
-                    this.logger.write(`${this.name} speech suppressed as an echo of ${echo.of}: ${said.slice(0, 120)}`);
+                if (echo.echo || placeVerdict.refused) {
+                    if (echo.echo)
+                        this.logger.write(`${this.name} speech suppressed as an echo of ${echo.of}: ${said.slice(0, 120)}`);
                     // Counted as having spoken. The model made its one speech act
                     // for this stimulus; that it came out as a line the room had
-                    // just heard does not buy it another go.
+                    // just heard -- or a line placing the speaker in a room they
+                    // are not in -- does not buy it another go. The rest of the
+                    // reply still runs: a swallowed sentence must not cost this
+                    // NPC the commands it issued in the same breath.
                     this._spokeThisStimulus = true;
                 }
                 else {
@@ -2507,7 +2598,40 @@ Your objective is to drive the story line.`}
             const bystanders = (this.currentLocation
                 ? this._scene?.getActorsInRoom?.(this.currentLocation) ?? []
                 : []).map(a => a.name).filter(n => n && n !== this.name);
-            for (const exposition of expositionLines) {
+            // ONE BEAT PER STIMULUS, THE WAY SPEECH ALREADY WORKS
+            // (WQhacGNGuqoDzdPyM: "the pros for NPCs is rather verbose" ->
+            // "there was an NPC moving around that had 3 large blocks of
+            // text... none of which was really relevant to our run. I do want
+            // there to be background actors, but it shouldn't take up the
+            // player's game screen that much").
+            //
+            // `say` has been capped at one line per reply for as long as the
+            // gate above has existed, and exposition never was: every
+            // non-command line the model produced printed, at whatever length
+            // it produced them. Same stimulus, same model, two different
+            // policies -- and the uncapped half is the one that fills a
+            // screen. The prompt has asked for "bare minimum" exposition all
+            // along and is plainly not obeyed, which is the argument for a
+            // limit in code rather than a firmer request.
+            //
+            // TRIMMED AT A SENTENCE, not mid-word: a background actor gets a
+            // beat, not a paragraph, and a beat that runs long ends where its
+            // first sentence does rather than in an ellipsis. The player's own
+            // emote has carried a hard cap (commands/emote.ts MAX_LENGTH) since
+            // long before this; NPCs simply never had the matching one.
+            // ONE PRINTED, not one CONSIDERED. Slicing to the first line
+            // before the gates would let a single out-of-character or refused
+            // opener silence a perfectly good beat behind it -- the cap is
+            // about how much reaches the screen, and a line that never prints
+            // has not spent it. So the loop still walks every candidate and
+            // stops the moment one lands.
+            if (expositionLines.length > 1) {
+                this.logger.write(`${this.name} produced ${expositionLines.length} exposition lines; printing at most one.`);
+            }
+            let beatPrinted = false;
+            for (const exposition of expositionLines.map(trimToBeat)) {
+                if (beatPrinted)
+                    break;
                 if (!exposition?.length)
                     continue;
                 if (isOutOfCharacter(exposition, this.name)) {
@@ -2520,7 +2644,16 @@ Your objective is to drive the story line.`}
                 // defence, no Combat Turn, no consequence. Suppressed, and the
                 // NPC is told why so the next beat can commit to it as a real
                 // command instead.
-                const verdict = judgeNarration(exposition, this.name, bystanders, { holding: this.grappling });
+                // AND WHERE THIS NPC IS (KwiMKNMN2e8KBqTY7): the same judge, one
+                // more rule. The geography pin in the brief says which rooms
+                // EXIST; it never said the speaker was in one of them, so a
+                // pawnbroker at his own counter could name a real alley and
+                // claim to be standing in it. The player walked there.
+                const verdict = judgeNarration(exposition, this.name, bystanders, {
+                    holding: this.grappling,
+                    here: this.currentLocation?.name,
+                    worldRooms: Object.values(this._scene?.getRooms?.() ?? {}).map(r => r.name),
+                });
                 if (verdict.refused) {
                     this.logger.write(`${this.name} narration refused (agency over ${verdict.subject}): ${exposition.slice(0, 160)}`);
                     if (verdict.note)
@@ -2549,6 +2682,7 @@ Your objective is to drive the story line.`}
                     continue;
                 }
                 this.logger.logWithColor(`${prefix}${exposition}`, inCall ? CALL_COLOR : 'blue', expositionScope);
+                beatPrinted = true;
                 // DID, therefore remembered -- and only now, at the far end of
                 // the OOC filter, the prose gate, the withheld checks and the
                 // echo gate. A line that never printed is not a thing this NPC

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

@@ -11,7 +11,7 @@ import { AI } from '../../../../tools/ai/ai.class.js';
 import { AbstractRoom } from '../types/shared/abstracts.js';
 import { spotsActive, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
 import { canHearSpeech, canHearShout } from '../utilities/earshot.js';
-import { synthesizeGrid, } from '../utilities/room-grid.js';
+import { synthesizeGrid, attachExitCell, detachExitCell, } from '../utilities/room-grid.js';
 export class Room extends AbstractRoom {
     logger = Logger.getInstance();
     actors = new Set();
@@ -871,15 +871,33 @@ Keep it concise and dramatic.`;
         // Doors, which findExistingDoor never collapses.
         for (const [dir, d] of [...this.exits.entries()]) {
             if (d === door && dir !== direction)
-                this.exits.delete(dir);
+                this.removeExit(dir);
         }
         const back = this.getOppositeDirection(direction);
         for (const [dir, d] of [...targetRoom.exits.entries()]) {
             if (d === door && dir !== back)
-                targetRoom.exits.delete(dir);
+                targetRoom.removeExit(dir);
         }
         this.exits.set(direction, door);
         targetRoom.exits.set(back, door);
+        // A DOOR THE MAP CAN SEE (BDFAZgcjZrtbXRNdn). ensureGrid() caches
+        // for the life of the room, so an exit wired after the first
+        // synthesis -- which is every runtime exit, the hideout door above
+        // all -- existed only in `exits` and never got a cell. Both clients
+        // draw doorways from exitCells, so it was invisible on both while
+        // "go down" worked. Patch each side's grid if one has been built;
+        // rooms not yet rendered pick the exit up from synthesis as usual.
+        if (this._grid)
+            attachExitCell(this._grid, this.name, direction);
+        if (targetRoom._grid)
+            attachExitCell(targetRoom._grid, targetRoom.name, back);
+    }
+    /** Unwires an exit AND its doorway cell. Use this rather than a bare
+     *  `exits.delete` -- see addExit's note on the memoized grid. */
+    removeExit(direction) {
+        this.exits.delete(direction);
+        if (this._grid)
+            detachExitCell(this._grid, direction);
     }
     attemptUnlockExit(direction, itemOrSolution) {
         const exit = this.exits.get(direction);

package/bundle/typescript/src/commands/game/sideQuest/utilities/narration-limits.js

@@ -95,6 +95,67 @@ const COMPELLED_MOVEMENT = new RegExp([
     String.raw `\b(?:drag\w*|haul\w*|pull\w*|tug\w*|yank\w*|tows?|towed|towing|carr(?:y|ies|ied|ying)|lift\w*)\b`,
     String.raw `\b(?:walk\w*|mov\w+|lead\w*|tak\w+)\s+\w+\s+(?:toward|towards|to|out|off|away|through|into|back)\b`,
 ].join('|'), 'i');
+/**
+ * CLAIMING TO BE SOMEWHERE ELSE (KwiMKNMN2e8KBqTY7: "Whisper told me to
+ * go to Rain-Chewed Alley but Whisper is not in the rain chewed ally,
+ * but he says he is").
+ *
+ * PRESENT-TENSE SELF-LOCATION ONLY, and the narrowness is the whole
+ * design. "Meet me at the Undermarket" is legitimate -- he can walk
+ * there. "Go to Rain-Chewed Alley" is legitimate and often the point --
+ * directions are what a fixer is for. "I'm at Rain-Chewed Alley", said
+ * by a pawnbroker standing behind his own counter, is the only shape
+ * that is false on its face, so it is the only shape this matches.
+ *
+ * The capture group is the place, which the caller compares against the
+ * speaker's real room: a pattern cannot know which rooms exist, and one
+ * that refused every "I'm in the back" would gag ordinary fiction about
+ * the room the NPC is actually standing in.
+ */
+const SELF_LOCATION = new RegExp([
+    // "I'm at/in/over at X", "I am down at X", and the contracted forms.
+    String.raw `\bI(?:'|’)?m\s+(?:currently\s+|right\s+|over\s+|down\s+|up\s+|back\s+|still\s+|here\s+)*(?:at|in|inside|outside)\s+(?:the\s+)?([^.,;!?"'’]{2,48})`,
+    String.raw `\bI\s+am\s+(?:currently\s+|right\s+|over\s+|down\s+|up\s+|back\s+|still\s+|here\s+)*(?:at|in|inside|outside)\s+(?:the\s+)?([^.,;!?"'’]{2,48})`,
+    // "you'll find me at X", "find me over at X", "catch me at X".
+    String.raw `\b(?:find|catch|reach)\s+me\s+(?:over\s+|down\s+|up\s+)*(?:at|in|inside|outside)\s+(?:the\s+)?([^.,;!?"'’]{2,48})`,
+    // "I'm standing/sitting/waiting in X".
+    String.raw `\bI(?:'|’)?m\s+(?:stand|sitt|wait|post|hang|hold)\w*\s+(?:up\s+|out\s+|around\s+)*(?:at|in|by|outside)\s+(?:the\s+)?([^.,;!?"'’]{2,48})`,
+].join('|'), 'i');
+/** Every place a self-location claim names in one line. */
+function placesClaimed(line) {
+    const out = [];
+    const re = new RegExp(SELF_LOCATION.source, 'gi');
+    for (const m of line.matchAll(re)) {
+        const place = m.slice(1).find(g => typeof g === 'string' && g.trim().length > 0);
+        if (place)
+            out.push(place.trim());
+    }
+    return out;
+}
+/**
+ * Does a claimed place name a room that is NOT where the speaker stands?
+ *
+ * Compared against the world's real room names rather than judged from
+ * the prose, so "I'm in the back", "I'm in trouble" and "I'm in a hurry"
+ * -- none of which is a room -- all pass untouched. Matching is
+ * whole-name and case-insensitive in either direction, because a beat
+ * writes "I'm down at the Flooded Undermarket" for the room recorded as
+ * "Flooded Undermarket".
+ */
+function elsewhereClaimed(line, here, worldRooms) {
+    const norm = (s) => s.toLowerCase().replace(/^the\s+/, '').trim();
+    const mine = norm(here);
+    for (const claim of placesClaimed(line)) {
+        const c = norm(claim);
+        const room = worldRooms.find(r => {
+            const n = norm(r);
+            return n !== mine && (c === n || c.includes(n) || n.includes(c));
+        });
+        if (room)
+            return room;
+    }
+    return undefined;
+}
 const ALLOWED = { refused: false };
 /**
  * THE WORDS OF A NAME THAT CAN STAND FOR IT.
@@ -195,6 +256,18 @@ export function judgeNarration(line, speaker, others, opts = {}) {
     const t = line.replace(/^[\s│|>*-]+/, '').trim();
     if (t.length === 0)
         return ALLOWED;
+    // BEFORE the agency rules, because it is about the SPEAKER's own body
+    // rather than anyone else's, and needs no subject resolution.
+    if (opts.here && opts.worldRooms?.length) {
+        const claimed = elsewhereClaimed(t, opts.here, opts.worldRooms);
+        if (claimed) {
+            return {
+                refused: true,
+                subject: speaker,
+                note: `YOU ARE IN ${opts.here.toUpperCase()}, NOT ${claimed.toUpperCase()}. Your last beat said you were at ${claimed}, so it did not happen and the player was not shown it -- and a player who believes you are somewhere you are not will go there and find nobody. Tell them where to go, offer to meet them somewhere, say where a place is: all fine. Just never say you are anywhere but ${opts.here}. If you want to be at ${claimed}, walk there first ("[COMMAND] go <direction>").`,
+            };
+        }
+    }
     const contactAt = t.match(CONTACT);
     const movedAt = t.match(COMPELLED_MOVEMENT);
     if (!contactAt && !movedAt)

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

@@ -823,6 +823,82 @@ export function synthesizeGrid(input) {
 // the module doc); Room.ensureGrid queries this cell by that same
 // string. A rename on either side must update both.
 export const OPEN_FLOOR_NAME = 'open floor';
+/**
+ * Cuts a doorway into a grid that has ALREADY been synthesized, for an
+ * exit the room did not have when it was.
+ *
+ * THE MISSING "D" ON NEON STRIP (BDFAZgcjZrtbXRNdn: "the D down door is
+ * gone, I can still go down but I can't see it"). ensureGrid() memoizes
+ * for the life of the room and reads this.exits once; Room.addExit()
+ * mutated the exit map and left the grid alone. The hideout door is not
+ * in any seed -- Game.connectHomeRoom() wires it at runtime, DOWN first
+ * -- and it is wired AFTER the player is seated in the start room, which
+ * is itself what forces the first synthesis. So the grid was built one
+ * exit short and stayed that way. `go down` kept working because
+ * GoCommand reads room.exits; every map reads exitCells, on both
+ * clients (the CLI draws from it directly, the browser from
+ * serializeRoomGrid below).
+ *
+ * PATCHES RATHER THAN INVALIDATES, deliberately. Re-synthesizing would
+ * be one line, but synthesis re-seats spots, footprints and terrain from
+ * the RNG -- so a door appearing mid-session would slide the furniture
+ * out from under everyone standing on it. Cutting one cell cannot move
+ * anything that already exists.
+ *
+ * Occupancy is read back off the grid (footprints, existing doorways)
+ * instead of the closure synthesis used, so a late doorway still avoids
+ * the bar and the other exits. Deterministic per room+direction.
+ */
+export function attachExitCell(grid, roomName, direction) {
+    if (grid.exitCells.has(direction))
+        return;
+    const occupied = new Set();
+    for (const cells of grid.spotFootprints.values()) {
+        for (const c of cells)
+            occupied.add(key(c));
+    }
+    for (const c of grid.exitCells.values())
+        occupied.add(key(c));
+    const levelCells = LEVEL_CELLS.get(grid) ?? new Map();
+    const exists = (c) => cellExists(grid, c, levelCells);
+    const dims = grid.dims;
+    const rng = mulberry32(hashFnv1a(`${roomName}:${String(direction)}`));
+    const wallSide = { north: 'north', south: 'south', east: 'east', west: 'west' }[String(direction)];
+    let cell;
+    if (wallSide) {
+        const mid = {
+            north: () => ({ x: clamp(Math.floor(dims.x / 2) + jitter(rng), 0, dims.x - 1), y: 0, z: 0 }),
+            south: () => ({ x: clamp(Math.floor(dims.x / 2) + jitter(rng), 0, dims.x - 1), y: dims.y - 1, z: 0 }),
+            west: () => ({ x: 0, y: clamp(Math.floor(dims.y / 2) + jitter(rng), 0, dims.y - 1), z: 0 }),
+            east: () => ({ x: dims.x - 1, y: clamp(Math.floor(dims.y / 2) + jitter(rng), 0, dims.y - 1), z: 0 }),
+        };
+        cell = nearestFreeOnWall(mid[wallSide](), wallSide, occupied, dims, exists);
+    }
+    else {
+        // up/down: no wall to sit on -- an open z=0 cell near the centroid,
+        // the same region synthesis uses for a floor hatch.
+        const region = WALL_REGIONS.center(dims);
+        const candidates = [];
+        for (let x = region.x0; x <= region.x1; x++) {
+            for (let y = region.y0; y <= region.y1; y++) {
+                const c = { x, y, z: 0 };
+                if (exists(c) && !occupied.has(key(c)))
+                    candidates.push(c);
+            }
+        }
+        cell = candidates.length > 0
+            ? candidates[Math.floor(rng() * candidates.length)]
+            : nearestFree({ x: Math.floor(dims.x / 2), y: Math.floor(dims.y / 2), z: 0 }, occupied, dims, exists);
+    }
+    grid.exitCells.set(direction, cell);
+}
+/** The other half of attachExitCell: an exit that has been unwired must
+ *  stop being drawn. Without this a home door that moves direction
+ *  between jobs (Game.connectHomeRoom picks the first free one) leaves
+ *  its old doorway on the map -- the ghost twin of the missing "D". */
+export function detachExitCell(grid, direction) {
+    grid.exitCells.delete(direction);
+}
 /** Flattens a live IRoomGrid's Maps into ISerializedRoomGrid. Spots ship
  *  UNFILTERED (the caller resolves actor positions against the full
  *  list, open floor included -- see room-view.ts's seatingIn); only the

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

@@ -1281,10 +1281,19 @@ export function lockedRouteHint(room, direction, door) {
     // naming a route that exists is not inventing one, and the silence
     // read as a soft-lock in play. Scene-factory step 4.95 guarantees the
     // named key is a real item somewhere in the scene.
+    //
+    // AND THE ROUTE THAT NEEDS NO KEY (Gfx5RFFpHJdKB87Bh). The key was
+    // named as if it were the only way through, so a runner with muscle
+    // and no datachip read a locked door as a wall. It never was: breach
+    // works a door as well as a maglock -- it just could not REACH one
+    // until this item, which is exactly why the hint had nothing to
+    // offer. Hint and verb have to agree; that they did not is half of
+    // what the report is.
+    const forceHint = ` Or put a shoulder through it -- "breach ${String(direction).toLowerCase()}", and the whole floor hears you.`;
     if (door.unlockItemOrSolution) {
-        return ` It takes ${door.unlockItemOrSolution} -- "unlock ${String(direction).toLowerCase()}" with it on you.`;
+        return ` It takes ${door.unlockItemOrSolution} -- "unlock ${String(direction).toLowerCase()}" with it on you.${forceHint}`;
     }
-    return '';
+    return forceHint;
 }
 /**
  * WHAT KIND OF WAY THROUGH a spot's name describes, or undefined when

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.204.0",
+  "version": "5.206.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.",