@maka/maka-cli 5.182.0 → 5.184.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.182.0",
+  "version": "5.184.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 = `{cyan-fg}The overlay blinks back in.{/cyan-fg}`;
+        const head = `{lightblue-fg}The overlay blinks back in.{/lightblue-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, `{cyan-fg}Nothing here is talking -- a dead patch of street.{/cyan-fg}`, note].filter(Boolean).join('\n');
+            return [head, `{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
         }
-        return [head, ...tags.map(t => `  {cyan-fg}${t}{/cyan-fg}`), note].filter(Boolean).join('\n');
+        return [head, ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-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 [`{cyan-fg}Nothing here is talking -- a dead patch of street.{/cyan-fg}`, note].filter(Boolean).join('\n');
+            return [`{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
         }
         return [
-            `{cyan-fg}AR OVERLAY:{/cyan-fg}`,
-            ...tags.map(t => `  {cyan-fg}${t}{/cyan-fg}`),
+            `{lightblue-fg}AR OVERLAY:{/lightblue-fg}`,
+            ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`),
             note,
         ].filter(Boolean).join('\n');
     }

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

@@ -218,6 +218,9 @@ export class AttackCommand extends Command {
         // holstered dry/jammed piece is not what's being attacked with, so it
         // must not block a bare-fisted attack the player never asked to fail.
         const weaponItem = this.actor.equipment.rightHand?.weapon ?? this.actor.equipment.leftHand?.weapon;
+        if (this.usesEquippedWeapon() && this.actor.weaponDrawn && weaponItem?.isFirearm() && weaponItem.bricked) {
+            return `The ${weaponItem.name} is BRICKED -- its electronics burned out under a Data Spike (p.228). Bench work while you rest brings it back; for now, go in swinging.`;
+        }
         if (this.usesEquippedWeapon() && this.actor.weaponDrawn && weaponItem?.isFirearm() && weaponItem.jammed) {
             return `The ${weaponItem.name}'s smartlink is LOCKED -- someone cracked your PAN. "reboot" to clear it, or go in swinging.`;
         }

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

@@ -25,7 +25,7 @@ export class DelayCommand extends Command {
             return `Too late to delay -- you've already acted this phase (${budget.ledger()}). "end turn" instead.`;
         }
         if (this.scene.isHumanControlled(actor)) {
-            this.logger.log(`{cyan-fg}You hold your action, watching.{/cyan-fg}`, { actor: actor.name });
+            this.logger.log(`{yellow-fg}You hold your action, watching.{/yellow-fg}`, { actor: actor.name });
         }
         await enc.delayPhase(actor);
         return this.scene.isHumanControlled(actor) ? '' : `${actor.name} holds their action.`;

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

@@ -0,0 +1,331 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { rollPool, formatRoll } from '../utilities/dice.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { hostsInReach, hostOver, gridVicinity, roomsInReach } from '../utilities/grid-reach.js';
+import { hostLabel, matchesCameraName } from '../utilities/grid-names.js';
+import { isWatched, cameraMasterHost } from '../utilities/surveillance.js';
+import { deviceDefensePool, wanDefensePool, hostDefensePool } from '../utilities/matrix-intrusion.js';
+import { accrueOverwatch } from '../utilities/overwatch.js';
+import { leaveMatrix } from '../utilities/planes.js';
+import { applyDeviceOpened } from '../utilities/devices.js';
+import { gridActionModifier, gridNote } from '../utilities/grids.js';
+import { billAction } from '../utilities/action-cost.js';
+import { MAX_MARKS } from '../utilities/marks.js';
+import { sameHostSide } from '../models/player.js';
+/** The marks Control Device wants for a Simple device action (p.238). */
+export const MARKS_TO_CONTROL = 2;
+export class DisableCommand extends Command {
+    static verb = 'disable';
+    static description = 'Control Device (SR5 p.238): with 2 marks on a device, order it -- a maglock unlocks, a camera cluster loops, a smartgun\'s clip drops. Electronic Warfare + Intuition [Sleaze] v. Device Rating + Firewall. "disable loud <icon>" is a Data Spike instead (see "brick").';
+    /** The Data Spike route: `brick` always, `disable loud` by the word. */
+    way(args) {
+        const rest = [...args];
+        if (rest[0]?.toLowerCase() === 'loud' || rest[0]?.toLowerCase() === 'brick') {
+            rest.shift();
+            return { way: 'spike', rest };
+        }
+        if (rest[0]?.toLowerCase() === 'quiet')
+            rest.shift();
+        return { way: 'control', rest };
+    }
+    async execute(args = []) {
+        const actor = this.actor;
+        const { way, rest } = this.way(args);
+        const named = rest.join(' ').trim();
+        if (!named) {
+            return way === 'spike'
+                ? `Brick what? Name the icon: "brick <device>", "brick cameras", "brick <person>" for their gun.`
+                : `Disable what? Name the icon: "disable <device>", "disable cameras", "disable <person>" for their gun.${hint(` (Control Device wants ${MARKS_TO_CONTROL} marks on it -- "hack <it>" first.)`)}`;
+        }
+        // REACH: riding the Matrix, a living persona, or AR with a working
+        // deck in hand -- the same gate a PAN intrusion uses (hack.ts).
+        if (actor.plane === 'astral')
+            return `The Matrix doesn't answer to spirits.`;
+        if (actor.plane !== 'matrix' && !actor.isTechnomancer() && !actor.getCyberdeck()) {
+            return `You'd need to be jacked in, or have a working cyberdeck in hand, to reach a device's icon.`;
+        }
+        const target = this.resolve(named);
+        if (typeof target === 'string')
+            return target;
+        const bill = billAction(this.scene, actor, 'complex', way === 'spike' ? 'Data Spike' : 'Control Device', { attack: way === 'spike' });
+        if (bill)
+            return bill;
+        return way === 'spike' ? this.dataSpike(target) : this.controlDevice(target);
+    }
+    // ------------------------------------------------------------ targets --
+    resolve(named) {
+        const actor = this.actor;
+        const raw = named.toLowerCase();
+        const rooms = this.rooms ?? this.scene.getRooms();
+        // 1. THE CAMERA CLUSTER of the room the persona is over / inside.
+        if (matchesCameraName(named)) {
+            const room = actor.insideHost ?? (actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation);
+            if (!isWatched(room))
+                return `No cameras on ${room.name} -- nothing to loop.`;
+            return { kind: 'camera', room, master: cameraMasterHost(rooms, room) };
+        }
+        // 2. A DEVICE ICON: inside the host, its WAN; from the grid, a slaved
+        //    device you hold a host mark for, or a loose wireless one where
+        //    the body stands. Mirrors hack.ts tryDeviceHack.
+        const matching = (room) => room.openableDevices().filter(d => d.rating > 0).filter(d => d.name.toLowerCase().includes(raw)
+            || (d.opensExit ?? '').toLowerCase() === raw
+            || d.description.toLowerCase().includes(raw));
+        const inside = actor.insideHost;
+        if (inside) {
+            const matches = matching(inside);
+            if (matches.length === 1)
+                return { kind: 'device', device: matches[0], room: inside, host: inside, viaWan: false };
+            if (matches.length > 1)
+                return `More than one thing in here answers to "${named}": ${matches.map(d => d.name).join(', ')}.`;
+        }
+        else {
+            const found = hostsInReach(rooms, actor).map(r => ({ room: r, matches: matching(r) })).filter(x => x.matches.length === 1);
+            if (found.length === 1) {
+                const host = found[0].room;
+                const device = found[0].matches[0];
+                if ((host.hostMarksBy.get(actor.name) ?? 0) < 1) {
+                    return `${device.name} hangs off ${hostLabel(host)}'s WAN -- slaved, and a host's devices answer nobody who holds no mark on the host itself (p.233).${hint(` ("hack ${hostLabel(host)}" for a mark first.)`)}`;
+                }
+                return { kind: 'device', device, room: host, host, viaWan: true };
+            }
+            const here = actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation;
+            const loose = hostOver(here) ? [] : matching(here).filter(d => d.wireless);
+            if (loose.length === 1)
+                return { kind: 'device', device: loose[0], room: here, viaWan: false };
+        }
+        // 3. A PERSON'S GUN, broken out of their PAN (p.219). Same reach as
+        //    a PAN intrusion: bodies on this side of the host wall.
+        const reach = (actor.plane === 'matrix' && !actor.insideHost)
+            ? roomsInReach(rooms, actor)
+            : [{ room: actor.currentLocation, noise: 0 }];
+        const bodies = reach.flatMap(({ room: r }) => this.scene.getActorsInRoom(r)
+            .filter(a => a !== actor && a.plane === 'meat' && !a.isIncapacitated() && sameHostSide(actor, a)));
+        const picked = fuzzyPickName(named, bodies.map(a => a.name));
+        const owner = picked ? bodies.find(a => a.name === picked) : undefined;
+        if (owner) {
+            const gun = owner.equipment.rightHand?.weapon ?? owner.equipment.leftHand?.weapon;
+            if (!gun || !gun.isFirearm())
+                return `${owner.name} has no firearm on the grid to work -- nothing wireless in their hands.`;
+            return { kind: 'gun', owner, gun };
+        }
+        return `Nothing on the grid answers to "${named}".${hint(` ("look" lists the icons in reach.)`)}`;
+    }
+    marksOn(t) {
+        const me = this.actor.name;
+        if (t.kind === 'device')
+            return t.device.marksBy.get(me) ?? 0;
+        if (t.kind === 'camera')
+            return t.master?.hostMarksBy.get(me) ?? 0;
+        return t.owner.panMarksBy.get(me) ?? 0;
+    }
+    nameOf(t) {
+        return t.kind === 'device' ? t.device.name : t.kind === 'camera' ? `the camera cluster on ${t.room.name}` : `${t.owner.name}'s ${t.gun.name}`;
+    }
+    /** What defends: DR + Firewall for an unattended device (the master's
+     *  where higher, seen from the grid), the host for its cameras, the
+     *  owner's Intuition + Firewall for a gun on their PAN. */
+    defence(t) {
+        if (t.kind === 'device') {
+            return t.viaWan && t.host?.host ? wanDefensePool(t.device, t.host.host) : deviceDefensePool(t.device);
+        }
+        if (t.kind === 'camera') {
+            return t.master?.host ? hostDefensePool(t.master.host) : { label: 'Device Rating + Firewall', pool: 4 };
+        }
+        return { label: 'Intuition + Firewall', pool: t.owner.getPanDefensePool('sleaze') };
+    }
+    godBill(defenseHits, why) {
+        const bill = accrueOverwatch(this.scene, this.actor, defenseHits, why);
+        if (bill.converged && this.actor.plane === 'matrix') {
+            bill.lines.push(...leaveMatrix(this.scene, this.actor, { forced: true, reason: `GOD force-reboots your persona --` }));
+        }
+        return bill.lines;
+    }
+    /** The owner of the thing learns something went wrong. */
+    wakeOwner(t, made) {
+        const actor = this.actor;
+        actor.sneaking = false;
+        const host = t.kind === 'device' ? t.host : t.kind === 'camera' ? t.master : undefined;
+        if (host) {
+            host.hostAlert = true;
+            if (made)
+                host.hostMarksOn.set(actor.name, Math.min(MAX_MARKS, (host.hostMarksOn.get(actor.name) ?? 0) + 1));
+        }
+        if (t.kind === 'gun' && made) {
+            actor.panMarksBy.set(t.owner.name, Math.min(MAX_MARKS, (actor.panMarksBy.get(t.owner.name) ?? 0) + 1));
+            t.owner.performAction('notices a Matrix probe', 'their link flashing an intrusion warning');
+        }
+        this.scene.updateStatus();
+    }
+    // ------------------------------------------------------ Control Device --
+    controlDevice(t) {
+        const actor = this.actor;
+        const name = this.nameOf(t);
+        const marks = this.marksOn(t);
+        if (marks < MARKS_TO_CONTROL) {
+            const how = t.kind === 'device' ? `"hack ${t.device.name}"` : t.kind === 'camera' ? `"hack ${t.master ? hostLabel(t.master) : 'the host'}"` : `"hack ${t.owner.name}"`;
+            return `${name} takes orders from ${MARKS_TO_CONTROL} marks and you hold ${marks} (Control Device, p.238: a Simple device action wants two).${hint(` (${how} places them; or "brick" it -- no marks, but loud, and a bricked lock stays locked.)`)}`;
+        }
+        const burned = actor.burnedAttributeRefusal('sleaze');
+        if (burned)
+            return burned;
+        // ELECTRONIC WARFARE + INTUITION [SLEAZE] v. Intuition + Firewall
+        // (p.238), the no-test device action's test. Unskilled at -1 (p.130).
+        const ew = actor.skillRating('electronic-warfare');
+        const grid = gridActionModifier(actor.currentGrid, !!actor.hostInside, t.kind === 'device' ? t.host?.host?.grid : t.kind === 'camera' ? t.master?.host?.grid : undefined);
+        const pool = Math.max(1, actor.intuition + (ew > 0 ? ew : -1) + actor.bonus('hacking') + actor.bonus('matrix-sleaze')
+            + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty + grid.total);
+        const limit = actor.matrixAttribute('sleaze');
+        const roll = rollPool(pool, limit, { gremlins: actor.deckGremlins });
+        const defence = this.defence(t);
+        const defenceRoll = rollPool(defence.pool);
+        const net = roll.hits - defenceRoll.hits;
+        actor.performAction('takes control of a device', name, { quiet: this.scene.isHumanControlled(actor) });
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Control Device (Electronic Warfare + Intuition [Sleaze])${gridNote(grid)}: ${formatRoll(roll)}`);
+            this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);
+        }
+        const godLines = this.godBill(defenceRoll.hits, 'Control Device (sleaze)');
+        if (net <= 0) {
+            // A blown Sleaze is noticed (p.236): the owner marks you and the
+            // host it hangs off is awake.
+            this.wakeOwner(t, true);
+            const who = t.kind === 'gun' ? `${t.owner.name}'s firewall holds a MARK on your persona now` : `whoever owns it has your icon on file now`;
+            return [`${name} refuses the order and SAYS SO -- ${who}.`, ...godLines].join('\n');
+        }
+        const lines = [];
+        if (t.kind === 'device') {
+            // THE ORDER: it opens. Same aftermath as a key or a forced door
+            // (utilities/devices.ts) -- the exit unseals in the meat.
+            const opened = t.device.force(true);
+            lines.push(`${t.device.name} takes the order as its owner's: ${opened.message}`);
+            lines.push(...applyDeviceOpened(this.scene, actor, t.room, t.device, 'disable'));
+        }
+        else if (t.kind === 'camera') {
+            t.room.camerasLooped = true;
+            lines.push(`The cluster on ${t.room.name} takes the order: every lens loops on an empty hallway. Security sees NOTHING there now.${hint(` ("snoop ${t.room.name}" rides the real feed.)`)}`);
+            this.scene.addWorldEvent(`An unseen hand looped the cameras on ${t.room.name}.`);
+        }
+        else {
+            t.gun.jammed = true;
+            lines.push(`${t.owner.name}'s ${t.gun.name} takes the order: the smartlink seizes and the clip drops -- LOCKED until they reboot.`);
+            t.owner.performAction('suffers a PAN crack', `their ${t.gun.name} locking up in their hand`);
+            this.scene.addWorldEvent(`An unseen hand seized ${t.owner.name}'s ${t.gun.name}.`);
+        }
+        this.scene.updateStatus();
+        return [...lines, ...godLines].join('\n');
+    }
+    // ----------------------------------------------------------- Data Spike --
+    dataSpike(t) {
+        const actor = this.actor;
+        const name = this.nameOf(t);
+        const burned = actor.burnedAttributeRefusal('attack');
+        if (burned)
+            return burned;
+        if (t.kind === 'device' && t.device.isBricked)
+            return `${t.device.name} is already bricked -- dead boards, nothing left to spike.`;
+        if (t.kind === 'camera' && t.room.camerasBricked)
+            return `The cluster on ${t.room.name} is already dead glass.`;
+        if (t.kind === 'gun' && t.gun.bricked)
+            return `${t.owner.name}'s ${t.gun.name} is already bricked.`;
+        // CYBERCOMBAT + LOGIC [ATTACK] v. Intuition + Firewall (p.239).
+        const grid = gridActionModifier(actor.currentGrid, !!actor.hostInside, t.kind === 'device' ? t.host?.host?.grid : t.kind === 'camera' ? t.master?.host?.grid : undefined);
+        const pool = Math.max(1, actor.getAttackPool() + actor.matrixActionPenalty + actor.bonus('matrix-attack') + grid.total);
+        const limit = actor.matrixAttribute('attack');
+        const roll = rollPool(pool, limit, { gremlins: actor.deckGremlins });
+        const defence = this.defence(t);
+        const defenceRoll = rollPool(defence.pool);
+        const net = roll.hits - defenceRoll.hits;
+        actor.performAction('throws a Data Spike', name, { quiet: this.scene.isHumanControlled(actor) });
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Data Spike (Cybercombat + Logic [Attack ${limit}])${gridNote(grid)}: ${formatRoll(roll)}`);
+            this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);
+        }
+        const godLines = this.godBill(defenceRoll.hits, 'Data Spike (attack)');
+        if (net <= 0) {
+            // A failed Attack action is never noticed (p.236), but the
+            // target's software rejects the code and sends it back: one
+            // unresistable box per net hit the defender got (Data Trails p.181).
+            const rebound = Math.max(0, -net);
+            const lines = [`${name} shrugs the spike off${rebound > 0 ? ' -- and sends it back' : ''}.`];
+            if (rebound > 0) {
+                if (actor.isTechnomancer()) {
+                    actor.takeStun(rebound);
+                    lines.push(`  Rejected code burns back through your living persona -- ${rebound} stun: ${actor.stunSummary()}`);
+                }
+                else {
+                    actor.takeMatrixDamage(rebound);
+                    lines.push(`  Rejected code burns back into your deck -- ${rebound} box${rebound === 1 ? '' : 'es'}, unresisted: ${actor.matrixSummary()}`);
+                    if (actor.matrixCrashed)
+                        lines.push(...leaveMatrix(this.scene, actor, { forced: true, reason: `Your own spike bricks the deck under you.` }));
+                }
+            }
+            lines.push(`  Nobody upstairs noticed -- a spike that doesn't land leaves no trace.`);
+            return [...lines, ...godLines].join('\n');
+        }
+        // DV = Attack + net hits, +2 per mark held (p.239); resisted with
+        // Device Rating + Firewall (p.228).
+        const marks = this.marksOn(t);
+        const dv = limit + net + 2 * marks;
+        const soak = rollPool(this.defence(t).pool);
+        const dealt = Math.max(0, dv - soak.hits);
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Data Spike -- ${dv} DV (Attack ${limit} +${net} net${marks > 0 ? ` +${2 * marks} for ${marks} mark${marks === 1 ? '' : 's'}` : ''}) v. ${defence.label}: ${formatRoll(soak)} -> ${dealt}`);
+        }
+        // An Attack action is never subtle: the owner knows.
+        this.wakeOwner(t, false);
+        const lines = [];
+        if (dealt <= 0) {
+            lines.push(`${name} takes the spike and its firewall holds -- barely. It knows it was hit.`);
+            return [...lines, ...godLines].join('\n');
+        }
+        if (t.kind === 'device') {
+            t.device.takeMatrixDamage(dealt);
+            lines.push(`The spike lands on ${t.device.name} -- ${dealt} box${dealt === 1 ? '' : 'es'} (${t.device.matrixSummary()}).`);
+            if (t.device.isBricked) {
+                lines.push(t.device.kind === 'lock'
+                    ? `  ${t.device.name} BRICKS -- sparks, a pop, a smell of hot plastic. And the lock STAYS LOCKED (p.228): a dead maglock holds like a bolt.${hint(` (Marks and "disable" would have opened it; now it is "pick" or "breach".)`)}`
+                    : `  ${t.device.name} BRICKS -- sparks, a pop, dead electronics. Whatever it was doing, it has stopped.`);
+                this.scene.addWorldEvent(`${actor.name} bricked ${t.device.name} in ${t.room.name} with a Data Spike.`);
+            }
+        }
+        else if (t.kind === 'camera') {
+            // The cluster has no Device of its own to hold a monitor; a hit
+            // that lands past the firewall kills it. Engine ruling.
+            t.room.camerasBricked = true;
+            lines.push(`The spike lands on the cluster -- ${dealt} box${dealt === 1 ? '' : 'es'} -- and every lens on ${t.room.name} goes to static and stays there. Dead glass.`);
+            this.scene.addWorldEvent(`${actor.name} bricked the cameras on ${t.room.name} with a Data Spike.`);
+        }
+        else {
+            // A gun is a Rating 2 device with a monitor of 9 (p.228, the
+            // book's own smartgun example): a spike that lands past its
+            // firewall for that much bricks it outright.
+            const monitor = 8 + 1;
+            if (dealt >= monitor) {
+                t.gun.bricked = true;
+                lines.push(`The spike lands on ${t.owner.name}'s ${t.gun.name} -- it sparks, crackles and smokes in their hand. BRICKED: it will not fire again until somebody's bench work.`);
+                t.owner.performAction('suffers a PAN crack', `their ${t.gun.name} smoking in their hand`);
+            }
+            else {
+                t.gun.jammed = true;
+                lines.push(`The spike lands on ${t.owner.name}'s ${t.gun.name} -- ${dealt} box${dealt === 1 ? '' : 'es'}: the smartlink seizes and LOCKS. It boots again on a reboot; another spike like that bricks it.`);
+                t.owner.performAction('suffers a PAN crack', `their ${t.gun.name} locking up in their hand`);
+            }
+            this.scene.addWorldEvent(`${actor.name} spiked ${t.owner.name}'s ${t.gun.name}.`);
+        }
+        this.scene.updateStatus();
+        return [...lines, ...godLines].join('\n');
+    }
+}
+/** `brick <icon>`: the Data Spike, by its street name. */
+export class BrickCommand extends DisableCommand {
+    static verb = 'brick';
+    static description = 'Data Spike (SR5 p.239): Cybercombat + Logic [Attack] v. Device Rating + Firewall, no marks needed, never subtle. Fill a device\'s Matrix condition monitor (8 + DR/2, p.228) and it BRICKS -- a camera goes dead, a smartgun sparks and dies; a lock stays locked. A miss burns your own deck.';
+    way(args) {
+        const rest = [...args];
+        if (rest[0]?.toLowerCase() === 'loud')
+            rest.shift();
+        return { way: 'spike', rest };
+    }
+}
+//# sourceMappingURL=disable.js.map

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 = [`{cyan-fg}Within reach to pull down:{/cyan-fg}`];
+            const lines = [`{lightblue-fg}Within reach to pull down:{/lightblue-fg}`];
             for (const i of loose)
                 lines.push(`  ${planeTintItemName(i, actor.plane)} -- loose on the grid here`);
             for (const c of carried)
@@ -134,11 +134,11 @@ export class DownloadCommand extends Command {
         this.scene.updateStatus();
         return fromSprite
             ? [
-                `{cyan-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/cyan-fg}`,
+                `{lightblue-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/lightblue-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')
             : [
-                `{cyan-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/cyan-fg}`,
+                `{lightblue-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/lightblue-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/end-turn.js

@@ -49,7 +49,7 @@ export class EndTurnCommand extends Command {
             // Logged now rather than returned: the phases that follow announce
             // themselves while this command is still running, and a return
             // value would land under them, out of order.
-            this.logger.log(`{cyan-fg}You end your Action Phase${budget && budget.spent.length > 0 ? ` -- ${ledger}` : ' -- nothing spent'}.{/cyan-fg}`, { actor: actor.name });
+            this.logger.log(`{yellow-fg}You end your Action Phase${budget && budget.spent.length > 0 ? ` -- ${ledger}` : ' -- nothing spent'}.{/yellow-fg}`, { actor: actor.name });
         }
         await enc.endPhase(actor);
         return this.scene.isHumanControlled(actor) ? '' : `${actor.name} ends their Action Phase.`;

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 [
-                `{cyan-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/cyan-fg}`,
+                `{lightblue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/lightblue-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');
         }
@@ -79,14 +79,15 @@ export class EnterHostCommand extends Command {
         // you there). currentLocation is never written -- it is the body's.
         actor.matrixPosition = { kind: 'host', host: target.host, from: actor.currentGrid };
         movePersonaWith(this.game ?? undefined, actor);
-        actor.performAction('enters a host', `icon crossing into ${target.name}'s architecture`);
+        actor.performAction('enters a host', `icon crossing into ${target.name}'s architecture`, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} entered the host at ${target.name}.`);
         this.scene.updateStatus();
+        // ONE LINE (2026-09-13, "too much text"): the crossing, and the
+        // coaching behind the hints toggle.
         return [
-            `{cyan-fg}You cross into ${hostLabel(target, { capital: false })}.{/cyan-fg}`,
-            `{cyan-fg}The outside grid folds shut behind you -- the icons in reach, the PANs, the personas out on the grid: all of it gone, not hidden. In here there is only what the host keeps.{/cyan-fg}`,
-            hint(`"look" reads the space you're standing in now. "exit" puts you back on the grid.`),
-        ].join('\n');
+            `{lightblue-fg}You cross into ${hostLabel(target, { capital: false })} -- the outside grid folds shut behind you.{/lightblue-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');
     }
     /**
      * The host this verb means. Bare `enter` takes the one under your feet
@@ -109,14 +110,14 @@ export class EnterHostCommand extends Command {
             const over = hostOver(gridVicinity(this.actor)) ?? hostOver(here);
             if (over)
                 return over;
-            return `{cyan-fg}Thin grid here -- no host stands over ${gridVicinity(this.actor).name}.{/cyan-fg} ${hint(`Overhead: ${roster} -- "enter <name>" crosses into any of them from here.`)}`;
+            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.`)}`;
         }
         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 `{cyan-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/cyan-fg}`;
+            return `{lightblue-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/lightblue-fg}`;
         return `No host called "${named}" overhead. ${hint(`Overhead: ${roster}.`)}`;
     }
 }
@@ -148,13 +149,10 @@ export class ExitHostCommand extends Command {
         const from = actor.matrixPosition?.kind === 'host' ? actor.matrixPosition.from : undefined;
         actor.matrixPosition = { kind: 'grid', grid: from };
         movePersonaWith(this.game ?? undefined, actor);
-        actor.performAction('exits a host', `icon surfacing out of ${host.name}'s architecture`);
+        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 [
-            `{cyan-fg}You step back out of ${hostLabel(host, { capital: false })} and onto the grid -- your body still sits in ${actor.currentLocation.name}.{/cyan-fg}`,
-            `{cyan-fg}The host seals behind you: one icon again, whatever you saw in there now on the other side of its wall.{/cyan-fg}`,
-        ].join('\n');
+        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}`;
     }
 }
 //# sourceMappingURL=enter-host.js.map

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

@@ -173,7 +173,7 @@ export class HackCommand extends BypassCommand {
             const burned = this.actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
             if (burned)
                 return burned;
-            this.actor.performAction('hacks the host', room.name);
+            this.actor.performAction('hacks the host', room.name, { quiet: this.scene.isHumanControlled(this.actor) });
             const attempt = await this.hostIntrusionRoll(mode, declared, room);
             const success = attempt.success;
             // GOD BILLS THE DEFENDER'S HITS (p.231-232): "your OS increases by
@@ -276,7 +276,7 @@ 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(`  {cyan-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/cyan-fg}`);
+                    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}`);
                 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.)`)}`);
@@ -340,13 +340,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(`  {cyan-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/cyan-fg}`);
+                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}`);
             }
             // 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(`  {cyan-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).{/cyan-fg}`);
+                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}`);
             }
             // THE FEEDS ARE A REAL GAIN AND WERE NEVER MENTIONED
             // (BpR5cjhYuvgCyDSZc, 7aNWnDSHeZMYmS2De: "what have I gained?").
@@ -540,7 +540,7 @@ export class HackCommand extends BypassCommand {
             ? Math.max(1, actor.getAttackPool() + silence + actor.bonus('matrix-attack') + declarePenalty)
             : Math.max(1, actor.logic + actor.skillRating('hacking') + actor.bonus('hacking') + actor.bonus('matrix-sleaze')
                 + silence + actor.woundModifier - actor.sustainingPenalty + declarePenalty);
-        actor.performAction('works a slaved icon', device.name);
+        actor.performAction('works a slaved icon', device.name, { quiet: this.scene.isHumanControlled(actor) });
         const roll = rollPool(pool, limit, { gremlins: actor.deckGremlins });
         // From the grid the slave borrows its master's numbers where they are
         // higher (p.233); inside, it stands alone (Data Trails p.87-88).
@@ -606,18 +606,18 @@ export class HackCommand extends BypassCommand {
         else {
             const perception = freeMatrixPerceptionHits(netHits);
             if (perception > 0)
-                lines.push(`  {cyan-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/cyan-fg}`);
+                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}`);
         }
-        // ONE MARK COMMANDS IT. Opening a door is a Free action, and p.238
-        // puts a Free action at one mark -- so the key IS the door, and
-        // there is no second roll to make.
-        if (now >= 1 && !device.isOpen()) {
-            // NAME ONLY A VERB THAT DISPATCHES. An earlier draft offered
-            // "control <device>", which is not a command this game has --
-            // caught by advertised-verbs-structured.test.ts, which exists for
-            // exactly that. `open` is the real one, and it is a MEAT verb: the
-            // key is placed from in here, the door swings out there.
-            lines.push(`  That is enough to work it: ${device.opensExit ? `the ${device.opensExit} way` : device.name} answers to you now.${hint(` ("open ${device.opensExit ?? device.name}" once your body is back in the room.)`)}`);
+        // 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
+        // is the book's own example of the no-test device action, a Simple
+        // "Use Simple Device", p.165). The verb is `disable`
+        // (commands/disable.ts): the key is turned from in here, the door
+        // swings out there. One mark short says so.
+        if (!device.isOpen()) {
+            lines.push(now >= 2
+                ? `  That is enough to command it: ${hint(`"disable ${device.name}" (Control Device, p.238) ${device.opensExit ? `opens the ${device.opensExit} way` : `works it`} from right here.`)}`
+                : `  One more mark and it takes orders.${hint(` ("hack ${device.name}" again, then "disable ${device.name}" -- Control Device wants 2 marks for a Simple device action, p.238.)`)}`);
         }
         this.scene.updateStatus();
         return [...lines, ...godLines].join('\n');
@@ -765,7 +765,7 @@ export class HackCommand extends BypassCommand {
         // Intuition + Firewall against a sleaze, Willpower + Firewall
         // against a smash (p.240 / p.238), and no limit on either.
         const defense = rollPool(target.getPanDefensePool(mode === 'attack' ? 'attack' : 'sleaze'));
-        actor.performAction('runs a PAN intrusion', target.name);
+        actor.performAction('runs a PAN intrusion', target.name, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} PAN-hacks ${target.name}: ${attack.hits} vs ${defense.hits} (silent=${target.runningSilent}).`);
         // Dice anatomy to the Mechanics ticker (readability pass) --
         // player-gated like every roll site: an NPC's probe isn't your dice.

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

@@ -53,7 +53,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 `{cyan-fg}The sky changes texture and you're on ${target.name}.{/cyan-fg}${target.userPenalty ? ` ${hint(`Public grid: -2 on everything you do out here.`)}` : ''}`;
+            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.`)}` : ''}`;
         }
         // ILLEGAL HOP (p.240): Hack on the Fly against the grid itself.
         const burned = actor.burnedAttributeRefusal('sleaze');
@@ -87,7 +87,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 [
-            `{cyan-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/cyan-fg}`,
+            `{lightblue-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/lightblue-fg}`,
             ...bill.lines,
         ].join('\n');
     }