@maka/maka-cli 5.197.0 → 5.199.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.197.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/ar.js

@@ -64,14 +64,14 @@ export class ArCommand extends Command {
             return `Overlay back on -- over nothing. No commlink, no deck, no AR: you're reading the street with your eyes like it's 2050.`;
         }
         const tags = aroTags(this.scene, actor, actor.currentLocation);
-        const head = `{lightblue-fg}The overlay blinks back in.{/lightblue-fg}`;
+        const head = `{light-blue-fg}The overlay blinks back in.{/light-blue-fg}`;
         // Turning AR back on while silent is the other moment the question
         // lands -- you have just done the thing you were unsure was allowed.
         const note = silentAndSeeingNote(actor);
         if (tags.length === 0) {
-            return [head, `{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
+            return [head, `{light-blue-fg}Nothing here is talking -- a dead patch of street.{/light-blue-fg}`, note].filter(Boolean).join('\n');
         }
-        return [head, ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`), note].filter(Boolean).join('\n');
+        return [head, ...tags.map(t => `  {light-blue-fg}${t}{/light-blue-fg}`), note].filter(Boolean).join('\n');
     }
 }
 /**
@@ -105,11 +105,11 @@ export class ArosCommand extends Command {
         const note = silentAndSeeingNote(actor);
         const tags = aroTags(this.scene, actor, actor.currentLocation);
         if (tags.length === 0) {
-            return [`{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
+            return [`{light-blue-fg}Nothing here is talking -- a dead patch of street.{/light-blue-fg}`, note].filter(Boolean).join('\n');
         }
         return [
-            `{lightblue-fg}AR OVERLAY:{/lightblue-fg}`,
-            ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`),
+            `{light-blue-fg}AR OVERLAY:{/light-blue-fg}`,
+            ...tags.map(t => `  {light-blue-fg}${t}{/light-blue-fg}`),
             note,
         ].filter(Boolean).join('\n');
     }

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

@@ -92,7 +92,7 @@ export class DownloadCommand extends Command {
         // is that nobody could find the file should say what it can see.
         const query = args.join(' ').trim();
         if (query.length === 0) {
-            const lines = [`{lightblue-fg}Within reach to pull down:{/lightblue-fg}`];
+            const lines = [`{light-blue-fg}Within reach to pull down:{/light-blue-fg}`];
             for (const i of loose)
                 lines.push(`  ${planeTintItemName(i, actor.plane)} -- loose on the grid here`);
             for (const c of carried)
@@ -140,11 +140,11 @@ export class DownloadCommand extends Command {
         this.scene.updateStatus();
         return fromSprite
             ? [
-                `{lightblue-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/lightblue-fg}`,
+                `{light-blue-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/light-blue-fg}`,
                 `You pull {bold}{underline}${item.name}{/underline}{/bold} down onto a chip -- meat-world cargo now.${hint(` (You can "give ${item.name}" to somebody standing in front of you.)`)}`,
             ].join('\n')
             : [
-                `{lightblue-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/lightblue-fg}`,
+                `{light-blue-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/light-blue-fg}`,
                 hint(`(Meat-world cargo now: carry it, stash it, or "give" it to somebody.)`),
             ].join('\n');
     }

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

@@ -111,11 +111,11 @@ 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 [
-            `{lightblue-fg}${file.name} comes apart under your hand -- sectors zeroed, index entry gone, the host's own checksum rewritten to agree. ${hostLabel(room, { capital: true })} no longer has it.{/lightblue-fg}`,
+            `{light-blue-fg}${file.name} comes apart under your hand -- sectors zeroed, index entry gone, the host's own checksum rewritten to agree. ${hostLabel(room, { capital: true })} no longer has it.{/light-blue-fg}`,
             ...(banner ? [banner] : []),
         ].join('\n');
     }

package/bundle/typescript/src/commands/game/sideQuest/commands/enter-host.js

@@ -64,7 +64,7 @@ export class EnterHostCommand extends Command {
         const marks = target.hostMarksBy.get(actor.name) ?? 0;
         if (marks < 1 && !target.hostCracked && !target.hostSanctioned) {
             return [
-                `{lightblue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/lightblue-fg}`,
+                `{light-blue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/light-blue-fg}`,
                 hint(`A host opens to anyone holding a MARK on it (p.239) -- "mark ${target.name}" softens it, or "hack" takes one by force.`),
             ].join('\n');
         }
@@ -85,7 +85,7 @@ export class EnterHostCommand extends Command {
         // ONE LINE (2026-09-13, "too much text"): the crossing, and the
         // coaching behind the hints toggle.
         return [
-            `{lightblue-fg}You cross into ${hostLabel(target, { capital: false })} -- the outside grid folds shut behind you.{/lightblue-fg}`,
+            `{light-blue-fg}You cross into ${hostLabel(target, { capital: false })} -- the outside grid folds shut behind you.{/light-blue-fg}`,
             hint(`(In here there is only what the host keeps. "look" reads it; "exit" puts you back on the grid.)`),
         ].filter(Boolean).join('\n');
     }
@@ -110,14 +110,14 @@ export class EnterHostCommand extends Command {
             const over = hostOver(gridVicinity(this.actor)) ?? hostOver(here);
             if (over)
                 return over;
-            return `{lightblue-fg}Thin grid here -- no host stands over ${gridVicinity(this.actor).name}.{/lightblue-fg} ${hint(`Overhead: ${roster} -- "enter <name>" crosses into any of them from here.`)}`;
+            return `{light-blue-fg}Thin grid here -- no host stands over ${gridVicinity(this.actor).name}.{/light-blue-fg} ${hint(`Overhead: ${roster} -- "enter <name>" crosses into any of them from here.`)}`;
         }
         const host = resolveHostInReach(rooms, this.actor, named);
         if (host)
             return host;
         const street = Object.values(rooms).find(r => r.name.toLowerCase() === named.toLowerCase());
         if (street)
-            return `{lightblue-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/lightblue-fg}`;
+            return `{light-blue-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/light-blue-fg}`;
         return `No host called "${named}" overhead. ${hint(`Overhead: ${roster}.`)}`;
     }
 }
@@ -152,7 +152,7 @@ export class ExitHostCommand extends Command {
         actor.performAction('exits a host', `icon surfacing out of ${host.name}'s architecture`, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} exited the host at ${host.name}.`);
         this.scene.updateStatus();
-        return `{lightblue-fg}You step back out of ${hostLabel(host, { capital: false })} onto the grid; the host seals behind you. Your body still sits in ${actor.currentLocation.name}.{/lightblue-fg}`;
+        return `{light-blue-fg}You step back out of ${hostLabel(host, { capital: false })} onto the grid; the host seals behind you. Your body still sits in ${actor.currentLocation.name}.{/light-blue-fg}`;
     }
 }
 //# sourceMappingURL=enter-host.js.map

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.`,
@@ -317,14 +317,14 @@ export class HackCommand extends BypassCommand {
                 if (marksNow >= 1)
                     lines.push(`  One mark is the door: "enter" walks your persona inside (p.239).`);
                 if (perception > 0)
-                    lines.push(`  {lightblue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/lightblue-fg}`);
+                    lines.push(`  {light-blue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/light-blue-fg}`);
                 if (forcedDv > 0)
                     lines.push(`  The forcing burns ${forcedDv} DV into the architecture -- a host has no boards to brick, so it only announces you louder.`);
                 lines.push(`  ${MAX_MARKS - marksNow} more and its architecture stops asking who you are.${hint(` ("hack for ${MAX_MARKS - marksNow}" reaches for the rest at once -- ${declarationPenalty(MAX_MARKS - marksNow, this.actor.hasQuality(GO_BIG_QUALITY))} dice.)`)}`);
                 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();
@@ -388,13 +388,13 @@ export class HackCommand extends BypassCommand {
                 lines.push(`  ${iconLocks.length} ${iconLocks.length === 1 ? 'lock hangs' : 'locks hang'} off it, still sealed -- each its own icon behind its own rating: ${iconLocks.map(d => d.name).join(', ')}.${hint(` ("hack <lock>" from in here keys one; the host's key is not the door's.)`)}`);
             }
             if (vaultedFiles.length > 0) {
-                lines.push(`  {lightblue-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/lightblue-fg}`);
+                lines.push(`  {light-blue-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/light-blue-fg}`);
             }
             // AND WHAT THE CRACK DID NOT REACH: a wired site's data sits on an
             // air-gapped box the host never held (p.233) -- say so, or the next
             // "take" reads as a contradiction.
             if (room.offlineServer && room.inventory.getAllItems().some(i => i.plane === 'matrix')) {
-                lines.push(`  {lightblue-fg}Nothing on the grid side of the vault -- whatever this place keeps sits on the ${room.offlineServer}, an air-gapped box with no Matrix presence. Your BODY has to be in ${room.name} to cable in (p.233).{/lightblue-fg}`);
+                lines.push(`  {light-blue-fg}Nothing on the grid side of the vault -- whatever this place keeps sits on the ${room.offlineServer}, an air-gapped box with no Matrix presence. Your BODY has to be in ${room.name} to cable in (p.233).{/light-blue-fg}`);
             }
             // THE FEEDS ARE A REAL GAIN AND WERE NEVER MENTIONED
             // (BpR5cjhYuvgCyDSZc, 7aNWnDSHeZMYmS2De: "what have I gained?").
@@ -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');
                 }
@@ -683,7 +683,7 @@ export class HackCommand extends BypassCommand {
         else {
             const perception = freeMatrixPerceptionHits(netHits);
             if (perception > 0)
-                lines.push(`  {lightblue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/lightblue-fg}`);
+                lines.push(`  {light-blue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/light-blue-fg}`);
         }
         // TWO MARKS COMMAND IT (p.238 Control Device: 1 mark for a Free
         // action, 2 for a Simple, 3 for a Complex -- and unlocking a maglock

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

@@ -101,7 +101,7 @@ export class HideCommand extends Command {
         this.scene.addWorldEvent(`${host.name}'s ice lost ${actor.name} in the traffic.`);
         this.scene.updateStatus();
         return [
-            `{lightblue-fg}You drop into the host's own traffic and become one more packet in a million. ${hostLabel(room, { capital: true })} loses you.{/lightblue-fg}`,
+            `{light-blue-fg}You drop into the host's own traffic and become one more packet in a million. ${hostLabel(room, { capital: true })} loses you.{/light-blue-fg}`,
             `  Its ice has nothing to swing at -- but the host is still awake, and Patrol is looking every action now.${hint(` ("silent" keeps a sweep from seeing you for free; "search" is possible while it looks.)`)}`,
             ...god.lines,
         ].join('\n');

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

@@ -71,7 +71,7 @@ export class HopCommand extends Command {
             actor.performAction('hops grids', `persona blinking across to ${target.name}`);
             this.logger.write(`${actor.name} hopped to ${target.key} (legal, ${tier}).`);
             this.scene.updateStatus();
-            return `{lightblue-fg}The sky changes texture and you're on ${target.name}.{/lightblue-fg}${target.userPenalty ? ` ${hint(`Public grid: -2 on everything you do out here.`)}` : ''}${await land()}`;
+            return `{light-blue-fg}The sky changes texture and you're on ${target.name}.{/light-blue-fg}${target.userPenalty ? ` ${hint(`Public grid: -2 on everything you do out here.`)}` : ''}${await land()}`;
         }
         // ILLEGAL HOP (p.240): Hack on the Fly against the grid itself.
         const burned = actor.burnedAttributeRefusal('sleaze');
@@ -105,7 +105,7 @@ export class HopCommand extends Command {
         this.logger.write(`${actor.name} hopped to ${target.key} (illegal, ${attempt.hits} v ${defence.hits}).`);
         this.scene.updateStatus();
         return [
-            `{lightblue-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/lightblue-fg}`,
+            `{light-blue-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/light-blue-fg}`,
             ...bill.lines,
             ...(isLooseEnd ? [await land()] : []),
         ].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/look.js

@@ -387,7 +387,7 @@ export class LookCommand extends Command {
                 const dim = this.scene.getActorsInRoom(far)
                     .find(a => a !== this.actor && a.name.toLowerCase() === target.toLowerCase() && this.actor.canPerceive(a));
                 if (dim)
-                    return `${this.inspectPersona(dim)}\n{lightblue-fg}  -- a far icon, ${far.name}${noiseNote(noise)}{/lightblue-fg}`;
+                    return `${this.inspectPersona(dim)}\n{light-blue-fg}  -- a far icon, ${far.name}${noiseNote(noise)}{/light-blue-fg}`;
             }
         }
         // 3. THE HOST, as a thing you can name. gridIcons already renders it
@@ -404,8 +404,8 @@ export class LookCommand extends Command {
                 // `deck` reads out your own array.
                 const a = namedHost.hostAttributes();
                 return [
-                    `{lightblue-fg}${hostIcon}{/lightblue-fg}`,
-                    `{lightblue-fg}  Attack ${a.attack}  Sleaze ${a.sleaze}  Data Processing ${a.dataProcessing}  Firewall ${a.firewall}{/lightblue-fg}`,
+                    `{light-blue-fg}${hostIcon}{/light-blue-fg}`,
+                    `{light-blue-fg}  Attack ${a.attack}  Sleaze ${a.sleaze}  Data Processing ${a.dataProcessing}  Firewall ${a.firewall}{/light-blue-fg}`,
                 ].join('\n');
             }
         }
@@ -417,7 +417,7 @@ export class LookCommand extends Command {
         if (matchesCameraName(target)) {
             const eye = gridIcons(this.scene, this.actor, room).find(i => i.startsWith('◎'));
             if (eye)
-                return `{lightblue-fg}${eye}{/lightblue-fg}`;
+                return `{light-blue-fg}${eye}{/light-blue-fg}`;
             // Named correctly, and there is simply nothing here to name.
             // Worth its own line: the old answer said the WORDS were wrong,
             // which sent the player hunting for a synonym that never
@@ -533,7 +533,7 @@ export class LookCommand extends Command {
      * there's a deck anywhere in the shape of it.
      */
     inspectPersona(target) {
-        const lines = [`{lightblue-fg}◆ ${target.name} -- a persona on this grid.{/lightblue-fg}`];
+        const lines = [`{light-blue-fg}◆ ${target.name} -- a persona on this grid.{/light-blue-fg}`];
         const companion = this.scene.ownerGame?.companions.find(c => c.npc === target);
         if (companion) {
             lines.push(`Yours -- it goes where you go, and it answers when you speak.`);

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

@@ -93,7 +93,7 @@ export class MapCommand extends Command {
             actor.insideHost
                 ? `THE GRID -- INSIDE ${hostLabel(actor.insideHost, { capital: true }).toUpperCase()}`
                 : `THE GRID -- ${actor.currentGrid ? `on ${actor.currentGrid.name}, ` : ''}jacked in from ${body.name}`,
-            `{lightblue-fg}Black flatland under a black sky. No streets out here -- only icons. The hosts hang overhead; ${actor.insideHost ? '"exit" puts you back under them' : '"go <host>" (or "go <number>") crosses into one you hold a mark on, from anywhere'}.{/lightblue-fg}`,
+            `{light-blue-fg}Black flatland under a black sky. No streets out here -- only icons. The hosts hang overhead; ${actor.insideHost ? '"exit" puts you back under them' : '"go <host>" (or "go <number>") crosses into one you hold a mark on, from anywhere'}.{/light-blue-fg}`,
         ];
         if (hosts.length === 0) {
             lines.push('  Nothing overhead -- no host stands over this district.');

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

@@ -51,7 +51,7 @@ export class MarkCommand extends Command {
             screen: this.screen,
             game: this.game,
         }).execute(args);
-        return `{lightblue-fg}Placing a mark IS ${action} -- running it (p.238/p.240).{/lightblue-fg}\n${result}`;
+        return `{light-blue-fg}Placing a mark IS ${action} -- running it (p.238/p.240).{/light-blue-fg}\n${result}`;
     }
 }
 //# sourceMappingURL=mark.js.map

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

@@ -87,6 +87,7 @@ export class SayCommand extends Command {
         }
         const message = args?.join(' ');
         const currentPlayer = this.actor;
+        let farOff = "";
         const scene = this.context.scene;
         // Speaking out loud ends a sneak (see sneak.ts).
         currentPlayer.sneaking = false;
@@ -245,8 +246,23 @@ export class SayCommand extends Command {
             // (matrix-roster.ts); a body's reach the room, as always.
             if (currentPlayer.plane === 'matrix')
                 speakOnTheGrid(this.scene, currentPlayer, message);
-            else
-                currentPlayer.currentLocation.say(currentPlayer, message);
+            else {
+                const heard = currentPlayer.currentLocation.say(currentPlayer, message);
+                // NOBODY CLOSE ENOUGH is now a thing that can happen, and has to
+                // be said (en3p6eCpiRuqsTSKm). Speech used to escalate to a
+                // room-wide shout the moment nobody shared your spot, so this
+                // case did not exist; with `say` bounded by each listener's
+                // hearing range it does, and a player whose words reached nobody
+                // would otherwise see their own echo and assume they landed.
+                //
+                // Only when there was somebody TO miss: an empty room is not a
+                // failure to be heard, it is an empty room, and nagging about it
+                // every time a runner mutters to themselves would be noise.
+                const others = currentPlayer.currentLocation.getActors().filter(a => a !== currentPlayer);
+                if ((heard ?? []).length === 0 && others.length > 0 && !(this.actor instanceof NPC)) {
+                    farOff = `\n  Nobody's close enough to catch that.${hint(` ("shout" carries the whole room; "move to <place>" gets you near someone.)`)}`;
+                }
+            }
             // Talking in the CLIENT's presence is the meet (a real session
             // walked up to Ms. Veil, spoke with plain "say", and the advance
             // never triggered -- only talk-to/call/give were hooked). The
@@ -294,7 +310,7 @@ export class SayCommand extends Command {
                 ? `Your persona speaks and the grid carries it: ${heard.join(', ')} ${heard.length === 1 ? 'is' : 'are'} on this side of the architecture and hears you. Bodies in the room hear nothing -- you have no voice out there.`
                 : `Your words go out over the grid and find no persona to land on. Anyone here in the FLESH hears nothing -- a PAN icon is a commlink in somebody's pocket, not a person you can talk to. ("call <name>" reaches a body.)`;
         }
-        return "";
+        return farOff;
     }
     /**
      * "say private" -- the answer to "can anyone hear me right now",