@maka/maka-cli 5.196.0 → 5.198.0

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

@@ -0,0 +1,69 @@
+import { Command } from './command.js';
+import { NPC } from '../models/npc.js';
+import { hint } from '../utilities/hints.js';
+import { SHOUT_METERS } from '../utilities/earshot.js';
+import { speakOnTheGrid } from '../utilities/matrix-roster.js';
+/**
+ * SHOUTING IS A VERB NOW (en3p6eCpiRuqsTSKm: "add 'shout' can be heard
+ * by anyone within a reasonable distance, 50m?").
+ *
+ * It used to be something that HAPPENED TO YOU. Room.say escalated to a
+ * room-wide shout whenever nobody shared your spot, so a runner standing
+ * on their own could not say anything quietly, and a runner at a crowded
+ * table could not deliberately call across the room. Both halves of the
+ * volume decision belonged to the furniture rather than to the player.
+ *
+ * Now `say` carries to whoever is close enough to hear it (earshot.ts)
+ * and this is how you reach everyone else. The range is this engine's
+ * number, not the book's -- see SHOUT_METERS -- and in practice it is
+ * room-wide, because the largest room the generator builds is tens of
+ * metres across.
+ *
+ * WHAT IT COSTS, and why that is not nothing: every hostile in the room
+ * hears you, and shouting is not sneaking. `sneaking` is dropped here
+ * the same way `say` drops it -- talking on comms is not a quiet
+ * activity, and bellowing across a warehouse is less so.
+ */
+export class ShoutCommand extends Command {
+    static verb = 'shout';
+    static description = `Raise your voice so the whole place hears it (~${SHOUT_METERS}m), instead of just whoever is standing close. "say" is ordinary speech and only carries as far as a listener's ears reach -- roughly 5m, further for someone with the chrome for it. Shouting reaches everyone in the room, hostiles included, and drops any sneaking.`;
+    context;
+    constructor(context) {
+        super(context);
+        this.context = context;
+    }
+    async execute(args) {
+        if (!args || args.length === 0) {
+            return `What do you want to shout?${hint(` ("shout <message>" -- "say" keeps it between you and whoever is close.)`)}`;
+        }
+        const message = args.join(' ');
+        const actor = this.actor;
+        // THE PLANES, worded as say.ts words them -- one mechanic, one set
+        // of sentences. An astral voice never reaches meat ears and a
+        // persona's never leaves the grid, and volume changes neither: a
+        // louder voice on the wrong plane is still no voice at all.
+        if (actor.plane === 'astral') {
+            return `You can shout all you like -- the meat world hears nothing. Spirits and projections do.`;
+        }
+        // Talking is not sneaking (sneak.ts); shouting least of all.
+        actor.sneaking = false;
+        if (actor.plane === 'matrix') {
+            // ON THE GRID THERE IS NO DISTANCE (grid-reach.ts): personas hear
+            // each other or they do not, and no amount of volume crosses a
+            // host wall. So this routes to the same fan-out `say` uses rather
+            // than inventing a louder one.
+            const heard = speakOnTheGrid(this.scene, actor, message).map(a => a.name);
+            return heard.length > 0
+                ? `You push it out across the grid: "${message}"\n  Heard by ${heard.join(', ')}.`
+                : `You push it out across the grid -- nothing out here is listening.`;
+        }
+        const heard = actor.currentLocation.shout(actor, message);
+        if (!(this.actor instanceof NPC)) {
+            this.actor.performAction('shouts', actor.currentLocation.name, { quiet: true });
+        }
+        return heard.length > 0
+            ? `You raise your voice: "${message}"`
+            : `You raise your voice: "${message}"\n  Nothing answers -- there's nobody here to hear it.`;
+    }
+}
+//# sourceMappingURL=shout.js.map

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

@@ -49,7 +49,7 @@ export class SnoopCommand extends Command {
         this.logger.write(`Snoop: ${actor.name} watching ${target.name} via camera feed.`);
         const lines = [`CAMERA FEED: ${target.name.toUpperCase()}`];
         if (!camerasLive(allRooms, target)) {
-            lines.push(`{lightblue-fg}(Security sees a loop of empty hallways -- these eyes answer only to you now.){/lightblue-fg}`);
+            lines.push(`{light-blue-fg}(Security sees a loop of empty hallways -- these eyes answer only to you now.){/light-blue-fg}`);
         }
         const seen = this.scene.getActorsInRoom(target)
             .filter(a => a !== actor && a.plane === 'meat' && !a.sneaking);

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

@@ -73,7 +73,7 @@ export class SpritesCommand extends Command {
             const name = type?.name ?? set.spriteKey;
             const isMine = mineType === set.spriteKey;
             const powers = powersForSprite(set.spriteKey);
-            lines.push(`${name.toUpperCase()} SPRITE${isMine ? ' {lightblue-fg}(yours){/lightblue-fg}' : ''}${type ? ` -- ${type.blurb}` : ''}`);
+            lines.push(`${name.toUpperCase()} SPRITE${isMine ? ' {light-blue-fg}(yours){/light-blue-fg}' : ''}${type ? ` -- ${type.blurb}` : ''}`);
             lines.push(`  Skills: ${skillsForSprite(set.spriteKey).join(', ')}${hint(`  (${set.page})`)}`);
             if (!detailed) {
                 // The names alone, which is the comparison view.

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

@@ -79,8 +79,8 @@ export function resolveSpokenTarget(parsedArgs, names) {
     return undefined;
 }
 export class TalkCommand extends Command {
-    static verb = "talk-to";
-    static description = "Speak privately to a person in the room.";
+    static verb = "tell";
+    static description = "Speak privately to ONE person standing with you -- only they hear it, however loud the room is. \"tell <name> <message>\". (\"talk-to\" is the old spelling and still works.) Compare \"say\", which carries to whoever is close enough to hear, and \"shout\", which reaches the whole place.";
     context;
     constructor(context) {
         super(context);

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

@@ -164,9 +164,9 @@ export class TapCommand extends Command {
         }
         this.logger.write(`${actor.name} now holds ${now} mark(s) on ${host.name} via the ${room.name} cameras.`);
         const lines = [
-            `{lightblue-fg}The filament finds the connector and the camera stops being a camera -- it's a device, and it's talking to you.{/lightblue-fg}`,
-            `  {lightblue-fg}It never gets to hide behind ${hostLabel(host)}: a cable doesn't ask the network for permission, so the lens has to defend itself with what a lens has. It doesn't have much.{/lightblue-fg}`,
-            `  {lightblue-fg}MARK PLACED -- and it lands on the host too. The camera answers to ${host.name}, and anything ${host.name} trusts to speak for it just handed you a key. [${now}/${MAX_MARKS}]{/lightblue-fg}`,
+            `{light-blue-fg}The filament finds the connector and the camera stops being a camera -- it's a device, and it's talking to you.{/light-blue-fg}`,
+            `  {light-blue-fg}It never gets to hide behind ${hostLabel(host)}: a cable doesn't ask the network for permission, so the lens has to defend itself with what a lens has. It doesn't have much.{/light-blue-fg}`,
+            `  {light-blue-fg}MARK PLACED -- and it lands on the host too. The camera answers to ${host.name}, and anything ${host.name} trusts to speak for it just handed you a key. [${now}/${MAX_MARKS}]{/light-blue-fg}`,
         ];
         if (mode === 'attack') {
             lines.push(`  The housing is visibly forced -- the host FELT that one, even if nothing saw your face.`);
@@ -175,15 +175,15 @@ export class TapCommand extends Command {
             lines.push(`  Nothing logged, nothing flagged. You were never here.`);
         }
         if (host === room) {
-            lines.push(`  {lightblue-fg}${now >= MAX_MARKS
+            lines.push(`  {light-blue-fg}${now >= MAX_MARKS
                 ? `The host thinks you belong now -- "hack" walks straight in.`
-                : `${hostLabel(host, { capital: true })} cracks easier with every key you hold${hint(` -- "jack in" and "hack", or come back for another lens`)}.`}{/lightblue-fg}`);
+                : `${hostLabel(host, { capital: true })} cracks easier with every key you hold${hint(` -- "jack in" and "hack", or come back for another lens`)}.`}{/light-blue-fg}`);
         }
         else {
-            lines.push(`  {lightblue-fg}These lenses ride the site network, so the key fits ${hostLabel(host)}${hint(` -- "jack in", "go ${host.name}", "hack"`)}.{/lightblue-fg}`);
+            lines.push(`  {light-blue-fg}These lenses ride the site network, so the key fits ${hostLabel(host)}${hint(` -- "jack in", "go ${host.name}", "hack"`)}.{/light-blue-fg}`);
         }
         // A mark is all canSnoopFeeds ever wanted (surveillance.ts).
-        lines.push(`  {lightblue-fg}And the eyes are half yours already${hint(` -- jacked in, "snoop <room>" rides any feed on this network`)}.{/lightblue-fg}`);
+        lines.push(`  {light-blue-fg}And the eyes are half yours already${hint(` -- jacked in, "snoop <room>" rides any feed on this network`)}.{/light-blue-fg}`);
         lines.push(...godLines);
         this.scene.updateStatus();
         return lines.join('\n');

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

@@ -67,7 +67,7 @@ export class ThreadCommand extends Command {
             const lines = [`COMPLEX FORMS (thread <form> <level>)`];
             for (const f of FORMS) {
                 const held = actor.sustainedForms.some(s => s.key === f.key);
-                lines.push(`  ${f.name.padEnd(16)} ${f.kind === 'sustained' ? '[sustained]' : '[instant]  '} ${f.blurb}${held ? ' {lightblue-fg}(HELD){/lightblue-fg}' : ''}`);
+                lines.push(`  ${f.name.padEnd(16)} ${f.kind === 'sustained' ? '[sustained]' : '[instant]  '} ${f.blurb}${held ? ' {light-blue-fg}(HELD){/light-blue-fg}' : ''}`);
             }
             if (actor.sustainedForms.length > 0) {
                 lines.push('', `  Holding ${actor.sustainedForms.length} form${actor.sustainedForms.length === 1 ? '' : 's'} (${sustainTotal(actor.sustainedLedger().filter(w => w.kind === 'form'))}).${hint(` ("thread drop <form>" releases.)`)}`);

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

@@ -482,5 +482,49 @@
 //   hub, characterSheet.hydrate -- silently ATE the lifestyle point of a
 //   runner who left fed and slept. The tier is on the save; it is read
 //   there now (commerce.lifestyleTierFor, Squatter when unnamed).
-export const ENGINE_VERSION = '1.55.1';
+// 1.56.0 (2026-09-15): TWO FLAGS THAT WERE STANDING IN FOR STATE THEY
+//   DO NOT HOLD.
+//   - A CRACKED HOST IS NOT A HOST YOU HOLD MARKS ON
+//     (spcebZTKN24GYRHXW). `hack`/`mark` refused outright on the
+//     room-global hostCracked, so a persona that rebooted mid-run -- which
+//     canon wipes marks on (p.236, p.242) -- could never re-place one,
+//     while every device on the node went on refusing them for want of
+//     marks. Command semantics in shared scenes: the refusal is gone, the
+//     standing guard is 3 marks held, a repeat break-in is worded as one,
+//     and the host line prints the site's state and the persona's marks
+//     apart. The crack's world consequences stay permanent.
+//   - NO CAB MID-FIGHT (hHvR2kxrqAKuuXwED). The downtime verbs (buy,
+//     sell, install, register, initiate, quality-trade, advance, call
+//     taxi) gated on Player.inExchange, a re-entrancy lock that is false
+//     for most of a Combat Turn, so each refused for the half-second an
+//     exchange resolved and permitted itself the rest of the fight. They
+//     ask inLiveCombat (action-cost.ts) now. NEW EMBEDDER SURFACE:
+//     Scene.anyLiveEncounter(), which the site reads off the live handle
+//     to refuse sideQuest.settle -- on a shared run the cab is intercepted
+//     before the engine ever sees it, so the server is the only place
+//     that path can be stopped.
+// 1.57.0 (2026-09-15): A VOICE CARRIES AS FAR AS THE EAR, and two
+//   spellings change with it.
+//   - `say` was resolved by SPOT NAME -- whoever shared your spot, plus
+//     anyone CIRCULATING, because "no position" was read as "every
+//     position". A patrol officer walking through a back room answered a
+//     question put to a Johnson at a table. It also ESCALATED on its own:
+//     alone at a spot, a murmur became a room-wide shout nobody asked
+//     for. Now `say` reaches whoever is inside their OWN hearing range
+//     (utilities/earshot.ts canHearSpeech; range is 5 m plus the
+//     listener's perception dice) and never escalates. Canon gives no
+//     distance for speech -- it is dice and limits, p.445/p.453-454 --
+//     so the metres are this engine's and are labelled as such.
+//   - NEW VERB `shout` (~50 m, in practice room-wide) is the old
+//     escalation, now deliberate.
+//   - `talk-to` is spelled `tell`. Command semantics in shared scenes:
+//     the old spelling stays registered as an alias, so nothing that
+//     learned it breaks.
+//   - COLOUR TAGS: the run-together "lightblue" spelling never parsed
+//     in blessed (its tag parser wants "light blue fg", hyphens turned
+//     to spaces) and was printed to CLI players as literal braces for
+//     months, while the web client rendered it perfectly. 134 tags are
+//     now {light-blue-fg}. The site's render-tags.ts maps that back
+//     to a real CSS keyword, so the pin must carry both halves.
+export const ENGINE_VERSION = '1.57.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -73,6 +73,7 @@ import { LockCommand } from './commands/lock.js';
 import { SearchCommand } from './commands/search.js';
 import { SayCommand } from './commands/say.js';
 import { TalkCommand } from './commands/talk.js';
+import { ShoutCommand } from './commands/shout.js';
 import { StoreCommand } from './commands/store.js';
 import { OpenCommand, CloseCommand, PutCommand } from './commands/container-verbs.js';
 import { GiveCommand } from './commands/give.js';
@@ -708,7 +709,7 @@ export default class Game {
         Logger.getInstance().write(`Loose end "${c.id}" left: ${erased ? 'ERASED' : 'still open'}; hub is the scene again.`);
         this.requestSave('cleanup');
         return [erased
-                ? `\n{lightblue-fg}The grid closes behind you. ${le?.site ?? 'The site'}'s feeds run clean -- whatever they had of you is gone.{/lightblue-fg}`
+                ? `\n{light-blue-fg}The grid closes behind you. ${le?.site ?? 'The site'}'s feeds run clean -- whatever they had of you is gone.{/light-blue-fg}`
                 : `\n{yellow-fg}The grid closes behind you. The footage is still up there.{/yellow-fg}${hint(` (Jack in and "hop" again while the desk hasn't reviewed it.)`)}`];
     }
     /** The HUD's read on the district (bands, never the number). */
@@ -2692,7 +2693,14 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('open', OpenCommand);
         CommandFactory.registerCommand('close', CloseCommand);
         CommandFactory.registerCommand('put', PutCommand);
+        // TELL IS THE VERB (en3p6eCpiRuqsTSKm: "let's adjust 'talk-to' to
+        // 'tell' to be more concise"). `talk-to` stays registered as an
+        // alias rather than being deleted: it is the spelling in every
+        // transcript, every NPC brief and every backlog item written before
+        // today, and a player who learned it should not be told it is gone.
+        CommandFactory.registerCommand('tell', TalkCommand);
         CommandFactory.registerCommand('talk-to', TalkCommand);
+        CommandFactory.registerCommand('shout', ShoutCommand);
         CommandFactory.registerCommand('give', GiveCommand);
         CommandFactory.registerCommand('read', ReadCommand);
         CommandFactory.registerCommand('kill', KillCommand);
@@ -5955,7 +5963,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // works the grid while you're back in the meat (the AR-drop exit).
         const remoteAgent = this.companions.find(c => c.kind === 'agent');
         if (remoteAgent && player.plane !== 'matrix') {
-            lines.push(`{lightblue-fg}▣ DECK IN AR -- ${remoteAgent.npc.name} on the grid${remoteAgent.npc.objective ? ', working its directive' : ''}${hint(' ("jack in" to rejoin it, "recall" to fold it home)')}{/lightblue-fg}`);
+            lines.push(`{light-blue-fg}▣ DECK IN AR -- ${remoteAgent.npc.name} on the grid${remoteAgent.npc.objective ? ', working its directive' : ''}${hint(' ("jack in" to rejoin it, "recall" to fold it home)')}{/light-blue-fg}`);
         }
         // Off-plane context: which reality you're in, your persona's Matrix
         // track (cold-sim damage lands there), and where your empty body lies.
@@ -5974,7 +5982,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const track = jackedDeck
                 ? `  Deck A${jackedDeck.attack} S${jackedDeck.sleaze} D${jackedDeck.dataProcessing} F${jackedDeck.firewall} ${jackedDeck.deckSummary()}${player.simMode === 'hot' ? ' +biofeedback' : ''}${pgms}`
                 : `  (living persona -- damage is REAL stun)`;
-            lines.push(`{lightblue-fg}▣ MATRIX ${(player.simMode ?? 'cold').toUpperCase()}-SIM${track} -- body at ${player.bodyRoom?.name ?? '???'}{/lightblue-fg}`);
+            lines.push(`{light-blue-fg}▣ MATRIX ${(player.simMode ?? 'cold').toUpperCase()}-SIM${track} -- body at ${player.bodyRoom?.name ?? '???'}{/light-blue-fg}`);
         }
         else if (player.plane === 'astral') {
             lines.push(`{magenta-fg}✧ ASTRAL -- ${player.astralTicks} move${player.astralTicks === 1 ? '' : 's'} out -- body at ${player.bodyRoom?.name ?? '???'}{/magenta-fg}`);
@@ -6066,7 +6074,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const dockW = mapWidth ?? 15;
             const lines = hosts.length > 0
                 ? hosts.map(h => hostDockLine(h, this.player, dockW))
-                : ['{lightblue-fg}nothing overhead{/lightblue-fg}'];
+                : ['{light-blue-fg}nothing overhead{/light-blue-fg}'];
             lines.push(caption(this.player.insideHost ? `inside ${this.player.insideHost.name}` : `on the grid from ${gridVicinity(this.player).name}`, mapWidth));
             this.setMapOverlay(lines);
             if (onTheGrid) {
@@ -6575,7 +6583,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // technomancer-gated (a sprite task, SR5 p.256) and refuses anyone
         // else, so the Emerged shelf is where its audience looks.
         { title: 'resonance', entries: [['compile'], ['decompile'], ['thread'], ['unravel'], ['register'], ['standby'], ['sustain'], ['sprites']] },
-        { title: 'social', entries: [['say'], ['emote', 'me'], ['talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
+        { title: 'social', entries: [['say'], ['shout'], ['emote', 'me'], ['tell', 'talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
         { title: 'street', entries: [['abandon'], ['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['garage'], ['pay']] },
         { title: 'barriers', entries: [['pick'], ['breach'], ['dispel', 'dispell'], ['bluff'], ['unlock'], ['lock']] },
         { title: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['sin', 'sins', 'papers'], ['initiate', 'submerge'], ['install', 'chrome']] },

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

@@ -9,7 +9,8 @@ import * as fuzzyMatch from '../utilities/fuzzy-match.js';
 import { sameHostSide } from './player.js';
 import { AI } from '../../../../tools/ai/ai.class.js';
 import { AbstractRoom } from '../types/shared/abstracts.js';
-import { spotOf, spotsActive, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
+import { spotsActive, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
+import { canHearSpeech } from '../utilities/earshot.js';
 import { synthesizeGrid, } from '../utilities/room-grid.js';
 export class Room extends AbstractRoom {
     logger = Logger.getInstance();
@@ -724,16 +725,37 @@ Keep it concise and dramatic.`;
         const others = mouths - 1;
         return ` [System note: ${others} other ${others === 1 ? 'person' : 'people'} in earshot heard this too, and each is answering in the same moment as you -- none of you can see what the others are about to say. Say YOUR piece, in your own voice, but not the same piece: if the obvious reply is one anyone here would give, make yours specific to you instead. Two people reporting one event reads as a joke.]`;
     }
+    /**
+     * ORDINARY SPEECH, which now carries as far as the LISTENER can hear
+     * and no further (en3p6eCpiRuqsTSKm: "'say' should only be perceived
+     * by anyone within 3-5m un-augmented. Really, it's the audible
+     * perception range of the listener").
+     *
+     * WHAT THIS REPLACES, and why the old shape produced the report.
+     * Speech used to be resolved by SPOT NAME: whoever shared your spot
+     * heard you, plus anyone CIRCULATING -- and if nobody shared your
+     * spot, the words escalated to a room-wide shout automatically. Two
+     * consequences, both reported in one session:
+     *
+     *  - A circulating actor heard everything, because "no spot" was read
+     *    as "everywhere". That is how Patrol Officer Kessler, `moving
+     *    through` the back room, answered a question put to Ms. Quill at
+     *    a table (CugfYsH8DWH8FcfgS).
+     *  - Standing anywhere on your own turned every murmur into a shout
+     *    without you asking for one, so there was no way to say something
+     *    quietly and no verb that meant "I want the room to hear this".
+     *
+     * Now: earshot.ts owns the rule (canHearSpeech), distance is real
+     * metres between cells, and the range belongs to each listener's ears.
+     * The escalation is gone -- SHOUTING IS A VERB NOW (commands/shout.ts,
+     * Room.shout below). Saying something nobody is close enough to catch
+     * is a thing that can happen, and say.ts tells you so.
+     *
+     * Returns who actually heard it, so the caller can say "nobody did"
+     * without asking the same question a second way and risking a
+     * different answer.
+     */
     say(actor, message) {
-        // "At" spots: speech is LOCAL (player decision: speech local, sight
-        // room-wide -- walking into the bar had every NPC in the room
-        // engaging at once). Same-spot and circulating listeners hear
-        // normally. When NOBODY shares the speaker's spot but others are in
-        // the room, the words carry as a SHOUT -- delivered room-wide with
-        // a tag so an NPC AI reacts to being called across the room, not to
-        // bar-side murmur. When same-spot listeners exist, cross-spot
-        // actors hear nothing (v1: the murmur doesn't carry).
-        const speakerSpot = spotOf(actor);
         // THE HOST WALL IS ALSO A WALL FOR VOICES (FhXadizkMCxAdMaJx).
         //
         // Every verb that PICKS a target honours sameHostSide -- that is what
@@ -748,66 +770,67 @@ Keep it concise and dramatic.`;
         // have insideHost undefined, so they compare equal and nothing about
         // ordinary speech changes.
         const listeners = [...this.actors].filter(r => r !== actor && sameHostSide(actor, r));
+        const audience = listeners.filter(r => canHearSpeech(actor, r));
         // broadcast: true -- room speech is overheard, not addressed. A
         // companion shell at heel uses that distinction to stay quiet (see
-        // NPC.hear); targeted channels (talk/order/ask...) never set it.
-        if (speakerSpot === undefined) {
-            const crowd = this.crowdNote(listeners);
-            // CAUGHT, like every other hear() fan-out in the game (say.ts,
-            // planes.ts, game.ts heartbeat). These three were the only bare
-            // ones left: a bare `void` on a rejecting promise is an
-            // unhandledRejection, and ui.ts fatal handler kills the session
-            // on one -- which is exactly how a 502 from the AI relay ended a
-            // live game twice on 2026-08-29. Belt AND braces: NPC.hear now
-            // swallows its own reaction failures too, so this is redundant
-            // for NPCs on purpose -- it still guards any other Player
-            // subclass that grows an async hear().
-            for (const recipient of listeners) {
-                void Promise.resolve(recipient.hear(actor, recipient instanceof NPC ? `${message}${crowd}` : message, { broadcast: true })).catch(err => {
-                    this.logger.error(`${recipient.name} failed to hear ${actor.name}: ${err}`);
-                });
-            }
-            return;
-        }
-        const local = listeners.filter(r => {
-            const rs = spotOf(r);
-            return rs === undefined || rs === speakerSpot;
-        });
-        if (local.length > 0) {
-            const crowd = this.crowdNote(local);
-            for (const recipient of local) {
-                void Promise.resolve(recipient.hear(actor, recipient instanceof NPC ? `${message}${crowd}` : message, { broadcast: true })).catch(err => {
-                    this.logger.error(`${recipient.name} failed to hear ${actor.name}: ${err}`);
-                });
-            }
-            return;
+        // NPC.hear); targeted channels (tell/order/ask...) never set it.
+        const crowd = this.crowdNote(audience);
+        // CAUGHT, like every other hear() fan-out in the game (say.ts,
+        // planes.ts, game.ts heartbeat). These were the only bare ones
+        // left: a bare `void` on a rejecting promise is an
+        // unhandledRejection, and ui.ts fatal handler kills the session on
+        // one -- which is exactly how a 502 from the AI relay ended a live
+        // game twice on 2026-08-29. Belt AND braces: NPC.hear now swallows
+        // its own reaction failures too, so this is redundant for NPCs on
+        // purpose -- it still guards any other Player subclass that grows
+        // an async hear().
+        //
+        // NO VOICE TAG. Everyone here is inside their own hearing range by
+        // construction, which is what voiceBandFor calls 'conversation' --
+        // the band that has always rendered as no tag at all.
+        for (const recipient of audience) {
+            void Promise.resolve(recipient.hear(actor, recipient instanceof NPC ? `${message}${crowd}` : message, { broadcast: true })).catch(err => {
+                this.logger.error(`${recipient.name} failed to hear ${actor.name}: ${err}`);
+            });
         }
-        // VOICE RANGE (spatial pass 2026-08-25): how hard you have to work
-        // to be heard scales with the actual gap, not a flat "another spot"
-        // -- since the room resize, a stallholder answering across a 32 m
-        // market was tagged the same as a neighbour two tables over
-        // (playtest: "he's basically screaming"). See spots.ts voiceBandFor.
-        // The shout channel: a lone-at-spot PLAYER calling out reaches the
-        // whole room. A lone-at-spot NPC reaches only the PLAYER -- the
-        // camera, not the cast: when every NPC's murmur went room-wide, two
-        // barflies at opposite ends conducted a shouted conversation about
-        // the player's drink order (real session: Patch and Old Cray,
-        // volleying "(calling across the room)" lines through each other's
-        // AI). Same-spot NPC chat is untouched -- that's the local branch.
+        return audience;
+    }
+    /**
+     * SHOUTING, which used to happen to you and is now something you do
+     * (en3p6eCpiRuqsTSKm: "add 'shout' can be heard by anyone within a
+     * reasonable distance, 50m?").
+     *
+     * Reaches the whole room -- see earshot.ts SHOUT_METERS for why 50 m
+     * is in practice room-wide and why the number is this engine's rather
+     * than the book's. Each listener is told how far the words travelled
+     * (voiceTag), so an NPC's AI answers someone calling across a bar
+     * differently from someone at its elbow.
+     *
+     * THE NPC RESTRAINT IS KEPT from the old auto-escalation, because the
+     * reason for it has not changed: when every NPC's raised voice went
+     * room-wide, two barflies at opposite ends held a shouted conversation
+     * about the player's drink order through each other's AI (a real
+     * session -- Patch and Old Cray). An NPC shout reaches the PLAYER, the
+     * camera rather than the cast. A PLAYER's shout reaches everyone,
+     * which is the whole point of typing it.
+     */
+    shout(actor, message) {
+        const listeners = [...this.actors].filter(r => r !== actor && sameHostSide(actor, r));
         const player = [...this.actors].find(a => !(a instanceof NPC));
-        const shoutTargets = actor instanceof NPC
+        const targets = actor instanceof NPC
             ? listeners.filter(r => r === player)
             : listeners;
-        const shoutCrowd = this.crowdNote(shoutTargets);
-        for (const recipient of shoutTargets) {
+        const crowd = this.crowdNote(targets);
+        for (const recipient of targets) {
             const band = voiceBandFor(actorDistanceMeters(this, actor, recipient));
             // The crowd note goes LAST, after the voice tag: both are system
             // dressing, and the tag describes the words while the note
             // describes the room.
-            void Promise.resolve(recipient.hear(actor, `${message}${voiceTag(band)}${recipient instanceof NPC ? shoutCrowd : ''}`, { broadcast: true })).catch(err => {
+            void Promise.resolve(recipient.hear(actor, `${message}${voiceTag(band)}${recipient instanceof NPC ? crowd : ''}`, { broadcast: true })).catch(err => {
                 this.logger.error(`${recipient.name} failed to hear ${actor.name} shout: ${err}`);
             });
         }
+        return targets;
     }
     addExit(direction, targetRoom, keyItemOrSolution) {
         let door = this.findExistingDoor(targetRoom);

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

@@ -185,6 +185,30 @@ export class Scene extends AbstractScene {
         const enc = this.encounterAt(arenaOf(actor));
         return enc?.has(actor) ? enc : undefined;
     }
+    /**
+     * IS ANYBODY AT THIS TABLE IN A FIGHT, asked across every arena.
+     *
+     * For the EMBEDDER, not for a verb (hHvR2kxrqAKuuXwED: "I was able to
+     * call a taxi in the middle of a fight"). On a shared run the ride
+     * home is not an engine verb at all -- both the CLI
+     * (utilities/shared-run.ts) and the browser (the site's run-exit.ts)
+     * intercept "call taxi" before it reaches the table and call
+     * sideQuest.settle, which ends the run for EVERYONE. So the engine's
+     * own gate in commands/call.ts, correct as it is, never ran on the
+     * path the report came in on, and the site had no way to ask this
+     * question without reaching into `encounters`.
+     *
+     * Every arena, not just the leader's: settling the table yanks the
+     * whole party home, so a decker in a host trading with ice is reason
+     * enough to refuse even if the leader is standing in an empty street.
+     */
+    anyLiveEncounter() {
+        for (const enc of this.encounters.values()) {
+            if (!enc.ended)
+                return true;
+        }
+        return false;
+    }
     /**
      * Who is in the fight when `aggressor` opens on `target`: the two of
      * them, every human and bound shell in the room (the party fights as

package/bundle/typescript/src/commands/game/sideQuest/utilities/action-cost.js

@@ -3,6 +3,42 @@ import { hint } from './hints.js';
 export function encounterOf(scene, actor) {
     return scene.encounterFor?.(actor);
 }
+/**
+ * IS THERE A FIGHT ON, for a verb that simply cannot happen during one.
+ *
+ * `Player.inExchange` is NOT this question, and a family of verbs was
+ * asking it as though it were (hHvR2kxrqAKuuXwED: "I was able to call a
+ * taxi in the middle of a fight"). That flag is a re-entrancy lock --
+ * true only while one exchange is mid-RESOLUTION, set by
+ * CombatExchange.beginExchange and cleared by finishExchange -- so it is
+ * false for almost all of a Combat Turn, including the whole of your own
+ * Action Phase. Every verb that gated on it alone was therefore refusing
+ * during the narration beats of a single trade of fire and permitting
+ * itself freely the rest of the fight, while its refusal line said
+ * "firefight".
+ *
+ * The Combat Turn (utilities/combat-turn.ts) is what actually knows a
+ * fight is on: an encounter exists for the actor's arena and has not
+ * ended. That is the primary test here. The two exchange checks stay
+ * underneath it because an exchange can resolve outside an encounter
+ * (an NPC AI loop, a scene with no Combat Turn running), and because
+ * NPCs have no encounter phase of their own to consult.
+ *
+ * This is the "no" answer, not the "not yet" answer. Use requirePhase
+ * for something that IS legal in a fight but only on your own phase
+ * (walking out of the room); use this for something that is not a combat
+ * action at all and has no phase that could pay for it -- hailing a cab,
+ * ringing up a sale, a training montage.
+ */
+export function inLiveCombat(scene, actor) {
+    const enc = encounterOf(scene, actor);
+    if (enc && !enc.ended)
+        return true;
+    if (actor.inExchange)
+        return true;
+    return scene.isHumanControlled?.(actor) === true
+        && scene.isPlayerExchangeActive?.(actor.name) === true;
+}
 /**
  * The refusal when it is not this actor's Action Phase -- the wording
  * every verb shares, so a player learns one sentence.

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

@@ -256,7 +256,7 @@ export function aroBlock(scene, actor, room) {
     const tags = aroTags(scene, actor, room);
     if (tags.length === 0)
         return '';
-    return `{lightblue-fg}AR OVERLAY:{/lightblue-fg}\n${tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`).join('\n')}`;
+    return `{light-blue-fg}AR OVERLAY:{/light-blue-fg}\n${tags.map(t => `  {light-blue-fg}${t}{/light-blue-fg}`).join('\n')}`;
 }
 /** Gear that talks to the grid on its own, lying LOOSE in the room.
  *  Weapons are absent here because a carried one is handled above, as