@maka/maka-cli 5.207.0 → 5.209.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.207.0",
+  "version": "5.209.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/complete.js

@@ -0,0 +1,125 @@
+import { Command } from './command.js';
+import { nameablesFor, whereAmI } from '../utilities/nameables.js';
+import { normalizeLoose } from '../utilities/fuzzy-match.js';
+/**
+ * TAB COMPLETION, ANSWERED BY THE ENGINE (f79LLqTerep4nKWcA: "How do I
+ * know which host/PAN/etc I'm hacking?").
+ *
+ * The player presses Tab; their client sends `complete <whatever is in
+ * the box>`; this answers. It is not an action -- no phase, no bill, no
+ * Overwatch, no world event -- and it never appears in the transcript as
+ * a turn. It is the input box asking a question.
+ *
+ * WHY A ROUND-TRIP AND NOT A LOCAL LIST. The clients cannot do this
+ * themselves: the web and Unity hold only the meat-plane actor roster
+ * from the condition beat, and the CLI on a shared run holds nothing but
+ * rendered text. Jacked in -- where the reporter actually got lost --
+ * none of them can name a single icon. The engine can name all of them,
+ * on every plane, and `stance next` already proved this exact route
+ * works from all three clients. See utilities/nameables.ts.
+ *
+ * WHAT COMES BACK, in three shapes:
+ *   ONE MATCH     the whole command with the name completed, on the
+ *                 marker line the clients read to refill the box.
+ *   SEVERAL       the candidates, glyphed, with nothing typed for you --
+ *                 an ambiguous guess that picks is worse than none.
+ *   NONE          what IS nameable from here, which is the roster the
+ *                 refusals print, from the same reader.
+ *
+ * THE MARKER LINE is the first line and looks like `{complete}<text>`.
+ * Clients strip it and set the box; anything that does not understand it
+ * simply shows a line telling the player what to type, which is a
+ * perfectly good fallback and the reason it is phrased as one.
+ */
+/** What a client looks for to refill its input box. */
+export const COMPLETE_MARKER = '{complete}';
+export class CompleteCommand extends Command {
+    static verb = 'complete';
+    /** The input box is a human's. Nothing AI-driven types into one. */
+    static npcPolicy = 'human-only';
+    static description = 'What the Tab key sends: completes the name you are part-way through typing, against everything you could name from where you are standing -- hosts, personas, PANs, devices and files on the grid; people, devices, loot, your pack and the exits in the meat.';
+    /**
+     * Split the box into "the command so far" and "the fragment being
+     * typed". A trailing space means the fragment is empty and the player
+     * is asking what could come next, which is the single most useful
+     * thing Tab can answer: `hack ` lists every icon.
+     */
+    split(raw) {
+        if (raw.length === 0 || raw.endsWith(' '))
+            return { head: raw, fragment: '' };
+        const cut = raw.lastIndexOf(' ');
+        return cut < 0
+            ? { head: '', fragment: raw }
+            : { head: raw.slice(0, cut + 1), fragment: raw.slice(cut + 1) };
+    }
+    /**
+     * MATCH ON WHAT THE PLAYER HAS TYPED SO FAR, which is a prefix problem
+     * and not the fuzzy-nearest-name problem the verbs solve. Tab is being
+     * asked "finish this", so a name must CONTAIN what was typed -- by
+     * prefix first, then anywhere, so "garage" finds "Torque's Garage".
+     * Deliberately not fuzzyPickName: correcting a typo you are still in
+     * the middle of making would overwrite the letters under the cursor.
+     */
+    matches(all, fragment) {
+        const want = normalizeLoose(fragment);
+        if (want.length === 0)
+            return all;
+        const prefix = all.filter(n => normalizeLoose(n.name).startsWith(want));
+        if (prefix.length > 0)
+            return prefix;
+        // A word-start hit anywhere in the name -- how anyone refers to a
+        // long one out loud.
+        return all.filter(n => normalizeLoose(n.name).includes(want));
+    }
+    async execute(args = []) {
+        const actor = this.actor;
+        // The client sends the box VERBATIM, so the words rebuild it exactly;
+        // a trailing space is carried as an empty final word.
+        const raw = (args ?? []).join(' ');
+        const { head, fragment } = this.split(raw);
+        // A VERB ALONE IS NOT A NAME. With nothing typed after the verb the
+        // player wants the roster, which is the `fragment === ''` case below
+        // and handled by matches() returning everything.
+        const all = nameablesFor(this.scene, actor, this.rooms);
+        if (all.length === 0) {
+            return `Nothing to name from ${whereAmI(actor)}.`;
+        }
+        const hits = this.matches(all, fragment);
+        if (hits.length === 1) {
+            const only = hits[0];
+            return `${COMPLETE_MARKER}${head}${only.name}`;
+        }
+        if (hits.length === 0) {
+            return [
+                `Nothing at ${whereAmI(actor)} answers to "${fragment}". You could name:`,
+                ...all.slice(0, 12).map(n => `  ${n.glyph} ${n.name} -- ${n.what}`),
+                ...(all.length > 12 ? [`  ...and ${all.length - 12} more.`] : []),
+            ].join('\n');
+        }
+        // SEVERAL. Complete as far as they AGREE -- the shell behaviour
+        // everyone already has in their fingers -- and show the field.
+        const common = CompleteCommand.commonPrefix(hits.map(h => h.name));
+        const grown = common.length > fragment.length ? `${COMPLETE_MARKER}${head}${common}\n` : '';
+        return [
+            `${grown}${hits.length} answer to "${fragment}":`,
+            ...hits.slice(0, 12).map(n => `  ${n.glyph} ${n.name} -- ${n.what}`),
+            ...(hits.length > 12 ? [`  ...and ${hits.length - 12} more.`] : []),
+        ].join('\n');
+    }
+    /** The longest head every candidate shares, case-insensitively, but
+     *  spelled the way the FIRST candidate spells it -- so completing into
+     *  "Torque's" never changes the capitals already on screen. */
+    static commonPrefix(names) {
+        if (names.length === 0)
+            return '';
+        let end = names[0].length;
+        for (const n of names.slice(1)) {
+            let i = 0;
+            while (i < end && i < n.length && n[i].toLowerCase() === names[0][i].toLowerCase())
+                i++;
+            end = i;
+        }
+        return names[0].slice(0, end);
+    }
+}
+//# sourceMappingURL=complete.js.map

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

@@ -18,17 +18,20 @@ import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-aud
 export const MARKS_TO_CONTROL = 2;
 export class DisableCommand extends Command {
     static verb = 'disable';
-    static description = 'Control Device (SR5 p.238): with 2 marks on a device, order it -- a maglock unlocks, a camera cluster loops, a smartgun\'s clip drops. Electronic Warfare + Intuition [Sleaze] v. Device Rating + Firewall. "disable loud <icon>" is a Data Spike instead (see "brick").';
-    /** The Data Spike route: `brick` always, `disable loud` by the word. */
+    static description = 'Control Device (SR5 p.238): with 2 marks on a device, order it -- a maglock unlocks, a camera cluster loops, a smartgun\'s clip drops. Electronic Warfare + Intuition [Sleaze] v. Device Rating + Firewall. To wreck it instead of driving it, that is a different action and a different verb: "brick <icon>" is a Data Spike (p.239).';
+    /**
+     * WHICH ACTION THIS IS -- and since f79LLqTerep4nKWcA it is decided by
+     * the VERB alone. `disable` is Control Device; `brick` is Data Spike,
+     * and BrickCommand overrides this.
+     *
+     * `disable loud <icon>` used to be a second spelling of `brick`, and
+     * `disable quiet` a no-op word that just got eaten. That is the same
+     * shape the reporter met on the grid: an adverb sitting where a target
+     * name goes, silently choosing between two different book actions.
+     * Both words are gone; a device named "loud" is now simply findable.
+     */
     way(args) {
-        const rest = [...args];
-        if (rest[0]?.toLowerCase() === 'loud' || rest[0]?.toLowerCase() === 'brick') {
-            rest.shift();
-            return { way: 'spike', rest };
-        }
-        if (rest[0]?.toLowerCase() === 'quiet')
-            rest.shift();
-        return { way: 'control', rest };
+        return { way: 'control', rest: [...args] };
     }
     async execute(args = []) {
         const actor = this.actor;
@@ -326,10 +329,7 @@ export class BrickCommand extends DisableCommand {
     static verb = 'brick';
     static description = 'Data Spike (SR5 p.239): Cybercombat + Logic [Attack] v. Device Rating + Firewall, no marks needed, never subtle. Fill a device\'s Matrix condition monitor (8 + DR/2, p.228) and it BRICKS -- a camera goes dead, a smartgun sparks and dies; a lock stays locked. A miss burns your own deck.';
     way(args) {
-        const rest = [...args];
-        if (rest[0]?.toLowerCase() === 'loud')
-            rest.shift();
-        return { way: 'spike', rest };
+        return { way: 'spike', rest: [...args] };
     }
 }
 //# sourceMappingURL=disable.js.map

package/bundle/typescript/src/commands/game/sideQuest/commands/erase-mark.js

@@ -156,7 +156,7 @@ export class EraseMarkCommand extends Command {
         if (target.kind !== 'self' && held < MAX_MARKS) {
             return [
                 `You hold ${held}/${MAX_MARKS} marks on ${label} -- Erase Mark needs THREE on the icon you are scrubbing (p.239), not on whoever placed the mark.`,
-                hint(` ("hack" ${label} up to ${MAX_MARKS}. To clear marks off YOURSELF instead, "unmark me" -- or "reboot"/"jack out", which wipe every mark on you for free, p.242.)`),
+                hint(` ("hack ${label}" or "force ${label}" up to ${MAX_MARKS}. To clear marks off YOURSELF instead, "unmark me" -- or "reboot"/"jack out", which wipe every mark on you for free, p.242.)`),
             ].join('');
         }
         const wanted = Math.min(count, MAX_MARKS, placers.reduce((n, p) => n + p.count, 0));

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

@@ -0,0 +1,40 @@
+import { HackCommand } from './hack.js';
+/**
+ * BRUTE FORCE (SR5 p.238) -- the loud half of the intrusion fork, and its
+ * own verb since f79LLqTerep4nKWcA.
+ *
+ * THIS FILE IS A NAME, NOT A MECHANIC. Every line of the intrusion --
+ * the target ladder (host by name, PAN, slaved device, loose device,
+ * camera, the meat-side puzzle rail), the opposed roll, the declared-mark
+ * penalties, the GOD bill -- lives in hack.ts and is shared. The only
+ * thing that differs between the two verbs is which of the book's two
+ * actions they are, and that is one method.
+ *
+ * WHY IT IS A VERB AND NOT A WORD YOU ADD. It used to be a word you added:
+ * `hack loud` (or `force`, `brute`, `attack`) anywhere in the args flipped
+ * a hidden per-player posture for one action, and with no word at all you
+ * got whatever Tab had left the posture set to. The reporter met the other
+ * half of that switch and read it as a target -- "what is 'hack quiet' --
+ * I don't see a 'quiet', is it just 'mark'?" -- which is the correct
+ * reading of a bare adverb sitting where a name goes.
+ *
+ * So: one verb per action, and the verb says which action it is. There is
+ * nothing to override, nothing to discover, and every word the player
+ * types is part of the name of the thing they are naming.
+ *
+ * THE TWO ARE NOT INTERCHANGEABLE (p.236 "Noticing Hackers"), which is the
+ * whole reason the player must be able to pick on purpose:
+ *   - `hack` (Hack on the Fly, Sleaze): succeed and nobody knows. MISS and
+ *     the target gets a free mark on YOU -- alarm, ice hunting, spotted.
+ *   - `force` (Brute Force, Attack): succeed and it knows it is under
+ *     attack but has not spotted you. MISS and nothing is noticed at all;
+ *     the firewall just bites you back.
+ */
+export class ForceCommand extends HackCommand {
+    static verb = 'force';
+    static description = 'BRUTE FORCE (SR5 p.238) on a host, a PAN, or a device: Cybercombat + Logic [Attack] against it, and what it leaves behind is a MARK. The loud route -- a MISS goes unnoticed entirely (the firewall just bites you), but a HIT tells the target it is under attack. Always name what you are smashing: "force <host>", "force <person>" for their PAN, "force <device>". Its quiet twin is "hack <target>" (Hack on the Fly, p.240). Also "brute", "smash".';
+    verbName = 'force';
+    noDeviceMessage = "There's nothing here to force.";
+    mode() { return 'attack'; }
+}
+//# sourceMappingURL=force.js.map

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

@@ -10,6 +10,7 @@ import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { isWatched, canSnoopFeeds } from '../utilities/surveillance.js';
 import { matchesCameraName, hostLabel } from '../utilities/grid-names.js';
 import { TapCommand } from './tap.js';
+import { nameableNames } from '../utilities/nameables.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS } from '../utilities/marks.js';
 import { billAction } from '../utilities/action-cost.js';
@@ -30,56 +31,42 @@ const MARKS_TO_COMMAND_A_PAN = 2;
  *  Anchored so it never fires on a name that merely contains one. */
 export class HackCommand extends BypassCommand {
     static verb = 'hack';
-    static description = 'Hack a terminal, host, or PAN. TWO ROUTES, and your STANCE picks which (Tab flips it, "stance" shows it): ATTACK is Brute Force (p.238 -- Cybercombat + Logic [Attack]; a MISS goes unnoticed, the firewall just bites you). SLEAZE is Hack on the Fly (p.240 -- Hacking + Logic [Sleaze]; succeed and NOBODY knows; fail and you are MADE: alarm, ice hunting, walls up). "hack loud" / "hack quiet" override the stance for one action. The BRACKET IS A LIMIT: it caps how many HITS you can count, and is never a die in the pool -- so the Sleaze or Attack on your deck is a CEILING on what a run of luck can buy you, not a bonus ("deck" shows the array, and the Mechanics line says when the cap bit). "hack <name>" cracks a PAN the same two ways. Terminal-puzzle hacks are their own rail (a failed one locks you out for good).';
+    static description = 'HACK ON THE FLY (SR5 p.240) on a host, a PAN, or a device: Hacking + Logic [Sleaze] against it, and what it leaves behind is a MARK. The quiet route -- succeed and NOBODY knows; fail and you are MADE: alarm, ice hunting, and it holds a mark on YOU. Always name what you are cracking: "hack <host>", "hack <person>" for their PAN, "hack <device>". Its loud twin is a different verb -- "force <target>" is Brute Force (p.238). The BRACKET IS A LIMIT: your deck\'s Sleaze caps how many HITS you can count, and is never a die in the pool ("deck" shows the array, and the Mechanics line says when the cap bit). Terminal-puzzle hacks are their own rail (a failed one locks you out for good).';
     deviceKind = 'panel';
     verbName = 'hack';
     noDeviceMessage = "There's nothing here to hack.";
     /**
-     * The Attack/Sleaze fork (canon p.236 "Noticing Hackers", player
-     * ruling 2026-08-23): "loud"/"force"/"brute"/"attack" anywhere in the
-     * words picks Brute Force; "quiet"/"sleaze"/"sneak" picks Hack on the
-     * Fly explicitly; the default is the player's STANCE (Tab, see
-     * MatrixStance), which ships as Brute Force.
-     * The mode word is stripped so "hack loud mama wu" still finds Mama Wu.
+     * WHICH OF THE BOOK'S TWO INTRUSION ACTIONS THIS VERB IS.
+     *
+     * There used to be one verb and a hidden posture: `hack` read the
+     * player's Matrix stance (Tab), and "loud"/"quiet"/"sleaze"/"sneak"
+     * anywhere in the args overrode it for one action. The reporter of
+     * f79LLqTerep4nKWcA met that as `hack quiet` and reasonably read
+     * "quiet" as a target -- "I don't see a 'quiet', is it just 'mark'?"
+     *
+     * So the fork is a VERB now, one per book action, and this hook is the
+     * whole difference between them (commands/force.ts is the other half).
+     * Nothing is stripped from the args any more: every word the player
+     * types is part of the name of the thing they are naming.
      */
-    static parseMode(args, stance) {
-        const rest = [...(args ?? [])];
-        // THE DEFAULT IS THE STANCE, NOT A LITERAL (uMQAhaAysgaKpWFkn,
-        // mjmcee 2026-09-03). It used to be hardcoded 'sleaze' here and
-        // again in mark.ts -- two copies of a decision the player could
-        // not see or change. Tab now sets it once and both verbs read it;
-        // the mode words below stay as a one-shot override for the action
-        // you are about to take without moving your standing posture.
-        let mode = stance;
-        const loudIdx = rest.findIndex(w => /^(loud|force|brute|attack)$/i.test(w));
-        if (loudIdx >= 0) {
-            mode = 'attack';
-            rest.splice(loudIdx, 1);
-        }
-        const quietIdx = rest.findIndex(w => /^(quiet|sleaze|sneak)$/i.test(w));
-        // SETS the mode, it does not merely strip the word. While Sleaze was
-        // the hardcoded default this branch could get away with only
-        // splicing -- it was right for the wrong reason, and nothing could
-        // tell the difference because both paths agreed. The moment the
-        // default became the stance (uMQAhaAysgaKpWFkn) that omission turned
-        // "hack quiet" into a Brute Force.
-        if (quietIdx >= 0) {
-            mode = 'sleaze';
-            rest.splice(quietIdx, 1);
-        }
-        return { mode, rest };
+    mode() { return 'sleaze'; }
+    /** The action's name in the book, for every line this verb prints. */
+    actionName() {
+        return this.mode() === 'attack' ? 'Brute Force' : 'Hack on the Fly';
     }
     async execute(args = []) {
-        const { mode, rest: afterMode } = HackCommand.parseMode(args, this.actor.matrixStance);
+        const mode = this.mode();
+        const afterMode = [...(args ?? [])];
         // HOW MANY MARKS YOU ARE REACHING FOR, declared before the roll
-        // (p.238/p.240) -- "hack for 3", "hack 2 marks on the door". Stripped
-        // here so a declaration never lands in a target name, the same way
-        // the mode words are.
+        // (p.238/p.240) -- "hack for 3", "hack 2 marks on the door". This is
+        // the ONLY thing still stripped out of the words: it is a count, not
+        // a name, and parseMarkDeclaration will only take a digit that is
+        // spelled as one ("for 2", "2 marks", "x2").
         const { marks: declaredMarks, rest } = parseMarkDeclaration(afterMode);
         // BRUTE FORCE and HACK ON THE FLY are Complex Actions (p.238, p.240)
         // -- billed only inside a Combat Turn, where one intrusion is the
         // whole Action Phase.
-        const bill = billAction(this.scene, this.actor, 'complex', mode === 'sleaze' ? 'Hack on the Fly' : 'Brute Force');
+        const bill = billAction(this.scene, this.actor, 'complex', this.actionName());
         if (bill)
             return bill;
         // PAN warfare: "hack <name>" cracks a meat actor's personal area
@@ -118,7 +105,7 @@ export class HackCommand extends BypassCommand {
                 rooms: this.rooms,
                 screen: this.screen,
                 game: this.game,
-            }).execute(args);
+            }).withMode(mode).execute();
         }
         // The Matrix branch: hacking FROM INSIDE a host node reaches the
         // room's physical systems -- the meatspace payoff of jacking in. A
@@ -142,8 +129,17 @@ export class HackCommand extends BypassCommand {
                 ? resolveHostInReach(gridRooms, this.actor, named)
                 : (this.actor.insideHost ?? hostOver(gridVicinity(this.actor)) ?? hostOver(this.actor.currentLocation));
             if (!room) {
-                const overhead = hostsInReach(gridRooms, this.actor).map(h => hostLabel(h, { capital: true }));
-                const roster = overhead.length > 0 ? ` Overhead: ${overhead.join(', ')} -- "hack <name>" cracks one from here.` : '';
+                // THE ROSTER AND TAB'S COMPLETION READ THE SAME LIST
+                // (utilities/nameables.ts). They are the same question asked two
+                // ways -- "what could I have typed here?" -- and a refusal that
+                // named an icon Tab cannot complete, or omitted one it can, is
+                // the same defect in two coats. It used to list hosts only,
+                // while the sentence above it promised to have looked for a PAN
+                // and a camera too.
+                const names = nameableNames(this.scene, this.actor, gridRooms);
+                const roster = names.length > 0
+                    ? ` In reach: ${names.slice(0, 8).join(', ')}${names.length > 8 ? `, and ${names.length - 8} more` : ''} -- "${this.verbName} <name>" reaches one from here (Tab completes it).`
+                    : '';
                 return named
                     ? `Nothing on the grid answers to "${named}" -- no host by that name, no PAN, no camera.${roster}`
                     : `Thin grid out here -- no host node hangs over ${gridVicinity(this.actor).name}.${roster}`;
@@ -243,9 +239,16 @@ export class HackCommand extends BypassCommand {
                     this.actor.sneaking = false;
                     this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} MADE ${this.actor.name} mid-intrusion -- alarm flagged, ice hunting.`, { plane: 'matrix' });
                     this.scene.updateStatus();
+                    // NAME THE ICON YOU JUST MISSED (f79LLqTerep4nKWcA: "How do I
+                    // know which host/PAN/etc I'm hacking?"). The success lines
+                    // below have always named the host; both failure lines said
+                    // "the host" and left the player to guess which one -- the
+                    // exact moment they most need to know, since a blown Sleaze is
+                    // what hands a mark to something that did not have one.
+                    const marksOnMe = room.hostMarksOn.get(this.actor.name) ?? 0;
                     return [
-                        `The ice turns and LOOKS AT YOU -- your sleaze unravels mid-handshake.`,
-                        `  The host holds a MARK on your persona now: walls up (harder to crack until it falls), and everything guarding this place knows an intruder is on the grid.`,
+                        `${hostLabel(room, { capital: true })} turns and LOOKS AT YOU -- your Hack on the Fly unravels mid-handshake.`,
+                        `  It holds ${marksOnMe === 1 ? 'a mark' : `${marksOnMe} marks`} on your persona now, it can see you, and everything guarding this place knows someone is on the grid. ("unmark me" scrubs it; so do "reboot" and "jack out", p.242.)`,
                         ...godLines,
                     ].join('\n');
                 }
@@ -258,7 +261,7 @@ export class HackCommand extends BypassCommand {
                 if (showsMechanics(this.scene, this.actor)) {
                     this.logger.meta(`${mechanicsActorPrefix(this.scene, this.actor)}Firewall: ${formatRoll(bite)}`);
                 }
-                const lines = [`The host's defenses snap shut around your intrusion --`];
+                const lines = [`${hostLabel(room, { capital: true })} snaps its defenses shut around your Brute Force --`];
                 if (dealt > 0) {
                     // Same routing as ice hits: hardware eats it when there's
                     // hardware; a technomancer's living persona (and any hot-sim
@@ -321,7 +324,11 @@ export class HackCommand extends BypassCommand {
                     lines.push(`  {light-blue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/light-blue-fg}`);
                 if (forcedDv > 0)
                     lines.push(`  The forcing burns ${forcedDv} DV into the architecture -- a host has no boards to brick, so it only announces you louder.`);
-                lines.push(`  ${MAX_MARKS - marksNow} more and its architecture stops asking who you are.${hint(` ("hack for ${MAX_MARKS - marksNow}" reaches for the rest at once -- ${declarationPenalty(MAX_MARKS - marksNow, this.actor.hasQuality(GO_BIG_QUALITY))} dice.)`)}`);
+                // NAME THE VERB THEY JUST USED. This said "hack for N" whichever
+                // route had run, so a Brute Force answered with a hint for the
+                // other action -- the same class of mix-up the whole item is
+                // about (f79LLqTerep4nKWcA).
+                lines.push(`  ${MAX_MARKS - marksNow} more and its architecture stops asking who you are.${hint(` ("${this.verbName} for ${MAX_MARKS - marksNow}" reaches for the rest at once -- ${declarationPenalty(MAX_MARKS - marksNow, this.actor.hasQuality(GO_BIG_QUALITY))} dice.)`)}`);
                 if (mode === 'attack') {
                     this.actor.sneaking = false;
                     room.hostAlert = true;
@@ -386,7 +393,7 @@ export class HackCommand extends BypassCommand {
                 // NOT RELEASED -- NAMED. Telling the player these are here, and
                 // that each is one more action, is the difference between a
                 // decomposition and a thing that quietly stopped working.
-                lines.push(`  ${iconLocks.length} ${iconLocks.length === 1 ? 'lock hangs' : 'locks hang'} off it, still sealed -- each its own icon behind its own rating: ${iconLocks.map(d => d.name).join(', ')}.${hint(` ("hack <lock>" from in here keys one; the host's key is not the door's.)`)}`);
+                lines.push(`  ${iconLocks.length} ${iconLocks.length === 1 ? 'lock hangs' : 'locks hang'} off it, still sealed -- each its own icon behind its own rating: ${iconLocks.map(d => d.name).join(', ')}.${hint(` ("${this.verbName} <lock>" from in here keys one; the host's key is not the door's.)`)}`);
             }
             if (vaultedFiles.length > 0) {
                 lines.push(`  {light-blue-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/light-blue-fg}`);
@@ -556,7 +563,7 @@ export class HackCommand extends BypassCommand {
                 viaWan = true;
                 const onHost = host.hostMarksBy.get(actor.name) ?? 0;
                 if (onHost < 1) {
-                    return `${device.name} is on the map, but it hangs off ${hostLabel(host)}'s WAN -- slaved, and a host's devices answer nobody who holds no mark on the host itself (p.233).${hint(` ("hack ${hostLabel(host)}" for a mark first; "enter" once you have one and the lock defends with its own DR ${device.rating} alone.)`)}`;
+                    return `${device.name} is on the map, but it hangs off ${hostLabel(host)}'s WAN -- slaved, and a host's devices answer nobody who holds no mark on the host itself (p.233).${hint(` ("${this.verbName} ${hostLabel(host)}" for a mark first; "enter" once you have one and the lock defends with its own DR ${device.rating} alone.)`)}`;
                 }
             }
             else {
@@ -708,7 +715,7 @@ export class HackCommand extends BypassCommand {
             const command = hint(`"disable ${device.name}" (Control Device, p.238) ${device.opensExit ? `opens the ${device.opensExit} way` : `works it`} from right here.`);
             lines.push(now >= 2
                 ? `  That is enough to command it${command ? `: ${command}` : '.'}`
-                : `  One more mark and it takes orders.${hint(` ("hack ${device.name}" again, then "disable ${device.name}" -- Control Device wants 2 marks for a Simple device action, p.238.)`)}`);
+                : `  One more mark and it takes orders.${hint(` ("${this.verbName} ${device.name}" again, then "disable ${device.name}" -- Control Device wants 2 marks for a Simple device action, p.238.)`)}`);
         }
         this.scene.updateStatus();
         return [...lines, ...godLines].join('\n');
@@ -773,12 +780,12 @@ export class HackCommand extends BypassCommand {
      * Returns null when the args don't name a hackable actor here, so
      * barrier names and directions fall through to the puzzle path.
      *
-     * The Attack/Sleaze fork applies here too (canon p.236): SLEAZE
-     * (default) rides the deck's Sleaze edge -- fail and the target's
-     * link pings them a probe warning (you're noticed); succeed and the
-     * world events never name you. ATTACK ("hack loud <name>") rides the
-     * Attack edge -- success is announced with your name on it, but a
-     * MISS goes completely unnoticed and the firewall bites YOU instead.
+     * The Attack/Sleaze fork applies here too (canon p.236): "hack <name>"
+     * is Hack on the Fly and rides the deck's Sleaze edge -- fail and the
+     * target's link pings them a probe warning (you're noticed); succeed
+     * and the world events never name you. "force <name>" is Brute Force
+     * and rides the Attack edge -- success is announced with your name on
+     * it, but a MISS goes completely unnoticed and the firewall bites YOU.
      */
     async tryPanHack(args, mode) {
         const actor = this.actor;

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

@@ -363,7 +363,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: "mark" it, then "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".`}`;
             }
             // 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
@@ -519,7 +519,7 @@ export class LookCommand extends Command {
                         return `${far.item.name} is meat -- a thing standing in ${far.room.name}, not an icon. Your eyes are in ${body.name}, and a persona has none.`;
                     if (far.reach === 'offline')
                         return `You remember ${far.item.name}: it sits on the ${far.room.offlineServer} in ${far.room.name} -- an offline server, air-gapped, off the grid entirely. No persona reaches that box; your BODY has to be in ${far.room.name} (p.233).`;
-                    return `You remember ${far.item.name}: it is inside ${hostLabel(far.room)}'s vault (p.246). ${hint(`"enter ${far.room.name}" on a mark, or "hack" it open.`)}`;
+                    return `You remember ${far.item.name}: it is inside ${hostLabel(far.room)}'s vault (p.246). ${hint(`"enter ${far.room.name}" on a mark, or "hack ${hostLabel(far.room)}" to place one.`)}`;
                 }
             }
         }

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

@@ -1,7 +1,5 @@
 import { Command } from './command.js';
-import { HackCommand } from './hack.js';
-import { describeMarks, MAX_MARKS } from '../utilities/marks.js';
-import { MATRIX_STANCE_ACTION } from '../models/player.js';
+import { describeMarks, marksOnYou, MAX_MARKS } from '../utilities/marks.js';
 /**
  * THERE IS NO MARK ACTION (uMQAhaAysgaKpWFkn, pcampbell: "Marking is a
  * symptom of either Brute Force [Attack] or Hack on the Fly [Sleaze] ...
@@ -11,47 +9,70 @@ import { MATRIX_STANCE_ACTION } from '../models/player.js';
  * standalone action that places a mark. Brute Force (p.238) and Hack on
  * the Fly (p.240) are the only two, and a mark is what they leave behind.
  *
- * So this file no longer implements one. It used to carry its own copy of
- * the pool, the fork, the GOD bill and the outcome prose -- the same roll
- * hack.ts was making, kept in a second place where the two could drift.
- * They did: on a host, `hack` bought the entire node on that roll and
- * `mark` bought one increment, and which you got depended on the word you
- * typed. That was the report.
+ * So this verb stopped implementing one long ago. For a while it still
+ * ROUTED to the real action -- `mark <host>` quietly ran `hack` -- on the
+ * reasoning that a player who types it means to do the thing. That was
+ * the wrong kindness: it left two spellings for one action and no way to
+ * tell them apart, which is exactly what the reporter of
+ * f79LLqTerep4nKWcA hit -- "if we have 'hack quiet', then what is
+ * 'mark'?" Two names for one thing is not a convenience, it is the
+ * question.
  *
- * What survives is the INSPECTION -- "mark list" answers "what keys am I
- * holding", which is a reasonable thing to ask and not an action at all.
- * Everything else routes to the real verb and says its real name, so the
- * vocabulary teaches the book instead of hiding it.
+ * WHAT IT IS NOW: the ledger, and only the ledger. `mark` answers "who
+ * holds what", which is a reasonable thing to ask and not an action at
+ * all -- it costs nothing, bills nothing, and can be typed mid-fight.
+ *
+ * BOTH DIRECTIONS, which is the other half of the report ("when I have a
+ * mark on it, show my mark on it, and vice versa -- when it has a mark on
+ * me, show that"). The engine has always tracked the two separately --
+ * Host.marksBy / Device.marksBy / Player.panMarksBy for what you hold,
+ * Host.marksOn / the placer side of panMarksBy for what holds you -- and
+ * utilities/marks.ts has had a reader for each since the live sheet
+ * needed them. Only the web sheet ever printed both. This prints both.
  */
 export class MarkCommand extends Command {
     static verb = 'mark';
-    static description = 'Show the marks you are holding ("mark list"). Placing one is NOT its own action in SR5 -- a mark is what Brute Force (p.238) or Hack on the Fly (p.240) leaves behind, so "mark <target>" runs the real action and says which one. Use "hack" directly; your stance (Tab) picks the route.';
+    static description = 'The MARK LEDGER, both directions: what you hold on other icons, and what other icons hold on YOU. Not an action -- it costs nothing and bills nothing. Placing a mark is not its own action in SR5 either: a mark is what "hack <target>" (Hack on the Fly, p.240) or "force <target>" (Brute Force, p.238) leaves behind, and "unmark" scrubs one off (Erase Mark, p.239). Also "marks".';
     async execute(args = []) {
-        const words = [...(args ?? [])].map(w => w.toLowerCase());
-        // THE INSPECTION, which is not an action and keeps its home here.
-        if (words.length === 0 || words[0] === 'list' || words[0] === 'mine') {
-            const standing = describeMarks(this.scene, this.actor.name);
-            if (standing.length === 0) {
-                return `No standing marks -- your persona holds no keys right now.${this.actor.plane === 'matrix' ? ` ("hack <target>" places one: it is what ${MATRIX_STANCE_ACTION[this.actor.matrixStance]} leaves behind.)` : ''}`;
-            }
-            return [
-                `YOUR MARKS (max ${MAX_MARKS} per icon)`,
-                ...standing.map(l => `  ${l}`),
-            ].join('\n');
+        const actor = this.actor;
+        // SOMEONE WHO TYPED A TARGET MEANT TO DO THE THING, and the reporter
+        // of f79LLqTerep4nKWcA is on record expecting exactly that ("It's
+        // 'hack <target>' or 'mark <target>'"). This verb used to run the
+        // hack for them, which is how one action ended up with two spellings
+        // and no way to tell them apart. Saying so costs nothing -- there is
+        // no action to bill -- and the ledger still prints underneath, so
+        // the keystroke is never simply swallowed.
+        const named = (args ?? []).filter(w => !/^(list|mine|marks?)$/i.test(w)).join(' ').trim();
+        const aimed = named.length > 0
+            ? `{light-blue-fg}Marking is not an action in SR5 -- a mark is what an intrusion LEAVES BEHIND. For ${named}: "hack ${named}" is Hack on the Fly (p.240, quiet) and "force ${named}" is Brute Force (p.238, loud). Neither has been run; nothing has been spent.{/light-blue-fg}\n\n`
+            : '';
+        const held = describeMarks(this.scene, actor.name);
+        const on = marksOnYou(this.scene, actor);
+        // NOTHING EITHER WAY. Worth its own sentence rather than two empty
+        // headings: a clean ledger is a fact about your run, and on the grid
+        // it is the moment to say what places one.
+        if (held.length === 0 && on.length === 0) {
+            const teach = actor.plane === 'matrix'
+                ? ` ("hack <target>" is Hack on the Fly and "force <target>" is Brute Force -- a mark is what either one leaves behind.)`
+                : '';
+            return `${aimed}No marks either way -- you hold none, and nothing holds one on you.${teach}`;
+        }
+        const lines = [];
+        lines.push(`{light-blue-fg}YOUR MARKS -- what you hold (max ${MAX_MARKS} per icon){/light-blue-fg}`);
+        lines.push(...(held.length > 0
+            ? held.map(l => `  ${l}`)
+            : [`  nothing -- you hold no keys right now.`]));
+        lines.push('');
+        // The mirror. Named per placer, not summed: a session log showed
+        // three marks across two hosts, and one number cannot say that.
+        lines.push(`{light-blue-fg}MARKS ON YOU -- what holds you{/light-blue-fg}`);
+        lines.push(...(on.length > 0
+            ? on.map(r => `  ◆ ${r.placer} -- ${r.count} mark${r.count === 1 ? '' : 's'}${r.count >= MAX_MARKS ? ' (it owns your icon)' : ''}`)
+            : [`  nothing -- your icon is clean.`]));
+        if (on.length > 0) {
+            lines.push(`  {light-blue-fg}("unmark me" scrubs them one at a time, Erase Mark p.239; "reboot" and "jack out" wipe them all for free, p.242.){/light-blue-fg}`);
         }
-        // EVERYTHING ELSE IS THE REAL ACTION. Routed rather than refused: a
-        // player who types `mark the host` means to do the thing, and
-        // answering "no such action" would be pedantry that costs them a
-        // turn. They get the action AND its right name.
-        const action = MATRIX_STANCE_ACTION[this.actor.matrixStance];
-        const result = await new HackCommand({
-            actor: this.actor,
-            scene: this.scene,
-            rooms: this.rooms,
-            screen: this.screen,
-            game: this.game,
-        }).execute(args);
-        return `{light-blue-fg}Placing a mark IS ${action} -- running it (p.238/p.240).{/light-blue-fg}\n${result}`;
+        return aimed + lines.join('\n');
     }
 }
 //# sourceMappingURL=mark.js.map

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

@@ -48,9 +48,13 @@ export class ReloadCommand extends Command {
             }
         }
         else {
-            // NON-LETHAL STANCE: stun rounds first if you carry any (gel,
-            // stick-n-shock -- p.434); otherwise whatever is in the pack.
-            ammo = (actor.autoStance === 'non-lethal' ? boxes.find(b => Item.isStunAmmo(b)) : undefined) ?? boxes[0];
+            // NO STANCE TO CONSULT ANY MORE (f79LLqTerep4nKWcA). A bare
+            // "reload" used to reach for stun rounds when the standing posture
+            // was non-lethal -- a magazine chosen by a setting the player could
+            // not see from here. It takes what is in the pack; the line below
+            // names it, and "reload gel" / "reload stick-n-shock" is how you
+            // ask for the merciful box.
+            ammo = boxes[0];
         }
         if (!ammo) {
             return `No ammunition in your pack -- the ${weapon.name} stays at ${weapon.ammo}/${weapon.magazineCapacity}. Find a spare clip.`;
@@ -74,7 +78,13 @@ export class ReloadCommand extends Command {
         this.actor.performAction('reloads', weapon.name);
         this.scene.updateInventory(this.scene.getPlayer().inventory);
         this.scene.updateStatus();
-        return `You slap the ${ammo.name} home -- ${weapon.name} loaded, ${weapon.ammo}/${weapon.magazineCapacity}.${weapon.stunAmmo() ? ' Stun rounds: it drops people, it does not kill them.' : actor.autoStance === 'non-lethal' ? ' No stun rounds in the pack -- that gun is LETHAL until you find some.' : ''}${phaseHint(this.scene, actor)}`;
+        // WHAT WENT IN, ALWAYS -- the rounds are the whole of whether this
+        // gun can be used to take someone alive ("subdue"), so the line says
+        // which it is rather than leaving it to a posture readout.
+        const stunNote = weapon.stunAmmo()
+            ? ' Stun rounds: it drops people, it does not kill them -- "subdue" can use this.'
+            : ` Lethal rounds${boxes.some(b => Item.isStunAmmo(b)) ? ' -- "reload gel" or "reload stick-n-shock" if you want them alive' : ''}.`;
+        return `You slap the ${ammo.name} home -- ${weapon.name} loaded, ${weapon.ammo}/${weapon.magazineCapacity}.${stunNote}${phaseHint(this.scene, actor)}`;
     }
 }
 //# sourceMappingURL=reload.js.map