@maka/maka-cli 5.197.0 → 5.199.0

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

@@ -1,5 +1,7 @@
 import { registerNotice, registerProvocation, PROVOCATION } from '../utilities/hostile-contact.js';
 import { hint } from '../utilities/hints.js';
+import { judgeNarration } from '../utilities/narration-limits.js';
+import { judgeEcho } from '../utilities/beat-echo.js';
 import { WOUND_TALK, isClinicRoom, isStreetDoc, streetDocBrief, treatHint } from '../utilities/street-doc.js';
 import { capitalCase } from 'change-case';
 import { tableCrewNote, tableDeliveryNote } from '../utilities/table-notes.js';
@@ -687,6 +689,22 @@ export class NPC extends Player {
     // an agent's deck) that combat-exchange routes damage into;
     // companionKind flavors the prompt and the HUD.
     allyOf;
+    /**
+     * WHO THIS NPC ANSWERS TO (aCErAfvEW7G23FWDM) -- a faction slug, and
+     * a catalog row on maka-cli.com holds what that faction is. See
+     * factions.ts.
+     *
+     * DELIBERATELY NOT `allyOf`, which is the master of a bound companion
+     * shell and a relationship with the PLAYER. This is a relationship
+     * with the WORLD: the thing the engine could never say, so it could
+     * never work out that a badge at the next table changes what a
+     * Johnson will discuss out loud.
+     *
+     * Optional, and an NPC without one is the normal case. factionOf()
+     * falls back to the ephemeral spawn kind and otherwise answers
+     * "nobody in particular", which every rule reads as no opinion.
+     */
+    faction;
     /**
      * SET ONLY BY THE EPHEMERAL GOVERNOR (utilities/ephemeral.ts): this
      * body is a passing face, not a character. Its presence trims the
@@ -729,6 +747,12 @@ export class NPC extends Player {
         const parsed = await this.commandRegistry.parse(commandString, this);
         if (!parsed)
             return null;
+        // A refused verb is a REAL verb the engine would not let this actor
+        // run (utilities/npc-authorization.ts). It is not the "unknown
+        // command, treat it as a directive" case, so it must not return
+        // null -- the refusal itself is the outcome.
+        if (!parsed.command)
+            return parsed.refusal;
         return await parsed.command.execute(parsed.args);
     }
     async runCommand(commandString) {
@@ -1021,6 +1045,13 @@ description text.`;
             this.logger.error(`${this.name} (combat) tried to perform unknown command: ${commandString}`);
             return '';
         }
+        if (!parsed.command) {
+            // The deterministic combat brain reads refusals as results (see
+            // the header above), so this needs no special case beyond not
+            // executing anything.
+            this._addToHistory(parsed.refusal);
+            return parsed.refusal;
+        }
         const result = await parsed.command.execute(parsed.args);
         if (result)
             this._addToHistory(result);
@@ -1045,7 +1076,16 @@ description text.`;
             return;
         }
         const parsed = await this.commandRegistry.parse(commandString, this);
-        if (parsed) {
+        if (parsed && !parsed.command) {
+            // THE MODEL HEARS THE BOUNDARY. Reflecting on a refusal is the
+            // whole point: the reflect loop's own breakers (_triedThisStimulus,
+            // FAILED_RESULT) then stop a second attempt at the same refused
+            // act, so a refusal costs one beat and teaches, instead of
+            // becoming a grind the player watches.
+            this._addToHistory(parsed.refusal);
+            await this.recursiveReflect(commandString, parsed.refusal);
+        }
+        else if (parsed?.command) {
             // Capture the result of the command
             const result = await parsed.command.execute(parsed.args);
             this.relayToMaster(commandString, result);
@@ -1541,7 +1581,7 @@ description text.`;
             }
         }
         const historySummary = this.getHistorySummary();
-        const worldEventsSummary = this._scene?.getWorldEventsSummary() ?? 'Nothing notable has happened elsewhere yet.';
+        const worldEventsSummary = this._scene?.getWorldEventsSummary(this) ?? 'Nothing notable has happened elsewhere yet.';
         const objectiveSummary = this._objective
             ? `Your current objective: ${this._objective}`
             : `You don't have a specific objective right now.`;
@@ -1640,7 +1680,12 @@ ${worldEventsSummary}
                 this._spokeThisStimulus = true;
             }
             const parsed = await this.commandRegistry.parse(nextCommand, this);
-            if (parsed) {
+            if (parsed && !parsed.command) {
+                this._addToHistory(parsed.refusal);
+                this.relayToMaster(nextCommand, parsed.refusal);
+                await this.recursiveReflect(nextCommand, parsed.refusal, recursionDepth + 1, maxRecursion);
+            }
+            else if (parsed?.command) {
                 const nextResult = await parsed.command.execute(parsed.args);
                 if (nextResult) {
                     this._addToHistory(nextResult);
@@ -1744,7 +1789,7 @@ ${worldEventsSummary}
             ? `The overall storyline for this scene is: ${this._scene.story}`
             : `This scene has no overall storyline`;
         const historySummary = this.getHistorySummary();
-        const worldEventsSummary = this._scene?.getWorldEventsSummary() ?? 'Nothing notable has happened elsewhere yet.';
+        const worldEventsSummary = this._scene?.getWorldEventsSummary(this) ?? 'Nothing notable has happened elsewhere yet.';
         const objectiveSummary = this._objective
             ? `Your current objective: ${this._objective}`
             : `You don't have a specific objective yet -- if this event gives you one, set it.`;
@@ -1759,7 +1804,26 @@ ${worldEventsSummary}
         // winCondition.payout on completion, so a freely-invented figure in
         // dialogue becomes a broken promise -- found via a real session where
         // the fixer offered "50k" and the job actually paid 2000.
-        const payout = this._scene?.getWinCondition?.()?.payout;
+        // Who would have been told the terms: the Johnson who set them, and
+        // the runner's own contacts -- the people a runner actually talks
+        // shop with. Everyone else is a stranger in a bar.
+        const partyToTheDeal = this._scene?.ownerGame?.currentClient?.name === this.name
+            || !!this._scene?.ownerGame?.contacts?.get(this.name);
+        // WHOSE DEAL IS IT (aCErAfvEW7G23FWDM, the reporter's question:
+        // "Do they just 'have all the information' all the time?").
+        //
+        // The figure below is the RUN'S AGREED PRICE, and it was handed to
+        // every non-ephemeral NPC in the scene -- the bartender, the guard
+        // on the door, the fixer three rooms away. Each of them could quote
+        // what the runner is being paid by a Johnson they have never met.
+        //
+        // The BLOCK stays exactly as it was, because the reason for it has
+        // not changed: an invented figure becomes a broken promise, found
+        // in a real session where a fixer offered "50k" against a job that
+        // paid 2000. What changes is WHO IS TOLD -- the parties to the deal
+        // (the client, and anyone on the runner's own contact list, who are
+        // the people a runner would actually have discussed terms with).
+        const payout = partyToTheDeal ? this._scene?.getWinCondition?.()?.payout : undefined;
         const payoutSummary = payout
             ? `The agreed payout for the current job is EXACTLY ${payout} nuyen, paid as ONE LUMP SUM on delivery -- there is no advance and no half up front; never speak as if part has already been paid. Any time you mention payment, reward, or what the job is worth, use exactly this figure -- never invent a different one. Payment transfers automatically when the job completes; you never need to hand it over.`
             : '';
@@ -2265,7 +2329,23 @@ Your objective is to drive the story line.`}
         // ---------- AI call + parsing (defensive) ----------
         try {
             const reply = await AI.ask(prompt);
-            this._addToHistory(reply);
+            // WHAT AN NPC REMEMBERS IS WHAT IT DID, NOT WHAT IT DRAFTED
+            // (aCErAfvEW7G23FWDM).
+            //
+            // The RAW, UNPARSED model reply used to be pushed into _history
+            // right here, before anything had looked at it -- so an NPC's
+            // memory filled up with its own "[COMMAND] say ..." scaffolding,
+            // with out-of-character lines the OOC filter went on to suppress,
+            // with beats withheld because the player was not in the room, and
+            // now with narration the prose gate refuses. The model was then
+            // shown all of it as things that happened, and told not to repeat
+            // itself.
+            //
+            // _history is the ONE genuinely perception-filtered channel in
+            // the brief -- hear() and see() write to it, behind every gate in
+            // this file. Letting an undelivered draft in through the side
+            // door is what made it unreliable. What gets recorded now is what
+            // actually reached the world, recorded where that is known.
             const lines = toLines(reply);
             const repaired = splitSpokenLines(lines);
             lines.splice(0, lines.length, ...repaired);
@@ -2325,15 +2405,46 @@ Your objective is to drive the story line.`}
             if (spokenText) {
                 const commandText = spokenText.replace('[COMMAND]', '').trim();
                 this.logger.write(`${this.name} attempts to say: ${commandText}`);
-                try {
-                    if (commandText.length > 0) {
-                        this._spokeThisStimulus = true;
-                        await this.act(commandText);
-                    }
+                // THE SAME LINE TWICE, ONE STIMULUS LATER. _spokeThisStimulus
+                // allows one speech per stimulus and says nothing about the
+                // NEXT one a second later -- which is how Ms. Quill delivered
+                // the Drowned Choir hook twice in two phrasings at 10:57:18 and
+                // :19 (aCErAfvEW7G23FWDM). Judged on the SPOKEN words, not the
+                // command string, because "say X" and "say X, rephrased" are
+                // different strings and the same beat.
+                const said = commandText.replace(/^say\s+/i, '');
+                // 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
+                // ONE short line"), and two drones clearing two rooms say
+                // near-identical things on purpose. The DONE:/FAILED: protocol
+                // rides this channel too, and a swallowed DONE strands a
+                // standing directive forever.
+                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)}`);
+                    // 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.
+                    this._spokeThisStimulus = true;
                 }
-                catch (err) {
-                    this.logger.error(`${this.name} failed to say "${commandText}": ${err}`);
-                    // continue; don't throw so we can process remaining lines
+                else {
+                    try {
+                        if (commandText.length > 0) {
+                            this._spokeThisStimulus = true;
+                            await this.act(commandText);
+                            // SAID, therefore remembered. This is the replacement for
+                            // the raw-reply write above: what reached the room, in the
+                            // words the room heard.
+                            this._addToHistory(`${this.name} said: ${said}`);
+                        }
+                    }
+                    catch (err) {
+                        this.logger.error(`${this.name} failed to say "${commandText}": ${err}`);
+                        // continue; don't throw so we can process remaining lines
+                    }
                 }
             }
             // Log exposition. Tagged distinctly while this NPC is mid-call (see
@@ -2371,6 +2482,11 @@ Your objective is to drive the story line.`}
             // stop wasting swings and hold position, report clean" -- which
             // is planning, not fiction, and was the bulk of that same bleed.
             const isCompanion = !!this.allyOf;
+            // WHO THE BEAT COULD BE CLAIMING AGENCY OVER -- everyone else in
+            // the room, by name. Read once rather than per 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) {
                 if (!exposition?.length)
                     continue;
@@ -2378,11 +2494,46 @@ Your objective is to drive the story line.`}
                     this.logger.write(`${this.name} out-of-character exposition suppressed: ${exposition.slice(0, 160)}`);
                     continue;
                 }
+                // NARRATION MAY NOT DO WHAT DICE DECIDE (aCErAfvEW7G23FWDM).
+                // A beat describing hands on another actor, or walking them
+                // somewhere, is asserting an act the engine never ran -- no
+                // 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 });
+                if (verdict.refused) {
+                    this.logger.write(`${this.name} narration refused (agency over ${verdict.subject}): ${exposition.slice(0, 160)}`);
+                    if (verdict.note)
+                        this._addToHistory(verdict.note);
+                    continue;
+                }
                 if (isCompanion || !witnessed) {
                     this.logger.write(`${this.name} exposition withheld (${isCompanion ? 'companion: link protocol only' : 'not co-located with the player'}): ${exposition.slice(0, 160)}`);
                     continue;
                 }
+                // THE SAME BEAT REWRITTEN. Tallow polished the same glass in two
+                // consecutive beats at 11:05:10 (aCErAfvEW7G23FWDM) -- not
+                // identical text, so nothing short of a similarity check could
+                // have caught it, and the engine had none.
+                //
+                // LAST OF THE GATES, DELIBERATELY. It must only ever judge a
+                // line that is actually about to PRINT. Above the withheld
+                // checks it also read companion link traffic and beats from
+                // rooms the player is not in -- and those are FUNCTION, not
+                // flavour: two crew members reporting the same clear room is
+                // two reports, and suppressing the second loses information the
+                // player needs. Flavour repeats; reports coincide.
+                const echoed = judgeEcho(this.currentLocation, this.name, exposition);
+                if (echoed.echo) {
+                    this.logger.write(`${this.name} exposition suppressed as an echo of ${echoed.of}: ${exposition.slice(0, 160)}`);
+                    continue;
+                }
                 this.logger.logWithColor(`${prefix}${exposition}`, inCall ? CALL_COLOR : 'blue', expositionScope);
+                // 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
+                // did, and must not come back as one in the next brief.
+                this._addToHistory(exposition);
             }
             // Execute other commands
             for (const commandLine of commandLines) {

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, canHearShout } 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,77 @@ 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)
+            // SHOUT_METERS BECOMES A RULE RATHER THAN A COMMENT
+            // (aCErAfvEW7G23FWDM). It was declared, documented and never
+            // read: this method reached the whole room and computed a
+            // distance only to DESCRIBE the shout (voiceTag), never to bound
+            // it. In practice 50 m is wider than any room this generator
+            // builds, so today this changes nothing -- and that is exactly
+            // why it is worth closing now, while it is free, rather than
+            // discovering it the first time a scene has a courtyard in it.
+            && canHearShout(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

@@ -7,6 +7,45 @@ import { Category, Size, Rating } from '../types/shared/item-enum.js';
 import { AbstractScene } from '../types/shared/abstracts.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { CombatEncounter, arenaKey, arenaOf, inArena } from '../utilities/combat-turn.js';
+/**
+ * CAN THIS READER HAVE HEARD ABOUT IT?
+ *
+ * Generous by construction, and deliberately so: word on the street is
+ * SUPPOSED to travel, and an engine that made every NPC an eyewitness
+ * would be a duller and quieter game than the one that shipped. Two
+ * rules, both from the report.
+ */
+function reaches(event, reader) {
+    if (!reader)
+        return true;
+    const npc = reader;
+    // A PASSING FACE DOES NOT GET THE WORLD'S NEWS. An ephemeral is not
+    // in the plot and cannot create obligations (utilities/ephemeral.ts
+    // says so in as many words) -- and this ring reached them anyway,
+    // because it sits outside the `eph` trim in the NPC brief. A
+    // bystander who has been on screen for two beats reciting what
+    // happened three rooms ago is the ephemeral governor's whole premise
+    // inverted.
+    if (npc.ephemeral)
+        return false;
+    // THE MATRIX IS NOT THE STREET. `canPerceive` gates hear() and see()
+    // so a meat NPC never WITNESSES a Matrix act, and this channel walked
+    // straight around that: a bartender polishing a glass could read
+    // "the host MADE the intruder mid-intrusion -- ice hunting", which is
+    // a fact about the inside of a host nobody outside it can have.
+    //
+    // WHICH EVENTS ARE MATRIX-ONLY IS A JUDGEMENT AT THE CALL SITE, and
+    // the tagging is deliberately conservative. A bricked camera, a
+    // jammed gun and a crash that "carried" are all Matrix ACTIONS with
+    // meat-world consequences, and they stay street noise. So does GOD
+    // convergence, which is not a leak at all: the whole point of it is
+    // that your physical location is reported outward (p.231), so the
+    // block hearing about it is the rule working.
+    if (event.plane && event.plane !== 'meat') {
+        return reader.plane === event.plane;
+    }
+    return true;
+}
 export class Scene extends AbstractScene {
     story;
     // SYMMETRIC PLAYERS: the scene holds a LIST of human players --
@@ -705,11 +744,16 @@ export class Scene extends AbstractScene {
         this.logger.write(`removeActorQuietly: ${name} (dead in the save).`);
     }
     // ---------------- Persistence accessors (utilities/persistence.ts) ----
+    /** THE SAVE FORMAT DOES NOT CHANGE. Where an event happened is
+     *  in-memory colour for the beat that reads it, not history worth
+     *  persisting -- a reloaded event is street noise like any other, and
+     *  flattening here is what keeps save-file.ts's `worldEvents:
+     *  string[]` true without a migration. */
     get worldEvents() {
-        return this._worldEvents;
+        return this._worldEvents.map(e => e.text);
     }
     restoreWorldEvents(events) {
-        this._worldEvents = [...events];
+        this._worldEvents = events.map(text => ({ text }));
     }
     /**
      * THE ALARM SURVIVES A RELOAD, and it took a peer asking to notice.
@@ -1103,12 +1147,34 @@ export class Scene extends AbstractScene {
         this.logger.write(`${label}: ${net} nuyen credited to "${PAYSTICK_NAME}" (${player.name})${tax > 0 ? ` (${tax} withheld: SIN tax ${Math.round(taxRate * 100)}%)` : ''}.`);
         return { net, tax };
     }
-    addWorldEvent(event) {
-        this._worldEvents.push(event);
+    /**
+     * WORD ON THE STREET -- and since aCErAfvEW7G23FWDM, word that knows
+     * WHICH street.
+     *
+     * THE DEFECT. This ring is handed to every NPC identically
+     * (getWorldEventsSummary, read by models/npc.ts), and it was
+     * unfiltered by room, by plane, by presence, and by whether the
+     * reader was even a character. `canPerceive` gates hear() and see()
+     * so a meat NPC never witnesses a Matrix act -- but nothing gated
+     * this, and ~30 command files write to it, hack.ts and disable.ts and
+     * edit-file.ts among them.
+     *
+     * The reported session is full of NPCs narrating a runner's Matrix
+     * business back at his slumped body, and this ring is the channel
+     * that fed them: a bartender could read "the host MADE the intruder
+     * mid-intrusion -- ice hunting", which is a fact about the inside of
+     * a host and cannot be known from a bar.
+     *
+     * `where` is optional and an event without it stays global, which is
+     * both the compatibility story for ~30 existing call sites and the
+     * honest default: most of these genuinely ARE street noise.
+     */
+    addWorldEvent(event, where) {
+        this._worldEvents.push({ text: event, ...(where?.plane ? { plane: where.plane } : {}), ...(where?.room ? { room: where.room } : {}) });
         if (this._worldEvents.length > this._maxWorldEvents) {
             this._worldEvents.shift();
         }
-        this.logger.write(`World event: ${event}`);
+        this.logger.write(`World event${where?.plane ? ` (${where.plane})` : ''}: ${event}`);
     }
     /**
      * THE SITE HAS GONE LOUD. Idempotent in the sense that matters: a
@@ -1131,7 +1197,16 @@ export class Scene extends AbstractScene {
             ? `THE SITE IS ALARMED -- it has gone loud ${this._alarm.count} times tonight, most recently: ${this._alarm.reason}`
             : `THE SITE IS ALARMED -- ${this._alarm.reason}`;
     }
-    getWorldEventsSummary() {
+    /**
+     * WHAT THIS READER HAS HEARD ABOUT (aCErAfvEW7G23FWDM).
+     *
+     * `reader` is optional and omitting it returns everything, which is
+     * what every non-NPC caller wants and what the old signature did.
+     * models/npc.ts passes itself, and that one argument is the whole
+     * difference between a bartender who reads the Matrix and one who
+     * does not.
+     */
+    getWorldEventsSummary(reader) {
         // THE ALARM IS STANDING CONTEXT, NOT A HEADLINE THAT SCROLLS.
         //
         // World events are a 100-entry ring, so on a long run the sentence
@@ -1143,10 +1218,11 @@ export class Scene extends AbstractScene {
         const alarm = this.alarmSummary;
         const head = alarm ? `${alarm}
 ` : '';
-        if (this._worldEvents.length === 0) {
+        const heard = this._worldEvents.filter(e => reaches(e, reader));
+        if (heard.length === 0) {
             return `${head}Nothing notable has happened elsewhere yet.`;
         }
-        return `${head}Word on the street (things that happened elsewhere in the world):\n${this._worldEvents.map((e, i) => `  ${i + 1}. ${e}`).join('\n')}`;
+        return `${head}Word on the street (things that happened elsewhere in the world):\n${heard.map((e, i) => `  ${i + 1}. ${e.text}`).join('\n')}`;
     }
     getRooms() {
         return this.rooms;

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

@@ -27,7 +27,7 @@
  * 2.5.0 adds IReproHost.purpose / .sculpt and IReproItem.file (engine
  * 1.50.0, hosts with a purpose) -- additive.
  */
-export const REPRO_SCHEMA_VERSION = '2.5.0';
+export const REPRO_SCHEMA_VERSION = '2.6.0';
 /** THE LIVE REASON, from the field or the card's own words.
  *
  *  `repro.live` is authoritative -- but the server's validator must

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