@maka/maka-cli 5.198.0 → 5.199.0

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

@@ -152,6 +152,8 @@ import { MoveCommand, RunCommand, SprintCommand } from './commands/move.js';
 import { ClimbCommand, DescendCommand } from './commands/climb.js';
 import { HintsCommand } from './commands/hints.js';
 import { hint } from './utilities/hints.js';
+import { businessWitness } from './factions.js';
+import { wouldNotice } from './utilities/spots.js';
 import { camerasLive, liveFootage } from './utilities/surveillance.js';
 import { InstallCommand } from './commands/install.js';
 import { BuyCommand } from './commands/buy.js';
@@ -2400,6 +2402,38 @@ export default class Game {
      * Completing the objective before ever meeting them still collapses
      * cleanly -- the wrap-up is the only beat that moves money.
      */
+    /**
+     * ANYBODY IN THIS ROOM THE JOHNSON WOULD NOT TALK IN FRONT OF
+     * (aCErAfvEW7G23FWDM). Returns the first, or undefined when the room
+     * is safe to do business in.
+     *
+     * SIGHT IS THE TEST, NOT EARSHOT, and getting that backwards is worth
+     * recording because it was the first thing tried. Earshot is the
+     * wrong question twice over: a badge who cannot make out the words
+     * can still make out the MEETING, and -- the part that actually broke
+     * it -- canHearSpeech refuses an unplaced listener, so a patrol
+     * officer WORKING THE ROOM is exactly the witness it excludes. The
+     * reporter's own words are about presence: "there wouldn't be a
+     * 'meet' if there was a police officer STANDING THERE."
+     *
+     * wouldNotice is the engine's existing "can this observer see that
+     * actor" -- distance, cover and all -- so a cop at the far end of a
+     * warehouse still counts and one behind a wall does not.
+     */
+    witnessesUnsafeForBusiness(clientName) {
+        const client = this.scene?.getActor?.(clientName);
+        if (!client)
+            return undefined;
+        const room = client.currentLocation;
+        if (!room)
+            return undefined;
+        // THE RUNNER AND THEIR OWN CREW ARE WHO THE DEAL IS WITH, so they
+        // are filtered out here rather than inside the faction rule -- that
+        // is a fact about this Game, not about factions.
+        const others = (this.scene?.getActorsInRoom?.(room) ?? [])
+            .filter(a => !this.scene?.isHumanControlled?.(a) && !a.allyOf);
+        return businessWitness(client, others, wouldNotice);
+    }
     onClientInteraction(npcName) {
         const client = this.currentClient;
         if (!client || !this.scene || this.scene === this._hubScene)
@@ -2411,6 +2445,25 @@ export default class Game {
         const payout = this.scene.getWinCondition()?.payout ?? 0;
         const lines = [];
         if (!client.met) {
+            // A MEET WITH A BADGE IN IT IS NOT A MEET (aCErAfvEW7G23FWDM:
+            // "there wouldn't be a 'meet' if there was a police officer
+            // standing there").
+            //
+            // The reported session, 10:57. Ms. Quill laid out 8,500 nuyen
+            // across a table with Patrol Officer Kessler working the same
+            // room, and the WRITING knew -- she clocked him on arrival and
+            // told the runner to keep his questions off the ledger. The
+            // ENGINE had no idea, because the Meet is a name match on
+            // currentClient and nothing else, and the scene generator demands
+            // staff for any bar.
+            //
+            // Held, not cancelled: the job is still there and the Johnson is
+            // still willing. Deal with the room, or take it somewhere else.
+            const overheard = this.witnessesUnsafeForBusiness(client.name);
+            if (overheard) {
+                Logger.getInstance().write(`Client meet held off: ${overheard.name} is within earshot of ${client.name}.`);
+                return `${client.name} sees ${overheard.name} in the room and lets the sentence die. Not here.${hint(` (Somewhere quieter, or without them.)`)}`;
+            }
             client.met = true;
             lines.push(`THE MEET: ${client.name} lays out the terms -- ${payout}¥ certified, in full, on delivery.${hint(` (The rate is negotiable exactly once: "haggle" while you have them.)`)}`);
             Logger.getInstance().write(`Client meet: ${this.player.name} met ${client.name}, terms ${payout} lump sum on delivery.`);

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

@@ -10,7 +10,7 @@ import { sameHostSide } from './player.js';
 import { AI } from '../../../../tools/ai/ai.class.js';
 import { AbstractRoom } from '../types/shared/abstracts.js';
 import { spotsActive, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
-import { canHearSpeech } from '../utilities/earshot.js';
+import { canHearSpeech, canHearShout } from '../utilities/earshot.js';
 import { synthesizeGrid, } from '../utilities/room-grid.js';
 export class Room extends AbstractRoom {
     logger = Logger.getInstance();
@@ -815,7 +815,17 @@ Keep it concise and dramatic.`;
      * which is the whole point of typing it.
      */
     shout(actor, message) {
-        const listeners = [...this.actors].filter(r => r !== actor && sameHostSide(actor, r));
+        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 targets = actor instanceof NPC
             ? listeners.filter(r => r === player)

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