@maka/maka-cli 5.391.0 → 5.392.0

package/bundle/typescript/package.json

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

@@ -121,7 +121,7 @@ export class AssenseCommand extends Command {
         const room = actor.currentLocation;
         const lines = [header];
         lines.push(room.warded
-            ? `  • This place is WARDED -- an astral barrier seals it against projection.`
+            ? `  • This place is WARDED -- an astral barrier of Force ${room.wardForce} seals it against astral forms (bodies walk through it unhindered).`
             : `  • No wards here -- the astral is open ground.`);
         if (room.hasNode) {
             lines.push(`  • The room's tech hums with dataflow -- a live Matrix node (nothing astral, but a decker would care).`);

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

@@ -11,11 +11,13 @@ import { distanceMeters } from '../utilities/room-grid.js';
 import { wallsBetween } from '../utilities/district-plane.js';
 import { formatCoord, parseCoord } from '../utilities/barrier-geometry.js';
 import { resolveBarrierStrike, resolveCameraStrike, resolveSpellBarrierStrike } from '../utilities/barrier-combat.js';
+import { resolveWardStrike } from '../utilities/wards.js';
 import { isWatched, cameraWithinReach, cameraOutOfReach } from '../utilities/surveillance.js';
 import { matchesCameraName } from '../utilities/grid-names.js';
 import { billAction, notYourPhase, phaseHint } from '../utilities/action-cost.js';
 import { arenaOf, inArena } from '../utilities/combat-turn.js';
 import { spendMovementMeters } from '../utilities/movement-cost.js';
+import { ownerWitnesses } from '../utilities/owner-guard.js';
 /**
  * Shadowrun-style dice-pool combat, one full exchange per command:
  *
@@ -50,7 +52,7 @@ export class AttackCommand extends Command {
     async readyForStrike() {
         return {};
     }
-    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). "attack barrier [x,y]" breaks a face of a barrier spell.';
+    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). "attack barrier [x,y]" breaks a face of a barrier spell; from the astral, "attack ward" tears at a ward (Armor and Structure = its Force, p.316).';
     async execute(args = []) {
         if (!args || args.length === 0) {
             return 'Who do you want to attack? Try: `attack <name>`';
@@ -155,12 +157,36 @@ export class AttackCommand extends Command {
                     });
                     const lines = [...(drawn ? [`${this.actor.name} draws ${drawn.name}.`] : []), ...strike.world];
                     this.actor.performAction('attacks', `the ${lens.name}`);
+                    // Their camera, smashed in front of them (owner-guard.ts).
+                    const seenLens = ownerWitnesses(this.scene, room, this.actor, `the ${lens.name}`);
+                    if (seenLens)
+                        lines.push(seenLens);
                     this.scene.updateStatus();
                     const exchange = new CombatExchange(this.scene, this.logger, this.actor);
                     await exchange.announce(lines, strike.meta);
                     return this.scene.isHumanControlled(this.actor) ? '' : lines.join('\n');
                 }
             }
+            // A WARD (p.316): "attack ward" tears at the ward over the room you
+            // are in, or a warded room next to it ("attack ward over <room>").
+            // Astral only: to a bullet a ward is not there at all.
+            const wardWords = /^(?:the\s+)?ward(?:\s+(?:over|on|of|at)\s+(.+))?$/i.exec(targetName.trim());
+            if (wardWords) {
+                const picked = this.wardTarget(wardWords[1]);
+                if (typeof picked === 'string')
+                    return picked;
+                if (this.scene.encounterFor?.(this.actor)) {
+                    const bill = billAction(this.scene, this.actor, 'complex', 'Attack Ward', { attack: true });
+                    if (bill)
+                        return bill;
+                }
+                const strike = resolveWardStrike(this.scene, this.logger, this.actor, picked);
+                this.actor.performAction('attacks', `the ward over ${picked.name}`);
+                this.scene.updateStatus();
+                const exchange = new CombatExchange(this.scene, this.logger, this.actor);
+                await exchange.announce(strike.world, strike.meta);
+                return this.scene.isHumanControlled(this.actor) ? '' : strike.world.join('\n');
+            }
             // A BARRIER SPELL (2026-10-05; p.197-198, p.294, p.316): "attack
             // barrier" hits the nearest standing face you can see, "attack
             // barrier 3,5" the face holding that cell. A Physical Barrier is
@@ -235,6 +261,10 @@ export class AttackCommand extends Command {
                     });
                     const lines = [...(reach.line ? [reach.line] : []), ...(drawn ? [`${this.actor.name} draws ${drawn.name}.`] : []), ...strike.world];
                     this.actor.performAction('attacks', device.name);
+                    // Their lock, hit in front of them (owner-guard.ts).
+                    const seenDevice = ownerWitnesses(this.scene, room, this.actor, device.name);
+                    if (seenDevice)
+                        lines.push(seenDevice);
                     this.scene.updateStatus();
                     const exchange = new CombatExchange(this.scene, this.logger, this.actor);
                     await exchange.announce(lines, strike.meta);
@@ -601,6 +631,35 @@ export class AttackCommand extends Command {
         }
         return null;
     }
+    /**
+     * THE WARD THIS FORM CAN REACH: the one over the room it is in (sealed
+     * in), else a warded room through one of its ways (kept out). Named
+     * when there is more than one. A refusal string when there is none, or
+     * when the attacker is not on the astral.
+     */
+    wardTarget(named) {
+        if (this.actor.plane !== 'astral') {
+            return `A ward is woven mana on the astral -- ${this.actor.getCarriedWeapon()?.name ?? 'your fists'} would pass through it as if it were not there. Only an astral form can touch it (p.315).`;
+        }
+        const here = this.actor.currentLocation;
+        const near = here.warded ? [here] : [];
+        for (const exit of here.exits.values()) {
+            const other = typeof exit.getOtherSide === 'function'
+                ? exit.getOtherSide(here) : undefined;
+            if (other?.warded && !near.includes(other))
+                near.push(other);
+        }
+        if (named) {
+            const pick = fuzzyPickName(named, near.map(r => r.name));
+            const ward = pick ? near.find(r => r.name === pick) : undefined;
+            return ward ?? `No ward over "${named}" within reach.${near.length > 0 ? ` In reach: ${near.map(r => r.name).join(', ')}.` : ''}`;
+        }
+        if (near.length === 0)
+            return `No ward within reach -- the astral here is open ground.`;
+        if (near.length > 1 && !here.warded)
+            return `Which ward? ${near.map(r => `"attack ward over ${r.name}"`).join(', ')}.`;
+        return near[0];
+    }
     /**
      * "barrier", "the force wall", "mana barrier 3,5" -> the standing face
      * this actor would hit, or a refusal that says why not, or undefined

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

@@ -41,7 +41,7 @@ import { AFFORDANCE_FLAVOR } from '../utilities/affordances.js';
  */
 export class BluffCommand extends Command {
     static verb = 'bluff';
-    static description = 'Talk a PERSON round -- Charisma + con. Locks, wards and terminals have no opinion to change; work those with "pick", "hack" or "cast".';
+    static description = 'Talk a PERSON round -- Charisma + con. Locks and terminals have no opinion to change; work those with "pick" or "hack".';
     async execute(args = []) {
         // Fast-talk needs a face and a voice on the scene -- your meat ones.
         if (this.actor.plane === 'matrix') {

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

@@ -2,6 +2,7 @@ import { BypassCommand } from './bypass-command.js';
 import { Door } from '../models/door.js';
 import { ensureAtExit } from '../utilities/spots.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
+import { ownerWitnesses } from '../utilities/owner-guard.js';
 /**
  * The FORCEFUL route past a physical barrier (player ruling: "solve" was
  * too broad -- a maglock wants finesse OR muscle, and muscle deserves its
@@ -119,7 +120,8 @@ export class BreachCommand extends BypassCommand {
         const where = String(direction).toLowerCase();
         if (!gave) {
             this.actor.performAction('throws a shoulder at', `the ${where} door, and it holds`);
-            return `${crossNote}${this.failureFlavor}`;
+            const seen = ownerWitnesses(this.scene, room, this.actor, `the ${where} door`);
+            return `${crossNote}${this.failureFlavor}${seen ? `\n  ${seen}` : ''}`;
         }
         door.isLocked = false;
         this.actor.sneaking = false;
@@ -128,7 +130,8 @@ export class BreachCommand extends BypassCommand {
         this.scene.raiseAlarm(`${this.actor.name} breached the ${where} door in ${room.name} -- the crash carried`);
         this.scene.addWorldEvent(`${this.actor.name} breached the ${where} door in ${room.name} -- the crash carried.`);
         this.game?.addHeat(2, `breached the ${where} door`);
-        return `${crossNote}${this.successFlavor}\n  The crash CARRIES -- anyone nearby knows exactly where you are now.`;
+        const seen = ownerWitnesses(this.scene, room, this.actor, `the ${where} door`);
+        return `${crossNote}${this.successFlavor}\n  The crash CARRIES -- anyone nearby knows exactly where you are now.${seen ? `\n  ${seen}` : ''}`;
     }
     async determineOutcome() {
         // Raw muscle -- Strength + Body, 2 hits to give. No skill governs

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

@@ -1,6 +1,7 @@
 import { Command } from './command.js';
 import { ensureAtSpot, ensureAtExit } from '../utilities/spots.js';
 import { applyDeviceOpened } from '../utilities/devices.js';
+import { ownerWitnesses } from '../utilities/owner-guard.js';
 /**
  * Shared implementation for pick/breach/hack/cast/dispel -- FORCING a
  * device rather than opening it the way it was meant to open.
@@ -257,6 +258,11 @@ export class BypassCommand extends Command {
         }
         this.logger.write(`${this.actor.name} attempted to ${this.verbName} "${device.name}": ${result.success ? 'success' : 'failure'}${result.alarmed ? ' (alarmed)' : ''}`);
         this.actor.performAction(this.verbName, result.message);
+        // THE OWNER WATCHING (owner-guard.ts): picking, breaching or forcing
+        // their lock in front of them turns them. A key or a keycard is the
+        // legitimate way through and is not a hostile act.
+        const seen = this.verbName === 'use' ? undefined : ownerWitnesses(this.scene, room, this.actor, device.name);
+        const ownerLine = seen ? `\n  ${seen}` : '';
         if (result.alarmed) {
             this.actor.sneaking = false;
             const teeth = await this.onForceFailure();
@@ -268,9 +274,9 @@ export class BypassCommand extends Command {
                 // promising a permanence that no longer exists.
                 `  It holds. You can try again, but the noise has already carried.`,
                 ...teeth,
-            ].join('\n');
+            ].join('\n') + ownerLine;
         }
-        return crossNote + [result.message, ...consequence].join('\n');
+        return crossNote + [result.message, ...consequence].join('\n') + ownerLine;
     }
 }
 //# sourceMappingURL=bypass-command.js.map

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

@@ -9,7 +9,7 @@ import { isOutdoorsPlace } from '../utilities/outdoors.js';
 import { readEarshot } from '../utilities/earshot.js';
 import { firstReachable } from '../utilities/spots.js';
 import { meetLocationFor } from '../utilities/meet-location.js';
-import { partyCanDeck, partyCanDispel } from '../factories/scene-chunks.js';
+import { partyCanDeck } from '../factories/scene-chunks.js';
 import { requirementLine } from '../factories/job-order.js';
 import { readJobAsk, fixerMenuLine, fixerPickupLine, fixerPickupNote, commissionFromFixer } from '../utilities/fixer-menu.js';
 import { RecallCommand } from './companions.js';
@@ -543,7 +543,9 @@ export class CallCommand extends Command {
                 // against the caller, not the crew -- a hired seat's gear is
                 // not knowable from the dossier, so the line says "put one on
                 // the crew" and lets the player judge whether they already did.
-                const lacks = (pending.requires ?? []).filter((r) => r === 'decker' ? !partyCanDeck(this.actor) : !partyCanDispel(this.actor));
+                // A 'mage' an older pending job still carries is dropped: it was
+                // the door-ward requirement, and a ward stops no body any more.
+                const lacks = (pending.requires ?? []).filter((r) => r === 'decker' && !partyCanDeck(this.actor));
                 const needsLine = requirementLine(lacks);
                 // WETWORK IS SAID OUT LOUD (user ruling 2026-09-24; SR5 p.336:
                 // "one or more runners refuse 'wetwork'"). The flag is

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

@@ -1,5 +1,5 @@
 import { sustainBurden } from '../utilities/sustaining.js';
-import { BypassCommand } from './bypass-command.js';
+import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { CombatExchange } from '../utilities/combat-exchange.js';
 import { rollPool, formatRoll, rollD6Total } from '../utilities/dice.js';
@@ -87,125 +87,29 @@ const COMBAT_SPELL_FLAVOR = {
  * Gear-driven spellcasting (see Player's magic section): you know a spell
  * if you carry its SpellFormula (or any Grimoire), and the best Focus on
  * you scales the casting pool. "cast <spell> [at <target>]" casts; a bare
- * "cast" (or "cast <direction/barrier>") is still the ward-bypass route
- * inherited from BypassCommand -- now gated on actually having magic gear,
- * instead of being a free-floating coin flip anyone could attempt.
+ * A WARD IS NOT CAST AT (user 2026-10-06): it is an astral barrier over a
+ * room (utilities/wards.ts), pressed through or attacked from the astral --
+ * never a door this verb unweaves.
  */
 /**
  * BLIND FIRE (p.178): "the same as the Total Darkness modifier", -6 -- the
  * number p.197 gives for a target completely hidden from the attacker.
  */
 const BLIND_FIRE = -6;
-export class CastCommand extends BypassCommand {
+export class CastCommand extends Command {
     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. Barriers take map coordinates: "cast barrier 3 3,4 3,6" (a wall), "cast barrier 3 5,5" (a dome), "cast barrier east 2". Area spells too: "cast fireball 4 at 12,7" (a point) or "cast fireball 4 at <someone>" -- Force m around it, friend and foe. A ward is "dispel <direction>".';
-    deviceKind = 'ward';
-    verbName = 'cast';
+    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. Barriers take map coordinates: "cast barrier 3 3,4 3,6" (a wall), "cast barrier 3 5,5" (a dome), "cast barrier east 2". Area spells too: "cast fireball 4 at 12,7" (a point) or "cast fireball 4 at <someone>" -- Force m around it, friend and foe.';
     /** The bolt in flight is at someone the caster cannot see (castCombatSpell). */
     unseenTarget = false;
-    noDeviceMessage = "There's nothing here to cast at.";
-    /** Backlash drain when a ward-bypass fails -- resisted with Willpower,
-     * like any drain. The nastiest drain in the game: forcing a hostile
-     * ward is harder on the caster than any spell of their own. */
-    static BACKLASH_DRAIN = 4;
-    /**
-     * The ward-bypass outcome is a real SPELLCASTING test now, not the
-     * legacy coin flip (a real session died to a 50/50 that ignored Magic 6
-     * + spellcasting entirely): the full casting pool -- Magic +
-     * spellcasting (or the book-caster's base), best focus, wounds,
-     * sustaining -- needs 2 hits to unweave the barrier, same threshold as
-     * pick/hack/bluff.
-     */
-    async determineOutcome() {
-        const pool = Math.max(1, this.actor.getMagicPool());
-        const roll = rollPool(pool);
-        if (this.scene.isHumanControlled(this.actor)) {
-            this.logger.meta(`Spellwork: ${formatRoll(roll)} (2+ to unweave)`);
-        }
-        return roll.hits >= 2;
-    }
-    /**
-     * A failed unweaving isn't quiet OR free: the ward's backlash is drain
-     * (BACKLASH_DRAIN, resisted with Willpower like any drain), landing on
-     * the real stun track with overflow into physical. Enough of it still
-     * knocks out or kills -- but through dice and the condition monitors,
-     * the same death any spell drain earns, not by fiat.
-     */
-    async onForceFailure() {
-        const actor = this.actor;
-        // Centering (metamagic, p.325): +grade dice on every drain resist --
-        // the chant that keeps the backlash outside the skull.
-        const resist = rollPool(actor.willpower + (actor.hasMetamagic('centering') ? actor.initiationGrade : 0));
-        const taken = Math.max(0, CastCommand.BACKLASH_DRAIN - resist.hits);
-        const lines = [
-            `  The barrier's backlash arcs up your own weave:`,
-        ];
-        // Roll anatomy to the ticker for the player; an NPC keeps it in the
-        // returned lines that feed its own AI history (readability pass).
-        const backlashRoll = `Backlash (${CastCommand.BACKLASH_DRAIN}): resist ${formatRoll(resist)}`;
-        if (this.scene.isHumanControlled(actor))
-            this.logger.meta(backlashRoll);
-        else
-            lines.push(`  ${backlashRoll}`);
-        if (taken === 0) {
-            lines.push(`  You ground it out through clenched teeth -- shaken, but standing.`);
-            return lines;
-        }
-        const { stun, overflow } = actor.takeStun(taken);
-        this.logger.write(`${actor.name} took ${taken} ward backlash (stun ${actor.stunTaken}/${actor.maxStunBoxes}, overflow ${overflow}).`);
-        lines.push(`  It burns through you -- ${stun} stun: ${actor.stunSummary()}`);
-        if (overflow > 0) {
-            lines.push(`  More than your mind can hold -- ${overflow} box${overflow === 1 ? '' : 'es'} spill into your body: ${actor.conditionSummary()}`);
-        }
-        // Backlash can still finish you -- through the tracks, same flows as
-        // spell drain (cast.ts drainCollapse) and the stim crash (use.ts).
-        if (actor.isIncapacitated()) {
-            const human = this.scene.isHumanControlled(actor);
-            const dead = actor.isDown();
-            if (human) {
-                if (dead) {
-                    // A runner past the track goes through the one door every
-                    // runner death takes (CombatExchange.resolveDeath): down and
-                    // bleeding short of Body overflow (p.170), and at death's door
-                    // -- DocWagon, Not Dead Yet, the banner -- past it. This called
-                    // endGame straight off a full track, and only for the primary.
-                    const exchange = new CombatExchange(this.scene, this.logger, actor);
-                    lines.push(...await exchange.resolveDeath(actor, actor, {
-                        fallLine: `The weave snaps back through every nerve at once. The last thing you feel is the barrier holding.`,
-                        gameOverLine: `💀 GAME OVER: the ward's backlash burned ${actor.name} out from the inside.`,
-                        cause: `a ward's backlash`,
-                    }));
-                }
-                else {
-                    // A stun KO defers to the room (RAW p.379/p.207, see
-                    // Scene.beginPlayerKnockout): a ward has no legs -- alone, the
-                    // player simply comes to at its foot; with hostiles about, the
-                    // street still gets its say.
-                    this.scene.addWorldEvent(`${actor.name} was knocked cold by a ward's backlash in ${actor.currentLocation.name}.`);
-                    lines.push('', `The world grays out -- the ward stands over you, humming, as everything goes dark.`);
-                    this.scene.beginPlayerKnockout([], actor);
-                }
-            }
-            else {
-                this.scene.addWorldEvent(dead
-                    ? `${actor.name} was killed by a ward's backlash in ${actor.currentLocation.name}.`
-                    : `${actor.name} was knocked cold by a ward's backlash in ${actor.currentLocation.name}.`);
-                if (dead)
-                    this.scene.removeActor(actor.name);
-                lines.push('', `${actor.name} drops at the barrier's foot, ${dead ? 'dead before they land' : 'out cold'}.`);
-            }
-        }
-        return lines;
-    }
     async execute(args = []) {
         // Incantations carry -- casting ends a sneak (see sneak.ts).
         this.actor.sneaking = false;
         // "cast increase reflexes ..." -- the natural phrasing for the spell
         // whose key is 'reflexes'; strip the qualifier before resolution or
-        // the whole phrase falls through to the ward-bypass path.
+        // the whole phrase reads as no spell at all.
         let words = args ?? [];
         if (words[0]?.toLowerCase() === 'increase' && words[1]?.toLowerCase().startsWith('reflex')) {
             words = words.slice(1);
@@ -228,18 +132,17 @@ export class CastCommand extends BypassCommand {
         if (!this.actor.isCaster()) {
             return `Casting takes talent you don't have -- you'd need to be Awakened, or have a spell formula, grimoire, or focus on you.`;
         }
-        // "CAST <DIRECTION>" IS GONE (user ruling 2026-10-05): it used to
-        // unweave a ward on that exit, which is DISPEL's job and now only
-        // dispel's. A direction gets pointed at both verbs it might mean;
-        // anything else is not a spell this caster knows.
+        // "CAST <DIRECTION>" IS GONE (user ruling 2026-10-05), and a ward is
+        // not a door any more (2026-10-06): a direction gets the barrier
+        // spell it might mean; anything else is not a spell this caster knows.
         const first = words[0]?.toLowerCase();
         if (!first) {
             return `Cast what? "spells" lists what you know -- "cast <spell> [force] ...".`;
         }
         if (this.isValidDirection(first)) {
-            return `To unweave a ward that way, "dispel ${first}". To wall the way off, "cast barrier ${first} [cells]".`;
+            return `To wall the way off, "cast barrier ${first} [cells]".`;
         }
-        return `"${words.join(' ')}" isn't a spell you know. "spells" lists them; a ward is "dispel <it>".`;
+        return `"${words.join(' ')}" isn't a spell you know. "spells" lists them.`;
     }
     /**
      * ONE REFUSAL FOR THE ASPECT, wherever it is reached from -- the
@@ -254,8 +157,7 @@ export class CastCommand extends BypassCommand {
     /**
      * Lenient spell-name matching: the exact key, or a unique fragment of at
      * least 3 characters ("bolt"/"mana" -> manabolt). Anything that doesn't
-     * resolve falls through to the ward-bypass path, which is what a
-     * direction or barrier name ("cast north", "cast maglock") needs.
+     * resolve is answered as not a spell this caster knows.
      */
     resolveSpellName(arg) {
         const wanted = arg?.toLowerCase();
@@ -291,7 +193,7 @@ export class CastCommand extends BypassCommand {
         }
         // NOT A SHOPPING PROBLEM (EL9pWnQe3w5PieogT, found reading this
         // item's own bench). The aspect refusal above only guards the
-        // ward-bypass path -- the one a spell NAME never reaches -- so a
+        // non-spell path -- the one a spell NAME never reaches -- so a
         // named spell fell through to the line below and told a Conjurer to
         // go and buy a formula or a grimoire. p.69 says neither will ever
         // work for them: the formula stands in for the SKILL, and the skill
@@ -381,31 +283,6 @@ export class CastCommand extends BypassCommand {
         }
         return { target };
     }
-    /**
-     * Does this string name a WARD in the room? Checked only AFTER actor
-     * matching fails, so a person's name always wins. Matches the exit it
-     * holds, its own name, a noun from its description, or -- with
-     * exactly one ward here -- a generic barrier word.
-     */
-    findSpellBarrier(rawInput) {
-        const raw = rawInput.trim().toLowerCase();
-        const room = this.actor.currentLocation;
-        const targets = (room?.openableDevices() ?? []).filter(d => d.kind === 'ward');
-        if (targets.length === 0)
-            return undefined;
-        if (this.isValidDirection(raw))
-            return targets.find(d => d.opensExit === raw);
-        if (raw.length < 3)
-            return undefined;
-        const named = targets.filter(d => d.name.toLowerCase().includes(raw)
-            || d.description.toLowerCase().includes(raw));
-        if (named.length === 1)
-            return named[0];
-        if (targets.length === 1 && /^(the )?(lock|door|ward|barrier|seal|gate|hatch|glyph|field|sigil|way)$/.test(raw)) {
-            return targets[0];
-        }
-        return undefined;
-    }
     /** How the caster's pool reads in narration: focus-assisted, raw talent, or book-learned. */
     castingLabel() {
         const focus = this.actor.getBestFocus();
@@ -604,17 +481,6 @@ export class CastCommand extends BypassCommand {
         const pickedName = fuzzyPickName(targetName, candidates.map(a => a.name));
         const target = pickedName ? candidates.find(a => a.name === pickedName) : undefined;
         if (!target) {
-            // A WARDED BARRIER is a legal target (a real session tried "cast
-            // manabolt at hatch", "at lock", "at down" and bounced on all
-            // three): when the words name no person but DO name a spell-keyed
-            // barrier here -- by direction, title, or a noun from its own
-            // description -- the cast routes to the ward test. The specific
-            // spell doesn't matter: "show us your spark" wants spellwork, and
-            // the bypass rolls the full casting pool.
-            const barrier = this.findSpellBarrier(targetName);
-            if (barrier) {
-                return super.execute([barrier.opensExit ?? barrier.name]);
-            }
             // Visible on another plane beats "no one" -- an astral caster CAN
             // see the meat target they're aiming at; name the actual rule
             // (see planes.crossPlaneRefusal).
@@ -1273,8 +1139,8 @@ export class CastCommand extends BypassCommand {
      * of each per caster; casting again replaces the standing one, with a
      * fresh roll and fresh drain. -2 sustaining like every held weave.
      *
-     * Bare "cast north" no longer reaches a ward from here -- that is
-     * "dispel north" (user ruling 2026-10-05).
+     * Bare "cast north" reaches no ward: a ward is a room's astral barrier
+     * now (utilities/wards.ts), not a door (user rulings 2026-10-05/06).
      */
     async castBarrier(spellKey, force, overcast, rest, 
     /** Set when no Force was named: the talent a sized cast may reach. */

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

@@ -0,0 +1,76 @@
+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 { overwatchFromDefense } from '../utilities/matrix-intrusion.js';
+import { accrueOverwatch } from '../utilities/overwatch.js';
+import { leaveMatrix } from '../utilities/planes.js';
+import { hostLabel } from '../utilities/grid-names.js';
+import { pickHostFile } from '../utilities/file-guard.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
+/**
+ * CRACK FILE (SR5 p.238, RAG-checked 2026-10-06): "removes the protection
+ * from a file, making it readable". Complex Action, Marks Required 1,
+ * Hacking + Logic [Attack] v. Protection Rating x 2. An Attack action
+ * (p.244), so GOD bills the defence hits (p.231-232). No penalty on a
+ * miss beyond that bill, and -- not being on p.242's trigger list -- it
+ * never sets off a data bomb.
+ *
+ * The mark is the host's, the stand-in edit-file.ts already uses for a
+ * mark on a file inside it.
+ */
+export class CrackCommand extends Command {
+    static verb = 'crack';
+    static description = 'Crack File (SR5 p.238, Complex Action): "crack <file>" -- Hacking + Logic [Attack] v. the file\'s Protection x 2, from inside the host with a mark on it. An Attack action: GOD counts the defence hits. A cracked file can be read, copied and erased.';
+    async execute(args = []) {
+        const actor = this.actor;
+        const found = pickHostFile(actor, args.join(' ').trim(), 'crack');
+        if (typeof found === 'string')
+            return found;
+        const { host, file } = found;
+        const room = host.over;
+        if (!file.protection) {
+            return `${file.name} carries no protection -- nothing to crack.${file.dataBomb && file.bombSeenBy.has(actor.name) ? hint(` (The bomb on it is another matter: "disarm ${file.name}".)`) : ''}`;
+        }
+        if ((room.hostMarksBy.get(actor.name) ?? 0) < 1) {
+            return `Crack File needs a MARK (p.238) -- you hold none on ${hostLabel(room)}. ${hint(`"hack" the host for one.`)}`;
+        }
+        const burned = actor.burnedAttributeRefusal('attack');
+        if (burned)
+            return burned;
+        const bill = billAction(this.scene, actor, 'complex', 'Crack File');
+        if (bill)
+            return bill;
+        const hacking = actor.skillRating('hacking');
+        const grid = gridActionModifier(actor.currentGrid, !!actor.hostInside, actor.currentGrid);
+        const pool = Math.max(1, actor.logic + (hacking > 0 ? hacking : -1) + actor.bonus('hacking')
+            + actor.matrixActionPenalty + grid.total + actor.woundModifier - actor.sustainingPenalty);
+        const attempt = rollPool(pool, actor.matrixAttribute('attack'), { gremlins: actor.deckGremlins });
+        const resist = rollPool(file.protection * 2);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Crack File -- Hacking + Logic [Attack]: ${formatRoll(attempt)}`);
+            this.logger.meta(`  v. ${file.name}'s Protection ${file.protection} x 2: ${formatRoll(resist)}`);
+        }
+        actor.performAction('cracks a file', `${file.name} in ${hostLabel(room)}`, { quiet: this.scene.isHumanControlled(actor) });
+        const god = this.godBill(overwatchFromDefense(resist.hits), 'Crack File (attack)');
+        const tail = god.length > 0 ? `\n${god.join('\n')}` : '';
+        if (attempt.hits <= resist.hits) {
+            this.logger.write(`${actor.name} failed to crack "${file.name}" in ${room.name}: ${attempt.hits} v ${resist.hits}.`);
+            return `The encryption holds -- ${file.name} stays a sealed block of noise.${hint(` (Try again; each attempt is a Complex Action.)`)}${tail}`;
+        }
+        file.protection = 0;
+        this.logger.write(`${actor.name} cracked "${file.name}" in ${room.name}: ${attempt.hits} v ${resist.hits}.`);
+        this.scene.updateStatus();
+        return `{light-blue-fg}The protection on ${file.name} unravels -- the file reads clean now.{/light-blue-fg}${tail}`;
+    }
+    /** GOD's bill, and the forced dump when it converges (erase-mark.ts). */
+    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;
+    }
+}
+//# sourceMappingURL=crack.js.map

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

@@ -4,7 +4,7 @@ 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, stillWatching } from '../utilities/surveillance.js';
+import { isWatched, lensMaster, stillWatching } from '../utilities/surveillance.js';
 import { deviceDefensePool, wanDefensePool } from '../utilities/matrix-intrusion.js';
 import { accrueOverwatch } from '../utilities/overwatch.js';
 import { leaveMatrix, leaveDrone } from '../utilities/planes.js';
@@ -17,6 +17,7 @@ import { MAX_MARKS } from '../utilities/marks.js';
 import { deviceMaster, wanDevices } from '../utilities/wan.js';
 import { sameHostSide } from '../models/player.js';
 import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
+import { ownerInformed } from '../utilities/owner-guard.js';
 /** The marks Control Device wants for a Simple device action (p.238). */
 export const MARKS_TO_CONTROL = 2;
 export class DisableCommand extends Command {
@@ -68,8 +69,37 @@ export class DisableCommand extends Command {
         // 1. A CAMERA of the room the persona is over / inside -- by its own
         //    name ("north camera"), or "camera"/"cameras" for the first lens
         //    still recording. One lens per action (p.238-239).
-        const camRoom = actor.insideHost ?? (actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation);
-        const namedLens = isWatched(camRoom) ? camRoom.cameraNamed(named) : undefined;
+        // INSIDE A HOST, ITS CAMERA WAN IS EVERY LENS SLAVED TO IT, wherever
+        // the lens hangs (surveillance.ts lensMaster; user 2026-10-06: a
+        // camera on the strip outside a shop is the shop's) -- and not a lens
+        // on its own floor that an author slaved to some other host.
+        const inside = actor.insideHost;
+        if (inside) {
+            const slaved = [];
+            for (const r of [inside, ...Object.values(rooms).filter(r => r !== inside)]) {
+                if (!isWatched(r))
+                    continue;
+                for (const c of r.ensureCameras())
+                    if (lensMaster(rooms, r, c) === inside)
+                        slaved.push({ room: r, camera: c });
+            }
+            const namedHit = slaved.find(s => s.room.cameraNamed(named) === s.camera);
+            if (namedHit || matchesCameraName(named)) {
+                if (slaved.length === 0)
+                    return `No cameras answer to ${hostLabel(inside)} -- nothing to loop.`;
+                const pick = namedHit ?? slaved.find(s => s.camera.working) ?? slaved.find(s => !s.camera.destroyed && !s.camera.bricked);
+                if (!pick)
+                    return `Every lens slaved to ${hostLabel(inside)} is already dead -- smashed or bricked, no icon left to order.`;
+                if (pick.camera.destroyed)
+                    return `The ${pick.camera.name} is smashed -- glass and a dangling cable. No icon left to reach.`;
+                // The WAN order loops the picked lens's room, one room per order,
+                // so the report below can say which room went blind.
+                const wan = namedHit ? undefined : slaved.filter(s => s.room === pick.room && s.camera.working).map(s => s.camera);
+                return { kind: 'camera', room: pick.room, camera: pick.camera, master: inside, ...(wan && wan.length > 1 ? { wan } : {}) };
+            }
+        }
+        const camRoom = inside ?? (actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation);
+        const namedLens = !inside && isWatched(camRoom) ? camRoom.cameraNamed(named) : undefined;
         if (namedLens || matchesCameraName(named)) {
             if (!isWatched(camRoom))
                 return `No cameras on ${camRoom.name} -- nothing to loop.`;
@@ -80,8 +110,7 @@ export class DisableCommand extends Command {
             // A lens shot off the wall is not on the grid at all.
             if (camera.destroyed)
                 return `The ${camera.name} is smashed -- glass and a dangling cable. No icon left to reach.`;
-            const wan = !namedLens && actor.insideHost === camRoom ? cams.filter(c => c.working) : undefined;
-            return { kind: 'camera', room: camRoom, camera, master: cameraMasterHost(rooms, camRoom), ...(wan && wan.length > 1 ? { wan } : {}) };
+            return { kind: 'camera', room: camRoom, camera, master: lensMaster(rooms, camRoom, camera) };
         }
         // 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
@@ -92,7 +121,6 @@ export class DisableCommand extends Command {
         const matching = (entries, inHost = false) => entries.filter(({ device: d }) => d.rating > 0 && d.hasIconFor(actor.name, inHost) && (d.name.toLowerCase().includes(raw)
             || (d.opensExit ?? '').toLowerCase() === raw
             || d.description.toLowerCase().includes(raw)));
-        const inside = actor.insideHost;
         if (inside) {
             const matches = matching(wanDevices(rooms, inside), true);
             if (matches.length === 1)
@@ -252,6 +280,14 @@ export class DisableCommand extends Command {
                 host.host?.spotted.add(actor.name);
             }
         }
+        // THE PLACE'S OWNER is told too (owner-guard.ts): a blown Control
+        // Device hands them the mark; a landed Data Spike raises the alarm.
+        if (t.kind === 'device' || t.kind === 'camera') {
+            const what = t.kind === 'device' ? t.device.name : `The ${t.room.name} cameras`;
+            const told = ownerInformed(this.scene, t.room, actor, made ? 'device-sleaze' : 'attack-landed', what);
+            if (told)
+                this.logger.logWithColor(told, 'yellow');
+        }
         if ((t.kind === 'gun' || t.kind === 'implant') && 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');