@maka/maka-cli 5.207.0 → 5.208.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-exchange.js

@@ -318,8 +318,13 @@ export class CombatExchange {
      * involuntary strikes (retaliation) where refusing to swing at all would
      * make no sense; a deliberately INITIATED attack with a dry gun is
      * blocked with a reload prompt before ever reaching here (attack.ts).
+     *
+     * `opts.nonLethal` is the verb's INTENT to take the target alive -- set
+     * by `subdue` and by nothing else. Retaliation never passes it, which
+     * is the honest reading of p.236's cousin in the meat: someone you are
+     * choking out is not obliged to pull their own punch.
      */
-    weaponProfile(attacker, defender) {
+    weaponProfile(attacker, defender, opts = {}) {
         const weapon = attacker.getWeaponProfile();
         // The physical weapon only backs a MEAT-plane strike by someone who
         // has it DRAWN (see Player.weaponDrawn) -- a holstered gun never
@@ -380,16 +385,24 @@ export class CombatExchange {
         //  - electricity is Stun: taser, stun baton, shock gloves (p.170-171, p.424);
         //  - stun ammunition: gel rounds Stun at AP +1, stick-n-shock Stun at
         //    DV -2 / AP -5 (p.434) -- whatever the magazine was loaded with;
-        //  - NON-LETHAL BY STANCE: a lethal melee weapon swung as a club deals
+        //  - NON-LETHAL BY INTENT: a lethal melee weapon swung as a club deals
         //    Stun at Accuracy 3 and no Reach (p.186 "Changing Damage Types").
-        //    A lethal gun with lethal rounds has no such door: it stays
-        //    Physical and the label says so, so the stance never lies.
+        //    A lethal gun with lethal rounds has no such door.
+        //
+        // THE INTENT COMES FROM THE VERB NOW (f79LLqTerep4nKWcA). It used to
+        // come from `attacker.autoStance`, a standing posture set by Tab --
+        // so whether your blade cut or clubbed depended on a setting made
+        // some turns ago, and the only way to find out which was to read the
+        // label after the swing. `attack` is the lethal verb and `subdue` is
+        // the one that takes them alive; each says so when it builds the
+        // strike, and `lethalAnyway` no longer needs to exist, because
+        // subdue refuses a lethal gun outright rather than firing it and
+        // tagging the corpse (commands/subdue.ts).
         const stunWeapon = !!weaponItem?.isStunWeapon();
         const ammoMods = weaponItem?.isFirearm() ? weaponItem.loadedAmmoMods() : undefined;
         const stunAmmo = weaponItem?.isFirearm() ? weaponItem.stunAmmo() : undefined;
-        const nonLethal = attacker.autoStance === 'non-lethal' && attacker.plane === 'meat';
+        const nonLethal = opts.nonLethal === true && attacker.plane === 'meat';
         const flatOfTheBlade = nonLethal && !!weaponItem && weaponItem.category === Category.MeleeWeapon && !stunWeapon;
-        const lethalAnyway = nonLethal && !!weaponItem?.isFirearm() && !stunWeapon && !stunAmmo;
         const stun = stunWeapon || !!stunAmmo || flatOfTheBlade || !!fistsAreStun;
         const ap = (weapon.armorPen ?? 0) + (ammoMods?.apMod ?? 0);
         const meatDefender = defender.plane === 'meat';
@@ -401,8 +414,7 @@ export class CombatExchange {
         const roundTag = ammoMods && !stunAmmo && (ammoMods.dvMod !== 0 || ammoMods.apMod !== 0) ? `, ${ammoMods.kind}` : '';
         const tag = flatOfTheBlade ? ' (flat of the blade, STUN)'
             : stunAmmo ? ` (${stunAmmo.kind}, STUN)`
-                : stunWeapon ? ' (STUN)'
-                    : lethalAnyway ? ' (LETHAL -- no stun rounds loaded)' : '';
+                : stunWeapon ? ' (STUN)' : '';
         return {
             label: `with ${weapon.name}${ap !== 0 ? ` (AP ${ap > 0 ? '+' : ''}${ap}${roundTag})` : roundTag ? ` (${roundTag.slice(2)})` : ''}${tag}`,
             pool: attacker.getAttackPool() + edgeBoost,

package/bundle/typescript/src/commands/game/sideQuest/utilities/condition-report.js

@@ -143,7 +143,6 @@ export function buildConditionReport(player, deps) {
             ? { grid: player.currentGrid?.name, host: player.hostInside?.name }
             : undefined,
         simMode: player.simMode,
-        stance: player.autoStance,
         drawn: player.weaponDrawn,
         weapon: player.weaponDrawn ? player.getCarriedWeapon()?.name : undefined,
         sustained: player.sustainedNames(),
@@ -348,8 +347,8 @@ extra) {
             // sheet's "where" stays as fresh as its monitors). Read at FIRE
             // time, not schedule time -- the coalescing beat means the player
             // may have moved since the mutation that armed it.
-            // The full state installment (contract 2026-09-01): plane/sim/
-            // stance and brandish flow through their accessors' own reports;
+            // The full state installment (contract 2026-09-01): plane/sim mode
+            // and brandish flow through their accessors' own reports;
             // sustained and deck programs are composed here and ride whatever
             // beat fires next. All read at FIRE time, like position.
             const report = buildConditionReport(player, { saveSlug, arSightUp, isHostile: extra?.isHostile, isParty: extra?.isParty, phaseActor: extra?.phaseActor });

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

@@ -172,23 +172,50 @@ export function noiseNote(noise) {
 export function hostLine(room, actor) {
     const inside = actor.insideHost === room;
     const marks = room.hostMarksBy.get(actor.name) ?? 0;
-    // STANDING IS TWO FACTS, NOT ONE (spcebZTKN24GYRHXW: "it's saying
-    // I've already cracked open (hold 3 marks) but I don't").
+    // SAY IT IN WORDS (f79LLqTerep4nKWcA, Maka: "'sealed, walls UP, over
+    // you' means nothing, it's just jargon. Remove it, when I have a mark
+    // on it, show my mark on it, and vice versa -- when it has a mark on
+    // me, show that.").
+    //
+    // This row was three tokens of shorthand welded together, and the
+    // first of them was not merely opaque, it was WRONG: `standing` read
+    // only the marks YOU hold, so a host holding three marks on your
+    // persona -- owning you outright -- printed "sealed", the word for a
+    // node nobody has touched. The two ledgers were always separate in
+    // the model (Host.marksBy / Host.marksOn); only the renderer collapsed
+    // them.
     //
-    // "cracked open" is the SITE's state -- somebody took this node to
-    // three marks and its vault has been hanging open ever since. The
-    // marks count is YOUR state, and canon wipes it on every reboot
-    // (p.236). The two used to be one string with the crack winning, so a
-    // rebooted persona holding nothing read a line that says the place is
-    // yours -- while every device on it refused them for want of marks.
-    // Print both whenever they disagree.
-    const held = `${marks}/${MAX_MARKS} marks`;
-    const standing = room.hostSanctioned ? 'haven'
-        : room.hostCracked ? (marks >= MAX_MARKS ? 'cracked open' : `cracked open, but you hold ${held}`)
-            : marks > 0 ? held
-                : 'sealed';
-    const alert = room.hostAlert && !room.hostSanctioned ? ', walls UP' : '';
-    const over = hostOver(gridVicinity(actor)) === room ? ', over you' : '';
+    // Four facts, four plain clauses, and never more than the row has
+    // earned:
+    //   - what YOU hold on it, counted;
+    //   - what IT holds on you, counted -- the number that decides whether
+    //     its ice can come find you;
+    //   - whether it has been cracked, or is a haven you belong in;
+    //   - whether it knows someone is in (Host.alert) or can see YOU
+    //     specifically (Host.spotted) -- two different facts that
+    //     "walls UP" flattened into one (p.236).
+    //
+    // STANDING IS TWO FACTS, NOT ONE (spcebZTKN24GYRHXW: "it's saying
+    // I've already cracked open (hold 3 marks) but I don't"). "Cracked
+    // open" is the SITE's state -- somebody took this node to three marks
+    // and its vault has hung open since. The marks count is YOUR state,
+    // and canon wipes it on every reboot (p.236). Print both whenever they
+    // disagree.
+    const onYou = room.hostMarksOn.get(actor.name) ?? 0;
+    const yours = marks > 0 ? `you hold ${marks} of ${MAX_MARKS} marks` : 'you hold no marks';
+    const theirs = onYou > 0
+        ? `it holds ${onYou} on YOU`
+        : undefined;
+    const standing = room.hostSanctioned ? 'a haven -- you belong here'
+        : room.hostCracked ? (marks >= MAX_MARKS ? `cracked open, and ${yours}` : `cracked open, but ${yours}`)
+            : yours;
+    // Seen beats merely alerted: if it can pick your icon out it does not
+    // need to sweep for you.
+    const eyes = room.hostSanctioned ? ''
+        : room.host?.spotted.has(actor.name) ? ', and it can SEE you'
+            : room.hostAlert ? ', and it knows someone is on the grid' : '';
+    const alert = theirs ? `, ${theirs}${eyes}` : eyes;
+    const over = hostOver(gridVicinity(actor)) === room ? ', directly overhead' : '';
     const onGrid = room.host?.grid ? ` on ${room.host.grid.name}` : '';
     // A haven shows no rating and no eyes (jackpoint.ts): it is not a
     // thing you crack, so the numbers you would crack it with stay off.
@@ -216,7 +243,13 @@ export function hostDockLine(room, actor, width) {
         : room.hostCracked ? ` open ${marks}/${MAX_MARKS}`
             : marks > 0 ? ` ${marks}/${MAX_MARKS}`
                 : '';
-    const raw = `${inside ? '▣' : '●'} ${room.name} HR${room.hostRating}${tag}`;
+    // AND WHAT IT HOLDS ON YOU (f79LLqTerep4nKWcA). The dock had room for
+    // one ledger and showed the flattering one; a persona with a host's
+    // key riding it could read every panel in the game and never meet the
+    // number. Two glyphs: yours forward, theirs back.
+    const onYou = room.hostMarksOn.get(actor.name) ?? 0;
+    const onYouTag = onYou > 0 ? ` <${onYou}` : '';
+    const raw = `${inside ? '▣' : '●'} ${room.name} HR${room.hostRating}${tag}${onYouTag}`;
     const cut = [...raw].slice(0, Math.max(4, width)).join('');
     return `{light-blue-fg}${cut}{/light-blue-fg}`;
 }

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

@@ -16,6 +16,13 @@ import { isWatched, camerasLive, canSnoopFeeds } from './surveillance.js';
  * ▣ PAN, ▲ dangerous device, ◇ data. (There is no air-gapped-host glyph
  * any more -- see hhSWzLSXECFtfoAGa and canReachHost.)
  */
+/** The heading gridIcons drops between a host's icon and the icons merely
+ *  standing NEAR it. See the comment where it is spliced in. */
+const NEAR_DIVIDER = '-- and NEAR it, out on the open grid (not inside the host): --';
+/** A heading is not an icon: the distance bands must not name it. */
+export function isNearDivider(line) {
+    return line === NEAR_DIVIDER;
+}
 /**
  * A DEVICE ICON, AND WHAT WORKS IT (commands/disable.ts, 2026-09-13).
  * Control Device (p.238) needs 2 marks on the device -- "disable" -- and
@@ -89,14 +96,30 @@ export function gridIcons(scene, actor, room) {
             // is still unearned -- a host that has already told you its
             // business has nothing left to sell. Built as a list so a dropped
             // entry cannot leave a dangling separator.
+            // EVERY WAY NAMES THE ICON (f79LLqTerep4nKWcA: "How do I know which
+            // host/PAN/etc I'm hacking?"). These used to read `"hack" slips in
+            // on sleaze` / `"hack loud" smashes` / `"mark" softens it first` --
+            // a bare verb, a verb plus an adverb that looks like a target, and
+            // a third spelling of the first one. Now: one verb per book action,
+            // each shown with the name you would actually type.
+            const name = hostLabel(room);
             const ways = [
-                ...(myMarks > 0 ? ['"enter" walks in on your mark'] : []),
-                '"hack" slips in on sleaze',
-                '"hack loud" smashes',
-                '"mark" softens it first',
-                ...(found ? [] : ['"search" reads what it runs (p.241)']),
+                ...(myMarks > 0 ? [`"enter" walks in on your mark`] : []),
+                `"hack ${name}" slips a mark in quiet (Hack on the Fly, p.240)`,
+                `"force ${name}" smashes one in (Brute Force, p.238)`,
+                ...(found ? [] : [`"search" reads what it runs (p.241)`]),
             ];
-            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- sculpted ice geometry, sealed. Whatever it holds is inside it.${room.hostAlert ? ' Walls UP -- it holds a mark on an intruder.' : ''}${myMarks > 0 ? ` [your marks: ${myMarks}/3]` : ''} (${ways.join('; ')})`);
+            // BOTH LEDGERS, PLAINLY. "Walls UP -- it holds a mark on an
+            // intruder" named no number and no one: the reader could not tell
+            // whether the intruder it meant was them.
+            const onYou = room.hostMarksOn.get(actor.name) ?? 0;
+            const standing = [
+                myMarks > 0 ? `you hold ${myMarks} of 3 marks on it` : undefined,
+                onYou > 0 ? `it holds ${onYou} on YOU` : undefined,
+                room.host?.spotted.has(actor.name) ? 'and it can see you'
+                    : room.hostAlert ? 'and it knows someone is on the grid' : undefined,
+            ].filter(Boolean).join(', ');
+            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- sculpted ice geometry, sealed. Whatever it holds is inside it.${standing.length > 0 ? ` ${standing.charAt(0).toUpperCase()}${standing.slice(1)}.` : ''} (${ways.join('; ')})`);
         }
     }
     // WHERE THE HOST'S OWN ICON ENDS AND THE STREET BEGINS.
@@ -262,12 +285,19 @@ export function gridIcons(scene, actor, room) {
     // is no wall for a reader to put an icon on the wrong side of, and a
     // heading over an empty list is noise.
     //
+    // IT IS A HEADING, NOT AN ICON, and gridIconBlock's distance bands have
+    // to know that: they take each entry, strip its glyph and cut at " -- "
+    // to get a name, which turned this sentence into an icon called "and
+    // NEAR it, out on the open grid (not inside the host):" listed beside
+    // the real ones. A constant so the one predicate that filters it out
+    // (isNearDivider, below) cannot drift from the string it matches.
+    //
     // It says NEAR, not IN, and it says why they are visible -- proximity
     // to your body, not a leak in the host (p.235). A reader who wondered
     // whether the host was showing them its insides now has the answer in
     // the list itself instead of having to file a report to get it.
     if (room.hasNode && icons.length > afterHost) {
-        icons.splice(afterHost, 0, `-- and NEAR it, out on the open grid (not inside the host): --`);
+        icons.splice(afterHost, 0, NEAR_DIVIDER);
     }
     return icons;
 }
@@ -542,7 +572,7 @@ export function gridIconBlock(scene, actor, room, rooms) {
     for (const { room: r, noise } of roomsInReach(rooms, actor).slice(1)) {
         let icons = [];
         try {
-            icons = gridIcons(scene, actor, r).filter(i => !isHostLine(i));
+            icons = gridIcons(scene, actor, r).filter(i => !isHostLine(i) && !isNearDivider(i));
         }
         catch {
             icons = [];
@@ -583,9 +613,26 @@ export function hostInteriorPanel(scene, actor, host, rows, cols) {
     if (purpose)
         lines.push(cut(purpose));
     const marks = host.marksBy.get(actor.name) ?? 0;
+    // BOTH DIRECTIONS IN THE DOCK TOO (f79LLqTerep4nKWcA). "marks 2/3" was
+    // only ever the marks YOU hold, and "WALLS UP" was the host's whole
+    // side of the ledger compressed to two words that named no number.
+    // The dock is narrow, so this is the terse spelling of the same four
+    // facts hostLine spells out: yours forward, theirs back, and what it
+    // can see.
+    const onYou = host.marksOn.get(actor.name) ?? 0;
     lines.push(cut(host.sanctioned
         ? 'haven -- welcome here'
-        : `HR ${host.rating} · marks ${marks}/3${host.alert ? ' · WALLS UP' : ''}${host.cracked ? ' · cracked' : ''}`));
+        : `HR ${host.rating} · you ${marks}/3 · on you ${onYou}${host.cracked ? ' · cracked' : ''}`));
+    // ITS EYES GET THEIR OWN ROW rather than a third token on the one
+    // above: the dock is ~30 columns and the ledger already fills it, so a
+    // cut line would eat exactly the word that matters. Seen beats merely
+    // alerted -- an icon it can pick out does not need to sweep for you.
+    if (!host.sanctioned) {
+        if (host.spotted.has(actor.name))
+            lines.push(cut('it can SEE you'));
+        else if (host.alert)
+            lines.push(cut('it knows someone is in'));
+    }
     for (const kind of host.runningIC) {
         const ice = host.iceActors.get(kind);
         lines.push(cut(`▲ ${kind}${ice ? ` ${ice.damageTaken}/${ice.maxConditionBoxes}` : ''}`));

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

@@ -2,8 +2,9 @@ import { hostLabel } from './grid-names.js';
 import { Logger } from './logger.js';
 /**
  * MARKS -- MAtrix Recognition Keys (canon p.235-236, player go
- * 2026-08-24). Placing a mark is the "mark" command (commands/mark.ts,
- * same Attack/Sleaze fork and GOD bill as hack); this module is the
+ * 2026-08-24). Placing a mark is "hack" (Hack on the Fly, p.240) or
+ * "force" (Brute Force, p.238) -- never "mark", which since
+ * f79LLqTerep4nKWcA is the LEDGER and nothing else; this module is the
  * BOOKKEEPING: capped at 3 per icon, keyed by placer, and wiped by the
  * canon events -- the PLACER's reboot/jack-out/convergence erases all
  * marks they placed anywhere (a fresh persona has no keys), and a

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

@@ -0,0 +1,107 @@
+import { hostLabel } from './grid-names.js';
+import { gridVicinity, hostsInReach, roomsInReach } from './grid-reach.js';
+import { cybercombatCandidates } from './matrix-roster.js';
+import { visibleActorsIn } from './spots.js';
+function push(out, seen, n) {
+    const key = n.name.toLowerCase();
+    if (n.name.trim().length === 0 || seen.has(key))
+        return;
+    seen.add(key);
+    out.push(n);
+}
+/** Every icon a persona could name from where it stands. */
+function matrixNameables(scene, actor, rooms) {
+    const out = [];
+    const seen = new Set();
+    // HOSTS have no distance on the grid (p.246) -- every one in reach is
+    // nameable from anywhere, which is precisely why naming one matters.
+    for (const room of hostsInReach(rooms, actor)) {
+        push(out, seen, { glyph: '●', name: hostLabel(room), what: `host, rating ${room.hostRating}` });
+    }
+    // PERSONAS AND CONSTRUCTS on your side of the host wall -- the same
+    // set cybercombat resolves against, so what Tab offers is what
+    // `attack` will find.
+    for (const a of cybercombatCandidates(scene, actor)) {
+        if (a === actor)
+            continue;
+        push(out, seen, { glyph: '◆', name: a.name, what: 'persona' });
+    }
+    // PANs AND DEVICES. A body in reach carries a PAN you can crack by its
+    // owner's name (hack.ts tryPanHack resolves it exactly that way), and
+    // every slaved or loose device answers to its own name.
+    for (const { room } of roomsInReach(rooms, actor)) {
+        for (const body of room.getActors()) {
+            if (body === actor)
+                continue;
+            push(out, seen, { glyph: '▣', name: body.name, what: 'a body in reach -- its PAN' });
+        }
+        for (const device of room.openableDevices()) {
+            push(out, seen, { glyph: '▤', name: device.name, what: `device, rating ${device.rating}` });
+        }
+    }
+    // THE ARCHIVE, once a Matrix Search has listed it (Host.searchedBy) or
+    // the node is cracked -- the same gate every other renderer asks.
+    const inside = actor.insideHost;
+    const host = inside?.host;
+    if (host && (host.cracked || host.searchedBy.has(actor.name))) {
+        for (const file of host.files()) {
+            push(out, seen, { glyph: '◇', name: file.name, what: 'file' });
+        }
+    }
+    return out;
+}
+/** Everything a body could name in the room it is standing in. */
+function meatNameables(actor) {
+    const out = [];
+    const seen = new Set();
+    const room = actor.currentLocation;
+    if (!room)
+        return out;
+    for (const a of visibleActorsIn(room, actor)) {
+        if (a === actor)
+            continue;
+        push(out, seen, { glyph: '◆', name: a.name, what: 'someone here' });
+    }
+    for (const device of room.openableDevices()) {
+        push(out, seen, { glyph: '▤', name: device.name, what: 'a device' });
+    }
+    for (const item of room.getItemsForActor(actor)) {
+        push(out, seen, { glyph: '◇', name: item.name, what: 'on the ground' });
+    }
+    // WHAT YOU ARE CARRYING is nameable too -- "equip", "drop", "reload
+    // <box>" and "use" all read the pack, and a long ammunition name is
+    // exactly the sort of thing nobody should have to spell.
+    for (const item of actor.inventory.getAllItems()) {
+        push(out, seen, { glyph: '▪', name: item.name, what: 'carried' });
+    }
+    // The ways out, by the name "go" takes.
+    for (const dir of Object.keys(room.exits ?? {})) {
+        push(out, seen, { glyph: '→', name: dir, what: 'a way out' });
+    }
+    return out;
+}
+/**
+ * The nameable set for whichever plane this actor is standing on.
+ * Astral and rigged frames fall back to the meat room: an astral form
+ * still names the people and the ward in front of it.
+ */
+export function nameablesFor(scene, actor, rooms) {
+    if (actor.plane === 'matrix') {
+        return matrixNameables(scene, actor, rooms ?? scene.getRooms());
+    }
+    return meatNameables(actor);
+}
+/** The roster a refusal prints: just the names, ready to join. */
+export function nameableNames(scene, actor, rooms) {
+    return nameablesFor(scene, actor, rooms).map(n => n.name);
+}
+/** Where the persona is, for a "nothing here" line that says where here is. */
+export function whereAmI(actor) {
+    if (actor.plane !== 'matrix')
+        return actor.currentLocation?.name ?? 'nowhere';
+    const inside = actor.insideHost;
+    if (inside)
+        return hostLabel(inside);
+    return actor.currentGrid?.name ?? gridVicinity(actor).name;
+}
+//# sourceMappingURL=nameables.js.map

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

@@ -1,5 +1,4 @@
 import * as fs from 'fs';
-import { normalizeMatrixStance, normalizeStance } from '../models/player.js';
 import { resolveSpot } from './spots.js';
 import { isAspectKey } from '../aspects.js';
 import * as path from 'path';
@@ -374,8 +373,6 @@ export function serializePlayer(p) {
             hungerStreak: p.hungerStreak, sleepStreak: p.sleepStreak,
             hungerFatigue: p.hungerFatigue, sleepFatigue: p.sleepFatigue,
         },
-        autoStance: p.autoStance,
-        matrixStance: p.matrixStance,
         inventory: p.inventory.getAllItems().map(serializeItem),
         equipment: serializeEquipment(p.equipment),
     };
@@ -542,10 +539,9 @@ export function restorePlayer(p, s) {
     p.sleepStreak = s.needs.sleepStreak;
     p.edgeRemaining = s.edgeRemaining;
     p.haggledThisJob = s.haggledThisJob;
-    p.autoStance = normalizeStance(s.autoStance);
-    // Older saves have no Matrix stance; normalizeMatrixStance defaults to
-    // Brute Force, which is the shipped default (models/player.ts).
-    p.matrixStance = normalizeMatrixStance(s.matrixStance);
+    // (s.autoStance / s.matrixStance are ignored: the stance was retired in
+    // f79LLqTerep4nKWcA and the choice lives on the verbs. Older saves still
+    // carry both fields; reading them would restore a setting nothing obeys.)
     if (s.archetypeName)
         p.archetypeName = s.archetypeName;
     if (s.gender)

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

@@ -123,7 +123,7 @@ export function enterMatrix(scene, actor, mode) {
         : `Your ${actor.activeDeck?.name ?? 'deck'} spins up and the room dissolves into geometry -- you're in. Your body slumps where you stood in ${actor.bodyRoom.name}, empty.`;
     return [
         `${entry}${hotWarning}${deckNote} You come up on ${actor.currentGrid?.name ?? 'the grid'}.${actor.currentGrid?.userPenalty ? ' Public grid: -2 on everything you do out here.' : ''}`,
-        hint(`No streets out here: "map" lights the hosts overhead, "mark" then "enter" (or "go") a host to get inside its architecture from anywhere, "hack" to force it, "jack out" to return.`),
+        hint(`No streets out here: "map" lights the hosts overhead and names them, "hack <host>" slips a mark in quiet (p.240) and "force <host>" smashes one in (p.238), one mark lets "enter <host>" walk you inside from anywhere, "mark" shows who holds what, "jack out" to return.`),
     ].filter(l => l.length > 0);
 }
 /**

package/package.json

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

@@ -1,121 +0,0 @@
-import { Command } from './command.js';
-import { STANCE_CYCLE, STANCE_ALIASES, STANCE_DESCRIPTION, MATRIX_STANCE_CYCLE, MATRIX_STANCE_ALIASES, MATRIX_STANCE_ACTION } from '../models/player.js';
-import { fuzzyPickName } from '../utilities/fuzzy-match.js';
-/**
- * The typed twin of the Tab key: set (or inspect) the stance. On either
- * plane the stance is what your next action DOES -- in the meat, the
- * damage type your blow is meant to deal (lethal / non-lethal, see
- * FightStance in models/player.ts); on the Matrix, which intrusion
- * action a hack is (Brute Force / Hack on the Fly). It never decides
- * whether you act: since the Combat Turn (2026-09-06) every phase is
- * yours to play and "end turn" to commit, and the fight autopilot this
- * verb used to set was retired with it (2026-09-07).
- */
-export class StanceCommand extends Command {
-    static verb = 'stance';
-    static description = 'Set your stance -- what your next action does, never whether you take it. ON THE MATRIX it picks the intrusion action: attack (Brute Force, p.238) or sleaze (Hack on the Fly, p.240); "deck config" still sets the array. IN THE MEAT it picks the damage type you mean: lethal (the gear as sold) or non-lethal (Stun wherever the gear allows -- stun rounds when you reload, the flat of the blade at Accuracy 3 per p.186, bare hands; a lethal gun with lethal rounds warns you it stays lethal). Tab flips it.';
-    /**
-     * ON THE MATRIX, TAB FLIPS THE INTRUSION ACTION instead of the fight
-     * autopilot (mjmcee, uMQAhaAysgaKpWFkn). One verb and one key, two
-     * planes -- because the player's question is the same in both ("how
-     * hard am I about to go?") and they are never on both planes at once.
-     */
-    matrixLines(actor) {
-        const cur = actor.matrixStance;
-        return [
-            `Matrix stance: ${MATRIX_STANCE_ACTION[cur].toUpperCase()} (${cur}) -- ${StanceCommand.describeMatrix(cur)}.`,
-            '',
-            ...MATRIX_STANCE_CYCLE.map(m => `  ${MATRIX_STANCE_ACTION[m].padEnd(16)} -- ${StanceCommand.describeMatrix(m)}`),
-            '',
-            `Set with "stance attack" / "stance sleaze", or Tab to flip. "deck config" still sets the array itself.`,
-        ].join('\n');
-    }
-    /** What each route costs and buys, in the book's terms (p.238/240). */
-    static describeMatrix(m) {
-        return m === 'attack'
-            ? 'Cybercombat + Logic [Attack]; a miss goes unnoticed but the firewall bites, and net hits burn the target'
-            : 'Hacking + Logic [Sleaze]; a miss gets you MADE, and net hits read the target while you key it';
-    }
-    async execute(args = []) {
-        const actor = this.actor;
-        const onMatrix = actor.plane === 'matrix';
-        if (!args || args.length === 0) {
-            if (onMatrix)
-                return this.matrixLines(actor);
-            const lines = [
-                `Stance: ${actor.autoStance.toUpperCase()} -- ${STANCE_DESCRIPTION[actor.autoStance]}.`,
-                '',
-                ...STANCE_CYCLE.map(s => `  ${s.padEnd(10)} -- ${STANCE_DESCRIPTION[s]}`),
-                '',
-                `Set with "stance <name>", or Tab to flip. The stance is what a blow does, not who throws it -- every action is yours to type, and "end turn" commits the phase.`,
-            ];
-            return lines.join('\n');
-        }
-        // "stance next" -- THE TAB KEY'S WIRE FORM (playtest 2026-08-27:
-        // "the combat stance isn't updating in the menu bar"). Tab used to
-        // cycle by mutating game.player.autoStance directly, which in a
-        // SHARED RUN is the local hub player, not the runner on the table:
-        // the server's stance never moved, the autopilot never changed
-        // temperature, and the HUD -- painted from the server's status
-        // events -- never showed the switch. Tab now sends this instead, so
-        // the cycle advances from the ACTOR's real stance wherever the
-        // engine happens to be running. Checked before the fuzzy match: it
-        // is a control word, not a stance name, and fuzzyPickName would
-        // otherwise try to spell-correct it into one.
-        const raw = args.join(' ').trim().toLowerCase();
-        if (raw === 'next' || raw === 'cycle') {
-            if (onMatrix) {
-                const i = MATRIX_STANCE_CYCLE.indexOf(actor.matrixStance);
-                const next = MATRIX_STANCE_CYCLE[(i + 1) % MATRIX_STANCE_CYCLE.length];
-                actor.matrixStance = next;
-                this.scene.updateStatus();
-                this.logger.write(`${actor.name} flipped to ${MATRIX_STANCE_ACTION[next]}.`);
-                return `Matrix stance: ${MATRIX_STANCE_ACTION[next].toUpperCase()} -- ${StanceCommand.describeMatrix(next)}.`;
-            }
-            const cur = STANCE_CYCLE.indexOf(actor.autoStance);
-            const nextStance = STANCE_CYCLE[(cur + 1) % STANCE_CYCLE.length];
-            actor.autoStance = nextStance;
-            this.scene.updateStatus();
-            this.logger.write(`${actor.name} cycled stance to ${nextStance}.`);
-            return `Stance: ${nextStance.toUpperCase()} -- ${STANCE_DESCRIPTION[nextStance]}.`;
-        }
-        // A Matrix route by name, from either plane's vocabulary -- so
-        // "stance sleaze" works while jacked in and reads as a typo
-        // otherwise, rather than fuzzy-matching into a fight stance.
-        const matrixNamed = MATRIX_STANCE_ALIASES[raw] ?? (MATRIX_STANCE_CYCLE.includes(raw) ? raw : undefined);
-        if (onMatrix && matrixNamed) {
-            if (matrixNamed === actor.matrixStance)
-                return `Already ${MATRIX_STANCE_ACTION[matrixNamed].toUpperCase()} -- ${StanceCommand.describeMatrix(matrixNamed)}.`;
-            actor.matrixStance = matrixNamed;
-            this.scene.updateStatus();
-            this.logger.write(`${actor.name} set Matrix stance to ${MATRIX_STANCE_ACTION[matrixNamed]}.`);
-            return `Matrix stance: ${MATRIX_STANCE_ACTION[matrixNamed].toUpperCase()} -- ${StanceCommand.describeMatrix(matrixNamed)}.`;
-        }
-        if (onMatrix) {
-            return `That's not a Matrix route. Choose: ${MATRIX_STANCE_CYCLE.join(', ')} (${MATRIX_STANCE_CYCLE.map(m => MATRIX_STANCE_ACTION[m]).join(' / ')}).`;
-        }
-        // THE EXACT NAME ALWAYS WINS. "stance non-lethal" -- the very word the
-        // refusal below lists -- used to be refused: fuzzyPickName normalizes
-        // punctuation to whitespace, so "non-lethal" and the "non lethal"
-        // alias both became "non lethal", the exact tier saw two candidates,
-        // and an ambiguous guess deliberately misses. Caught by a bench that
-        // typed the name off the "Choose:" line (2jbprbSYqF7EPXrkR's dry run).
-        // The old words (and their typos) still land: fuzzy over the cycle AND the aliases, then through the alias map.
-        const pickedRaw = STANCE_CYCLE.includes(raw)
-            ? raw
-            : STANCE_ALIASES[raw] ?? fuzzyPickName(args.join(' '), [...STANCE_CYCLE, ...Object.keys(STANCE_ALIASES)]);
-        const picked = pickedRaw ? (STANCE_ALIASES[pickedRaw] ?? pickedRaw) : undefined;
-        if (!picked) {
-            return `That's not a stance. Choose: ${STANCE_CYCLE.join(', ')}.`;
-        }
-        const stance = picked;
-        if (stance === actor.autoStance) {
-            return `Already ${stance.toUpperCase()} -- ${STANCE_DESCRIPTION[stance]}.`;
-        }
-        actor.autoStance = stance;
-        this.scene.updateStatus();
-        this.logger.write(`${actor.name} set stance to ${stance}.`);
-        return `Stance: ${stance.toUpperCase()} -- ${STANCE_DESCRIPTION[stance]}.`;
-    }
-}
-//# sourceMappingURL=stance.js.map