@maka/maka-cli 5.198.0 → 5.199.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.198.0",
+  "version": "5.199.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

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

@@ -33,6 +33,9 @@ import { spendMovementMeters } from '../utilities/movement-cost.js';
  */
 export class AttackCommand extends Command {
     static verb = 'attack';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Attack someone in the room -- dice-pool combat with your equipped weapon. They WILL hit back. "attack <door>" shoots a barrier apart instead (unopposed; its Armor and Structure decide, p.197).';
     async execute(args = []) {
         if (!args || args.length === 0) {

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

@@ -89,6 +89,9 @@ const COMBAT_SPELL_FLAVOR = {
  */
 export class CastCommand extends BypassCommand {
     static verb = 'cast';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Cast a spell you know, at a FORCE you choose: "cast manabolt 8 at <target>" (default Force = your Magic; drain scales with it, and OVERCASTING past your talent makes the drain PHYSICAL). "spells" lists what you know. Bare "cast" tries to unweave a warded barrier.';
     deviceKind = 'ward';
     verbName = 'cast';

package/bundle/typescript/src/commands/game/sideQuest/commands/command-registry.js

@@ -1,6 +1,7 @@
 // src/commands/command-registry.ts
 import { CommandFactory } from '../factories/command-factory.js';
 import { Logger } from '../utilities/logger.js';
+import { authorizeNpcAction } from '../utilities/npc-authorization.js';
 export class CommandRegistry {
     scene;
     constructor(scene) {
@@ -12,6 +13,10 @@ export class CommandRegistry {
      * execute() internally, and callers ran it a second time on top of that
      * with no arguments at all, which crashed any command whose execute()
      * doesn't guard against a missing `args` array.)
+     *
+     * `null` = no such verb. A result carrying `refusal` = a real verb the
+     * engine refused for this actor; `command` is absent and the caller
+     * must not execute anything.
      */
     async parse(commandString, actor) {
         const parts = commandString.trim().split(' ');
@@ -49,6 +54,26 @@ export class CommandRegistry {
             Logger.getInstance().write(`Refused "${verb}" from ${actor.name}: that verb is the player's alone.`);
             return null;
         }
+        // THE AI PROPOSES, THE ENGINE DISPOSES (aCErAfvEW7G23FWDM).
+        //
+        // The same choke point, one question further out: humanOnly asks
+        // whether this verb belongs to the player's ACCOUNT, and this asks
+        // whether an AI-driven actor may do this PARTICULAR thing to this
+        // PARTICULAR target right now. An NPC is entitled to attack; it was
+        // equally entitled, until this line, to lay hands on a body whose
+        // owner was jacked into the Matrix and could not roll a defence.
+        //
+        // The refusal REASON is returned to the caller rather than swallowed
+        // -- NPC.act feeds it back to the model as a system note, so the
+        // boundary is something the fiction learns instead of something it
+        // grinds against.
+        if (declaring.getNpcPolicy() === 'authorized' && !this.scene.isHumanControlled(actor)) {
+            const verdict = authorizeNpcAction(this.scene, actor, verb, args);
+            if (!verdict.allowed) {
+                Logger.getInstance().write(`Refused "${commandString.trim()}" from ${actor.name}: ${verdict.reason}`);
+                return { args, refusal: verdict.reason ?? `That is not yours to do.` };
+            }
+        }
         return { command, args };
     }
 }

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

@@ -21,6 +21,31 @@ export class Command {
     static isHumanOnly() {
         return this.humanOnly;
     }
+    /**
+     * WHAT AN AI-DRIVEN ACTOR MAY DO WITH THIS VERB (aCErAfvEW7G23FWDM,
+     * reporter's ruling: "the only way to solve these is with engine
+     * enforcement against AI allowed actions").
+     *
+     * `humanOnly` above answers "is this the player's account", which is a
+     * narrower question than "is this the AI's to do". A verb that puts
+     * hands on somebody, moves them, or changes the world is not
+     * account-scoped at all -- an NPC is entitled to attack, and was
+     * equally entitled to attack a body whose owner was jacked into the
+     * Matrix and could not roll a defence.
+     *
+     *   'open'       harmless in an NPC's hands -- look, say, the default.
+     *   'human-only' the player's alone; kept in lockstep with humanOnly.
+     *   'authorized' must pass utilities/npc-authorization.ts first.
+     *
+     * Declared on the command, enforced once in CommandRegistry.parse, and
+     * a test scans this directory for the world-touching verb that forgets.
+     */
+    static npcPolicy = 'open';
+    static getNpcPolicy() {
+        // One source of truth: a verb that declares humanOnly IS human-only,
+        // whether or not it also remembered to say so here.
+        return this.humanOnly ? 'human-only' : this.npcPolicy;
+    }
     static verb;
     static description; // Make this static
     actor;

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

@@ -132,7 +132,7 @@ export class CompileCommand extends Command {
         const resist = rollPool(Math.max(1, actor.willpower + actor.resonance));
         const fadingTaken = Math.max(0, fadingValue - resist.hits);
         actor.performAction('goes still, eyes tracking code that is not there', 'threading a sprite');
-        this.scene.addWorldEvent(`${actor.name} compiled a sprite in ${actor.currentLocation.name}.`);
+        this.scene.addWorldEvent(`${actor.name} compiled a sprite in ${actor.currentLocation.name}.`, { plane: 'matrix' });
         this.logger.write(`CompileCommand: ${actor.name} ${typeKey} level ${level} -- ${mine.hits} vs ${sprite.hits}, tasks ${tasks}, fading ${fadingValue} (took ${fadingTaken}${overreach ? ' physical' : ''}).`);
         const poolParts = [`Resonance ${actor.resonance}`, compiling > 0 ? `compiling ${compiling}` : `no compiling -1`];
         if (actor.woundModifier < 0)

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

@@ -161,18 +161,18 @@ export class DecompileCommand extends Command {
         const lines = [`You find ${target.name}'s thread and PULL AGAINST THE WEAVE:`];
         if (net <= 0) {
             lines.push(`  Its code holds -- and now it KNOWS you, the touch traced straight back to your persona.`);
-            this.scene.addWorldEvent(`${actor.name} tried to decompile ${target.name} in ${room.name} -- and failed. It is alert.`);
+            this.scene.addWorldEvent(`${actor.name} tried to decompile ${target.name} in ${room.name} -- and failed. It is alert.`, { plane: 'matrix' });
         }
         else {
             const dmg = net + Math.floor(actor.resonance / 2);
             target.takeDamage(dmg);
             if (target.isDown()) {
-                this.scene.addWorldEvent(`${actor.name} decompiled ${target.name} in ${room.name} -- unraveled to static.`);
+                this.scene.addWorldEvent(`${actor.name} decompiled ${target.name} in ${room.name} -- unraveled to static.`, { plane: 'matrix' });
                 this.scene.removeActor(target.name);
                 lines.push(`  Thread by thread it comes APART -- ${dmg} boxes -- and ${target.name} unravels into clean static. Decompiled.`);
             }
             else {
-                this.scene.addWorldEvent(`${actor.name} tore at ${target.name}'s code in ${room.name}.`);
+                this.scene.addWorldEvent(`${actor.name} tore at ${target.name}'s code in ${room.name}.`, { plane: 'matrix' });
                 lines.push(`  Threads tear loose -- ${dmg} boxes: it holds together, barely, and it's coming for you.`);
             }
         }

package/bundle/typescript/src/commands/game/sideQuest/commands/edit-file.js

@@ -111,7 +111,7 @@ export class EditFileCommand extends Command {
         room.inventory.removeItem(file.name);
         room.plainSightItems.delete(file.name.toLowerCase());
         this.logger.write(`${actor.name} deleted "${file.name}" from ${room.name}'s host: ${attempt.hits} v ${resist.hits}.`);
-        this.scene.addWorldEvent(`${file.name} was erased from ${host.name}'s archive.`);
+        this.scene.addWorldEvent(`${file.name} was erased from ${host.name}'s archive.`, { plane: 'matrix' });
         const banner = this.scene.checkErased?.(file.name, actor.name);
         this.scene.updateStatus();
         return [

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

@@ -4,6 +4,9 @@ import { sameSpot, spotOf, spotRefusal } from '../utilities/spots.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 export class GiveCommand extends Command {
     static verb = 'give';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Give an item or money to someone.';
     async execute(args) {
         if (!args)

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

@@ -5,6 +5,7 @@ import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { physicalLimit, heldBy, holding, releaseGrapple } from '../utilities/grapple.js';
 import { spotOf, ensureAtSpot } from '../utilities/spots.js';
 import { billAction } from '../utilities/action-cost.js';
+import { arenaOf } from '../utilities/combat-turn.js';
 /**
  * SUBDUING (SR5e p.195) -- "grapple"/"restrain"/"clinch": seize someone
  * and hold them, dealing NO damage. The RAW shape, faithfully: a normal
@@ -20,6 +21,9 @@ import { billAction } from '../utilities/action-cost.js';
  */
 export class GrappleCommand extends Command {
     static verb = 'grapple';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Seize and restrain someone (SR5e Subduing, p.195) -- no damage, they can\'t move or fight until they break free ("struggle"). "release" lets them go. Also: "restrain", "clinch".';
     async execute(args = []) {
         const actor = this.actor;
@@ -113,6 +117,7 @@ export class GrappleCommand extends Command {
         if (net <= 0) {
             actor.performAction('grapples', `at ${target.name} -- and comes up with air`);
             this.finishMeta(isPlayer, meta, lines);
+            await this.openFightOverTheGrab(target);
             return `${crossNote}${lines.join('\n')}You lunge for ${target.name} -- they twist clear. Now they know exactly what you want.`;
         }
         // Strength + net hits must EXCEED the Physical limit (p.195).
@@ -122,6 +127,7 @@ export class GrappleCommand extends Command {
         this.finishMeta(isPlayer, meta, lines);
         if (grip <= limit) {
             actor.performAction('grapples', `${target.name} -- a grip, but not a hold; they wrench loose`);
+            await this.openFightOverTheGrab(target);
             return `${crossNote}${lines.join('\n')}You get hands on ${target.name}, but they're too solid to hold -- they wrench loose.`;
         }
         target.grappledBy = actor.name;
@@ -129,9 +135,52 @@ export class GrappleCommand extends Command {
         actor.grappling = target.name;
         actor.performAction('grapples', `${target.name} and locks them down -- held fast, unable to move`);
         this.scene.addWorldEvent(`${actor.name} grappled and restrained ${target.name} in ${room.name}.`);
+        await this.openFightOverTheGrab(target);
         this.scene.updateStatus();
         return `${crossNote}${lines.join('\n')}You seize ${target.name} and lock the hold -- HELD FAST, no damage done. They can't move, flee, or fight until they break your grip${isPlayer ? `, and your hands are full until you "release"` : ''}.${hint(` (They escape only by beating ${net} hits on Unarmed + Strength.)`)}`;
     }
+    /**
+     * SEIZING SOMEONE STARTS A FIGHT (aCErAfvEW7G23FWDM: "moving someone
+     * against their will is a hostile action, and should start some sort
+     * of combat").
+     *
+     * IT DID NOT, AND THAT WAS THE HOLE. Subduing is a melee attack in
+     * canon (p.195) and this command has always rolled it as one -- but
+     * `attack` opens a Combat Turn (attack.ts, Scene.startEncounter) and
+     * `grapple` never did. The only cost it paid was billAction, which is
+     * a NO-OP outside combat (action-cost.ts). So laying hands on someone
+     * in a quiet room cost nothing, started nothing, and left the target
+     * held with no turn in which to struggle -- the engine's most hostile
+     * act was also its cheapest.
+     *
+     * THE GRAB LANDS FIRST, then the fight opens. That is deliberate and
+     * it is the one place this differs from attack.ts, which opens the
+     * encounter BEFORE resolving so initiative can put someone faster
+     * ahead of the swing. A grapple is the opening act of a fight that
+     * did not exist yet -- there is no initiative to lose to, and
+     * re-plumbing this command through the phase loop to resolve a grab
+     * that has already been rolled would buy nothing but a second copy of
+     * executeInEncounter. The target answers on their phase, with
+     * "struggle", which is exactly what the turn now gives them.
+     */
+    async openFightOverTheGrab(target) {
+        const actor = this.actor;
+        // Already fighting: the turn loop owns this and must not be
+        // re-opened underneath itself.
+        if (this.scene.encounterFor?.(actor))
+            return;
+        // Hands up is not a fight (see the surrendered branch above): a
+        // zip-tie on someone who already yielded starts nothing.
+        if (target.surrendered)
+            return;
+        if (target.isIncapacitated() || !actor.sharesCombatPlane(target))
+            return;
+        await this.scene.startEncounter(arenaOf(actor), {
+            aggressor: actor,
+            target,
+            ambush: actor.sneaking,
+        });
+    }
     /** NPC actors keep roll anatomy inline for their AI history; the
      *  player's goes to the Mechanics ticker (readability pass). */
     finishMeta(isPlayer, meta, lines) {

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

@@ -240,7 +240,7 @@ export class HackCommand extends BypassCommand {
                     room.host?.spotted.add(this.actor.name);
                     this.actor.noteConditionChanged();
                     this.actor.sneaking = false;
-                    this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} MADE ${this.actor.name} mid-intrusion -- alarm flagged, ice hunting.`);
+                    this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} MADE ${this.actor.name} mid-intrusion -- alarm flagged, ice hunting.`, { plane: 'matrix' });
                     this.scene.updateStatus();
                     return [
                         `The ice turns and LOOKS AT YOU -- your sleaze unravels mid-handshake.`,
@@ -324,7 +324,7 @@ export class HackCommand extends BypassCommand {
                 if (mode === 'attack') {
                     this.actor.sneaking = false;
                     room.hostAlert = true;
-                    this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} takes a forced key -- alarm flagged, ice hunting.`);
+                    this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} takes a forced key -- alarm flagged, ice hunting.`, { plane: 'matrix' });
                 }
                 lines.push(...godLines);
                 this.scene.updateStatus();
@@ -439,7 +439,7 @@ export class HackCommand extends BypassCommand {
                 // knows it is under attack and starts hunting; what it does not
                 // know is whose hand did it.
                 room.hostAlert = true;
-                this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} was smashed open by brute force -- its security is down, alarms screaming.`);
+                this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} was smashed open by brute force -- its security is down, alarms screaming.`, { plane: 'matrix' });
                 lines.push(`  The host SCREAMED on the way down -- everything listening knows it fell, even if nothing saw your hand. Its ice is hunting now: it knows it was hit, not who hit it.`);
             }
             else {
@@ -637,7 +637,7 @@ export class HackCommand extends BypassCommand {
                 actor.sneaking = false;
                 if (host) {
                     host.hostAlert = true;
-                    this.scene.addWorldEvent(`${device.name} flags a bad handshake -- ${hostLabel(host, { capital: true })} is awake.`);
+                    this.scene.addWorldEvent(`${device.name} flags a bad handshake -- ${hostLabel(host, { capital: true })} is awake.`, { plane: 'matrix' });
                     this.scene.updateStatus();
                     return [`${device.name} refuses the key and SAYS SO -- the node it answers to knows something is in here.${wanNote}`, ...godLines].join('\n');
                 }

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

@@ -9,6 +9,9 @@ import { AttackCommand } from './attack.js';
  */
 export class KillCommand extends AttackCommand {
     static verb = 'kill';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Alias for "attack" -- resolves as real dice-pool combat, not an instant kill.';
 }
 //# sourceMappingURL=kill.js.map

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

@@ -23,6 +23,9 @@ import { serializeItem } from '../utilities/persistence.js';
  */
 export class LeadCommand extends Command {
     static verb = 'lead';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Leadership (SR5e p.141): "lead rally" (+initiative, whole party), "lead direct <companion>" (teamwork dice on their next attack), "lead inspire" (primes the party\'s next defense). Bare "lead" shows the party.';
     leadPool() {
         const skill = this.actor.skillRating('leadership');

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

@@ -45,6 +45,9 @@ const EMPTY_ROSTER_PHRASES = Object.values({
  */
 export class OrderCommand extends Command {
     static verb = 'order';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Command a companion: exact commands run instantly ("order spirit attack Krow"); anything else becomes a standing DIRECTIVE its AI pursues ("order agent to find Mr. Krow"). Spirit tasks cost a service.';
     async execute(args = []) {
         const game = this.game;

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

@@ -15,6 +15,9 @@ import { NPC } from '../models/npc.js';
  */
 export class PalmCommand extends Command {
     static verb = 'palm';
+    /** Touches another actor: authorized per-act for AI-driven actors
+     *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
+    static npcPolicy = 'authorized';
     static description = 'Sleight of hand (Palming + Agility): lift an item without being seen -- opposed by the sharpest eyes in the room. Winning leaves no witnesses; losing means they watched your hand the whole way.';
     async execute(args = []) {
         const actor = this.actor;

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/engine-version.js

@@ -526,5 +526,56 @@
 //     months, while the web client rendered it perfectly. 134 tags are
 //     now {light-blue-fg}. The site's render-tags.ts maps that back
 //     to a real CSS keyword, so the pin must carry both halves.
-export const ENGINE_VERSION = '1.57.0';
+// 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,