@maka/maka-cli 5.238.0 → 5.240.0

package/bundle/typescript/package.json

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

@@ -13,6 +13,7 @@ import { asksForDataWork, noDeckForDataWork } from '../utilities/data-work.js';
 import { partyCanDeck } from '../factories/scene-chunks.js';
 import { RecallCommand } from './companions.js';
 import { inLiveCombat } from '../utilities/action-cost.js';
+import { radioIsDark } from '../utilities/pan-devices.js';
 export class CallCommand extends Command {
     static verb = 'call';
     static description = 'Call someone remotely over a commlink (no need to be in the same room; commlink must be equipped).';
@@ -56,9 +57,17 @@ export class CallCommand extends Command {
         if (!this.hasEquippedCommlink(this.actor)) {
             return `You need to equip a commlink before you can call anyone.`;
         }
-        // Running silent kills the broadcast both ways (see silent.ts).
-        if (this.actor.runningSilent) {
-            return `You're running silent -- your link isn't broadcasting. Go loud ("silent") before calling anyone.`;
+        // A DEAD RADIO STOPS A CALL; SILENCE DOES NOT (RXPvXqTwEyH9v3Zk7).
+        // This asked `runningSilent` and refused, on the strength of a claim
+        // canon does not make: p.235 says silent running "reduces your
+        // traffic to and from the Matrix, but it doesn't stop it entirely".
+        // Losing your traffic is p.421's wireless-off, so that is what
+        // refuses here now -- and a silent decker can finally call their own
+        // team, which is the whole reason a runner goes silent in the first
+        // place. The INBOUND direction is a different question and still
+        // refuses while silent; see the target check further down.
+        if (radioIsDark(this.actor)) {
+            return `Every radio you own is switched off -- nothing of yours is on the air.${hint(` ("wireless on" to come back up.)`)}`;
         }
         // Hacked dark is a different kind of quiet (see hack.ts PAN attacks).
         if (this.actor.arOffline) {
@@ -316,8 +325,18 @@ export class CallCommand extends Command {
         if (!onTheBond && !this.hasCommlink(target)) {
             return `You don't get through -- ${target.name} doesn't seem to have a commlink.`;
         }
+        // TWO WAYS TO FAIL TO REACH SOMEONE, and they are different facts
+        // about them (RXPvXqTwEyH9v3Zk7). A silent icon is out there and
+        // simply cannot be pointed at without winning a Matrix Perception
+        // test for it first (p.235) -- which a phone call is not. A dark
+        // radio is not out there at all (p.421). The wording says which,
+        // because to a player deciding what to do next they are not the
+        // same problem.
+        if (radioIsDark(target)) {
+            return `Nothing rings -- ${target.name}'s gear is all switched off. Wherever they are, they are not on the air.`;
+        }
         if (target.runningSilent) {
-            return `You can't raise ${target.name} -- their link isn't broadcasting. They're running silent.`;
+            return `You can't raise ${target.name} -- their icon isn't where it should be. They're running silent, and a call has nothing to point at.`;
         }
         // HUB flow: calling the fixer from home isn't a conversation -- it's
         // the COMMISSION. He answers, tells you to stay by your link, and

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

@@ -1,6 +1,6 @@
 import { Command } from './command.js';
 import { hint, hintsEnabled } from '../utilities/hints.js';
-import { CALL_ICON, isLinked } from '../utilities/comm-style.js';
+import { CALL_ICON, isReachable } from '../utilities/comm-style.js';
 /**
  * The roster: who talks to you, how plugged-in they are, and how deep
  * the relationship runs. Contacts are EARNED (see Game.touchContact) --
@@ -103,7 +103,7 @@ export class ContactsCommand extends Command {
             // the street, not just how much juice they carry. The 📞 marks
             // who's LINKED -- reachable by "call" from anywhere in the hub.
             const actor = this.game.hubActor(name);
-            const linked = actor ? isLinked(actor) : false;
+            const linked = actor ? isReachable(actor) : false;
             // The note is the relationship's memory -- a client's grudge or a
             // sloppy wrap-up (returnToHub's upsert) -- compacted to its first
             // word as a marker, hint-on shows the whole line.
@@ -122,7 +122,7 @@ export class ContactsCommand extends Command {
      *  jump once they're a real contact; Loyalty reads as unearned. */
     clientRow(name) {
         const actor = this.game.hubActor(name);
-        const linked = actor ? isLinked(actor) : false;
+        const linked = actor ? isReachable(actor) : false;
         return `  ${name.padEnd(17)} ${'Johnson'.padEnd(14)} ${linked ? CALL_ICON : '  '} Conn 4, Loyalty -  (this run's client)`;
     }
 }

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

@@ -1,6 +1,6 @@
 import { Command } from './command.js';
 import { movePersonaWith } from '../utilities/matrix-roster.js';
-import { resolveHostInReach, hostsInReach, gridVicinity, hostOver } from '../utilities/grid-reach.js';
+import { resolveHostInReach, hostsInReach, gridVicinity, hostOver, hostDoorOpenFor } from '../utilities/grid-reach.js';
 import { hint } from '../utilities/hints.js';
 import { hostLabel } from '../utilities/grid-names.js';
 import { billAction } from '../utilities/action-cost.js';
@@ -61,11 +61,21 @@ export class EnterHostCommand extends Command {
         // actions to get a mark has bought the door, and charging them a
         // test here would be inventing a rule the book explicitly denies
         // ("There is no test involved").
-        const marks = target.hostMarksBy.get(actor.name) ?? 0;
-        if (marks < 1 && !target.hostCracked && !target.hostSanctioned) {
+        //
+        // AND IT IS THE ONLY GATE (DxfeZTBrP6Bu7MLF4). It used to read `||
+        // hostCracked`, which is the SITE's state and never expires -- see
+        // grid-reach.ts hostDoorOpenFor for why that was a door nobody could
+        // ever close again. A persona whose keys are gone gets its own line:
+        // the wreckage it can see from out here is real, and saying "doesn't
+        // know you" about a node it personally tore open would read as the
+        // engine forgetting the last ten minutes.
+        if (!hostDoorOpenFor(target, actor)) {
+            const wrecked = target.hostCracked;
             return [
-                `{light-blue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/light-blue-fg}`,
-                hint(`A host opens to anyone holding a MARK on it (p.239) -- "mark ${target.name}" softens it, or "hack" takes one by force.`),
+                wrecked
+                    ? `{light-blue-fg}${hostLabel(target, { capital: true })} is still hanging open where you broke it -- and it does not know YOU. Your keys are out of the lattice; the architecture has nothing shaped like your icon to open for.{/light-blue-fg}`
+                    : `{light-blue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/light-blue-fg}`,
+                hint(`A host opens to anyone holding a MARK on it, and marks die with the session you placed them in (p.239, p.236) -- "hack ${target.name}" keys it quietly, "force ${target.name}" takes one loud.`),
             ].join('\n');
         }
         // A Complex Action (p.239) -- billed only inside a Combat Turn.

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

@@ -78,7 +78,7 @@ export class EquipmentCommand extends Command {
                         : `${dni.item?.name ?? 'trode net'} (${dni.host ? `built into your ${dni.host.name}${dni.worn ? '' : ', in the bag'}` : dni.worn ? 'worn' : 'in the bag'}) -- VR ready`;
             lines.push(`  Interface: ${dniLine}`);
             if (link) {
-                lines.push(`  Commlink:  ${link.name}${actor.runningSilent ? ' -- running silent' : ''}`);
+                lines.push(`  Commlink:  ${link.name}${!link.wirelessOn ? ' -- wireless OFF' : actor.runningSilent ? ' -- running silent (icon hidden, still broadcasting)' : ''}`);
             }
         }
         // WORN, by region, in words.

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

@@ -1,5 +1,5 @@
 import { whereIsThat } from '../utilities/matrix-roster.js';
-import { resolveHostInReach, roomsInReach, noiseNote, gridVicinity } from '../utilities/grid-reach.js';
+import { resolveHostInReach, roomsInReach, noiseNote, gridVicinity, hostDoorOpenFor } from '../utilities/grid-reach.js';
 import { perceptionTest } from '../utilities/perception.js';
 import { matchesHostName, matchesCameraName, hostLabel } from '../utilities/grid-names.js';
 import { Door } from '../models/door.js';
@@ -392,7 +392,7 @@ export class LookCommand extends Command {
                 return `That file is on the ${room.offlineServer} -- a box with no Matrix presence. Nothing out here reaches it; your body has to be in ${room.name} (p.233).`;
             }
             if (reach === 'enter') {
-                return `That file is INSIDE the host -- from out on the grid you have its shell and nothing through it (p.246). ${(room.hostMarksBy.get(this.actor.name) ?? 0) > 0 || room.hostCracked ? `"enter" to go in.` : `A mark opens the door: "hack ${hostLabel(room)}" (quiet) or "force ${hostLabel(room)}" (loud), then "enter".`}`;
+                return `That file is INSIDE the host -- from out on the grid you have its shell and nothing through it (p.246). ${hostDoorOpenFor(room, this.actor) ? `"enter" to go in.` : `A mark opens the door: "hack ${hostLabel(room)}" (quiet) or "force ${hostLabel(room)}" (loud), then "enter".`}`;
             }
             // The host's seal covers the HOST's archive. A file on an offline
             // server is not in there -- cracking the building's host does

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

@@ -3,6 +3,7 @@ import { hint } from '../utilities/hints.js';
 import { Player } from '../models/player.js';
 import { Category } from '../types/shared/item-enum.js';
 import { billAction } from '../utilities/action-cost.js';
+import { reachableDevices, radioIsDark } from '../utilities/pan-devices.js';
 /**
  * The PAN dashboard: your personal area network at a glance -- master
  * device and its firewall, every slaved device with what it grants while
@@ -35,29 +36,11 @@ export class PanCommand extends Command {
         }
         return this.dashboard();
     }
-    /**
-     * Everything on this runner the switch can reach, held and worn gear
-     * INCLUDED. Equipping moves an item out of `inventory.getAllItems()`,
-     * so a list built from inventory alone loses the gun in your hand --
-     * which is the one device a player is most likely to mute. Both the
-     * lookup and the "switched off" list read this, so a device you can
-     * turn off is always a device you can see is off.
-     */
+    /** Everything the switch can reach on this runner. Lives in
+     *  utilities/pan-devices.ts now that `wireless` sweeps the same list
+     *  (p.421 prices the one-device and all-devices forms together). */
     reachableDevices() {
-        const a = this.actor;
-        const seen = new Set();
-        return [
-            a.equipment.head?.commlink,
-            a.equipment.head?.eyes,
-            a.equipment.rightHand?.weapon,
-            a.equipment.leftHand?.weapon,
-            ...a.inventory.getAllItems(),
-        ].filter((i) => {
-            if (i == null || seen.has(i))
-                return false;
-            seen.add(i);
-            return true;
-        });
+        return reachableDevices(this.actor);
     }
     /** One device on or off the network (p.233 -- slaving is a choice). */
     switchDevice(name, on) {
@@ -123,11 +106,23 @@ export class PanCommand extends Command {
             }
             return `No devices, no PAN. You are unhackable and unreachable -- the monk's build.`;
         }
-        const state = a.runningSilent
-            ? `{magenta-fg}SILENT{/magenta-fg} -- hidden (+2 firewall), but no calls, no AR, no Matrix`
-            : a.arOffline
-                ? `{red-fg}LOUD, AR CUT{/red-fg} -- someone hacked your overlay dark ("reboot")`
-                : `{green-fg}LOUD{/green-fg} -- full bonuses, and hackable`;
+        // THREE STATES, NOT TWO (RXPvXqTwEyH9v3Zk7). The line this replaced
+        // read "SILENT -- hidden (+2 firewall), but no calls, no AR, no
+        // Matrix", and every clause after the comma described a DIFFERENT
+        // state: p.421's wireless-off. Worse, "no AR" contradicted the
+        // engine's own RAG-checked ruling three files away (utilities/ar.ts
+        // arSightUp: silence is what you EMIT, AR is what you RECEIVE), so
+        // one runner could read two opposite answers about one flag.
+        //
+        // Running silent costs the -2 and nothing else (p.235). Turning the
+        // radio off is what costs you the bonuses and the traffic (p.421).
+        const state = radioIsDark(a)
+            ? `{white-fg}RADIO OFF{/white-fg} -- nothing broadcasting: no bonuses, no calls, and nothing to hack${hint(` ("wireless on")`)}`
+            : a.runningSilent
+                ? `{magenta-fg}SILENT{/magenta-fg} -- icon hidden (+2 firewall), -2 dice on your Matrix actions; bonuses and calls untouched`
+                : a.arOffline
+                    ? `{red-fg}LOUD, AR CUT{/red-fg} -- someone hacked your overlay dark ("reboot")`
+                    : `{green-fg}LOUD{/green-fg} -- full bonuses, and hackable`;
         const slaves = a.panSlaves();
         const lines = [
             `PAN: ${a.name.toUpperCase()}`,
@@ -172,15 +167,22 @@ export class PanCommand extends Command {
             }
         }
         lines.push('');
-        lines.push(a.runningSilent
-            ? `Silent running: enemy deckers must FIND you before they can crack you -- but a good one can force you loud.`
-            : `Running loud: any decker in reach can try your firewall -- jammed guns and dead AR are how that feels.${hint(' "silent" goes dark.')}`);
+        // THE TWO SWITCHES, NAMED APART. A player reading this screen is
+        // deciding between them, and until this item they had only one verb.
+        lines.push(radioIsDark(a)
+            ? `Radio off: there is no icon of yours anywhere on the Matrix, and a cable ("tap") is the only way anyone reaches your gear.${hint(' "wireless on" to come back up.')}`
+            : a.runningSilent
+                ? `Silent running: enemy deckers must FIND you before they can crack you -- but a good one can force you loud.${hint(' "wireless off" is the harder version: no icon at all, and no bonuses either.')}`
+                : `Running loud: any decker in reach can try your firewall -- jammed guns and dead AR are how that feels.${hint(' "silent" hides your icon; "wireless off" kills the broadcast outright.')}`);
         return lines.join('\n');
     }
     /** What one slaved device is and what being on the net buys it. */
     slaveLine(item) {
         const a = this.actor;
-        const inactive = a.runningSilent || a.arOffline;
+        // A SLAVE'S BONUS DIES WITH ITS RADIO, NOT WITH SILENCE (p.421 vs
+        // p.235, RXPvXqTwEyH9v3Zk7). This asked `a.runningSilent`, which is
+        // the one thing canon says does NOT cost you wireless bonuses.
+        const inactive = !item.wirelessOn || a.arOffline;
         if (item.isCyberdeck()) {
             return `${item.name} (cyberdeck) -- Matrix access; ${item.deckSummary()}${item.isBricked ? ' BRICKED (rest to repair)' : ''}`;
         }

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { fetchPlayers } from '../utilities/social.js';
 import { authToken } from '../utilities/cloud-saves.js';
+import { radioIsDark } from '../utilities/pan-devices.js';
 /**
  * THE STREET ("crew players"). Real players' runners, shown by STREET
  * NAME only -- no account handles, no emails. A runner is "online" only
@@ -31,11 +32,17 @@ export class PlayersCommand extends Command {
         // "headers like that are too cluttery"). The heading itself stays --
         // it carries what the panel divider can't say for it.
         const lines = [`THE STREET (real runners, via maka-cli.com)`];
-        const myLink = game.player.liveLink() != null && !game.player.runningSilent;
+        // THREE REASONS THE BEACON IS DARK, and the line names which
+        // (RXPvXqTwEyH9v3Zk7). It used to offer two, with "running silent"
+        // standing in for the switched-off case as well -- which is exactly
+        // the conflation that item was filed about. The cure differs per
+        // reason, so the reason has to be the right one.
+        const dark = radioIsDark(game.player);
+        const myLink = game.player.liveLink() != null && !game.player.runningSilent && !dark;
         lines.push(beat === 'ok'
             ? myLink
                 ? `  Your beacon: broadcasting -- the street can see ${this.actor.name}.`
-                : `  Your beacon: DARK -- ${game.player.runningSilent ? 'you\'re running silent' : 'no commlink equipped'}; the street can't see you.`
+                : `  Your beacon: DARK -- ${dark ? 'your wireless is OFF ("wireless on")' : game.player.runningSilent ? 'you\'re running silent ("silent" to go loud)' : 'no commlink equipped'}; the street can't see you.`
             : beat === 'logged-out'
                 ? `  Your beacon: DARK -- \`maka login\` and the street will see you.`
                 : `  Your beacon: DARK -- the grid didn't answer; nobody sees you right now.`);

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

@@ -1,32 +1,53 @@
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { Category } from '../types/shared/item-enum.js';
-import { CALL_ICON, CALL_COLOR, dropActiveCall } from '../utilities/comm-style.js';
+import { CALL_ICON, CALL_COLOR } from '../utilities/comm-style.js';
+import { billAction } from '../utilities/action-cost.js';
+import { radioIsDark } from '../utilities/pan-devices.js';
 /**
- * Running silent, the Shadowrun way: your commlink stays on you but stops
- * broadcasting. While silent, you can't place calls and NOBODY can raise
- * you -- including the fixer, so a job callback will not find you until
- * you go loud again. Toggling silent drops any call you're on. The HUD's
- * Link line tracks the state (see game.ts updateStatus).
+ * RUNNING SILENT (p.235-236): your radio stays ON and your icon stops
+ * being findable. That is the whole of it.
  *
- * What silence COSTS and what it does NOT (canon p.235-236, checked
- * 2026-08-27): it hides your icon -- finding you takes a Matrix
- * Perception test first, then an Opposed test -- and it charges -2 dice
- * on every Matrix action you take (Player.matrixActionPenalty), on top
- * of the calls and the commlink initiative bonus this engine already
- * takes. It does NOT blind you: your own AR overlay keeps painting,
- * because AR is what you receive (p.229). See utilities/ar.ts arSightUp.
+ * WHAT THIS VERB STOPPED MEANING (RXPvXqTwEyH9v3Zk7, Maka: "we need to
+ * work out wireless vs silent. Silent should only be in the matrix, with
+ * its meat counterpart of 'sneak'. What turns off your broadcast should
+ * be 'wireless'"). Until that item, `silent` also killed your calls,
+ * your street-list beacon and your commlink's initiative bonus, and the
+ * HUD announced it in the meat as "Link SILENT" -- so the word meant
+ * "go dark", there was no other verb that did, and a player could not
+ * tell the two states apart because the engine did not either.
  *
- * WHERE IT WORKS: anywhere. Meat, AR, VR, and inside a host -- switching
- * to silent running is a Simple Action and the book puts no precondition
- * on it (p.235-236). It is not a device you power down, so being jacked
- * in is not an obstacle to it; Data Trails p.68-69 assumes a hacker runs
- * silent while already inside a host. See execute() for the refusal this
- * replaced and why it was wrong (qM7FmMABSMa9hZbqG).
+ * Canon separates them cleanly, and the split is now the code's:
+ *   - RUNNING SILENT (p.235, Simple Action) "reduces your traffic to and
+ *     from the Matrix, but it doesn't stop it entirely". It costs -2
+ *     dice on ALL your Matrix actions (Player.matrixActionPenalty) and
+ *     hides your icon behind an Opposed Computer + Intuition [Data
+ *     Processing] v. Logic + Sleaze test. It costs you NO wireless
+ *     bonuses -- the rules never take them.
+ *   - WIRELESS OFF (p.421, Free Action, commands/wireless.ts) is what
+ *     takes the bonuses, the calls and your Matrix presence entirely.
+ *
+ * It does NOT blind you: your own AR overlay keeps painting, because AR
+ * is what you receive (p.229). See utilities/ar.ts arSightUp.
+ *
+ * AND IT DOES NOT UN-SEE YOU. p.235, Spotting Duration: "Once you've
+ * spotted an icon in the Matrix, you continue to spot it even if it
+ * initiates silent running." Only Hide, a reboot or a jack-out clears a
+ * spot, so this verb deliberately never touches Player.matrixSpottedBy.
+ *
+ * WHERE IT WORKS: anywhere. Meat, AR, VR, and inside a host -- the book
+ * names "your commlink, deck, other device, or persona" and puts no
+ * precondition on the action (p.235-236). A body in a room hiding its
+ * PAN from a hostile decker is the ordinary case, not an edge one; Data
+ * Trails p.68-69 assumes a hacker runs silent while already INSIDE a
+ * host. The meat/Matrix pair the reporter asked for is enforced in the
+ * VOCABULARY -- this verb talks about your ICON, `sneak` talks about
+ * your body -- rather than by refusing a legal action. See execute() for
+ * the refusal this replaced and why it was wrong (qM7FmMABSMa9hZbqG).
  */
 export class SilentCommand extends Command {
     static verb = 'silent';
-    static description = 'Toggle your commlink broadcast: running silent hides your icon -- no calls in OR out (nobody can reach you, not even the fixer), no commlink initiative bonus, and -2 dice on your own Matrix actions, until you go loud again. Your AR overlay keeps painting.';
+    static description = 'Toggle running silent (p.235): your icon stops being findable -- anything hunting you needs an Opposed Matrix Perception test first -- at -2 dice on all your own Matrix actions. Your radio stays ON: calls, AR and wireless bonuses are untouched. "wireless off" is what goes properly dark.';
     async execute(_args = []) {
         const actor = this.actor;
         // JACKED IN IS EXACTLY WHEN YOU WANT THIS (qM7FmMABSMa9hZbqG, Deditri:
@@ -61,37 +82,56 @@ export class SilentCommand extends Command {
         if (!hasAnyLink) {
             return `You have no commlink, deck or persona to silence.`;
         }
+        // NOTHING BROADCASTING, NOTHING TO HIDE (RXPvXqTwEyH9v3Zk7). Running
+        // silent is a mode a LIVE icon runs in (p.235: it "reduces your
+        // traffic", which presupposes traffic). With every radio switched
+        // off there is no icon at all, so silence would be a state with no
+        // effect that still charged -2 dice. A technomancer's living persona
+        // has no switch to throw, so it is never dark this way.
+        if (!actor.isTechnomancer() && radioIsDark(actor)) {
+            return `Every radio you own is already off -- there is no icon of yours out there to hide.${hint(` ("wireless on" first if you want to be findable-but-silent instead of simply absent.)`)}`;
+        }
         // WHOSE VOICE THE ANSWER IS IN. Now that this verb works on the grid,
         // the meat-world wording would land on a persona that has no overlay
         // and, for a technomancer, no link either -- "your AR overlay is
         // unaffected" is a strange thing to tell someone who is currently IN
         // VR. Same mechanics either way; only the noun changes.
         const inVr = actor.plane === 'matrix';
+        // A SIMPLE ACTION, PRICED WHERE THE BOOK PRICES IT (p.235:
+        // "Switching to silent running is a Simple Action"). This verb billed
+        // nothing at all before RXPvXqTwEyH9v3Zk7 -- so mid-firefight a
+        // runner could go silent, go loud and go silent again for free while
+        // `pan`, three files away, correctly charged for a Free Action.
+        // billAction only charges inside an encounter, so this stays free
+        // out of combat.
+        const bill = billAction(this.scene, actor, 'simple', 'Running Silent');
+        if (bill)
+            return bill;
         // Going loud again.
         if (actor.runningSilent) {
             actor.runningSilent = false;
-            actor.performAction('goes loud', 'commlink broadcasting');
+            actor.performAction('goes loud', 'icon broadcasting openly');
             this.logger.write(`${actor.name} stops running silent.`);
             this.scene.updateStatus();
             // The street sees the link state (players list) -- beat now.
             if (this.game?.hasHub)
                 void this.game.pushPresenceNow();
             return inVr
-                ? `{${CALL_COLOR}-fg}${CALL_ICON} Your icon swims back into the open -- broadcasting again, and anything looking can see you.{/${CALL_COLOR}-fg}`
-                : `{${CALL_COLOR}-fg}${CALL_ICON} Your link comes back up -- broadcasting again. Calls can reach you now.{/${CALL_COLOR}-fg}`;
-        }
-        // Going silent: drop any active call first, both sides.
-        let hangupNote = '';
-        const partner = dropActiveCall(actor);
-        if (partner) {
-            this.logger.write(`${actor.name} dropped the call with ${partner} by going silent.`);
-            hangupNote = ` The call with ${partner} drops mid-word.`;
+                ? `{${CALL_COLOR}-fg}${CALL_ICON} Your icon swims back into the open -- anything looking can see you now, with no test to make.{/${CALL_COLOR}-fg}`
+                : `{${CALL_COLOR}-fg}${CALL_ICON} Your icon comes back into the open -- anyone sweeping for it finds it now, and the -2 on your Matrix actions lifts.{/${CALL_COLOR}-fg}`;
         }
+        // NO HANG-UP HERE ANY MORE. Dropping the call moved to
+        // commands/wireless.ts, where the state that actually kills your
+        // traffic lives (p.421). Canon is explicit that silence does not:
+        // it "reduces your traffic to and from the Matrix, but it doesn't
+        // stop it entirely" (p.235).
         actor.runningSilent = true;
-        actor.performAction('goes silent', 'commlink dark');
+        actor.performAction('goes silent', 'icon hidden');
         this.logger.write(`${actor.name} is now running silent.`);
         this.scene.updateStatus();
-        // Silent means OFF the street list too -- beat now.
+        // A hidden icon is off the street list too -- beat now. (The list is
+        // "who can be FOUND on the grid", which silence answers; whether
+        // they can be CALLED is a separate question now, and still yes.)
         if (this.game?.hasHub)
             void this.game.pushPresenceNow();
         // NOT {gray-fg} (standing ruling): blessed gray is ANSI
@@ -105,12 +145,15 @@ export class SilentCommand extends Command {
         // more small print. The exemption gets its own sentence now.
         return [
             inVr
-                ? `{white-fg}${CALL_ICON} Your persona stops broadcasting -- your icon thins out of the traffic around you.${hangupNote}`
-                : `{white-fg}${CALL_ICON} You kill your link's broadcast.${hangupNote}`,
-            `SILENT: your icon is hidden. No calls in or out, no commlink initiative bonus, and -2 dice on your own Matrix actions while you cover your tracks.`,
+                ? `{white-fg}${CALL_ICON} Your persona thins out of the traffic around you -- there, but no longer where anything can point at.`
+                : `{white-fg}${CALL_ICON} Your PAN's icon thins out of the grid's traffic -- still there, just no longer findable.`,
+            `SILENT: anything hunting you needs a Matrix Perception hit to know you exist, then an Opposed test to pin you (p.235). It costs -2 dice on all your own Matrix actions.`,
+            // THE RADIO IS STILL ON, SAID OUT LOUD, because until this item
+            // the verb claimed the opposite and a reporter had to ask. This is
+            // the sentence the item was filed for.
             inVr
-                ? `You are still jacked in and still see everything you saw a moment ago -- silence is what you BROADCAST, not what you can see.${hint(` ("silent" again to go loud.)`)}{/white-fg}`
-                : `Your AR overlay is UNAFFECTED and still painting -- silence is what you BROADCAST, not what you can see.${hint(` ("silent" again to go loud.)`)}{/white-fg}`,
+                ? `Your radio is untouched -- you are still jacked in, still see everything you saw a moment ago, and your gear keeps its wireless bonuses. Silence is what you BROADCAST, not what you can see.${hint(` ("silent" again to go loud; "wireless off" is the harder version that costs you the bonuses too.)`)}{/white-fg}`
+                : `Your radio is untouched -- AR still painting, calls still landing, wireless bonuses intact. Silence is what you BROADCAST, not what you can see.${hint(` ("silent" again to go loud; "wireless off" is what actually kills the broadcast.)`)}{/white-fg}`,
         ].join(' ');
     }
 }

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

@@ -16,7 +16,7 @@ export class SneakCommand extends Command {
         const actor = this.actor;
         if (actor.plane !== 'meat') {
             return actor.plane === 'matrix'
-                ? `Personas don't tiptoe.${hint(` Run silent ("silent") if you want to be hard to find on the grid.`)}`
+                ? `Personas don't tiptoe.${hint(` Sneaking is the MEAT half of this; on the grid the verb is "silent", which hides your icon instead of your body.`)}`
                 : `The astral doesn't care how softly you drift.`;
         }
         if (actor.inExchange) {

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

@@ -1,6 +1,6 @@
 import { Command } from './command.js';
 import { whereIsThat } from '../utilities/matrix-roster.js';
-import { gridVicinity } from '../utilities/grid-reach.js';
+import { gridVicinity, hostDoorOpenFor } from '../utilities/grid-reach.js';
 import { fileReach } from '../utilities/planes.js';
 import { canReach, ensureAtSpot, sealedRouteTo } from '../utilities/spots.js';
 import { hint } from '../utilities/hints.js';
@@ -143,7 +143,7 @@ export class TakeCommand extends Command {
                 return `Those files are on the ${room.offlineServer} -- off the network entirely. No persona reaches that box; your BODY has to be in ${room.name} (p.233).`;
             }
             if (reach === 'enter') {
-                return `Those files are INSIDE the host, and you're out on the grid looking at its shell (p.246). ${room.hostMarksBy.has(this.actor.name) || room.hostCracked ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
+                return `Those files are INSIDE the host, and you're out on the grid looking at its shell (p.246). ${hostDoorOpenFor(room, this.actor) ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
             }
             // Same split as look.ts: the host's seal does not reach a box that
             // is not on the network. The air gap IS the server's security.
@@ -291,7 +291,7 @@ export class TakeCommand extends Command {
                 if (far.reach === 'offline')
                     return `${far.item.name} is on the ${far.room.offlineServer} in ${far.room.name} -- an offline server, off the network entirely. No persona reaches that box; your BODY has to be in ${far.room.name} (p.233).`;
                 if (far.reach === 'host')
-                    return `${far.item.name} is INSIDE ${far.room.name}'s host, and you're out on the grid looking at its shell (p.246). ${far.room.hostMarksBy.has(this.actor.name) || far.room.hostCracked ? `"enter ${far.room.name}" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
+                    return `${far.item.name} is INSIDE ${far.room.name}'s host, and you're out on the grid looking at its shell (p.246). ${hostDoorOpenFor(far.room, this.actor) ? `"enter ${far.room.name}" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
                 if (far.reach === 'open')
                     return `${far.item.name} is loose on the grid -- a dim icon. ${hint(`"download ${far.item.name}" writes it to a chip from here.`)}`;
             }
@@ -337,7 +337,7 @@ export class TakeCommand extends Command {
                 return `The ${item.name} sits on the ${room.offlineServer} -- a box with no Matrix presence at all. No persona reaches it from anywhere: get your BODY into ${room.name} and cable in (p.233).`;
             }
             if (reach === 'enter') {
-                return `The ${item.name} is INSIDE the host -- you're on the outside grid, reading its shell (p.246). ${(room.hostMarksBy.get(this.actor.name) ?? 0) > 0 || room.hostCracked ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
+                return `The ${item.name} is INSIDE the host -- you're on the outside grid, reading its shell (p.246). ${hostDoorOpenFor(room, this.actor) ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
             }
             // A LOOSE END IS ERASED, NOT CARRIED (win-condition-seed.ts 'erase',
             // 2026-09-14): pulling the footage down to a chip leaves the desk's

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

@@ -0,0 +1,107 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { CALL_ICON, CALL_COLOR, dropActiveCall } from '../utilities/comm-style.js';
+import { billAction } from '../utilities/action-cost.js';
+import { switchableDevices, radioIsDark } from '../utilities/pan-devices.js';
+/**
+ * THE MASTER SWITCH (RXPvXqTwEyH9v3Zk7, Maka: "What turns off your
+ * broadcast should be 'wireless'").
+ *
+ * SR5 p.421, "Turning It Off", prices both scales in one sentence:
+ * "Toggling an individual device's wireless functionality off is a Free
+ * Action, as is toggling all of your wireless devices to 'wireless off.'
+ * You lose wireless bonuses, but the items can no longer be wirelessly
+ * hacked." The per-device half has existed since CgJ6uTfEvTd8JXdDN as
+ * `pan on|off <device>`. This is the other half, which canon names
+ * explicitly and the engine never had -- so the only way to go dark was
+ * `silent`, and that is how one verb came to mean two things.
+ *
+ * WHAT THIS IS NOT. Running silent (commands/silent.ts, p.235-236) is a
+ * DIFFERENT state and this verb must never be mistaken for it:
+ *
+ *                       wireless off (p.421)    running silent (p.235)
+ *   toggle              Free Action             Simple Action
+ *   on the Matrix       not at all              yes -- traffic "reduced,
+ *                                               not stopped entirely"
+ *   wirelessly hackable no                      yes, once found
+ *   wireless bonuses    LOST                    kept
+ *   costs you           the bonuses             -2 dice, all Matrix actions
+ *
+ * A cable still reaches a dark device (`tap`, p.233/p.421: the universal
+ * access port is not wireless and "nothing is completely safe from a
+ * hacker with a datajack"). Going dark is cover, not armour.
+ */
+export class WirelessCommand extends Command {
+    static verb = 'wireless';
+    static description = 'Switch every device you carry on or off the air at once (p.421, a Free Action). Wireless OFF costs you every wireless bonus and every call, and leaves nothing of yours on the Matrix to hack. Distinct from "silent", which hides your icon but keeps you broadcasting.';
+    async execute(args = []) {
+        const actor = this.actor;
+        const head = (args[0] ?? '').toLowerCase();
+        const devices = switchableDevices(actor);
+        if (devices.length === 0) {
+            return `You are carrying nothing with a radio in it. Nothing to switch.`;
+        }
+        // Bare "wireless" reports AND toggles, like `silent` and `sneak` --
+        // but only after the report, because a player who typed it to LOOK
+        // should not discover they have thrown the switch. An explicit
+        // on/off always wins.
+        const dark = radioIsDark(actor);
+        const wanted = head === 'on' ? true
+            : head === 'off' ? false
+                : head === '' ? dark
+                    : undefined;
+        if (wanted === undefined) {
+            return `"wireless on" or "wireless off" -- or "pan off <device>" for just the one.`;
+        }
+        const changing = devices.filter(i => i.wirelessOn !== wanted);
+        if (changing.length === 0) {
+            return wanted
+                ? `Everything you carry is already on the air.`
+                : `Everything you carry is already dark -- no icons, nothing to hack.${hint(` ("wireless on" to come back up.)`)}`;
+        }
+        // p.421 prices the all-devices form the same as the single one, so
+        // this is billed exactly like commands/pan.ts's switch -- which also
+        // means it is free OUT of combat, because billAction only charges
+        // inside an encounter.
+        const bill = billAction(this.scene, actor, 'free', `Wireless ${wanted ? 'On' : 'Off'}`);
+        if (bill)
+            return bill;
+        for (const item of changing)
+            item.wirelessOn = wanted;
+        if (wanted) {
+            actor.performAction('brings its gear back on the air', 'wireless on');
+            this.logger.write(`${actor.name} switches ${changing.length} device(s) wireless ON.`);
+            this.scene.updateStatus();
+            if (this.game?.hasHub)
+                void this.game.pushPresenceNow();
+            return [
+                `{${CALL_COLOR}-fg}${CALL_ICON} ${changing.map(i => i.name).join(', ')} -- back on the air.{/${CALL_COLOR}-fg}`,
+                `{white-fg}Wireless bonuses are live again, calls can reach you, and so can anyone who goes looking.${actor.runningSilent ? ` You are still running SILENT, so your icon stays hidden.` : ''}{/white-fg}`,
+            ].join(' ');
+        }
+        // GOING DARK HANGS UP, and this is the verb that should do it --
+        // silent.ts used to, on the strength of a claim canon does not make.
+        // See utilities/comm-style.ts dropActiveCall for why both sides are
+        // cleared here rather than by each caller.
+        let hangupNote = '';
+        const partner = dropActiveCall(actor);
+        if (partner) {
+            this.logger.write(`${actor.name} dropped the call with ${partner} by going wireless-off.`);
+            hangupNote = ` The call with ${partner} drops mid-word.`;
+        }
+        actor.performAction('kills its radios', 'wireless off');
+        this.logger.write(`${actor.name} switches ${changing.length} device(s) wireless OFF.`);
+        this.scene.updateStatus();
+        // Dark means OFF the street list too -- beat now, same as silent.
+        if (this.game?.hasHub)
+            void this.game.pushPresenceNow();
+        // NOT {gray-fg} (standing ruling): blessed gray is ANSI bright-black
+        // and vanishes on stock dark palettes. White is the neutral.
+        return [
+            `{white-fg}${CALL_ICON} You thumb every radio you own off: ${changing.map(i => i.name).join(', ')}.${hangupNote}`,
+            `WIRELESS OFF: nothing of yours is on the Matrix at all -- no icon to find, nothing to hack (p.421).`,
+            `It costs you every wireless bonus: no calls, no AR initiative, no smartlink in the pool.${hint(` A cable still reaches you -- "tap" works on dark gear. "wireless on" to come back up.`)}{/white-fg}`,
+        ].join(' ');
+    }
+}
+//# sourceMappingURL=wireless.js.map

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -1614,5 +1614,60 @@
 //   names the cable. The AR overlay deliberately says NOTHING: that
 //   surface annotates broadcasts, which is its stated contract, and the
 //   first cut of this violated it.
-export const ENGINE_VERSION = '1.87.0';
+// 1.88.0 (2026-09-17): THE DOOR INTO A HOST IS A MARK AND NOTHING ELSE
+//   (DxfeZTBrP6Bu7MLF4, Maka: "I shouldn't be able to re-enter the host
+//   if I have no marks on it"). `enter` accepted Room.hostCracked as a
+//   substitute for the key. That flag is ROOM-GLOBAL and permanent for
+//   the save -- once anybody took a node to three marks its door never
+//   shut again, for anybody. The reporter's own transcript walks it:
+//   three marks forced into the Approach host, cracked, JACK OUT (canon
+//   deletes every mark they placed, p.242), jack back in reading MARKS
+//   0 held -- and straight back inside with the Patrol locking on.
+//   Canon is one sentence (p.239, RAG-checked 2026-09-17): "a host
+//   allows anyone to enter if they've got a mark", marks "only last a
+//   single Matrix session" (p.236), three of them buy nothing that
+//   outlives them, and a host's owner cannot be changed (p.237). This
+//   is 1.56.0's ruling (spcebZTKN24GYRHXW, a cracked host is not a host
+//   you hold marks on) finally applied to the one verb the flag was
+//   actually a door for. The crack's WORLD consequences are untouched:
+//   the vault still hangs open, the archive still reads unsealed, the
+//   maglocks it released stay released -- those are facts about the
+//   site, and the key is a fact about you.
+//   ONE GATE, ONE ANSWER: grid-reach.ts hostDoorOpenFor is now the only
+//   place that decides, and every surface that says "enter" asks it --
+//   the verb, look/take's file refusals, and the grid icon, which used
+//   to print `("enter" walks in)` under a crack and would otherwise have
+//   become an invitation the verb refuses.
+//   THE HAVEN IS THE ONE EXEMPTION and is labelled as an engine ruling,
+//   not canon: a sanctioned host (Room.hostSanctioned, JackPoint) is a
+//   members' place, and membership is the mark.
+// 1.89.0 (2026-09-17): WIRELESS vs SILENT vs SNEAK (RXPvXqTwEyH9v3Zk7,
+//   Maka: "we need to work out wireless vs silent. Silent should only be
+//   in the matrix, with its meat counterpart of 'sneak'. What turns off
+//   your broadcast should be 'wireless'"). `Player.runningSilent` was
+//   one flag doing two canon jobs: it hid your icon (p.235, right) and
+//   also killed your calls, your street beacon and your commlink's
+//   initiative bonus (p.421's wireless-off, wrong). There was no verb
+//   for the second, so `silent` was the only way to go dark and the HUD
+//   announced it in the meat as "Link SILENT".
+//   NEW VERB `wireless [on|off]` -- p.421 names the all-devices form
+//   explicitly ("as is toggling all of your wireless devices to
+//   'wireless off'") and prices it a Free Action; it sweeps the same
+//   device list `pan on|off <device>` uses, now shared in
+//   utilities/pan-devices.ts. It takes the hang-up, the wireless
+//   bonuses (smartgun +1, the AR initiative bonus) and both directions
+//   of `call`.
+//   `silent` is running silent and nothing else: a SIMPLE action now
+//   (p.235; it billed nothing before), refused when every radio is
+//   already off, and it keeps AR, calls and every wireless bonus. It
+//   stays legal in the meat -- the book silences "commlink, deck, other
+//   device, or persona" -- and the meat/Matrix pair the reporter asked
+//   for is carried by the VOCABULARY instead: the HUD slot reads
+//   "Icon SILENT" (was "Link SILENT") with a new "WIRELESS OFF" rung
+//   above it, and `sneak` keeps the body.
+//   utilities/comm-style.ts isLinked() split: isReachable() is the CALL
+//   question (a live radio) and isLinked() stays the ICON question (a
+//   live radio AND not silent). PRESENCE gains a sparse `wirelessOff`
+//   beside `linkUp`, so the site can name which dark it is.
+export const ENGINE_VERSION = '1.89.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -126,10 +126,12 @@ import { ProjectCommand, ReturnCommand } from './commands/project.js';
 import { AssenseCommand } from './commands/assense.js';
 import { DroneCommand } from './commands/drone.js';
 import { PanCommand } from './commands/pan.js';
+import { WirelessCommand } from './commands/wireless.js';
 import { ArCommand, ArosCommand } from './commands/ar.js';
 // The HUD's AR read (statusLinesFor) -- built there so it asks the same
 // predicate the overlay itself does; see utilities/ar.ts for why.
 import { arStatusSlots } from './utilities/ar.js';
+import { radioIsDark } from './utilities/pan-devices.js';
 import { RebootCommand } from './commands/reboot.js';
 import { BrandishCommand, HolsterCommand } from './commands/brandish.js';
 import { AdvanceCommand } from './commands/advance.js';
@@ -861,8 +863,18 @@ export default class Game {
             slug: saveSlug(this.player.name),
             hubName: this._hubName,
             // ONLINE means the LINK is live (player ruling): commlink equipped
-            // and broadcasting. Pull the link or run silent -> off the street.
-            linkUp: this.player.liveLink() != null && !this.player.runningSilent,
+            // and FINDABLE. Pull the link, kill the radio or run silent -> off
+            // the street. Two states answer it now (RXPvXqTwEyH9v3Zk7), and
+            // `linkUp` deliberately keeps meaning the union of them: the
+            // street list is "who can be found on the grid", and both a silent
+            // icon and a dead radio fail that for different reasons.
+            linkUp: this.player.liveLink() != null
+                && !this.player.runningSilent
+                && !radioIsDark(this.player),
+            // WHICH DARK IT IS, so the site can say so instead of guessing.
+            // Sparse on purpose: absent means "this client did not report",
+            // which is what every build before this one is.
+            wirelessOff: radioIsDark(this.player) ? true : undefined,
             summary: {
                 archetypeName: this.player.archetypeName,
                 karma: this.player.careerKarma,
@@ -2948,6 +2960,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('assense', AssenseCommand);
         CommandFactory.registerCommand('drone', DroneCommand);
         CommandFactory.registerCommand('pan', PanCommand);
+        CommandFactory.registerCommand('wireless', WirelessCommand);
         // THE AR LAYER (commands/ar.ts): `ar` mutes your own overlay,
         // `aros` reads what it is showing you -- player requests
         // 2026-08-26, "we need AROs on anything online" and "there

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

@@ -952,8 +952,13 @@ Available in-game commands (use with [COMMAND] prefix):
 - talk-to <target> — initiate conversation with another character
 - call <target> [message] — call someone remotely over a commlink (works even if they're not in your room; requires having a commlink equipped, and the target having one too)
 - end-call — hang up your current commlink call
-- silent — toggle your commlink broadcast. While running silent, you can't place
-  calls and nobody can call YOU. Toggle again to go loud.
+- silent — toggle running silent. Your radio stays ON and your calls still work; what
+  changes is that your Matrix icon stops being findable, and every Matrix action you
+  take costs 2 dice. Nobody can call YOU while silent — they have nothing to point at.
+  Toggle again to go loud.
+- wireless [on|off] — switch every device you carry on or off the air at once. Wireless
+  OFF is the real blackout: no calls either way, no wireless bonuses on any of your
+  gear, and nothing of yours on the Matrix at all to find or hack.
 - read <target> - Reads an item of Category "Book"
 - attack <target> — attack someone in your room. Resolved as opposed dice-pool combat
   (your weapon and armor matter); an initiative roll decides who strikes first each

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

@@ -3695,13 +3695,19 @@ export class Player extends AbstractPlayer {
         }
         // The live link, not just the worn one: a deck drives AR too (p.223).
         const link = this.liveLink();
-        // AR needs a link that's on you, broadcasting, and not hacked dark.
-        // An ENGINE ADDITION, not canon: p.474 gives AR a bare Intuition +
-        // Reaction. It predates this change and is left alone deliberately,
-        // because it is the counterweight that makes running silent cost
-        // something -- but it is named here so nobody later "verifies" it
-        // against the book and finds it missing.
-        const arBonus = link && !this.runningSilent && !this.arOffline ? link.qualityBonus : 0;
+        // AR needs a link that's on you, with its radio ON, and not hacked
+        // dark. An ENGINE ADDITION, not canon: p.474 gives AR a bare
+        // Intuition + Reaction, and it is named here so nobody later
+        // "verifies" it against the book and finds it missing.
+        //
+        // IT HANGS OFF THE RADIO, NOT OFF SILENCE (RXPvXqTwEyH9v3Zk7). This
+        // asked `!this.runningSilent`, described as "the counterweight that
+        // makes running silent cost something" -- but p.235 already prices
+        // silence at -2 dice on every Matrix action and is explicit that it
+        // costs you no wireless bonuses. A wireless bonus is exactly what
+        // this is, so it belongs to the state that p.421 says takes them:
+        // wireless off. The counterweight moves rather than disappears.
+        const arBonus = link && link.wirelessOn && !this.arOffline ? link.qualityBonus : 0;
         // INCREASE REFLEXES (p.288) adds +1 Initiative per hit AND a die per
         // two hits, capped at +5D6. This engine models the spell as a
         // BOOLEAN -- cast.ts stores no hit count -- so the exact canon grant

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

@@ -3,6 +3,7 @@ import { isWatched, camerasLive, canSnoopFeeds, camerasBroadcast } from './surve
 import { Category } from '../types/shared/item-enum.js';
 import { hint } from './hints.js';
 import { cameraDrTag, drTagFor } from './grid-view.js';
+import { radioIsDark } from './pan-devices.js';
 /**
  * AROs -- AUGMENTED REALITY OBJECTS (player request 2026-08-26: "we
  * need AROs on anything online"). The 2075 street is not bare: anything
@@ -62,7 +63,7 @@ export function arSightUp(actor) {
  * The mechanic is settled and is NOT in question here.
  *
  * That they had to ask is the bug. The HUD does show both axes at once
- * ("◉ AR ON | Link SILENT"), and `silent` says so when you toggle it --
+ * ("◉ AR ON | Icon SILENT"), and `silent` says so when you toggle it --
  * but a player who went dark twenty minutes ago has nothing in front of
  * them affirming that the combination is legal rather than a state they
  * have got themselves stuck in. Two independent axes look like a
@@ -227,12 +228,13 @@ export function aroTags(scene, actor, room) {
  *   OVERLAY -- is the world being painted FOR me? Muting is my own
  *     choice ("ar" flips it back); a hacker cutting it is not
  *     ("reboot" is the only cure).
- *   LINK -- is my commlink BROADCASTING? That is what calls ride
- *     (call.ts wants a worn commlink) and what silence kills.
+ *   LINK -- is my radio on the air, and is my icon findable on it?
+ *     That is what calls ride (call.ts wants a live link) and what
+ *     `wireless` and `silent` answer, in that order.
  *
  * They are genuinely independent -- canon p.229 vs p.235-236: AR is
  * what you RECEIVE, silence is what you EMIT -- so a silent runner
- * reads "AR ON | Link SILENT", both true at once. One slot could never
+ * reads "AR ON | Icon SILENT", both true at once. One slot could never
  * say that, which was the whole complaint.
  *
  * The overlay slot asks arSightUp() rather than re-deriving state, so
@@ -275,13 +277,34 @@ export function arStatusSlots(actor) {
     // performs all commlink functions). The old "AR ON | Link offline"
     // deck-only reading was the honest display of a canon deviation; the
     // mechanics moved, and the display moves with them.
-    const link = actor.liveLink() == null
-        ? `{white-fg}Link offline{/white-fg}`
-        : actor.arOffline
-            ? `{red-fg}Link CRACKED -- reboot{/red-fg}`
-            : actor.runningSilent
-                ? `{magenta-fg}Link SILENT{/magenta-fg}`
-                : `{${CALL_COLOR}-fg}Link online{/${CALL_COLOR}-fg}`;
+    //
+    // FIVE RUNGS, AND THE TOP TWO ARE THE POINT (RXPvXqTwEyH9v3Zk7, Maka:
+    // "we need to work out wireless vs silent"). This slot used to say
+    // "Link SILENT", in the meat, for a state that is about your ICON on
+    // the Matrix -- so the only word the game gave a runner for "I am
+    // hidden" was attached to the wrong noun and the wrong plane, and
+    // there was no rung at all for the state that genuinely kills your
+    // broadcast. Now there are both, and they read as different things:
+    //
+    //   WIRELESS OFF  -- p.421. No radio on at all: no icon, no bonuses,
+    //                    no calls. Your own choice; "wireless on" undoes it.
+    //   Icon SILENT   -- p.235. Radio ON, icon hidden, -2 dice. Says ICON
+    //                    because that is precisely what is hidden -- the
+    //                    link itself is still broadcasting.
+    //
+    // RADIO-OFF LEADS, ahead even of a cracked PAN: "every radio I own is
+    // switched off" is both the stronger statement and the only one that
+    // names its own cure, and a hacker has nothing on the air to crack
+    // anyway. Below it the existing order is untouched.
+    const link = radioIsDark(actor)
+        ? `{white-fg}WIRELESS OFF{/white-fg}`
+        : actor.liveLink() == null
+            ? `{white-fg}Link offline{/white-fg}`
+            : actor.arOffline
+                ? `{red-fg}Link CRACKED -- reboot{/red-fg}`
+                : actor.runningSilent
+                    ? `{magenta-fg}Icon SILENT{/magenta-fg}`
+                    : `{${CALL_COLOR}-fg}Link online{/${CALL_COLOR}-fg}`;
     return { overlay, link };
 }
 /** The tags as the standard cyan block, or '' when there is nothing to

package/bundle/typescript/src/commands/game/sideQuest/utilities/comm-style.js

@@ -18,26 +18,45 @@ export const CALL_COLOR = 'cyan';
  *  any typed message from colliding with it. */
 export const END_CALL_SENTINEL = 'end-call';
 /**
- * Whether an actor is REACHABLE over the grid: a commlink carried or
- * worn, and the link actually broadcasting. Same shape as call.ts's own
- * reachability checks -- shared here so rosters (contacts.ts) can show
- * who's a call away without re-deriving it.
+ * IS THERE A RADIO ON THIS PERSON -- a commlink carried or worn with its
+ * wireless switch ON. This is the CALL question: can a voice get to
+ * them, and can theirs get out.
+ *
+ * SILENCE IS NOT AN ANSWER TO IT (RXPvXqTwEyH9v3Zk7, and p.235 in one
+ * clause: running silent "reduces your traffic to and from the Matrix,
+ * but it doesn't stop it entirely"). This predicate and isLinked() below
+ * used to be one function that returned false for BOTH a dead radio and
+ * a silent one, which is how `silent` came to mean "go dark" -- the
+ * thing the reporter asked us to untangle. Losing your traffic is what
+ * `wireless off` buys (p.421); silence only hides the icon.
+ *
+ * A LINK YOU SWITCHED OFF IS NOT A LINK (p.233, `pan off <device>`;
+ * CgJ6uTfEvTd8JXdDN). Undefined counts as ON, so every caller that
+ * passes a plain shape (NPC fixtures, saves written before the switch)
+ * is unchanged.
  */
-export function isLinked(actor) {
-    if (actor.runningSilent)
-        return false;
-    // A LINK YOU SWITCHED OFF IS NOT A LINK (p.233, `pan off <device>`;
-    // CgJ6uTfEvTd8JXdDN). This used to ask only whether a commlink was
-    // present, so a runner who deliberately took theirs off the air still
-    // took calls and still hung a PAN icon on the grid for anyone to
-    // find -- the switch would have been a lie everywhere it mattered.
-    // Undefined counts as ON, so every caller that passes a plain shape
-    // (NPC fixtures, saves written before the switch) is unchanged.
+export function isReachable(actor) {
     const worn = actor.equipment.head?.commlink;
     const wornOn = worn != null && worn.wirelessOn !== false;
     const carried = actor.inventory.getAllItems().some(i => i.category === 'commlink' && i.wirelessOn !== false);
     return wornOn || carried;
 }
+/**
+ * DOES THIS PERSON HANG AN ICON anyone can see -- a live radio AND not
+ * running silent. This is the VISIBILITY question, and it is what the
+ * AR overlay (ar.ts), the grid's PAN icons (grid-view.ts) and the Matrix
+ * roster all ask: a silent icon is correctly absent from every one of
+ * them until somebody wins the opposed Matrix Perception test for it
+ * (p.235-236, utilities/silent-icons.ts).
+ *
+ * Keeps the name because every existing caller wanted exactly this; the
+ * half that was wrong split off into isReachable() above.
+ */
+export function isLinked(actor) {
+    if (actor.runningSilent)
+        return false;
+    return isReachable(actor);
+}
 /**
  * DROP A LIVE CALL, BOTH SIDES, and say who was on it.
  *

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-reach.js

@@ -41,6 +41,42 @@ export function hostsInReach(rooms, actor) {
 export function hostOver(room) {
     return room?.hasNode ? room : undefined;
 }
+/**
+ * IS THE DOOR OPEN TO THIS PERSONA -- the one answer, so that the verb
+ * that crosses and every hint that says "enter" cannot disagree
+ * (DxfeZTBrP6Bu7MLF4, Maka: "I shouldn't be able to re-enter the host if
+ * I have no marks on it").
+ *
+ * p.239 is one sentence long: "Marks required 1 ... a host allows anyone
+ * to enter if they've got a mark." RAG-checked 2026-09-17, which also
+ * settles the other half: marks "only last a single Matrix session and
+ * are deleted when you reboot" (p.236), reaching three of them buys
+ * nothing that outlives them, and a host's owner cannot be changed
+ * (p.237) -- so there is no state in canon that stands in for the key.
+ *
+ * WHAT USED TO STAND IN FOR IT. `enter` accepted Room.hostCracked, which
+ * is ROOM-GLOBAL and permanent for the save: once anybody took the node
+ * to three marks, that door never closed again -- not for the decker who
+ * jacked out (canon wipes their marks, p.242) and not for a team-mate
+ * who had never touched it. That is the same confusion 1.56.0 named for
+ * `hack`/`mark` (spcebZTKN24GYRHXW: a cracked host is not a host you
+ * hold marks on) with the one verb the flag was actually a door for left
+ * out. The crack's WORLD consequences are untouched -- a vault hanging
+ * open stays open, its archive stays listed -- because those are facts
+ * about the site and this is a fact about your keys.
+ *
+ * THE HAVEN IS THE ONE EXEMPTION, and it is an engine ruling, not canon:
+ * a sanctioned host (utilities/jackpoint.ts, Room.hostSanctioned) is a
+ * members' place you belong to, and membership is the mark. Labelled
+ * here rather than hidden in a boolean.
+ */
+export function hostDoorOpenFor(room, actor) {
+    if (!room.hasNode)
+        return false;
+    if (room.hostSanctioned)
+        return true;
+    return (room.hostMarksBy.get(actor.name) ?? 0) >= 1;
+}
 /**
  * A host by any name the game shows for it (grid-names.ts), from
  * anywhere on the grid. Bare "host" (or nothing) means the one over the

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-view.js

@@ -1,6 +1,6 @@
 import { sameHostSide } from '../models/player.js';
 import { personasInside } from './matrix-roster.js';
-import { hostsInReach, hostLine, roomsInReach, gridVicinity } from './grid-reach.js';
+import { hostsInReach, hostLine, roomsInReach, gridVicinity, hostDoorOpenFor } from './grid-reach.js';
 import { NPC } from '../models/npc.js';
 import { hostLabel, hostPurposeFor } from './grid-names.js';
 import { isLinked } from './comm-style.js';
@@ -142,7 +142,17 @@ export function gridIcons(scene, actor, room) {
             icons.push(`● ${hostLabel(room, { capital: true })} -- three spheres turning over rooms that were never sold to anyone. You're on the list; nothing here is hunting.`);
         }
         else if (room.hostCracked) {
-            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- cracked open, security in shreds. Whatever it guarded is unsealed, inside. ("enter" walks in)`);
+            // THE WRECKAGE IS THE SITE'S; THE DOOR IS STILL YOURS TO HOLD
+            // (DxfeZTBrP6Bu7MLF4). This line offered `"enter" walks in` on the
+            // room-global crack alone, so a persona whose marks a jack-out had
+            // just wiped (p.242) read an invitation the verb then refused --
+            // or, before the verb was fixed, accepted, which is the report.
+            // Both halves stay true now: the vault hangs open, and the key is
+            // per-persona and dies with the session (p.236).
+            const way = hostDoorOpenFor(room, actor)
+                ? `("enter" walks in on your mark)`
+                : `("hack ${hostLabel(room)}" or "force ${hostLabel(room)}" for a mark -- yours are gone, and a host still asks for one, p.239)`;
+            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- cracked open, security in shreds. Whatever it guarded is unsealed, inside. ${way}`);
         }
         else {
             const myMarks = room.hostMarksBy.get(actor.name) ?? 0;

package/bundle/typescript/src/commands/game/sideQuest/utilities/pan-devices.js

@@ -0,0 +1,54 @@
+import { Player } from '../models/player.js';
+/**
+ * WHAT THE WIRELESS SWITCH CAN REACH ON ONE RUNNER.
+ *
+ * Lifted out of commands/pan.ts (RXPvXqTwEyH9v3Zk7) when `wireless`
+ * became a second caller. SR5 p.421 prices the two forms side by side --
+ * "Toggling an individual device's wireless functionality off is a Free
+ * Action, as is toggling all of your wireless devices to 'wireless off'"
+ * -- so they are one switch at two scales, and they must agree about
+ * which devices exist. Two hand-built lists would eventually differ, and
+ * the failure would be silent: `wireless off` leaving a smartgun quietly
+ * broadcasting because only `pan` knew to look in the hand.
+ */
+/**
+ * Everything on this runner the switch can reach, held and worn gear
+ * INCLUDED. Equipping moves an item out of `inventory.getAllItems()`,
+ * so a list built from inventory alone loses the gun in your hand --
+ * which is the one device a player is most likely to mute. The lookup,
+ * the "switched off" list and the whole-PAN sweep all read this, so a
+ * device you can turn off is always a device you can see is off.
+ */
+export function reachableDevices(actor) {
+    const seen = new Set();
+    return [
+        actor.equipment.head?.commlink,
+        actor.equipment.head?.eyes,
+        actor.equipment.rightHand?.weapon,
+        actor.equipment.leftHand?.weapon,
+        ...actor.inventory.getAllItems(),
+    ].filter((i) => {
+        if (i == null || seen.has(i))
+            return false;
+        seen.add(i);
+        return true;
+    });
+}
+/** Of those, the ones a PAN can actually hold (p.233) -- what the
+ *  whole-PAN switch acts on, and the only things `wireless` counts. */
+export function switchableDevices(actor) {
+    return reachableDevices(actor).filter(i => Player.canJoinPan(i));
+}
+/**
+ * EVERY RADIO THIS RUNNER OWNS IS OFF.
+ *
+ * Deliberately false for someone carrying nothing: owning no devices is
+ * "the monk's build", a different fact with a different HUD slot
+ * ("Link offline"), and telling a barehanded runner their wireless is
+ * off would name a switch they have never touched.
+ */
+export function radioIsDark(actor) {
+    const devices = switchableDevices(actor);
+    return devices.length > 0 && devices.every(i => !i.wirelessOn);
+}
+//# sourceMappingURL=pan-devices.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/verb-index.js

@@ -25,7 +25,7 @@ export const HELP_CATEGORIES = [
     // players" / "crew street"); the bare verb still answers quietly.
     { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
     { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
-    { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+    { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['wireless'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
     // The Emerged get their own shelf (player request: "there MUST be
     // resonance" -- matrix is the place, Resonance is the talent).
     // `sustain` shelves here and not under magic: the command is

package/package.json

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