@maka/maka-cli 5.390.0 → 5.392.0

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

@@ -0,0 +1,64 @@
+import { Command } from './command.js';
+import { gridActionModifier } from '../utilities/grids.js';
+import { hint } from '../utilities/hints.js';
+import { rollPool, formatRoll } from '../utilities/dice.js';
+import { billAction } from '../utilities/action-cost.js';
+import { hostLabel } from '../utilities/grid-names.js';
+import { detonate, pickHostFile } from '../utilities/file-guard.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
+/**
+ * DISARM DATA BOMB (SR5 p.239, RAG-checked 2026-10-06): Complex Action,
+ * Marks Required none, Software + Intuition [Firewall] v. Data Bomb
+ * Rating x 2. "If you get any net hits, the Data Bomb is removed and
+ * deleted. If you fail, the Data Bomb activates." A Firewall action
+ * (p.244) -- legal, so GOD does not count it.
+ *
+ * You disarm what you have FOUND: a bomb is detected with Matrix
+ * Perception (p.242), "look <file>" inside the host. Software cannot be
+ * defaulted (p.145, "Default: No").
+ */
+export class DisarmCommand extends Command {
+    static verb = 'disarm';
+    static description = 'Disarm Data Bomb (SR5 p.239, Complex Action): "disarm <file>" -- Software + Intuition [Firewall] v. the bomb\'s Rating x 2, once Matrix Perception ("look <file>" inside the host) has turned the bomb up. Any net hit deletes the bomb; failure sets it off. Legal.';
+    async execute(args = []) {
+        const actor = this.actor;
+        const found = pickHostFile(actor, args.join(' ').trim(), 'disarm');
+        if (typeof found === 'string')
+            return found;
+        const { host, file } = found;
+        if (!file.dataBomb || !file.bombSeenBy.has(actor.name)) {
+            return `You see no data bomb on ${file.name} to disarm. ${hint(`(Matrix Perception finds one: "look ${file.name}".)`)}`;
+        }
+        const software = actor.skillRating('software');
+        if (software <= 0) {
+            return `Disarming a data bomb is Software, and Software cannot be defaulted (p.145) -- without the skill there is no test to try.`;
+        }
+        const burned = actor.burnedAttributeRefusal('firewall');
+        if (burned)
+            return burned;
+        const bill = billAction(this.scene, actor, 'complex', 'Disarm Data Bomb');
+        if (bill)
+            return bill;
+        const rating = file.dataBomb.rating;
+        const grid = gridActionModifier(actor.currentGrid, !!actor.hostInside, actor.currentGrid);
+        const pool = Math.max(1, actor.intuition + software + actor.bonus('software')
+            + actor.matrixActionPenalty + grid.total + actor.woundModifier - actor.sustainingPenalty);
+        const attempt = rollPool(pool, actor.matrixAttribute('firewall'), { gremlins: actor.deckGremlins });
+        const resist = rollPool(rating * 2);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Disarm Data Bomb -- Software + Intuition [Firewall]: ${formatRoll(attempt)}`);
+            this.logger.meta(`  v. Data Bomb ${rating} x 2: ${formatRoll(resist)}`);
+        }
+        actor.performAction('works at a data bomb', `on ${file.name} in ${hostLabel(host.over)}`, { quiet: this.scene.isHumanControlled(actor) });
+        if (attempt.hits <= resist.hits) {
+            this.logger.write(`${actor.name} failed to disarm the bomb on "${file.name}": ${attempt.hits} v ${resist.hits}.`);
+            return [`Your probe trips the trigger.`, ...detonate(this.scene, this.logger, actor, host, file).lines].join('\n');
+        }
+        file.dataBomb = undefined;
+        file.bombSeenBy.clear();
+        this.logger.write(`${actor.name} disarmed the bomb on "${file.name}": ${attempt.hits} v ${resist.hits}.`);
+        this.scene.updateStatus();
+        return `{light-blue-fg}You unpick the payload thread by thread -- the data bomb on ${file.name} deletes itself, harmless.{/light-blue-fg}`;
+    }
+}
+//# sourceMappingURL=disarm.js.map

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

@@ -1,19 +1,19 @@
 import { CastCommand } from './cast.js';
-import { BypassCommand } from './bypass-command.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { billAction } from '../utilities/action-cost.js';
 import { roomAtCell } from '../utilities/district-plane.js';
 /**
- * The magical barrier's OWN verb (player ruling: "solve" was too broad --
- * a ward wants "dispel", not a generic answer verb), and the second half
- * of counterspelling (RAW p.295): "dispel <name>" unweaves a SUSTAINED
- * SPELL off an actor in the room -- an enemy mage's invisibility, an
- * armor weave, quickened reflexes -- Magic + counterspelling opposed by
- * their grip on it. Barrier flow is unchanged: no actor match falls
- * through to the ward route (same pool, backlash on failure, both
- * inherited from CastCommand). Bare "cast" keeps working as it always
- * has.
+ * COUNTERSPELLING'S SECOND HALF (RAW p.295): "dispel <name>" unweaves a
+ * SUSTAINED SPELL off an actor in the room -- an enemy mage's
+ * invisibility, an armor weave, quickened reflexes, a barrier spell --
+ * Magic + counterspelling opposed by their grip on it.
+ *
+ * A WARD IS NOT DISPELLED (user 2026-10-06). It used to be: a ward was a
+ * door device this verb unweaved, with backlash. A ward is a ritual's
+ * astral barrier over a room (utilities/wards.ts), and canon gives no
+ * rule for dispelling one -- it is pressed through or attacked, from the
+ * astral (p.316).
  *
  * Registered under both spellings ("dispel" is the book's, "dispell" is
  * how half the table types it).
@@ -30,8 +30,7 @@ const SUSTAINED_EFFECTS = [
     // The barrier pair (ruling 2026-08-24; canon p.294). MANA first:
     // find() takes the first word match, so "dispel mana barrier" lands
     // here instead of on the physical entry's 'barrier'. With no
-    // spell-wall standing, these words fall through to the warded-door
-    // route as before (holderless named effects return undefined below).
+    // spell-wall standing, these words find no holder (undefined below).
     { key: 'manabarrier', words: ['manabarrier', 'mana'], label: 'mana barrier',
         has: p => !!p.sustainedManaBarrier, clear: p => { p.sustainedManaBarrier = undefined; } },
     { key: 'barrier', words: ['barrier', 'wall'], label: 'force barrier',
@@ -39,23 +38,7 @@ const SUSTAINED_EFFECTS = [
 ];
 export class DispelCommand extends CastCommand {
     static verb = 'dispel';
-    static description = 'Unweave magic -- Magic + counterspelling. A barrier: "dispel" (or "dispel north"/"dispel <name>"; fail and the backlash BITES, the barrier seals for good). A SUSTAINED SPELL on someone: "dispel <name>" or "dispel invisibility on <name>" -- opposed by their grip; no backlash, retry freely.';
-    verbName = 'dispel';
-    noDeviceMessage = `There's no magical barrier here to dispel.`;
-    /**
-     * RAW dispelling (p.295): Magic + counterspelling -- the unweave is a
-     * parry, not a working, so the CASTING pool (cast's ward route) stays
-     * cast's. Unskilled follows the house -1 default; a gear-only caster
-     * (grimoire, no Magic) is down to scraps here -- their route is still
-     * "cast", which rolls the full casting pool.
-     */
-    async determineOutcome() {
-        const roll = rollPool(this.dispelPool());
-        if (this.scene.isHumanControlled(this.actor)) {
-            this.logger.meta(`Counterspelling: ${formatRoll(roll)} (2+ to unweave)`);
-        }
-        return roll.hits >= 2;
-    }
+    static description = 'Unweave a SUSTAINED SPELL -- Magic + counterspelling, opposed by its caster\'s grip: "dispel <name>", "dispel invisibility on <name>", "dispel barrier". No backlash; retry freely. A ward is not dispelled -- press through it or attack it from the astral.';
     dispelPool() {
         const skill = this.actor.skillRating('counterspelling');
         return Math.max(1, this.actor.magic + (skill > 0 ? skill : -1) + this.actor.woundModifier - this.actor.sustainingPenalty);
@@ -70,27 +53,27 @@ export class DispelCommand extends CastCommand {
             return `Unweaving is Sorcery, and your gift is aspected to conjuring -- you can see the weave, not pull it.`;
         }
         if (!this.actor.isCaster()) {
-            return `Unweaving a ward takes talent you don't have -- you'd need to be Awakened, or have a spell formula, grimoire, or focus on you.`;
+            return `Unweaving a spell takes talent you don't have -- you'd need to be Awakened, or have a spell formula, grimoire, or focus on you.`;
+        }
+        if (!args || args.length === 0) {
+            return `Dispel what? "dispel <name>" strips a sustained spell off someone here.`;
         }
         // DISPELLING IS A COMPLEX ACTION (SR5 p.295) inside a Combat Turn.
         const bill = billAction(this.scene, this.actor, 'complex', 'Dispel');
         if (bill)
             return bill;
-        // An actor's name beats a barrier noun -- "dispel ghost" means the
-        // mage, "dispel ward" falls through to the barrier route below.
-        if (args && args.length > 0) {
-            const sustained = this.tryDispelSustained(args);
-            if (sustained !== undefined)
-                return sustained;
+        const sustained = this.tryDispelSustained(args);
+        if (sustained !== undefined)
+            return sustained;
+        if (args.some(w => /^wards?$/i.test(w))) {
+            return `A ward is a ritual's astral barrier, not a sustained spell -- there is no grip on it to unweave. From the astral, "go" presses through it and "attack ward" tears at it (p.316).`;
         }
-        // Skip CastCommand's spell-name resolution entirely -- dispel only
-        // ever means a barrier or a sustained spell.
-        return BypassCommand.prototype.execute.call(this, args);
+        return `No sustained spell by that name here to unweave.`;
     }
     /**
      * "dispel <name>" / "dispel invisibility on <name>": strip a sustained
      * spell off an actor here. Returns undefined when the words name no
-     * actor in the room (the barrier flow's turn), a message otherwise.
+     * actor in the room, a message otherwise.
      */
     tryDispelSustained(args) {
         const lowered = args.map(w => w.toLowerCase());
@@ -143,12 +126,6 @@ export class DispelCommand extends CastCommand {
             if ((target.sustainedForms?.length ?? 0) > 0) {
                 return `What's woven around ${target.name} isn't mana -- it's RESONANCE. Your counterspelling finds nothing to grip.`;
             }
-            // A fuzzy actor hit holding nothing, with a warded barrier standing
-            // here and no effect named ("dispel ward" grazing an NPC called
-            // Warden): the word was probably aimed at the barrier -- yield.
-            const barriers = (room.openableDevices() ?? []).filter(d => d.kind === 'ward');
-            if (barriers.length > 0 && !named)
-                return undefined;
             return target === this.actor
                 ? `Nothing of yours is sustained right now.`
                 : `No sustained spell clings to ${target.name}.`;

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

@@ -9,6 +9,7 @@ import { hostLabel } from '../utilities/grid-names.js';
 import { editFileBlocked, rollEditFile } from '../utilities/edit-file-test.js';
 import { copyFile, deviceHas, fileOnto, findDataDevice, libraryDevice } from '../utilities/data-library.js';
 import { NPC } from '../models/npc.js';
+import { guardFile, splitPasscode } from '../utilities/file-guard.js';
 /**
  * "download" -- COPY A FILE OFF THE GRID INTO YOUR DEVICE'S LIBRARY.
  *
@@ -50,7 +51,9 @@ export class DownloadCommand extends Command {
     static description = 'Copy a file off the Matrix into your device\'s library -- "download <file>" (or "download <file> to <device>"). Edit File (SR5 p.239, a Complex Action): Computer + Logic [Data Processing] v. the host, with a mark on it -- no roll once the host is cracked, or for data loose on the grid or held by your own sprites. The host keeps its original. "inv" lists your libraries; "transfer" moves files between devices or onto a chip.';
     async execute(args = []) {
         const actor = this.actor;
-        let words = args.join(' ').trim();
+        // "download <file> with <passcode>" walks past its data bomb (p.242).
+        const { rest: named, passcode } = splitPasscode(args);
+        let words = named.join(' ').trim();
         // "... to <device>": split on the LAST " to ", and only when the tail
         // names a data device you carry -- a file called "Letter to Krow"
         // still downloads whole.
@@ -106,7 +109,7 @@ export class DownloadCommand extends Command {
                 return elsewhere;
             return `No file called "${words}" within reach.${hint(` ("download" on its own lists what is.)`)}`;
         }
-        const out = this.pull(source, target);
+        const out = this.pull(source, target, passcode);
         return out.text;
     }
     /**
@@ -186,7 +189,7 @@ export class DownloadCommand extends Command {
      * only when a file actually landed -- take-all stops on a refusal that
      * is about the ACTOR (out of actions), not the file.
      */
-    pull(source, target) {
+    pull(source, target, passcode) {
         const actor = this.actor;
         const item = source.item;
         // A LOOSE END IS ERASED, NOT DOWNLOADED: the desk keeps its copy
@@ -245,12 +248,26 @@ export class DownloadCommand extends Command {
         const bill = billAction(this.scene, actor, 'complex', 'Edit File (copy)');
         if (bill)
             return { ok: false, text: bill, stop: true };
+        // THE FILE'S OWN DEFENCES (utilities/file-guard.ts, p.239: a
+        // protected file's copy "automatically fails", and a bomb "goes off
+        // on you"). A cracked HOST is not a cracked FILE -- this gate stands
+        // whether or not the host roll does.
+        let blast = '';
+        if (host) {
+            const guard = guardFile(this.scene, this.logger, actor, host, item, 'copy', passcode);
+            if (guard.stop) {
+                actor.performAction('edits a file', `${item.name} in ${hostLabel(host.over)}`, { quiet: this.scene.isHumanControlled(actor) });
+                return { ok: false, text: guard.lines.join('\n') };
+            }
+            if (guard.lines.length > 0)
+                blast = `${guard.lines.join('\n')}\n`;
+        }
         if (host && needsRoll) {
             const roll = rollEditFile(this.scene, this.logger, actor, host, 'copy');
             if (!roll.success) {
                 actor.performAction('edits a file', `${item.name} in ${hostLabel(host.over)}`, { quiet: this.scene.isHumanControlled(actor) });
                 this.logger.write(`${actor.name} failed to copy "${item.name}" from ${host.over.name}: ${roll.hits} v ${roll.defence}.`);
-                return { ok: false, text: `The copy stalls -- ${hostLabel(host.over)}'s checksum rejects the read and nothing comes down. A failed edit is not a failed sleaze; nobody upstairs noticed.${hint(` (Try again; each attempt is a Complex Action.)`)}` };
+                return { ok: false, text: `${blast}The copy stalls -- ${hostLabel(host.over)}'s checksum rejects the read and nothing comes down. A failed edit is not a failed sleaze; nobody upstairs noticed.${hint(` (Try again; each attempt is a Complex Action.)`)}` };
             }
         }
         // THE MOVE. A sprite's file is already yours and moves; everything
@@ -281,11 +298,11 @@ export class DownloadCommand extends Command {
         this.logger.write(`${actor.name} downloaded "${item.name}" (${source.kind}) ${onto ? `onto ${onto.name}` : 'into its own hands'}.`);
         this.game?.requestSave('data');
         this.scene.updateStatus();
-        const text = onto
+        const text = blast + (onto
             ? source.kind === 'sprite'
                 ? `{light-blue-fg}${source.npc.name} opens its hands and the data pours out of them -- {bold}{underline}${item.name}{/underline}{/bold} is on your ${onto.name} now.{/light-blue-fg}`
                 : `{light-blue-fg}You copy {bold}{underline}${item.name}{/underline}{/bold} onto your ${onto.name}${host ? ` -- ${hostLabel(host.over)} keeps its original` : ''}.{/light-blue-fg}${hint(` ("give" or "call" hands it over straight from the device; "transfer ${item.name} to chip" writes it to physical media.)`)}`
-            : `{light-blue-fg}You take hold of ${item.name}.{/light-blue-fg}`;
+            : `{light-blue-fg}You take hold of ${item.name}.{/light-blue-fg}`);
         // 'possess' objectives complete in the runner's hands; a device library
         // is the runner's hands for data (scene.ts checkWinCondition).
         if (this.scene.isHumanControlled(actor))

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

@@ -4,6 +4,7 @@ import { billAction } from '../utilities/action-cost.js';
 import { editFileBlocked, rollEditFile } from '../utilities/edit-file-test.js';
 import { hostLabel } from '../utilities/grid-names.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { guardFile, splitPasscode } from '../utilities/file-guard.js';
 /**
  * EDIT FILE (SR5 p.239, RAG-checked 2026-09-14): a Complex Action, Marks
  * Required 1, Computer + Logic [Data Processing] v. Intuition + Firewall.
@@ -87,7 +88,9 @@ export class EditFileCommand extends Command {
         }
         const room = host.over;
         const files = host.files();
-        const query = rest.join(' ').trim();
+        // "erase <file> with <passcode>" walks past its data bomb (p.242).
+        const { rest: named, passcode } = splitPasscode(rest);
+        const query = named.join(' ').trim();
         if (!query) {
             return files.length === 0
                 ? `${hostLabel(room, { capital: true })} keeps nothing here to edit.`
@@ -119,20 +122,29 @@ export class EditFileCommand extends Command {
         const bill = billAction(this.scene, actor, 'complex', 'Edit File');
         if (bill)
             return bill;
+        // THE FILE'S OWN DEFENCES (utilities/file-guard.ts): the attempt
+        // springs a bomb, and protection refuses the delete outright.
+        const guard = guardFile(this.scene, this.logger, actor, host, file, 'delete', passcode);
+        if (guard.stop) {
+            actor.performAction('edits a file', `${file.name} in ${hostLabel(room)}`, { quiet: this.scene.isHumanControlled(actor) });
+            return guard.lines.join('\n');
+        }
+        const blast = guard.lines.length > 0 ? `${guard.lines.join('\n')}
+` : '';
         // The roll is utilities/edit-file-test.ts, shared with download (copy)
         // and upload (create) so the family cannot drift apart.
         const attempt = rollEditFile(this.scene, this.logger, actor, host, 'delete');
         actor.performAction('edits a file', `${file.name} in ${hostLabel(room)}`, { quiet: this.scene.isHumanControlled(actor) });
         if (!attempt.success) {
             this.logger.write(`${actor.name} failed to delete "${file.name}" in ${room.name}: ${attempt.hits} v ${attempt.defence}.`);
-            return `The file's checksum holds -- your edit rolls off it and the archive keeps ${file.name}. Nothing upstairs noticed: a failed edit is not a failed sleaze.${hint(` (Try again; each attempt is a Complex Action.)`)}`;
+            return `${blast}The file's checksum holds -- your edit rolls off it and the archive keeps ${file.name}. Nothing upstairs noticed: a failed edit is not a failed sleaze.${hint(` (Try again; each attempt is a Complex Action.)`)}`;
         }
         host.removeFile(file.name);
         this.logger.write(`${actor.name} deleted "${file.name}" from ${room.name}'s host: ${attempt.hits} v ${attempt.defence}.`);
         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 [
+        return blast + [
             `{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/go.js

@@ -15,7 +15,7 @@ import { hint } from '../utilities/hints.js';
 import { gridIconBlock } from '../utilities/grid-view.js';
 import { requirePhase } from '../utilities/action-cost.js';
 import { midClimbRefusal } from '../utilities/climb-state.js';
-import { camerasLive } from '../utilities/surveillance.js';
+import { cameraSeeing } from '../utilities/surveillance.js';
 import { maybeSinSweep } from '../utilities/sin.js';
 import { despawnEphemerals } from '../utilities/ephemeral.js';
 import { maybeStreetGang } from '../utilities/street-gang.js';
@@ -25,9 +25,11 @@ import { Direction } from '../types/shared/direction-enum.js';
 import { dragFollowers } from './follow.js';
 import { escortedBy } from './bring.js';
 import { NPC } from '../models/npc.js';
+import { caughtAtDoor, springDoorWatch } from '../utilities/door-watch.js';
 import { Command } from './command.js';
 import { doorwayOf, streetDoors } from '../utilities/district-plane.js';
 import { driftAstral, driftRefusal } from '../utilities/astral-move.js';
+import { pressThroughWard, spendWardPass, wardBetween } from '../utilities/wards.js';
 import { isOutdoorsPlace } from '../utilities/outdoors.js';
 import { crowdLine } from '../utilities/crowd.js';
 import { startPathRun, goalReached, routeMeters, planSegment } from '../utilities/path-run.js';
@@ -571,7 +573,21 @@ export class GoCommand extends Command {
          */
         if (this.actor.plane === 'astral' && this.isValidDirection(direction)
             && DRIFT_WAYS.has(direction)) {
-            const drift = driftAstral(this.scene, this.actor, this.rooms ?? {}, direction, 1, true);
+            let drift = driftAstral(this.scene, this.actor, this.rooms ?? {}, direction, 1, true);
+            // A WARD IN THE WAY IS PRESSED, NOT JUST REFUSED (p.316): `go` is
+            // the verb that means to get there, so it makes the attempt.
+            if (drift !== undefined && drift.taken === 0 && drift.blockedBy === 'ward') {
+                const ward = Object.values(this.rooms ?? {}).find(r => r.name === drift.ward);
+                if (ward) {
+                    const press = pressThroughWard(this.scene, this.logger, this.actor, ward);
+                    if (this.scene.isHumanControlled(this.actor))
+                        this.logger.meta(press.meta);
+                    if (!press.through) {
+                        return `The ward over ${ward.name} holds -- Force ${ward.wardForce}. You press against the lattice and it presses back; the astral does not pass.`;
+                    }
+                    drift = driftAstral(this.scene, this.actor, this.rooms ?? {}, direction, 1, true);
+                }
+            }
             if (drift !== undefined) {
                 if (drift.taken === 0)
                     return driftRefusal(drift, direction);
@@ -691,6 +707,21 @@ export class GoCommand extends Command {
             // either one holds the way -- there is no route around a door the
             // way there is around a table. Checked BEFORE the walk, so you're
             // told who's in your way instead of crossing the room to find out.
+            // A GUARDED DOOR (utilities/door-watch.ts): whoever watches it -- or
+            // holds it, which watches it too -- and catches the runner going for
+            // it turns hostile, and the fight opens here; the move does not
+            // happen. A runner who slips past unseen carries on. Runners only:
+            // NPCs walking the site do not spring each other's watch.
+            if (!(this.actor instanceof NPC)) {
+                const watched = caughtAtDoor(currentRoom, direction, this.actor, this.scene.isHumanControlled(this.actor));
+                if (this.scene.isHumanControlled(this.actor))
+                    for (const line of watched.lines)
+                        this.logger.meta(line);
+                if (watched.npc) {
+                    this.actor.performAction('is caught going for the door', `${watched.npc.name} watches the ${direction} door`);
+                    return await springDoorWatch(this.scene, currentRoom, direction, this.actor, watched.npc);
+                }
+            }
             const blocker = doorwayBlocker(currentRoom, direction, this.actor);
             if (blocker) {
                 this.actor.performAction('finds the way blocked', `${blocker.name} holds the ${direction} doorway`);
@@ -898,6 +929,7 @@ export class GoCommand extends Command {
         this.actor.performAction('exits', `${currentRoom.name} to ${targetRoom.name}`);
         this.actor.cameFrom = { room: currentRoom.name, back: GoCommand.opposite(travelled) };
         this.actor.currentLocation = targetRoom;
+        spendWardPass(this.actor);
         // "At" spots: an arrival stands at the room's entry (the setter
         // cleared any stale spot), and the WITNESS event says where -- so
         // an NPC's history reads "enters the bar (at the door)" and its AI
@@ -1106,7 +1138,7 @@ export class GoCommand extends Command {
         let camLine = '';
         if (this.game?.onRun && this.actor === this.scene.getPlayer()
             && this.actor.qualities.has('sinner-criminal')
-            && camerasLive(this.rooms ?? {}, room)
+            && !!cameraSeeing(this.rooms ?? {}, this.actor)
             && !this.game.camPingedRooms.has(room.name)) {
             this.game.camPingedRooms.add(room.name);
             this.game.addHeat(1, 'facial rec: criminal SIN on camera', this.actor, { identity: true });
@@ -1237,21 +1269,27 @@ export class GoCommand extends Command {
         const map = { north: 'south', south: 'north', east: 'west', west: 'east', up: 'down', down: 'up' };
         return map[direction] ?? direction;
     }
-    /** Wards block astral forms and nothing else. Returns the refusal, or
-     * null. MASKING (metamagic, p.325-326, adapted): a masked aura reads as
-     * mundane background -- the ward has nothing to flare at, and the
-     * initiate slips through like weather. */
+    /**
+     * WARDS STOP ASTRAL FORMS AND NOTHING ELSE (p.294, p.315), both ways --
+     * into a warded room and out of one. Crossing one is a press (p.316):
+     * Magic + Charisma [Astral] v. Force x 2, and a breach is something the
+     * creator knows (utilities/wards.ts). Its creator crosses freely.
+     *
+     * No Masking slip any more: Masking hides an aura from Assensing and
+     * crosses nothing (SG p.149). Fooling Wards (SG p.135) needs Flux or an
+     * astral doppelganger, which this engine does not model.
+     */
     checkWard(target) {
-        if (this.actor.plane === 'astral' && target.warded) {
-            if (this.actor.hasMetamagic('masking')) {
-                this.actor.performAction('slips a ward', target.name);
-                if (this.scene.isHumanControlled(this.actor)) {
-                    this.logger.logWithColor(`The ward tastes your aura and finds... weather. Masking carries you through.`, 'magenta');
-                }
-                return null;
-            }
-            this.actor.performAction('is repelled by a ward', target.name);
-            return `A ward seals ${target.name} -- the barrier flares at your touch and holds. No astral form passes without tearing it down.`;
+        if (this.actor.plane !== 'astral')
+            return null;
+        const ward = wardBetween(this.actor.currentLocation, target, this.actor);
+        if (!ward)
+            return null;
+        const press = pressThroughWard(this.scene, this.logger, this.actor, ward);
+        if (this.scene.isHumanControlled(this.actor))
+            this.logger.meta(press.meta);
+        if (!press.through) {
+            return `A ward seals ${ward.name} -- Force ${ward.wardForce}. You press against the lattice and it presses back; the astral does not pass${hint(` ("attack ward" tears at it instead)`)}.`;
         }
         return null;
     }

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

@@ -16,6 +16,7 @@ import { MARKS_TO_CONTROL } from './disable.js';
 import { nameableNames } from '../utilities/nameables.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS, markHackerFromDevice } from '../utilities/marks.js';
+import { ownerInformed } from '../utilities/owner-guard.js';
 import { actionRefusal, billAction } from '../utilities/action-cost.js';
 import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 import { declarationPenalty, parseMarkDeclaration, hostDefensePool, wanDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
@@ -323,9 +324,12 @@ export class HackCommand extends BypassCommand {
                     // exact moment they most need to know, since a blown Sleaze is
                     // what hands a mark to something that did not have one.
                     const marksOnMe = room.hostMarksOn.get(this.actor.name) ?? 0;
+                    // ...and its OWNER is told (owner-guard.ts; p.236).
+                    const told = ownerInformed(this.scene, room, this.actor, 'host-sleaze', hostLabel(room, { capital: true }));
                     return [
                         `${hostLabel(room, { capital: true })} turns and LOOKS AT YOU -- your Hack on the Fly unravels mid-handshake.`,
                         `  It holds ${marksOnMe === 1 ? 'a mark' : `${marksOnMe} marks`} on your persona now, it can see you, and everything guarding this place knows someone is on the grid. ("unmark me" scrubs it; so do "reboot" and "jack out", p.242.)`,
+                        ...(told ? [`  ${told}`] : []),
                         ...godLines,
                     ].join('\n');
                 }
@@ -410,6 +414,9 @@ export class HackCommand extends BypassCommand {
                     this.actor.sneaking = false;
                     room.hostAlert = true;
                     this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} takes a forced key -- alarm flagged, ice hunting.`, { plane: 'matrix' });
+                    const told = ownerInformed(this.scene, room, this.actor, 'attack-landed', hostLabel(room, { capital: true }));
+                    if (told)
+                        lines.push(`  ${told}`);
                 }
                 lines.push(...godLines);
                 this.scene.updateStatus();
@@ -507,6 +514,9 @@ export class HackCommand extends BypassCommand {
                 // under attack and screams to its owner -- it just can't see
                 // WHOSE hand did it).
                 this.actor.sneaking = false;
+                const told = ownerInformed(this.scene, room, this.actor, 'attack-landed', hostLabel(room, { capital: true }));
+                if (told)
+                    lines.push(`  ${told}`);
                 // A SUCCESSFUL ATTACK ACTION WAKES THE HOST (p.236: the target
                 // "becomes aware that it is under attack" though it does not
                 // automatically spot you; p.247: a host that notices something
@@ -765,7 +775,8 @@ export class HackCommand extends BypassCommand {
                 actor.sneaking = false;
                 // ...and it marks you (p.236) -- the trace a blown Sleaze leaves.
                 const onYou = markHackerFromDevice(actor, device.name, host);
-                const trace = ` It holds ${onYou} mark${onYou === 1 ? '' : 's'} on your deck now${hint(' ("mark" shows who holds you; a reboot or "unmark me" shakes it)')}.`;
+                const toldOwner = ownerInformed(this.scene, Object.values(allRooms).find(r => r.devices.includes(device)), actor, 'device-sleaze', device.name);
+                const trace = ` It holds ${onYou} mark${onYou === 1 ? '' : 's'} on your deck now${hint(' ("mark" shows who holds you; a reboot or "unmark me" shakes it)')}.${toldOwner ? ` ${toldOwner}` : ''}`;
                 if (host) {
                     host.hostAlert = true;
                     this.scene.addWorldEvent(`${device.name} flags a bad handshake -- ${hostLabel(host, { capital: true })} is awake.`, { plane: 'matrix' });
@@ -810,6 +821,9 @@ export class HackCommand extends BypassCommand {
             if (host)
                 host.hostAlert = true;
             actor.sneaking = false;
+            const told = ownerInformed(this.scene, Object.values(allRooms).find(r => r.devices.includes(device)), actor, 'attack-landed', device.name);
+            if (told)
+                lines.push(`  ${told}`);
         }
         else {
             const perception = freeMatrixPerceptionHits(netHits);

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

@@ -0,0 +1,23 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { ledgeDirection, ledgeJump } from '../utilities/ledge-jump.js';
+/**
+ * "leap off <direction>" (user ruling 2026-10-06): going over the edge of
+ * a balcony, catwalk or rooftop on purpose. The extra word is the safety
+ * catch -- a fall is never one mistyped direction away -- so a bare
+ * "leap north" is refused and told the full form. utilities/ledge-jump.ts
+ * does the drop and the landing.
+ */
+export class LeapCommand extends Command {
+    static verb = 'leap';
+    static description = 'Go over the edge of a balcony, catwalk or rooftop on purpose: "leap off <north|south|east|west>". You land on the outdoor ground below that spot and take the fall (SR5 p.172: more than 3 m is DV = metres, AP -4, Body + Armor).';
+    async execute(args = []) {
+        const [off, dirWord] = args.map(a => a.toLowerCase());
+        const dir = ledgeDirection(dirWord);
+        if (off !== 'off' || !dir) {
+            return `Leap where? ${hint(`"leap off <north|south|east|west>" -- the word off is on purpose: a drop is never one word away.`)}`;
+        }
+        return ledgeJump(this.scene, this.actor, dir);
+    }
+}
+//# sourceMappingURL=leap.js.map

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

@@ -507,6 +507,14 @@ export class LookCommand extends Command {
         const onDevice = findDeviceFile(this.actor, target);
         if (onDevice)
             return this.describeItem(onDevice.file, target);
+        // A FILE IN THE ARCHIVE YOU STAND IN, once it is found: Matrix
+        // Perception on the file (p.241-242) -- what turns up a data bomb.
+        const inHost = this.actor.hostInside;
+        if (inHost && (inHost.searchedBy.has(this.actor.name) || inHost.over.hostCracked)) {
+            const file = inHost.files().find(f => f.name.toLowerCase() === target.toLowerCase());
+            if (file)
+                return this.perceiveFile(file, target);
+        }
         const onGrid = room.inventory.getItem(target);
         if (onGrid?.plane === 'matrix') {
             const reach = fileReach(this.actor, room);
@@ -774,6 +782,38 @@ export class LookCommand extends Command {
     }
     /** The item's prose and stat block -- the same read for a thing in the
      *  bag, on the body, or on the floor. */
+    /**
+     * MATRIX PERCEPTION ON A HOST FILE (p.241; p.242: "a Data Bomb can be
+     * detected using Matrix Perception"). Computer + Intuition [Data
+     * Processing], a Complex Action; a bomb does not run silent, so it is
+     * not an opposed test -- one hit turns it up (p.235: each hit buys a
+     * piece of information). Protection needs no test: the file is a
+     * sealed block on its face, and the book's own refusal (p.239) tells
+     * anyone who tries.
+     */
+    perceiveFile(file, itemName) {
+        const bill = billAction(this.scene, this.actor, 'complex', 'Matrix Perception');
+        if (bill)
+            return bill;
+        const lines = [this.describeItem(file, itemName)];
+        if (file.protection > 0)
+            lines.push(`{light-blue-fg}  PROTECTED -- encrypted at rating ${file.protection}. "crack ${file.name}" breaks it (p.238).{/light-blue-fg}`);
+        if (file.dataBomb && !file.bombSeenBy.has(this.actor.name)) {
+            const computer = this.actor.skillRating('computer');
+            const pool = Math.max(1, this.actor.intuition + (computer > 0 ? computer : -1)
+                + this.actor.matrixActionPenalty + this.actor.woundModifier - this.actor.sustainingPenalty);
+            const roll = rollPool(pool, this.actor.matrixAttribute('dataProcessing'), { gremlins: this.actor.deckGremlins });
+            if (showsMechanics(this.scene, this.actor)) {
+                this.logger.meta(`${mechanicsActorPrefix(this.scene, this.actor)}Matrix Perception on ${file.name} -- Computer + Intuition [Data Processing]: ${formatRoll(roll)}`);
+            }
+            if (roll.hits > 0)
+                file.bombSeenBy.add(this.actor.name);
+        }
+        if (file.dataBomb && file.bombSeenBy.has(this.actor.name)) {
+            lines.push(`{red-fg}  DATA BOMB -- rating ${file.dataBomb.rating}${file.dataBomb.deletesFile ? ', set to take the file with it' : ''}. Touch it without the passcode and it goes off. "disarm ${file.name}" (p.239).{/red-fg}`);
+        }
+        return lines.join('\n');
+    }
     describeItem(item, itemName) {
         // A CODE ON THE PAGE IS A PERCEPTION TEST (Xxbwtgffkyq8uCHfR): a
         // scrap of paper with a combination on it is read here, not by