@maka/maka-cli 5.382.0 → 5.384.0

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

@@ -1,7 +1,7 @@
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { capitalCase } from 'change-case';
-import { planeTintItemName, objectiveMark } from '../utilities/planes.js';
+import { planeTintItemName, jobMark } from '../utilities/planes.js';
 import { dataDevices } from '../utilities/data-library.js';
 /**
  * On-demand inventory panel, replacing the always-on blessed sidebar box
@@ -76,7 +76,7 @@ export class InventoryCommand extends Command {
             const tinted = item.plane === 'meat'
                 ? rarityTint(item.rating, planeTintItemName(item, 'meat'))
                 : planeTintItemName(item, 'meat');
-            let line = `  ${CARRIED_MARK}${objectiveMark(this.scene, item.name)}${tinted}`;
+            let line = `  ${CARRIED_MARK}${jobMark(this.scene, item)}${tinted}`;
             // x N for a stack, the same shape the currency tag below uses.
             if (item.quantity > 1)
                 line += ` �${item.quantity}`;
@@ -130,7 +130,7 @@ export class InventoryCommand extends Command {
         if (libraries.length > 0) {
             lines.push('', `{light-blue-fg}On your devices:{/light-blue-fg}`);
             for (const device of libraries) {
-                lines.push(`  ${device.name}: ${device.files.map(f => `${objectiveMark(this.scene, f.name)}${planeTintItemName(f, 'meat')}`).join(', ')}`);
+                lines.push(`  ${device.name}: ${device.files.map(f => `${jobMark(this.scene, f)}${planeTintItemName(f, 'meat')}`).join(', ')}`);
             }
             const legend = hint(`("transfer <file> to <device>" moves one; "transfer <file> to chip" writes it to physical media.)`);
             if (legend)

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

@@ -12,7 +12,7 @@ import { getPref, setPref } from '../utilities/prefs.js';
 import { roomMetresPerDot } from '../utilities/room-view.js';
 import { roomRasterRows } from '../utilities/room-grid.js';
 import { PLANE_METRES_PER_DOT, fogEye, fogName, fogOf } from '../utilities/map-view.js';
-import { PLAYER_GLYPH, OTHER_PLAYER_GLYPH, CREW_GLYPH, NEUTRAL_GLYPH, HOSTILE_GLYPH, DOWNED_GLYPH, DEAD_GLYPH, RIGGED_GLYPH, SPOT_GLYPH, CAMERA_GLYPH, CAMERA_COLOR, CAMERA_DEAD_COLOR, WALL_GLYPH, DOOR_GLYPH, FLOOR_GLYPH, FRONTIER_GLYPH, BLOCKED_GLYPH, UP_GLYPH, DOWN_GLYPH, } from '../utilities/map-glyphs.js';
+import { PLAYER_GLYPH, OTHER_PLAYER_GLYPH, CREW_GLYPH, NEUTRAL_GLYPH, HOSTILE_GLYPH, DOWNED_GLYPH, DEAD_GLYPH, RIGGED_GLYPH, SPOT_GLYPH, CAMERA_GLYPH, CAMERA_COLOR, CAMERA_DEAD_COLOR, BARRIER_GLYPH, BARRIER_COLOR, MANA_BARRIER_COLOR, WALL_GLYPH, DOOR_GLYPH, FLOOR_GLYPH, FRONTIER_GLYPH, BLOCKED_GLYPH, UP_GLYPH, DOWN_GLYPH, } from '../utilities/map-glyphs.js';
 /**
  * The on-demand WAYS-ON list. Registered as both "map" and "exits";
  * since 2026-08-25 the drawn maps are permanently docked beside the log
@@ -41,7 +41,7 @@ export class MapCommand extends Command {
         if (sub === 'legend' || sub === 'key') {
             // Asked of the panel rather than guessed -- see Game.roomGridWidth.
             const availW = this.game?.roomGridWidth() ?? 19;
-            const metres = roomMetresPerDot(room, availW, roomRasterRows());
+            const metres = roomMetresPerDot(room, availW, roomRasterRows(), room.planeFrame?.()?.origin);
             const out = [];
             out.push(`{bold}THE MAP KEY{/bold}`);
             out.push('');
@@ -81,6 +81,14 @@ export class MapCommand extends Command {
             out.push(`  {${CAMERA_DEAD_COLOR}-fg}${CAMERA_GLYPH}{/${CAMERA_DEAD_COLOR}-fg}  a smashed one`);
             out.push(`  On the elevation bar, ${CAMERA_GLYPH} marks the height a camera hangs at.`);
             out.push('');
+            out.push(`{bold}Barriers{/bold}`);
+            out.push(`  {${BARRIER_COLOR}-fg}${BARRIER_GLYPH}{/${BARRIER_COLOR}-fg}  a force barrier -- nothing physical passes; "attack barrier" breaks a face`);
+            out.push(`  {${MANA_BARRIER_COLOR}-fg}${BARRIER_GLYPH}{/${MANA_BARRIER_COLOR}-fg}  a mana barrier, if you can see the astral -- it stops spirits and astral forms`);
+            out.push('');
+            out.push(`{bold}Coordinates{/bold}`);
+            out.push(`  The numbers along the top and left edges are district x and y -- 2 m a cell, north is up.`);
+            out.push(`  Your own x,y,z is under the Floor Plan. "cast barrier <x,y> <x,y>" raises a wall between two of them.`);
+            out.push('');
             out.push(`{bold}Scale{/bold}`);
             out.push(`  Floor Plan: one dot is {white-fg}${metres} m{/white-fg} here.`);
             out.push(`  Outside, the map runs at {white-fg}${PLANE_METRES_PER_DOT} m{/white-fg} a dot on the ground and scrolls with you;`);

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

@@ -45,6 +45,7 @@ import { onTheWall, midClimbRefusal } from '../utilities/climb-state.js';
  * verb that leaves a room.
  */
 export class MoveCommand extends Command {
+    static movesActor = true;
     static verb = 'walk';
     static description = 'Cross the room to a named spot or person: "move to bar", "move to Brick" (also "walk"/"approach"; "run to"/"sprint to" are the fast crossings). "move south 2" paces you across the room by cells instead -- use "go" to leave the room entirely. Bare "move" lists the room\'s spots. You must share a spot with someone to talk or trade with them.';
     /** Which movement mode this registration answers to (see subclasses). */
@@ -1200,7 +1201,10 @@ export class MoveCommand extends Command {
                         // world simply stops. Naming it a wall would send the
                         // player looking for a door.
                         : blockedBy === 'edge' ? `the ground ends there`
-                            : `there's a wall`;
+                            // A barrier spell, said as one: it is drawn, and it is
+                            // somebody's working (barrier-geometry.ts).
+                            : blockedBy === 'barrier' ? `a shimmer-wall of hardened air stands there${blocker ? ` -- ${blocker}'s barrier` : ''}`
+                                : `there's a wall`;
             const refusal = `You can't step ${direction} -- ${why}.${this.doorHint(room, cell, blockedBy)}`;
             // SAY IT ONCE (player screenshot 2026-09-21: twelve identical
             // "You can't step south -- there's a wall." filling the log).
@@ -1279,7 +1283,8 @@ export class MoveCommand extends Command {
             ? `Pulled up short after ${meters} m -- ${blockedBy === 'someone' ? 'someone is standing there'
                 : blockedBy === 'furniture' ? 'furniture blocks the way'
                     : blockedBy === 'terrain' ? 'the way is blocked'
-                        : blockedBy === 'edge' ? 'the ground ends there' : 'the wall'}.`
+                        : blockedBy === 'edge' ? 'the ground ends there'
+                            : blockedBy === 'barrier' ? 'a force barrier stands there' : 'the wall'}.`
             : '';
         const arrived = actor.atSpot !== wasAt && actor.atSpot !== OPEN_FLOOR
             ? `You're at the ${actor.atSpot} now.`
@@ -1724,7 +1729,8 @@ export class MoveCommand extends Command {
             return driftRefusal(drift, direction);
         const stopped = drift.blockedBy === undefined ? ''
             : drift.blockedBy === 'ward' ? ` A ward stops you${drift.ward ? ` at ${drift.ward}` : ''}.`
-                : ' Then solid earth.';
+                : drift.blockedBy === 'barrier' ? ` A mana barrier stops you${drift.ward ? ` -- ${drift.ward}'s working` : ''}.`
+                    : ' Then solid earth.';
         // Silent on a plain drift, like a meat step: the map moved, which
         // is the answer. Speak when you arrived over somewhere named, or
         // when something out here stopped you.

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

@@ -1,6 +1,6 @@
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
-import { planeTintItemName, emphasizeFind, objectiveMark, fileReach } from '../utilities/planes.js';
+import { planeTintItemName, emphasizeFind, jobMark, fileReach } from '../utilities/planes.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { perceptionTest, matrixSearchTest, matrixSearchSeconds, MATRIX_SEARCH } from '../utilities/perception.js';
 import { gridVicinity } from '../utilities/grid-reach.js';
@@ -194,7 +194,7 @@ export class SearchCommand extends Command {
             if (files.length === 0) {
                 return `The archive is indexed and EMPTY -- ${hostLabel(where)} keeps nothing worth the trip. ${clock}`;
             }
-            const list = files.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+            const list = files.map(i => `${jobMark(this.scene, i)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
             const seal = where.hostCracked
                 ? hint(` ("take" them -- the seal is already broken.)`)
                 : hint(` (sealed in the host's data vault: "hack" the node to break the seal, then "take".)`);
@@ -206,7 +206,7 @@ export class SearchCommand extends Command {
             const sealedElsewhere = files.length > 0 && where.hasNode;
             return `Nothing loose on ${where.name}'s grid. ${clock}${sealedElsewhere ? hint(` (${hostLabel(where)} keeps its files INSIDE -- "enter" it and search from in there.)`) : ''}`;
         }
-        const list = loose.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+        const list = loose.map(i => `${jobMark(this.scene, i)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
         return `Loose on ${where.name}'s grid: ${list}. ${clock}${hint(` ("take" rides them out on your deck.)`)}`;
     }
     async execute(_args) {
@@ -303,7 +303,7 @@ export class SearchCommand extends Command {
             // Plain lowercase for the log/AI history; the SCREEN list is tinted
             // per plane (see planeTintItemName) so paydata reads as data.
             const itemsList = found.map(i => i.name.toLowerCase()).join(', ');
-            const displayList = found.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, this.actor.plane))}`).join(', ');
+            const displayList = found.map(i => `${jobMark(this.scene, i)}${emphasizeFind(planeTintItemName(i, this.actor.plane))}`).join(', ');
             this.logger.write(`SearchCommand: ${this.actor.name} found the following items: ${itemsList}`);
             this.actor.performAction('search', itemsList);
             description += `You search the area and find: ${displayList}`;

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

@@ -4,6 +4,7 @@ import { Category } from '../types/shared/item-enum.js';
 import { hint } from '../utilities/hints.js';
 import { getAspect } from '../aspects.js';
 import { spellCreationCap } from '../spells.js';
+import { describeBarrier } from '../utilities/barrier-geometry.js';
 /**
  * The spellbook: how a player actually discovers what they can cast and
  * why. Especially load-bearing for INNATE casting -- an Awakened character
@@ -118,10 +119,10 @@ export class SpellsCommand extends Command {
             lines.push(`Sustaining on ${w.bearer}: ${w.key === 'reflexes' ? 'increase reflexes' : w.key} (${sustainBurden(w, ' to everything else')}).${hint(` Cast ${w.key} on ${w.bearer} again to release.`)}`);
         }
         if (actor.sustainedBarrier) {
-            lines.push(`Sustained: force barrier sealing ${actor.sustainedBarrier.direction} in ${actor.sustainedBarrier.roomName}, Force ${actor.sustainedBarrier.force} (${burden('barrier')}).${hint(' Cast barrier again to release.')}`);
+            lines.push(`Sustained: force barrier -- ${describeBarrier(actor.sustainedBarrier)} (${burden('barrier')}).${hint(' "cast barrier off" releases it.')}`);
         }
         if (actor.sustainedManaBarrier) {
-            lines.push(`Sustained: mana barrier sealing ${actor.sustainedManaBarrier.direction} in ${actor.sustainedManaBarrier.roomName}, Force ${actor.sustainedManaBarrier.force} (${burden('manabarrier')}).${hint(' Cast manabarrier again to release.')}`);
+            lines.push(`Sustained: mana barrier -- ${describeBarrier(actor.sustainedManaBarrier)} (${burden('manabarrier')}).${hint(' "cast manabarrier off" releases it.')}`);
         }
         if (actor.sustainedReflexes) {
             lines.push(`Sustained: increase reflexes, +2 initiative (${burden('reflexes')}).${hint(' Cast it again to release.')}`);
@@ -176,10 +177,10 @@ export class SpellsCommand extends Command {
                 line: 'sustained: light slides around the bearer, +3 on sneak contests at -2 dice. Drain F-4.' },
             { key: 'reflexes', cast: 'increase reflexes', how: 'cast increase reflexes [on <ally>]',
                 line: 'sustained: +2 initiative for the bearer at -2 dice. Drain F-3.' },
-            { key: 'barrier', cast: 'barrier', how: 'cast barrier <direction>; cast barrier again to release',
-                line: 'sustained: hardened air seals ONE exit of your room; nobody meat-side passes (you included) at -2 dice to you. Drain F-3.' },
-            { key: 'manabarrier', cast: 'manabarrier', how: 'cast manabarrier <direction>',
-                line: 'sustained: woven mana seals ONE exit against SPIRITS and astral forms; the living pass freely. Drain F-2.' },
+            { key: 'barrier', cast: 'barrier', how: 'cast barrier [F] <x,y> <x,y> (wall) | <x,y> (dome) | <direction> [cells] | at <someone> | (bare: a dome round you); cast barrier off',
+                line: 'sustained: hardened air -- a wall Force x 2 m long and Force m high, or a Force-metre dome. Armor/Structure = hits, a track per face; nobody meat-side passes (you included) at -2 dice to you. Drain F-1.' },
+            { key: 'manabarrier', cast: 'manabarrier', how: 'cast manabarrier [F] <x,y> <x,y> | <x,y> | <direction> [cells] | at <someone>; cast manabarrier off',
+                line: 'sustained: woven mana, same shapes -- stops SPIRITS and astral forms; the living pass freely, and so do you. Armor/Structure = Force. Drain F-2.' },
         ];
         for (const entry of book) {
             if (!actor.knowsSpell(entry.key))

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

@@ -153,7 +153,8 @@ export class TalkCommand extends Command {
         if (insideWithMe.includes(target)) {
             await speaker.hear(speaker, `(to ${target.name}) ${message}`);
             await target.hear(speaker, `(privately) ${message}`);
-            return `You speak to ${target.name} inside the host: "${message}"`;
+            // The echo above IS the confirmation (see the meat branch below).
+            return '';
         }
         // "At" spots: conversation needs shared ground (see
         // utilities/spots.ts) -- the bartender doesn't lean across the room.
@@ -174,7 +175,12 @@ export class TalkCommand extends Command {
         // Face time with the run's CLIENT is THE MEET (or the wrap-up) --
         // see Game.onClientInteraction (terms / lump-sum settlement).
         const clientBeat = this.game?.onClientInteraction(target.name);
-        return `You talk to ${target.name} privately: "${message}"${clientBeat ? `\n${clientBeat}` : ''}`;
+        // ONE LINE PER THING SAID (86LjwvK7xSbXhWXGi: "this repeated text can
+        // be removed: You talk to Mr. Vellum privately: ..."). The speaker's
+        // own hear() above already printed "Maka: (to Mr. Vellum) ...", so a
+        // reply quoting the same words back was the same sentence twice. The
+        // reply carries only what the echo cannot: the meet's beat.
+        return clientBeat ?? '';
     }
 }
 //# sourceMappingURL=talk.js.map

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

@@ -3319,5 +3319,41 @@
 //   hub boot (reaching a save that already slid) and after a shared
 //   run's homecoming. A move that cannot land now is retried next time;
 //   a session with no districtSeedLoader never moves.
-export const ENGINE_VERSION = '1.194.0';
+// 1.195.0 (2026-10-04): THE MEET, CLEANED UP (four live-table reports).
+// - The run's client holds his seat until the job is settled: his AI's
+//   move/approach/run/sprint/fly/go/follow are refused with a reason
+//   (npc-authorization.ts clientHoldsTheMeet; Command.movesActor), except
+//   inside a fight (CWMrB2aNyL4hhrjyG).
+// - A body nudged onto an exact cell (shoulderAside, yieldDoorway) still
+//   hears and is heard: earshot reads an exact cell as a place, so the
+//   shoved Johnson is no longer deaf to `say` (xurFSiqNtRNbXA88A).
+// - talk-to/tell no longer quote the words back under the speaker's own
+//   echo (86LjwvK7xSbXhWXGi).
+// - `inv`/`search` mark job leads with ☆ -- a page spelling a scene
+//   device's code, or a device's own key -- beside the objective's ★
+//   (nfrBW27eRRxstJ8uC).
+// - The HUD's holstered line drops its `-- "brandish"` tip
+//   (MkxamPxmsSyonR3wC).
+// 1.196.0 (2026-10-05): BARRIER SPELLS ON THE DISTRICT PLANE (SR5 p.294,
+//   p.197-198, p.315-316; utilities/barrier-geometry.ts).
+// - A barrier is cells, not a tag on an exit: `cast barrier [F] <x,y[,z]>
+//   [<x,y[,z]>]` (a wall between two points, or a Force-metre dome round
+//   one), `cast barrier [F] <dir> [cells]` (1x3 across the way), `cast
+//   barrier [F] at <someone>`, bare `cast barrier` (a dome round you),
+//   `cast barrier off`. Plane coordinates; LOS-gated; clipped by matter
+//   (physical) or by earth/wards/other weaves (mana).
+// - Physical Barrier rolls for real: Armor and Structure = hits [Force].
+//   Mana Barrier: Force. One damage track per FACE (a wall has one; a
+//   dome N/E/S/W, plus a crown past one level). `attack barrier [x,y]`
+//   breaks a face (p.197 text: DV must EXCEED Armor; guns do 1 box);
+//   a gun fired through one loses a box to it. Both regenerate at the
+//   Combat Turn boundary (mana at the end, physical at the start).
+// - Movement: findPath/stepFrom route round a physical barrier; astral
+//   `move` now stops at a mana barrier (it drifted through); astral `go`
+//   presses through on Magic + Charisma [Astral] v. Force x 2.
+// - Bare `cast <direction>` no longer unweaves a ward -- `dispel <dir>`.
+// - Wire: the room grid carries `barriers` (room-local cells; a mana
+//   barrier only for eyes that can see it). Docks draw x/y rulers in
+//   plane coordinates and the caption gives your x,y,z.
+export const ENGINE_VERSION = '1.196.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -149,6 +149,7 @@ import { ForceCommand } from './commands/force.js';
 import { CompleteCommand } from './commands/complete.js';
 import { DisableCommand, BrickCommand } from './commands/disable.js';
 import { CastCommand } from './commands/cast.js';
+import { barrierSpan } from './utilities/barrier-geometry.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
 import { BringCommand } from './commands/bring.js';
 import { SurrenderCommand } from './commands/surrender.js';
@@ -9273,8 +9274,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 ? ` {red-fg}[JAMMED -- reboot]{/red-fg}`
                 : weaponItem.ammo === 0 ? ` {red-fg}[DRY]{/red-fg}` : ` [${weaponItem.ammo} rds]`)
             : '';
+        // NO VERB COACHING IN THE HUD (MkxamPxmsSyonR3wC: "get rid of this
+        // line in the status bar: -- "brandish""). The status bar is state;
+        // the `brandish` hint already rides the equip/holster replies and
+        // `equipment`, where it answers the moment the question comes up.
         if (player.plane === 'meat' && weaponItem && !player.weaponDrawn) {
-            return `{white-fg}Holstered: ${weaponItem.name}${ammoNote}${hint(' -- "brandish"')}{/white-fg}`;
+            return `{white-fg}Holstered: ${weaponItem.name}${ammoNote}{/white-fg}`;
         }
         // White, not gray: gray is ANSI bright-black and illegible on
         // stock dark palettes -- the same ruling that moved the HUD
@@ -9473,10 +9478,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // the one that strands the team -- and both of them seal an exit
         // that the caster cannot pass either.
         if (player.sustainedBarrier) {
-            heldSpells.push(`physical barrier (${player.sustainedBarrier.roomName} ${player.sustainedBarrier.direction})`);
+            heldSpells.push(`physical barrier (${player.sustainedBarrier.shape} ${barrierSpan(player.sustainedBarrier)}, ${player.sustainedBarrier.roomName})`);
         }
         if (player.sustainedManaBarrier) {
-            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.roomName} ${player.sustainedManaBarrier.direction})`);
+            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.shape} ${barrierSpan(player.sustainedManaBarrier)}, ${player.sustainedManaBarrier.roomName})`);
         }
         // What this character holds on OTHERS -- the caster's burden, named
         // by bearer so the mage knows whose armor is costing them two dice.
@@ -9717,6 +9722,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 // Whose eyes, and what counts as hostile -- so the district draws
                 // the same people, with the same marks, the room panel does.
                 viewer: this.player,
+                rulers: true,
                 isOtherPlayer: a => this.scene.isHumanControlled(a),
                 isTableAlly: crewOfTable(this.scene.getPlayers()),
                 isHostile: a => hostileByStance(a) || enemyInFight(this.scene, this.player, a),
@@ -9749,6 +9755,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const roomLines = renderRoomLayoutCompact(here, this.player, {
                 isTableAlly: crewOfTable(this.scene.getPlayers()),
                 boxWidth,
+                // Rulers in PLANE coordinates -- the numbers "cast barrier x,y" takes.
+                origin: here.planeFrame?.()?.origin,
                 isOtherPlayer: a => this.scene.isHumanControlled(a),
                 // Red is the stance flag OR whoever the Combat Turn says is
                 // fighting you (room-view.ts hostileByStance).
@@ -9763,7 +9771,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 // of its own. The GLYPHS moved to `map legend`, where there is
                 // room to say what they mean instead of abbreviating them into
                 // a strip nobody could read.
-                roomLines.push(rightAlign(dockScale(roomMetresPerDot(here, this.roomGridWidth() ?? Math.max(6, (boxWidth ?? 27) - 8), roomRasterRows())), boxWidth));
+                roomLines.push(rightAlign(dockScale(roomMetresPerDot(here, this.roomGridWidth() ?? Math.max(6, (boxWidth ?? 27) - 8), roomRasterRows(), here.planeFrame?.()?.origin)), boxWidth));
                 roomLines.push(caption(roomCaption(here, this.player), boxWidth));
             }
             this.setRoomOverlay(roomLines);

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

@@ -564,6 +564,7 @@ function wireHeadless(game, ctx, logger) {
                 arEyes: p.hasMatrixEyes(),
                 at: game.scene.worldCellOf(p),
                 viewer: p,
+                rulers: true,
                 isOtherPlayer: (a) => game.scene.isHumanControlled(a),
                 isTableAlly: crewOfTable(game.scene.getPlayers()),
                 isHostile: (a) => hostileByStance(a) || enemyInFight(game.scene, p, a),
@@ -651,6 +652,7 @@ function wireHeadless(game, ctx, logger) {
             try {
                 const roomLines = renderRoomLayoutCompact(here, p, {
                     isOtherPlayer: a => game.scene.isHumanControlled(a),
+                    origin: here.planeFrame?.()?.origin,
                     isHostile: a => hostileByStance(a) || enemyInFight(game.scene, p, a),
                     // The leader's crew are the TABLE's crew -- without this
                     // every non-leader saw them as neutral bystanders.
@@ -671,7 +673,7 @@ function wireHeadless(game, ctx, logger) {
                 // here anyway rather than asserted, since a decoration must
                 // never take down the room push (same reasoning as the
                 // try/catch this sits inside).
-                const grid = roomGridWire(here);
+                const grid = roomGridWire(here, p);
                 const data = grid ? { grid } : undefined;
                 logger.system(roomLines.join('\n'), { actor: p.name }, 'room', data);
             }

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

@@ -2613,7 +2613,9 @@ staff, so codes, passphrases, and lock combinations are exactly the thing you we
 THEM to solve -- say so plainly when they ask, and send them to find it rather than
 handing them a number you'd be making up. If you genuinely don't know a thing, say so plainly and point at who might. You
 front half the pay at the meet and settle the rest on delivery (the engine moves the money
--- never haggle it yourself unless they invoke a negotiation).`
+-- never haggle it yourself unless they invoke a negotiation).
+You chose this venue and you HOLD YOUR SEAT in it: never move, walk, approach, follow or
+leave -- the runner comes to you. Turn, lean, gesture or speak instead.`
             : '';
         // ---------- prompt ----------
         const prompt = `

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

@@ -3180,6 +3180,10 @@ export class Player extends AbstractPlayer {
      * rather than leaving you drawn at the old one. NPCs keep re-deriving --
      * a picket or a crowd is placed by spot on purpose (NPC overrides).
      */
+    /** An exact cell somebody PUT this body on -- a step, a shove, a
+     *  flight -- as opposed to a drift seat pinned only so it is drawn in
+     *  one place (pinDerivedSeat). earshot.ts reads the first as a place. */
+    get placedOnCell() { return this._atCell !== undefined && !this._cellPinnedFromSeat; }
     get pinsDerivedSeat() { return true; }
     pinDerivedSeat(cell) {
         this.atCell = cell;
@@ -5240,10 +5244,11 @@ export class Player extends AbstractPlayer {
             }
         }
     }
-    /** The sustained PHYSICAL BARRIER spell (ruling 2026-08-24): seals
-     *  one exit of one room while held -- go.ts and move refuse passage
-     *  for everyone (the caster included; walls don't play favorites).
-     *  Session-only, like every sustain. */
+    /** The sustained PHYSICAL BARRIER spell: cells on the district plane
+     *  (utilities/barrier-geometry.ts, 2026-10-05 -- it used to seal one
+     *  exit). Nothing physical crosses a standing face, the caster
+     *  included; walls don't play favorites. Session-only, like every
+     *  sustain. */
     _sustainedBarrier;
     get sustainedBarrier() { return this._sustainedBarrier; }
     set sustainedBarrier(v) {
@@ -5255,8 +5260,9 @@ export class Player extends AbstractPlayer {
         this.noteConditionChanged();
     }
     /** The MANA BARRIER twin (canon p.294, RAG-checked): blocks SPIRITS
-     *  and astral forms at the sealed exit; living mundanes and physical
-     *  objects pass freely. Same lifecycle as sustainedBarrier. */
+     *  and astral forms at its cells; living mundanes and physical
+     *  objects pass freely, and so does its creator (p.315). Same
+     *  lifecycle as sustainedBarrier. */
     _sustainedManaBarrier;
     get sustainedManaBarrier() { return this._sustainedManaBarrier; }
     set sustainedManaBarrier(v) {

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

@@ -16,7 +16,7 @@ import { dwellingDims } from '../utilities/dwellings.js';
 import { spotsActive, isPerchSpot, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
 import { canHearSpeech, canHearShout } from '../utilities/earshot.js';
 import { freshCrowd, clampHeadcount, deriveOccupancy } from '../utilities/crowd.js';
-import { synthesizeGrid, attachExitCell, detachExitCell, hashFnv1a, mulberry32, } from '../utilities/room-grid.js';
+import { synthesizeGrid, attachExitCell, detachExitCell, hashFnv1a, mulberry32, setCellBlocker, } from '../utilities/room-grid.js';
 /**
  * A CAMERA'S DEVICE RATING when the scene does not say (p.356, which
  * lists "Camera" at 1 -- the same table that gives the door lock the 2
@@ -560,6 +560,9 @@ export class Room extends AbstractRoom {
             levels: this.levels,
             terrainHints: this.terrainHints,
         });
+        // A BARRIER SPELL IS ASKED, NOT STORED (room-grid.ts CELL_BLOCKERS):
+        // its cells come and go while the grid lives, and the scene owns them.
+        setCellBlocker(this._grid, c => this.scene?.physicalBarrierAtLocal?.(this, c) ?? false);
         return this._grid;
     }
     /**

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

@@ -8,6 +8,12 @@ import { Direction } from '../types/shared/direction-enum.js';
 import { Door } from './door.js';
 import { dwellingDims } from '../utilities/dwellings.js';
 import { actorCell } from '../utilities/spots.js';
+import { line3D } from '../utilities/room-grid.js';
+import { faceAt } from '../utilities/barrier-geometry.js';
+/** One step out through a doorway, per exit direction (north is -y). */
+const BARRIER_STEP = {
+    north: [0, -1], south: [0, 1], east: [1, 0], west: [-1, 0],
+};
 import { packDistrict, worldCell, buildAuthoredPlane, partyLayout, planeFaults } from '../utilities/district-plane.js';
 import { Category, Size, Rating } from '../types/shared/item-enum.js';
 import { AbstractScene } from '../types/shared/abstracts.js';
@@ -1222,30 +1228,93 @@ export class Scene extends AbstractScene {
         return this.characterLocations.get(character.name);
     }
     /**
-     * A sustained PHYSICAL BARRIER spell (Player.sustainedBarrier)
-     * sealing this room's exit in `direction` -- checked from BOTH sides
-     * of the doorway (the wall is in the frame, not painted on one face).
-     * go.ts refuses traversal for every meat-plane actor while it holds.
+     * EVERY BARRIER SPELL STANDING IN THIS SCENE (barrier-geometry.ts).
+     * They live on the casters -- one of each kind apiece -- so this is a
+     * walk of the players, the same place the old exit seal read them.
      */
-    barrierSealing(room, direction, kind = 'physical') {
+    spellBarriers(kind) {
+        const out = [];
+        for (const p of this.getPlayers()) {
+            if (p.sustainedBarrier && (!kind || kind === 'physical'))
+                out.push(p.sustainedBarrier);
+            if (p.sustainedManaBarrier && (!kind || kind === 'mana'))
+                out.push(p.sustainedManaBarrier);
+        }
+        return out;
+    }
+    /**
+     * The standing barrier face on this PLANE cell, if any. `passer` is
+     * who is asking to cross: a mana barrier "does not affect its
+     * creator, who can pass through at will" (p.315), so its own weaver
+     * gets undefined. A physical wall plays no favourites.
+     */
+    barrierAt(c, kind, passer) {
+        for (const barrier of this.spellBarriers(kind)) {
+            if (kind === 'mana' && passer !== undefined && barrier.caster === passer)
+                continue;
+            const face = faceAt(barrier, c);
+            if (face)
+                return { barrier, face };
+        }
+        return undefined;
+    }
+    /**
+     * The first standing barrier face a straight line crosses between two
+     * PLANE cells, endpoints excluded -- what a shot at someone behind a
+     * wall has to go through first (p.197-198).
+     */
+    barrierOnLine(a, b, kind) {
+        if (this.spellBarriers(kind).length === 0)
+            return undefined;
+        for (const c of line3D(a, b).slice(1, -1)) {
+            const hit = this.barrierAt(c, kind);
+            if (hit)
+                return hit;
+        }
+        return undefined;
+    }
+    /**
+     * A ROOM-LOCAL cell under a physical barrier -- what Room.ensureGrid
+     * registers with the grid, so findPath, stepFrom and seating all
+     * route round the wall without knowing spells exist.
+     */
+    physicalBarrierAtLocal(room, local) {
+        if (this.spellBarriers('physical').length === 0)
+            return false;
+        const c = worldCell(this.ensurePlane(), room.name, local);
+        return !!c && !!this.barrierAt(c, 'physical');
+    }
+    /**
+     * IS THIS EXIT WALLED OFF BY A BARRIER SPELL. Since 2026-10-05 a
+     * barrier is cells, not a tag on an exit, so the question is whether a
+     * standing face covers the doorway: the exit's own cell or the gap in
+     * the wall beyond it -- from either side, because the far room's
+     * doorway is the same hole.
+     */
+    barrierSealing(room, direction, kind = 'physical', passer) {
+        if (this.spellBarriers(kind).length === 0)
+            return undefined;
+        const plane = this.ensurePlane();
+        const cellsOf = (r, dir) => {
+            const local = r.ensureGrid()?.exitCells.get(dir.toLowerCase());
+            const at = local && worldCell(plane, r.name, local);
+            if (!at)
+                return [];
+            const step = BARRIER_STEP[dir.toLowerCase()];
+            return step ? [at, { x: at.x + step[0], y: at.y + step[1], z: at.z }] : [at];
+        };
         const exit = room.exits.get(direction);
         // getOtherSide (the Room), not getOtherSideToName (a "To X" display
         // string -- a probe caught the far-side check silently never
         // matching on it).
-        const destName = !exit ? undefined
-            : typeof exit === 'string' ? exit
-                : exit.getOtherSide?.(room)?.name;
+        const far = !exit || typeof exit === 'string' ? undefined
+            : exit.getOtherSide?.(room);
         const opposite = room.getOppositeDirection(direction);
-        for (const p of this.getPlayers()) {
-            const b = kind === 'physical' ? p.sustainedBarrier : p.sustainedManaBarrier;
-            if (!b)
-                continue;
-            if (b.roomName === room.name && b.direction.toLowerCase() === direction.toLowerCase()) {
-                return { caster: p.name, force: b.force };
-            }
-            if (destName && b.roomName === destName && opposite && b.direction.toLowerCase() === String(opposite).toLowerCase()) {
-                return { caster: p.name, force: b.force };
-            }
+        const cells = [...cellsOf(room, direction), ...(far && opposite ? cellsOf(far, String(opposite)) : [])];
+        for (const c of cells) {
+            const hit = this.barrierAt(c, kind, passer);
+            if (hit)
+                return { caster: hit.barrier.caster, force: hit.barrier.force };
         }
         return undefined;
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/astral-move.js

@@ -75,7 +75,7 @@ export function driftAstral(scene, actor, rooms, direction, count, untilOut = fa
     // the room it is trying to leave is large.
     const limit = untilOut ? 50 : count;
     while (taken < limit) {
-        const step = astralStepFrom(plane, cell, direction, 1, byKey);
+        const step = astralStepFrom(plane, cell, direction, 1, byKey, c => scene.barrierAt?.(c, 'mana', actor.name)?.barrier.caster);
         if (step.taken === 0) {
             blockedBy = step.blockedBy;
             ward = step.ward;
@@ -193,6 +193,9 @@ export function driftRefusal(d, direction) {
      * nearest outdoor room and simply goes. The only things that stop a
      * form are the two canon gives: solid earth and a ward.
      */
+    if (d.blockedBy === 'barrier') {
+        return `A mana barrier hangs across the way ${direction}${d.ward ? ` -- ${d.ward}'s working` : ''}: a hazy, solid sheet of woven mana. The astral does not pass (p.315-316).`;
+    }
     if (d.blockedBy === 'ward') {
         return `A lattice of woven mana stands across the way ${direction}${d.ward ? ` -- ${d.ward}'s` : ''}. The astral does not pass.`;
     }