@maka/maka-cli 5.390.0 → 5.392.0

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-seed-generator.js

@@ -3,12 +3,15 @@ import path from 'path';
 import { AI } from '../../../../tools/ai/ai.class.js';
 import { Player } from '../models/player.js';
 import { Room } from '../models/room.js';
+import { deviceMaster } from '../utilities/wan.js';
 import { Logger } from '../utilities/logger.js';
-import { clampDeviceKind } from '../utilities/affordances.js';
+import { clampDeviceKind, isWardDevice } from '../utilities/affordances.js';
+import { wardDevicesToRooms } from './seed-migration.js';
 import { GenerationCapture } from '../utilities/generation-capture.js';
 import { fetchCanonContext } from '../utilities/canon-lore.js';
 import { providerUnavailable } from '../utilities/draft-failure-note.js';
 import { SceneSynthesizer } from './scene-factory.js';
+import { resolveCatalogItemSeed } from './catalog-item-seed.js';
 import { gridDefects } from '../game-master/diagnose.js';
 import { rollTwist, sizeForTier, pickJobKind, shapeFor } from './job-order.js';
 import { chapterJobKind } from './operation.js';
@@ -467,6 +470,76 @@ export class SceneSeedGenerator {
         this.validateRewardItemPlacement(candidate);
         this.validateDevicePlacement(candidate);
     }
+    /**
+     * EVERY FAULT, NOT THE FIRST (player-built runs, 2026-10-06). The same
+     * gate dryRunValidate runs, for a seed somebody is EDITING: an author
+     * fixes faults one pass at a time only if they can see them all, so
+     * each check here is caught and recorded instead of ending the audit.
+     *
+     * Works on a copy -- clampDeviceKinds repairs its input, and an
+     * editor's seed is the author's, not the validator's. Structure and
+     * synthesis still stop the audit: every check after them reads the
+     * built scene or assumes named rooms, and would only echo the first
+     * fault in another voice. The built Scene comes back for a caller
+     * that wants to draw it.
+     */
+    static async auditSeed(seed, player) {
+        const candidate = structuredClone(seed);
+        const message = (err) => (err instanceof Error ? err.message : String(err));
+        // CATALOG SLUGS FIRST: a slug-only item has no name until its row is
+        // read, and the structure check below would call it nameless. Each
+        // bad slug is its own fault, and the item is left out of the build so
+        // the rest of the run is still checked.
+        const slugFaults = [];
+        candidate.items = (candidate.items ?? []).flatMap(item => {
+            try {
+                return [resolveCatalogItemSeed(item)];
+            }
+            catch (err) {
+                slugFaults.push({ check: 'items', message: message(err) });
+                return [];
+            }
+        });
+        try {
+            this.validateBasicStructure(candidate);
+        }
+        catch (err) {
+            return { faults: [...slugFaults, { check: 'structure', message: message(err) }] };
+        }
+        const nexus = new Room({ name: 'Nexus', description: 'A featureless room where lost souls drift.', roomType: 'void' });
+        const throwawayPlayer = new Player({ playerName: candidate?.player?.name || 'Maka', startLocation: nexus });
+        let built;
+        try {
+            built = await SceneSynthesizer.synthesizeFromJson(candidate, throwawayPlayer, false);
+        }
+        catch (err) {
+            return { faults: [...slugFaults, { check: 'synthesis', message: message(err) }] };
+        }
+        const faults = [
+            ...slugFaults,
+            ...built.planeFaults().map(f => ({ check: 'plane', message: f })),
+        ];
+        const checks = [
+            ['clues', () => this.validateClueItems(candidate, built)],
+            ['winCondition', () => this.validateWinCondition(candidate, player)],
+            ['client', () => this.validateClient(candidate)],
+            ['matrix', () => this.validateMatrixDefense(candidate)],
+            ['startingItems', () => this.validateStartingItems(candidate, player)],
+            ['devices', () => this.clampDeviceKinds(candidate)],
+            ['doorKeys', () => this.validateDoorKeys(candidate)],
+            ['rewardItem', () => this.validateRewardItemPlacement(candidate)],
+            ['devicePlacement', () => this.validateDevicePlacement(candidate)],
+        ];
+        for (const [check, run] of checks) {
+            try {
+                run();
+            }
+            catch (err) {
+                faults.push({ check, message: message(err) });
+            }
+        }
+        return { faults, built };
+    }
     /**
      * The one structural guarantee every other check assumes: every room,
      * NPC, and item actually has a real, non-blank "name". Nothing about the
@@ -632,6 +705,25 @@ export class SceneSeedGenerator {
                 edges.push({ a: room.name, b: exit.targetRoom, keyRequired: exit.keyRequired, puzzle: exit.puzzle });
             }
         }
+        // OUTDOOR SEAMS ARE WALKED, NOT DOORS (user rulings 2026-10-06: a space
+        // drawn on the ground joins it seamlessly, and spaces that touch join
+        // each other): two outdoor areas on one storey whose footprints
+        // overlap or meet edge to edge are open ground between them
+        // (move.ts crossOutdoorSeam), with no exit declared and none needed.
+        const outdoor = rooms.filter(r => r.outdoors && r.footprint);
+        for (let i = 0; i < outdoor.length; i++) {
+            for (let j = i + 1; j < outdoor.length; j++) {
+                const a = outdoor[i];
+                const b = outdoor[j];
+                if ((a.storey ?? 0) !== (b.storey ?? 0))
+                    continue;
+                const fa = a.footprint;
+                const fb = b.footprint;
+                if (fa.x <= fb.x + fb.w && fb.x <= fa.x + fa.w && fa.y <= fb.y + fb.h && fb.y <= fa.y + fa.h) {
+                    edges.push({ a: a.name, b: b.name });
+                }
+            }
+        }
         reachable.add(startRoom);
         let grew = true;
         while (grew) {
@@ -865,6 +957,18 @@ export class SceneSeedGenerator {
      * SYSTEM", which is backwards for a physical mechanism.
      */
     static clampDeviceKinds(candidate) {
+        // A WARD IS A ROOM'S (user 2026-10-06): anything written or read as
+        // one is moved onto the room it protects first, so the clamp below
+        // never turns it into a lock or a panel.
+        for (const room of candidate.rooms ?? []) {
+            for (const device of room.devices ?? []) {
+                if (isWardDevice(device.kind, device.name, device.description))
+                    device.kind = 'ward';
+            }
+        }
+        const moved = wardDevicesToRooms(candidate);
+        candidate.rooms = moved.rooms;
+        candidate.items = moved.items;
         for (const room of candidate.rooms ?? []) {
             for (const device of room.devices ?? []) {
                 const clamped = clampDeviceKind(device.kind, device.name, device.description);
@@ -950,8 +1054,24 @@ export class SceneSeedGenerator {
      * documentation -- finding it and seeing its name on screen already
      * reveals the answer. A Book clue is still required for anything else.
      */
-    static validateClueItems(candidate) {
+    static validateClueItems(candidate, built) {
         const items = candidate.items ?? [];
+        // THE HOST'S OWNER KNOWS IT (user ruling 2026-10-06: "circumvented if
+        // the keypad is connected to a host -> room -> room owner"). A panel
+        // slaved to a host whose room has an owner in the cast has its code
+        // in somebody's head (NPC hostCodeNote) -- social or violent, the way
+        // to it exists. Asked of the BUILT scene, so the master is the
+        // engine's own wiring (wan.ts deviceMaster, nearest-host default
+        // included); without one -- generation -- the rule is unchanged.
+        const knownToOwner = (roomName, deviceName) => {
+            if (!built)
+                return false;
+            const rooms = built.getRooms();
+            const room = Object.values(rooms).find(r => r.name === roomName);
+            const device = room?.allDevices().find(d => d.name === deviceName);
+            const master = room && device ? deviceMaster(rooms, room, device) : undefined;
+            return !!master?.owner && !!built.getActor(master.owner);
+        };
         for (const room of candidate.rooms ?? []) {
             for (const device of room.devices ?? []) {
                 // ONLY A PANEL HAS A CODE TO WRITE DOWN. A lock's findable way
@@ -979,7 +1099,7 @@ export class SceneSeedGenerator {
                 // playing, and so look like random flakiness. A code is
                 // findable for anyone; the decker who did not need it loses
                 // nothing by its existing.
-                if (!hasBookClue && !hasNamedItemClue) {
+                if (!hasBookClue && !hasNamedItemClue && !knownToOwner(room.name, device.name)) {
                     throw new Error(`Panel "${device.name}" has no discoverable clue: no Book-category item in a different room whose "details" contains the code "${device.code}", and no item elsewhere literally named "${device.code}". Every panel's code must be written down somewhere findable.`);
                 }
             }

package/bundle/typescript/src/commands/game/sideQuest/factories/seed-migration.js

@@ -1,4 +1,5 @@
 import { Logger } from '../utilities/logger.js';
+import { WARD_DEFAULT_FORCE } from '../models/room.js';
 /**
  * KIND, from the old bypassType (rule 4).
  *
@@ -11,7 +12,9 @@ import { Logger } from '../utilities/logger.js';
 function kindFor(bypassType) {
     switch (bypassType) {
         case 'lockpick': return 'lock';
-        case 'spell': return 'ward';
+        // A spell barrier was a ward. It is written as the legacy ward
+        // device here and moved onto its room by wardDevicesToRooms below.
+        case 'spell': return LEGACY_WARD;
         case 'hack': return 'panel';
         // Absent, 'con', or anything unrecognised.
         default: return 'panel';
@@ -39,6 +42,47 @@ function synthesiseCode(name) {
 export function migrateLegacySeed(json) {
     return migrateLegacySeedWithReport(json).seed;
 }
+/** The retired device kind, as old seeds and old models still write it. */
+const LEGACY_WARD = 'ward';
+/**
+ * A WARD IS A ROOM'S, NOT A DOOR'S (user 2026-10-06; SR5 p.294, p.297-298,
+ * p.315). The ward DEVICE stood on a door and locked it to bodies until a
+ * mage dispelled it -- but a ward is an astral barrier over a place, and
+ * it "does not restrict living beings or physical objects". So every
+ * legacy ward device becomes a warded ROOM:
+ *  - on an exit, the room behind that door -- what it was protecting;
+ *  - on no exit (a warded strongbox), the room it stood in.
+ * Its Force is the device's rating where it had one, else the default.
+ * The door it held is simply a door now. Whatever it granted is put on
+ * the floor of its room, so a prize behind a ward is not stranded.
+ * Pure and idempotent: a seed with no ward device comes back as itself.
+ */
+export function wardDevicesToRooms(json) {
+    const isWard = (d) => d.kind === LEGACY_WARD;
+    if (!(json.rooms ?? []).some(r => (r.devices ?? []).some(isWard)))
+        return json;
+    const log = Logger.getInstance();
+    const rooms = (json.rooms ?? []).map(r => ({ ...r, devices: [...(r.devices ?? [])] }));
+    const byName = new Map(rooms.map(r => [r.name, r]));
+    let items = json.items;
+    for (const room of rooms) {
+        const wards = room.devices.filter(isWard);
+        if (wards.length === 0)
+            continue;
+        room.devices = room.devices.filter(d => !isWard(d));
+        for (const d of wards) {
+            const exit = d.opensExit ? (room.exits ?? []).find(e => e.direction === d.opensExit) : undefined;
+            const warded = (exit ? byName.get(exit.targetRoom) : undefined) ?? room;
+            warded.warded = true;
+            warded.wardForce = Math.max(warded.wardForce ?? 0, d.rating !== undefined && d.rating > 0 ? Math.floor(d.rating) : WARD_DEFAULT_FORCE);
+            if (d.grantsItem) {
+                items = (items ?? []).map(i => i.name === d.grantsItem && !i.room && !i.heldBy ? { ...i, room: room.name } : i);
+            }
+            log.write(`seed-migration: ward device "${d.name}" -> ${warded.name} is WARDED (Force ${warded.wardForce}); a ward stops astral forms, not bodies.`);
+        }
+    }
+    return { ...json, rooms, items };
+}
 /**
  * THE HUB CARRIES NO HOSTS (ruling 2026-09-12 on N4erz3f63MiCZLkDE).
  *
@@ -113,7 +157,7 @@ export function migrateLegacySeedWithReport(json) {
     // Hub hosts first, so the puzzle pass below sees the rooms as they
     // will be played. Both passes are pure; order only matters for the
     // spread that follows.
-    json = stripHubHosts(json);
+    json = wardDevicesToRooms(stripHubHosts(json));
     const puzzles = json.puzzles ?? [];
     // IDEMPOTENCE: a seed already migrated has no puzzles left to move,
     // so the whole pass is a copy. Checked first so a re-migrated seed
@@ -207,7 +251,9 @@ export function migrateLegacySeedWithReport(json) {
             // MANDATORY (see device-seed.ts): an absent riddle used to render
             // the literal string "undefined" into an NPC's prompt.
             description: p.riddle || `${p.name} -- sealed.`,
-            kind,
+            // A legacy ward is written as one and moved onto its room at the
+            // end of this pass (wardDevicesToRooms).
+            kind: kind,
             code,
             keyItem: p.requiredItem,
             grantsItem: p.rewardItem,
@@ -244,6 +290,8 @@ export function migrateLegacySeedWithReport(json) {
         // dropping the content on the floor silently.
         log.error(`seed-migration: "${p.name}" is placed in no room and guards ${guardedExits.length} exits -- cannot site it. Dropped.`);
     }
-    return { seed: { ...json, rooms, npcs, puzzles: [] }, fates };
+    // The puzzle pass writes spell barriers as legacy ward devices; they
+    // land on their rooms here, the same as any other seed's.
+    return { seed: wardDevicesToRooms({ ...json, rooms, npcs, puzzles: [] }), fates };
 }
 //# sourceMappingURL=seed-migration.js.map

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

@@ -20,6 +20,9 @@ import { ledSeatsNow, hostCannotAnswer, reasonOf, CREW_JOB_RIDE_LINE, CREW_JOB_A
 import { isHostProcess } from './utilities/host-process.js';
 import { buildCleanupSeed } from './factories/cleanup-seed.js';
 import { EditFileCommand, EraseCommand } from './commands/edit-file.js';
+import { LeapCommand } from './commands/leap.js';
+import { CrackCommand } from './commands/crack.js';
+import { DisarmCommand } from './commands/disarm.js';
 import { EraseMarkCommand } from './commands/erase-mark.js';
 import { SPRITE_POWER_COMMANDS } from './commands/sprite-power.js';
 import { cleanupOutcome } from './utilities/cleanup-errand.js';
@@ -192,7 +195,7 @@ import { HintsCommand } from './commands/hints.js';
 import { hint, setHints, terse } from './utilities/hints.js';
 import { businessWitness } from './factions.js';
 import { wouldNotice } from './utilities/spots.js';
-import { camerasLive, liveFootage } from './utilities/surveillance.js';
+import { cameraSeeing, liveFootage } from './utilities/surveillance.js';
 import { InstallCommand } from './commands/install.js';
 import { BuyCommand, BrowseCommand } from './commands/buy.js';
 import { SellCommand } from './commands/sell.js';
@@ -666,8 +669,11 @@ export default class Game {
             this.scene.crimeLogged = true;
         let billed = amount;
         const who = actor ?? this.heatActor();
-        const room = who.bodyRoom ?? who.currentLocation;
-        if (room && camerasLive(this.scene.getRooms(), room)) {
+        // A LENS THAT CAN SEE THEM (surveillance.ts cameraSeeing: line of
+        // sight, no range) -- the room whose camera it is keeps the footage.
+        const seen = cameraSeeing(this.scene.getRooms(), who);
+        const room = seen?.room;
+        if (room) {
             billed *= 2;
             if (!this._camSeenRooms.has(room.name)) {
                 this._camSeenRooms.add(room.name);
@@ -5284,6 +5290,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // Vertical travel by name (commands/climb.ts) -- shortcuts over
         // move, which already crosses levels.
         CommandFactory.registerCommand('climb', ClimbCommand);
+        // Over a ledge on purpose (utilities/ledge-jump.ts).
+        CommandFactory.registerCommand('leap', LeapCommand);
         // The word a player actually typed (vkDz3cquad25GACpm). mantle is
         // six edits from climb, so no amount of typo tolerance was ever
         // going to find it -- a synonym has to be said out loud.
@@ -5365,6 +5373,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('edit', EditFileCommand);
         CommandFactory.registerCommand('erase', EraseCommand);
         CommandFactory.registerCommand('wipe', EraseCommand);
+        // A file's own defences (p.238-242, utilities/file-guard.ts).
+        CommandFactory.registerCommand('crack', CrackCommand);
+        CommandFactory.registerCommand('disarm', DisarmCommand);
         // MAtrix Recognition Keys (canon p.235-236).
         CommandFactory.registerCommand('mark', MarkCommand);
         CommandFactory.registerCommand('marks', MarkCommand);
@@ -10236,7 +10247,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // guessVerb, which owns the ordering and the reason.
         const guess = guessVerb(verb, knownVerbs);
         if (guess && guess !== verb) {
-            if (guess === 'quit' || guess === 'exit') {
+            // A LEAP IS NEVER GUESSED (user 2026-10-06: "don't attempt to auto
+            // read this one"): a fall is one deliberate command, not a typo's.
+            if (guess === 'quit' || guess === 'exit' || guess === 'leap') {
                 return out(`I don't understand "${verb}" -- did you mean "${guess}"?`);
             }
             const corrected = await this.runInputAs(actorName, [guess, ...args].join(' '));

package/bundle/typescript/src/commands/game/sideQuest/models/camera.js

@@ -49,8 +49,16 @@ export class Camera {
      *  dark without owning the host (surveillance.ts cameraStateNote).
      *  A smashed lens needs no knowing: anyone can see it. */
     knownOffBy = new Set();
+    /** THE HOST THIS LENS IS SLAVED TO, when the author named one: a room
+     *  with a node (surveillance.ts lensMaster). Unset = the room's master. */
+    masterHost;
+    /** The building an outdoor lens is bolted to (seed `mountedOn`): not a
+     *  pole, and hardlined to that building's host. */
+    mountedOn;
     constructor(cfg) {
         this.name = cfg.name;
+        this.masterHost = cfg.masterHost;
+        this.mountedOn = cfg.mountedOn;
         this.perch = cfg.name;
         this.wall = cfg.wall;
         this.rating = cfg.rating;

package/bundle/typescript/src/commands/game/sideQuest/models/device.js

@@ -6,9 +6,8 @@ import { hint } from '../utilities/hints.js';
  * which prices a door lock at 2, and p.234, where a device's Data
  * Processing and Firewall are both simply its Device Rating).
  *
- * A 'ward' is deliberately absent: it is the Art, not electronics, and
- * giving it a rating would be inventing a device where canon has none.
- * broadcastsAro() answers false for it on the same grounds -- see
+ * A WARD IS NOT A DEVICE (user 2026-10-06): it is a room's astral
+ * barrier (utilities/wards.ts), with a Force and no Device Rating -- see
  * kbWdrysBQSahg67cA, where the ask was "anything that can be HACKED must
  * be a device", not "everything in the room is".
  */
@@ -21,8 +20,7 @@ export const DEFAULT_DEVICE_RATING = {
  * hidden from view, such as locks and other security devices"; user
  * ruling 2026-09-16 on what that covers -- "cameras, locks, sensors
  * etc"). In this engine a 'lock' and a 'panel' ARE the security
- * furniture: the maglock, the keypad, the safe. A 'ward' is the Art and
- * has no wireless mode to hide in.
+ * furniture: the maglock, the keypad, the safe.
  */
 export const SILENT_BY_DEFAULT = new Set(['lock', 'panel']);
 /**
@@ -57,8 +55,7 @@ export const WIRELESS_OFF_BY_DEFAULT = new Set(['lock', 'panel']);
  * Structure / Armor. Fragile is standard glass; Reinforced is a security
  * door, armored glass, Kevlar wallboard; Heavy is concrete or a metal
  * beam. A device seed that says neither gets Reinforced -- the ordinary
- * locked door -- or Heavy when its footprint is large. A ward is the Art
- * and has no Structure to shoot.
+ * locked door -- or Heavy when its footprint is large.
  */
 export const BARRIER_TIERS = {
     fragile: { structure: 1, armor: 2 },
@@ -66,8 +63,6 @@ export const BARRIER_TIERS = {
     heavy: { structure: 12, armor: 20 },
 };
 export function barrierDefaultsFor(kind, footprint) {
-    if (kind === 'ward')
-        return { structure: 0, armor: 0 };
     return footprint === 'large' ? BARRIER_TIERS.heavy : BARRIER_TIERS.reinforced;
 }
 /** A seed's rating, kept to the range the book uses (1-12, the same
@@ -108,7 +103,7 @@ export function clampDeviceRating(rating) {
  * A CODE ONLY BELONGS ON A PANEL. User ruling, verbatim: "if it's a
  * _mechanical_ lock, it has a key or can be picked. You can't talk at a
  * _mechanical_ lock." A 'lock' therefore opens by key or by force, and
- * a 'ward' by the Art -- neither has anything to hear a phrase with.
+ * has nothing to hear a phrase with.
  * The migration enforces this by dropping the phrase off anything that
  * isn't a panel.
  */
@@ -262,7 +257,7 @@ export class Device {
      * ceases functioning" -- a camera records nothing, a smartgun sparks
      * and dies -- but "a lock stays locked" (p.228): bricking is never a
      * way through a maglock. Repaired on the bench (rest.ts), never by a
-     * reboot. A ward is not electronics and has no monitor at all.
+     * reboot.
      */
     _matrixDamage = 0;
     /**
@@ -289,19 +284,17 @@ export class Device {
         this.refuseMessage = config.refuseMessage || `Nothing happens.`;
         this.rating = config.rating !== undefined ? clampDeviceRating(config.rating) : DEFAULT_DEVICE_RATING[config.kind] ?? 0;
         const tier = barrierDefaultsFor(config.kind, config.footprint);
-        this.structure = config.kind === 'ward' ? 0 : Math.max(0, Math.floor(config.structure ?? tier.structure));
-        this.armor = config.kind === 'ward' ? 0 : Math.max(0, Math.floor(config.armor ?? tier.armor));
-        // A ward has no wireless mode to be in. Everything else defaults ON,
-        // because a seeded keypad nobody thought about is a keypad on the
+        this.structure = Math.max(0, Math.floor(config.structure ?? tier.structure));
+        this.armor = Math.max(0, Math.floor(config.armor ?? tier.armor));
+        // Wireless defaults ON, because a seeded keypad nobody thought about is a keypad on the
         // grid -- which is the state the report says the game should model.
-        this.wireless = config.kind === 'ward' ? false : (config.wireless ?? true);
+        this.wireless = config.wireless ?? true;
         this.masterHost = config.masterHost;
         // SECURITY IS SILENT BY DEFAULT (p.217-218: "locks and other
         // security devices"). In this engine a 'lock' and a 'panel' ARE the
         // security furniture -- the maglock, the keypad, the safe -- so both
-        // are born dark unless a seed says otherwise. A 'ward' has no
-        // wireless mode to hide in the first place.
-        this.silent = config.kind === 'ward' ? false : (config.silent ?? SILENT_BY_DEFAULT.has(config.kind));
+        // are born dark unless a seed says otherwise.
+        this.silent = config.silent ?? SILENT_BY_DEFAULT.has(config.kind);
     }
     isOpen() {
         return this.open;
@@ -335,7 +328,7 @@ export class Device {
      * of those three sites.
      */
     onHoled;
-    /** Boxes actually taken; a ward has nothing to fill. */
+    /** Boxes actually taken. */
     takeBarrierDamage(boxes) {
         if (this.structure <= 0)
             return 0;
@@ -372,7 +365,7 @@ export class Device {
      */
     // ---- The Matrix condition monitor (commands/disable.ts) ----
     /** p.228: 8 + (Device Rating / 2), rounded up as the deck's is. 0 for
-     *  a thing with no rating (a ward): nothing there to brick. */
+     *  a thing with no rating: nothing there to brick. */
     get matrixMonitor() {
         return this.rating > 0 ? 8 + Math.ceil(this.rating / 2) : 0;
     }

package/bundle/typescript/src/commands/game/sideQuest/models/host.js

@@ -165,6 +165,14 @@ export class Host {
      * to say for itself is the report.
      */
     purpose;
+    /** The author's IC launch order (room seed icOrder), names as written. */
+    icOrder;
+    /** Reboot a bricked program first, or continue down the line first. */
+    icBricked;
+    /** What the author called it (room seed hostName), when they did. The
+     *  host's IDENTITY stays `name` (its room's); this is what it is CALLED
+     *  -- grid-names.ts prints and accepts it. */
+    displayName;
     sculpt;
     constructor(over, opts = {}) {
         this.over = over;

package/bundle/typescript/src/commands/game/sideQuest/models/item.js

@@ -39,6 +39,10 @@ export class Item extends AbstractItem {
     price;
     // See IItemConstructorConfig.atSpot; take.ts gates reach on it.
     atSpot;
+    /** WHERE IT LIES, room-local cells, when an author put it there
+     *  (player-built runs, 2026-10-06; seed items[].cell). Reach still goes
+     *  through atSpot, which is set from this cell; maps draw it here. */
+    atCell;
     // PAN warfare (see commands/hack.ts): a cracked smart-device locks up.
     // A jammed firearm can't fire (fists until cleared); "reboot" clears
     // every jammed device you carry, in the lull.
@@ -112,6 +116,16 @@ export class Item extends AbstractItem {
      *  holds (commands/edit-file.ts). */
     hashedBy;
     hashTurns = 0;
+    /** PROTECTION (SR5 p.239): the rating Edit File's "protect" left on a
+     *  file. It cannot be read, changed, deleted or copied until Crack File
+     *  (p.238) breaks it -- utilities/file-guard.ts. 0 = unprotected. */
+    protection = 0;
+    /** A DATA BOMB (p.242): goes off on any read/edit/copy/delete without
+     *  the passcode (utilities/file-guard.ts). One per file. */
+    dataBomb;
+    /** Personas whose Matrix Perception has turned up the bomb (p.242) --
+     *  what Disarm Data Bomb (commands/disarm.ts) needs before it is tried. */
+    bombSeenBy = new Set();
     /** WATERMARK: an invisible tag only Resonance-driven things read -- a
      *  technomancer or another sprite. A new one overwrites the old. */
     watermark;

package/bundle/typescript/src/commands/game/sideQuest/models/npc.js

@@ -12,6 +12,7 @@ import { Door } from './door.js';
 import { AI } from '../../../../tools/ai/ai.class.js';
 import { CALL_ICON, CALL_COLOR } from '../utilities/comm-style.js';
 import { hostLabel } from '../utilities/grid-names.js';
+import { wanDevices } from '../utilities/wan.js';
 import { ephemeralDenials } from '../utilities/ephemeral.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { spotsActive, spotOf, describeSpotRoster, spotDistanceMeters, spotCoverBetween, wouldNotice } from '../utilities/spots.js';
@@ -152,6 +153,24 @@ export function hostileStanceNote(hostile, intruderName) {
         + ` told it or they tell you -- act on what you can see, not on a file you never read.`
         + ` If they talk their way round you, or beat you, that settles it.`;
 }
+/**
+ * THE OWNER KNOWS THEIR HOST'S CODES (user rulings 2026-10-06: "tie the
+ * data file all the way back to the owner of the host"; "keypad codes
+ * also bubble up to the host owner"). Whoever set a data bomb chose its
+ * passcode (SR5 p.242), and the codes of the locks slaved to a host are
+ * its owner's to know. Like a barrier's pass, each is a SECRET they guard:
+ * the way to it is social or violent -- persuaded, frightened, bribed or
+ * beaten out of them -- and telling it IS how they comply.
+ *
+ * PURE and exported, like barrierPostNote: it fails silently -- an owner
+ * who forgets they hold the code just shrugs, and nothing throws.
+ */
+export function hostCodeNote(codes) {
+    const guard = 'is a SECRET you guard with your standing: give it up only under real pressure -- beaten, genuinely frightened, well bribed, or masterfully played. Under that pressure, telling them IS how you comply. When you do, say it exactly.';
+    return codes.map(c => c.kind === 'file'
+        ? `\nA FILE YOU OWN: "${c.file}" in your host, ${c.host}, carries a data bomb you set -- its passcode is "${c.code}". Anyone who touches that file without it gets the bomb in the face. The passcode ${guard}`
+        : `\nA LOCK YOUR HOST KEEPS: ${c.device} in ${c.room}${c.direction ? ` (the ${c.direction} door)` : ''} is slaved to your host, ${c.host}, and you know its code: "${c.code}". The code ${guard}`).join('');
+}
 export function barrierPostNote(barriers) {
     return barriers.map(b => {
         const dirNote = b.sealingDirection ? ` sealing the way ${b.sealingDirection}` : '';
@@ -257,9 +276,15 @@ export function castPin(names) {
  * real. There is no assertion anywhere else in the engine that would
  * notice.
  */
-export function credentialHonestyNote(passesHeld) {
-    const known = passesHeld > 0
-        ? `the ${passesHeld === 1 ? 'pass' : `${passesHeld} passes`} for the barrier${passesHeld === 1 ? '' : 's'} at your own post, named above, and NO others`
+export function credentialHonestyNote(passesHeld, hostCodesHeld = 0) {
+    const held = [
+        ...(passesHeld > 0 ? [`the ${passesHeld === 1 ? 'pass' : `${passesHeld} passes`} for the barrier${passesHeld === 1 ? '' : 's'} at your own post`] : []),
+        // The codes your own host keeps (hostCodeNote): bomb passcodes on
+        // its files, keypad codes on the devices slaved to it.
+        ...(hostCodesHeld > 0 ? [`the ${hostCodesHeld === 1 ? 'code' : `${hostCodesHeld} codes`} your own host keeps`] : []),
+    ];
+    const known = held.length > 0
+        ? `${held.join(' and ')}, named above, and NO others`
         : `NO code, pass, or combination to anything -- you hold none`;
     return `
 CREDENTIALS YOU DO NOT HOLD: you know ${known}. You cannot deduce, guess, or
@@ -1087,9 +1112,6 @@ Available in-game commands (use with [COMMAND] prefix):
   on yourself or an ally; its bearer gets +soak, and YOU carry -2 dice to all else
   while you hold it; cast at them again to release). EVERY cast costs drain -- stun damage to YOU the caster; fill
   your stun track and you're out cold. Never cast if you're mundane with no magic gear.
-- cast — bare "cast" attempts to magically bypass the ward/barrier in this room
-  without knowing the answer (requires the same talent or gear; failing burns the
-  route for good and the backlash hurts you badly)
 - search — search the room for hidden things
 - look — look around the current room
 - look at <target> - looks at an item, player, or direction
@@ -1231,7 +1253,9 @@ description text.`;
      * stimulus to wake.
      */
     isConstruct() {
-        return this.icKind !== undefined || this.plane === 'matrix';
+        // A PERSONA WITH A BODY IS A PERSON (utilities/spider.ts): a spider
+        // jacked in from a chair is on the matrix plane and is not ice.
+        return this.icKind !== undefined || (this.plane === 'matrix' && !this.bodyRoom);
     }
     /** Every AI entry point asks this: a construct never runs the model,
      *  and anyone in a Combat Turn yields to the turn loop. */
@@ -2469,7 +2493,36 @@ An ORDER is the only way these goods change hands -- never a dialogue sale, neve
         // Applies to EVERYONE, companions and the client included: a bound
         // spirit inventing its master a code is the same bug wearing a
         // leash.
-        const credentialHonesty = credentialHonestyNote(passesHeldBy(barrierPosts));
+        // THE CODES THEIR OWN HOST KEEPS (hostCodeNote; user ruling
+        // 2026-10-06: "keypad codes also bubble up to the host owner, same
+        // as data bomb codes"). Read live off every host this NPC owns,
+        // wherever they stand: the bomb passcodes on its files, and the code
+        // of every still-shut device slaved to it (wan.ts wanDevices -- the
+        // same wiring a hack through the host reaches). A spent bomb or an
+        // opened lock drops out on its own; a lock already briefed as the
+        // barrier at their own post is not said twice. Not for an ally shell
+        // (the same caller decision as the barrier posts above).
+        const hostCodes = [];
+        if (!this.allyOf) {
+            const rooms = this._scene?.getRooms?.() ?? {};
+            const atPost = new Set(barrierPosts.map(b => b.name));
+            for (const r of Object.values(rooms)) {
+                if (r.owner !== this.name || !r.host)
+                    continue;
+                const host = hostLabel(r);
+                for (const f of r.host.files()) {
+                    if (f.dataBomb?.passcode)
+                        hostCodes.push({ kind: 'file', file: f.name, host, code: f.dataBomb.passcode });
+                }
+                for (const { device, room: at } of wanDevices(rooms, r)) {
+                    if (!device.code || device.open || atPost.has(device.name))
+                        continue;
+                    hostCodes.push({ kind: 'device', device: device.name, room: at.name, direction: device.opensExit ? String(device.opensExit) : undefined, host, code: device.code });
+                }
+            }
+        }
+        const hostCodeBlock = hostCodeNote(hostCodes);
+        const credentialHonesty = credentialHonestyNote(passesHeldBy(barrierPosts), hostCodes.length);
         const localKnowledge = localKnowledgeNote(room?.name);
         // AN EPHEMERAL IS A PASSING FACE (7ALf6u7PvTg6TZSm7, see
         // utilities/ephemeral.ts). The brief is trimmed hard everywhere
@@ -2664,7 +2717,7 @@ Your objective is to drive the story line.`}
     ${formattedExitsStr}
     ${roomInventoryDesc}
     ${eph ? '' : waresDesc}
-    ${eph ? '' : swagNote}${eph ? '' : clientNote}${hostileBlock}${picketBlock}${barrierBlock}${credentialHonesty}${localKnowledge}${ephDenials}
+    ${eph ? '' : swagNote}${eph ? '' : clientNote}${hostileBlock}${picketBlock}${barrierBlock}${hostCodeBlock}${credentialHonesty}${localKnowledge}${ephDenials}
     ${eph ? '' : familiarity}
     ${eph ? '' : ordersNote}
     ${droneNote}

package/bundle/typescript/src/commands/game/sideQuest/models/player.js

@@ -298,6 +298,14 @@ export class Player extends AbstractPlayer {
      * persuaded him while standing in the same doorway.
      */
     guarding = false;
+    /**
+     * THE DOOR THIS ACTOR WATCHES -- a direction out of the room they stand
+     * in (utilities/door-watch.ts). Not a barrier: they let you by, until
+     * they notice you going for it -- then they turn hostile and the fight
+     * opens there (user ruling 2026-10-06, "guarded by"). A guarding actor
+     * in a doorway watches it too, without this being set.
+     */
+    watching;
     /**
      * THIS ACTOR IS OPPOSITION (JjQdy4A4tzcQdPHno: "none of the NPCs ever
      * seem to get hostile").
@@ -5381,6 +5389,9 @@ export class Player extends AbstractPlayer {
     // Sneaking-vs-Perception rolls per witness (NPC.see). Broken by any
     // loud act -- attacking, casting, speaking, brandishing, calling.
     sneaking = false;
+    /** The ward this astral form has PRESSED THROUGH and not yet crossed
+     *  (utilities/wards.ts pressThroughWard): one crossing, then spent. */
+    wardPass;
     // ==================== Jumped-in rigging (commands/jump.ts) ====================
     // The drone currently being ridden while plane === 'drone': the item
     // whose hull track (Item.droneDamage) eats what would hit the rider,