@maka/maka-cli 5.197.0 → 5.199.0

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

@@ -313,8 +313,8 @@ export class SearchCommand extends Command {
             // tells a player standing next to an offline server that it is
             // there and what it wants from them.
             description += room.offlineServer
-                ? `\n{lightblue-fg}A ${room.offlineServer} sits here, dark and off the network -- no aerial, no marquee, nothing broadcasting. Whatever it holds comes out through a cable and no other way.${hint(` "jack in" RIGHT HERE to touch its files.`)}{/lightblue-fg}`
-                : `\n{lightblue-fg}The node here hums with locked files -- whatever's worth taking lives on the grid, inside the host.${hint(` "jack in", then "enter" the host.`)}{/lightblue-fg}`;
+                ? `\n{light-blue-fg}A ${room.offlineServer} sits here, dark and off the network -- no aerial, no marquee, nothing broadcasting. Whatever it holds comes out through a cable and no other way.${hint(` "jack in" RIGHT HERE to touch its files.`)}{/light-blue-fg}`
+                : `\n{light-blue-fg}The node here hums with locked files -- whatever's worth taking lives on the grid, inside the host.${hint(` "jack in", then "enter" the host.`)}{/light-blue-fg}`;
         }
         description += describeContainers(room, this.actor);
         description += describeBarriers(room, this.actor);

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/subdue.js

@@ -10,6 +10,9 @@ import { AttackCommand } from './attack.js';
  */
 export class SubdueCommand extends AttackCommand {
     static verb = 'subdue';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Take someone down ALIVE -- stun damage with your bare hands. Slower than shooting, they fight back for real, and overdoing it can still kill them.';
     async execute(args = []) {
         // A chokehold needs hands and a neck: no grappling as a Matrix persona

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

@@ -8,6 +8,9 @@ import { Category } from '../types/shared/item-enum.js';
 import { billAction } from '../utilities/action-cost.js';
 export class TakeCommand extends Command {
     static verb = 'take';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Pick up an item. "take all" sweeps everything here -- but only after you have searched the room.';
     async execute(args) {
         if (!args)

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

@@ -503,5 +503,79 @@
 //     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.
-export const ENGINE_VERSION = '1.56.0';
+// 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.
+// 1.58.0 (2026-09-15): THE AI PROPOSES, THE ENGINE DISPOSES
+//   (aCErAfvEW7G23FWDM, reporter: "the only way to solve these is with
+//   engine enforcement against AI allowed actions"). An NPC beat was
+//   free prose: any line of it beginning "[COMMAND] " went to the SAME
+//   registry the player types into with NO filter on the command text,
+//   and every other line was printed to the player as fact. So the
+//   engine could neither refuse an act nor even SEE one asserted.
+//   - WHAT AN NPC MAY DO. Command.npcPolicy, the same declarative shape
+//     as humanOnly, enforced once in CommandRegistry.parse and backed by
+//     utilities/npc-authorization.ts. A hands-on verb against a body
+//     whose owner is jacked in, projecting, or already down is refused
+//     -- SR5 resolves Subduing (p.195) as an OPPOSED melee attack, and
+//     there is nothing there to oppose. parse() grew a third outcome:
+//     null still means "no such verb", a REFUSAL carries a reason, and
+//     NPC.act feeds that reason back so the model hears the boundary.
+//   - WHAT A BEAT MAY CLAIM. utilities/narration-limits.ts: narration
+//     may do anything with the NPC's own body and nothing with anybody
+//     else's. A refused line is suppressed AND answered, so the next
+//     beat can commit to "[COMMAND] grapple X" and let the dice decide.
+//   - A GRAB IS A FIGHT. commands/grapple.ts never called startEncounter
+//     -- it billed through billAction, a no-op outside combat -- so the
+//     most hostile act in the engine was also its cheapest, and left the
+//     target held with no turn in which to struggle. Every outcome now
+//     opens a Combat Turn. `grapples` joins the PROVOCATION ladder, and
+//     turnHostile() is the runtime mirror standDown never had: `hostile`
+//     was written at BOOT and nowhere else, so an NPC who was not
+//     opposition when the scene was built had no path to becoming it.
+//   - WHAT AN NPC MAY KNOW. Seven blocks of the brief were scene-globals
+//     handed to everybody. World events now carry WHERE they happened
+//     and Matrix-plane events reach only the Matrix (a bartender could
+//     read "the host MADE the intruder -- ice hunting"); ephemerals get
+//     no grapevine at all; the run's payout goes to the parties to the
+//     deal. The raw, unparsed model reply is no longer written into the
+//     NPC's memory -- only what actually reached the world is.
+//   - NOBODY SAYS IT TWICE. utilities/beat-echo.ts, the engine's first
+//     dedupe of emitted text of any kind. Containment rather than
+//     Jaccard, with a lower bar when a speaker opens the same way twice;
+//     companion link traffic is never judged (two drones clearing two
+//     rooms say near-identical things on purpose).
+//   - FACTIONS, catalog-backed (site v20, kind 'faction'). factions.ts
+//     holds the rules; the rows say who exists. First rule reading them:
+//     a Johnson will not lay out terms in front of a badge she can SEE.
+//     An unknown faction is no opinion, so a catalog without the rows
+//     behaves exactly as this engine did before them.
+//   - NEW CATALOG LANE `hearing`: hearingRangeMeters read the flat
+//     `perception` pool, so CYBEREYES extended how far you could hear.
+//     Audio Enhancement I-III and Spatial Recognizer are rows at last
+//     (p.445, p.454; Chrome Flesh p.223).
+//   - BENCH: repro schema 2.6.0 adds npcs[].hostile. A fixture could not
+//     express a hostile PERSON -- only `ice` -- so no meat-side
+//     hostility report could be benched at all.
+export const ENGINE_VERSION = '1.58.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -0,0 +1,135 @@
+import { factionFor } from './utilities/catalog.js';
+/**
+ * THE SHADOW ECONOMY'S OWN SLUG. A Johnson, a fixer and a runner are
+ * not an organisation, but they are a SIDE -- the deniable one -- and
+ * the rules below need a name for it. Matches the catalog row.
+ */
+export const SHADOWS = 'shadows';
+/**
+ * WHAT FACTION IS THIS ACTOR, if the engine can tell.
+ *
+ * An explicit `faction` on the NPC wins, always -- a seed or a
+ * generator that says so is the author speaking. Failing that, the one
+ * thing the engine already knew about strangers is read: the ephemeral
+ * KIND that spawned them (utilities/ephemeral.ts). A sweep officer is
+ * an 'authority' body and was already, in every way that mattered, the
+ * law; this just gives the engine the word for it.
+ *
+ * DERIVING IS DELIBERATELY SHALLOW. It maps the three spawn archetypes
+ * the engine already has and stops. Guessing a faction from a name or a
+ * description would be the kind of inference that looks clever in a
+ * demo and puts a gang tattoo on a bartender in play.
+ */
+export function factionOf(actor) {
+    const npc = actor;
+    if (npc.faction)
+        return npc.faction;
+    switch (npc.ephemeral?.kind) {
+        case 'authority': return 'knight-errant';
+        case 'mob': return 'ancients';
+        case 'bystander': return 'civilians';
+        default: return undefined;
+    }
+}
+/**
+ * HOW `a` REGARDS `b`: -3 (blood) .. +3 (family), 0 for no opinion.
+ *
+ * ASYMMETRIC BY DESIGN. A gang can hate a corp that has never heard of
+ * it, so this reads the standing of the faction doing the JUDGING and
+ * never averages the two. Where a faction is silent about another, the
+ * SORTS answer instead -- the law and the shadows are structurally
+ * opposed whether or not anybody wrote a row about it, and two gangs
+ * are rivals until someone says otherwise.
+ */
+export function standingBetween(a, b) {
+    if (!a || !b)
+        return 0;
+    if (a === b)
+        return 3;
+    const rowA = factionFor(a);
+    const explicit = rowA?.standing?.[b];
+    if (typeof explicit === 'number')
+        return explicit;
+    // A DIVISION IS ITS PARENT'S. Knight Errant IS Ares Macrotechnology's
+    // security arm (p.38), so the two are one house unless a row says
+    // otherwise above -- and nobody writes "we like ourselves" into a
+    // standing table, which is exactly why this cannot be left to the
+    // declared numbers.
+    if (rowA?.parent === b)
+        return 3;
+    // And its opinion of a THIRD party is the house's, where it has not
+    // formed its own.
+    if (rowA?.parent) {
+        const inherited = factionFor(rowA.parent)?.standing?.[b];
+        if (typeof inherited === 'number')
+            return inherited;
+    }
+    const rowB = factionFor(b);
+    if (!rowA || !rowB)
+        return 0;
+    if (rowA.sort === 'law' && (rowB.sort === 'shadow' || rowB.sort === 'gang' || rowB.sort === 'syndicate'))
+        return -2;
+    if ((rowA.sort === 'shadow' || rowA.sort === 'gang' || rowA.sort === 'syndicate') && rowB.sort === 'law')
+        return -2;
+    if (rowA.sort === 'gang' && rowB.sort === 'gang')
+        return -1;
+    return 0;
+}
+/**
+ * WOULD BUSINESS BE DISCUSSED IN FRONT OF THIS ACTOR?
+ *
+ * The Johnson's question, and the one the reported session turned on.
+ * Three ways to be safe to talk in front of, and a stranger with no
+ * faction at all is one of them -- an unknown face in a bar is the
+ * normal condition of a bar, and treating every unplaceable body as a
+ * threat would mean no deal was ever struck anywhere.
+ */
+export function wouldTalkBusinessNear(dealer, witness) {
+    const theirs = factionOf(witness);
+    if (!theirs)
+        return true;
+    const row = factionFor(theirs);
+    // A faction that keeps its mouth shut is not a problem to talk in
+    // front of, whatever it thinks of you: the syndicates and the gangs
+    // are IN the deniable economy, not auditing it.
+    if (row?.discreet)
+        return true;
+    return standingBetween(dealer ?? SHADOWS, theirs) > -2;
+}
+/**
+ * THE FIRST BODY IN THIS ROOM THE DEAL CANNOT BE STRUCK IN FRONT OF,
+ * or undefined when the room will do.
+ *
+ * Lives here rather than in game.ts so it can be tested against a
+ * catalog the way every other faction rule is -- and because "who
+ * spoils a deal" is a faction question, not a Game one.
+ *
+ * SIGHT IS THE TEST, NOT EARSHOT, and getting that backwards was the
+ * first thing tried. Earshot is wrong twice over: a badge who cannot
+ * make out the WORDS can still make out the MEETING, and canHearSpeech
+ * deliberately refuses an unplaced listener -- which is precisely the
+ * patrol officer WORKING the room, the exact witness the report is
+ * about. The reporter's own words are about presence: "there wouldn't
+ * be a 'meet' if there was a police officer STANDING THERE."
+ *
+ * @param sees  the engine's own "can this observer see that actor"
+ *              (utilities/spots.ts wouldNotice), passed in so this
+ *              module stays free of the spatial layer.
+ */
+export function businessWitness(client, others, sees) {
+    const dealer = factionOf(client) ?? SHADOWS;
+    for (const other of others) {
+        if (other === client)
+            continue;
+        if (other.isIncapacitated?.())
+            continue;
+        if (!client.canPerceive(other))
+            continue;
+        if (!sees(client, other))
+            continue;
+        if (!wouldTalkBusinessNear(dealer, other))
+            return other;
+    }
+    return undefined;
+}
+//# sourceMappingURL=factions.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/repro-scene.js

@@ -162,6 +162,23 @@ export function buildReproScene(fixture) {
         throw new ReproFixtureError(`"${misplacedIce.name}" is ice, so it cannot also stand in a doorway, guard, circulate or carry a gun. `
             + `Ice lives in the host, not on the floor -- drop the meat-side flags, or drop "ice".`);
     }
+    // HOSTILITY SAID TWICE IS DECORATION ONCE (aCErAfvEW7G23FWDM). Ice is
+    // opposition BY CONSTRUCTION -- scene-factory makes a matrix-plane
+    // actor hostile unless the seed says otherwise -- so a fixture
+    // declaring both is asserting the flag rather than the rule, which is
+    // the objection the `ice` comment in repro.ts raises and is right
+    // about. A street doc who opens fire on the patient is not a fixture
+    // either; it is two fixtures wearing one name.
+    const hostileIce = npcs.find(n => n.hostile && n.ice);
+    if (hostileIce) {
+        throw new ReproFixtureError(`"${hostileIce.name}" is asked to be both ice and hostile. Ice is opposition by construction -- `
+            + `drop "hostile", or drop "ice" if you meant a hostile person.`);
+    }
+    const hostileDoc = npcs.find(n => n.hostile && n.doc);
+    if (hostileDoc) {
+        throw new ReproFixtureError(`"${hostileDoc.name}" is asked to be both a street doc and hostile. A doc who opens fire on the `
+            + `patient is two fixtures -- split them, or pick one.`);
+    }
     // A SEED HAS ONE PLANE. astral maps to 'astral' the same way ice maps
     // to 'matrix' (npc-seed.ts) -- asking for both is asking the builder
     // to pick a lie.
@@ -379,6 +396,13 @@ export function buildReproScene(fixture) {
                 // string, which would read as a spot whose name is nothing.
                 ...(npc.circulating ? {} : { startSpot: inDoorway ? REPRO_DOORWAY_SPOT : REPRO_FLOOR_SPOT }),
                 guarding: npc.guarding === true,
+                // OPPOSITION, IN THE MEAT (aCErAfvEW7G23FWDM). Straight onto
+                // the seed's own `hostile`, which scene-factory reads and the
+                // hostile-contact ladder then drives by itself -- notice,
+                // contact, provocation, patience. Emitted only when asked, so
+                // a fixture that says nothing builds the same peaceable NPC it
+                // always did.
+                ...(npc.hostile ? { hostile: true } : {}),
                 lifestyleChoices: [],
                 combat: {
                     body: 4, agility: 4, reaction: 4, combatSkill: 3, strength: 4,

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';
@@ -151,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';
@@ -708,7 +711,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). */
@@ -2399,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)
@@ -2410,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.`);
@@ -2692,7 +2746,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 +6016,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 +6035,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 +6127,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 +6636,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']] },