@maka/maka-cli 5.206.0 → 5.208.0

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

@@ -7,6 +7,7 @@ import { Logger } from './utilities/logger.js';
 import { getArchetype, outfitArchetype } from './archetypes.js';
 import { attachLineEditor, attachArrowMovement } from './utilities/line-editor.js';
 import { attachInputHistory } from './utilities/input-history.js';
+import { COMPLETE_MARKER } from './commands/complete.js';
 import { TERMINAL_RESET_SEQUENCE } from './utilities/terminal-reset.js';
 import { readSave } from './utilities/persistence.js';
 import { requireCatalog, CatalogUnavailableError } from './utilities/catalog.js';
@@ -322,10 +323,11 @@ export async function main(playerName, sceneSeed, options) {
         game.updateInventory(game.player.inventory, capitalCase(game.scene.getCurrencyType()));
         game.updateExits(game.player.currentLocation);
         game.updateStatus();
-        // Tab flips the stance: lethal <-> non-lethal in the meat, Brute
-        // Force <-> Hack on the Fly on the Matrix (models/player.ts; "stance"
-        // is the typed twin). Bound on the input box because that's where
-        // focus lives during play.
+        // TAB COMPLETES THE NAME YOU ARE TYPING (f79LLqTerep4nKWcA). It used
+        // to flip the stance; the stance is gone, and what the same report
+        // asked for in its place is a way to know which icon you are about
+        // to hit. Bound on the input box because that's where focus lives
+        // during play.
         game.inputBox.key(['tab'], () => {
             // Blessed's textarea reader appends the literal '\t' to the box
             // value on this same keypress (listener order isn't guaranteed
@@ -339,36 +341,36 @@ export async function main(playerName, sceneSeed, options) {
             };
             stripTab();
             setImmediate(() => { stripTab(); screen.render(); });
-            // ONE ROUTE, BOTH PLANES, BOTH RUN SHAPES. This used to fork: a
-            // shared run sent "stance next" to the server while a local run
-            // mutated game.player.autoStance here by hand. That duplicate is
-            // what made Tab plane-blind -- the Matrix stance
-            // (uMQAhaAysgaKpWFkn, 2026-09-03) would have had to be added
-            // twice, and the second copy is the one that gets forgotten.
+            // ONE ROUTE, BOTH PLANES, BOTH RUN SHAPES -- and the reason the
+            // completion is answered by the ENGINE rather than built here.
             //
-            // SHARED RUN: THE STANCE LIVES ON THE SERVER (playtest
-            // 2026-08-27: "the combat stance isn't updating in the menu
-            // bar"). game.player here is the LOCAL HUB player -- in a shared
-            // run the runner on the table is a different object in a
-            // different process, so cycling this one moved nothing the
-            // engine reads and nothing the HUD paints (updateStatus
-            // early-returns on remoteSession; the status box belongs to the
-            // server's events). Send the typed twin instead and let the
-            // engine cycle from the ACTOR's real stance.
+            // Locally this process holds the whole scene and could list the
+            // names itself. In a SHARED RUN it holds nothing: game.player is
+            // the LOCAL HUB player, the runner on the table is a different
+            // object in a different process, and the room arrives as rendered
+            // text with the structured payload dropped (utilities/shared-run.ts).
+            // A completer built on what is in memory here would work solo and
+            // silently do nothing on the grid with three other people -- which
+            // is the same duplicate-path trap the old stance binding fell into.
+            // So: send the box, let the engine answer, on both run shapes.
             void (async () => {
-                const res = await game.handleInput('stance next');
+                const box = game.inputBox.getValue().replace(/\t/g, '');
+                const res = await game.handleInput(`complete ${box}`);
                 if (!res)
                     return;
-                // Red for the lethal routes, yellow for the careful ones (same
-                // palette as the HUD stance in game.ts): Brute Force is the loud
-                // one, Hack on the Fly the careful one. Never gray -- ANSI
-                // bright-black is illegible on stock dark palettes.
-                const named = res.match(/(?:Matrix s|S)tance:\s*([\w-]+)/i)?.[1]?.toLowerCase();
-                const c = named === 'lethal' || named === 'brute' ? 'red'
-                    : named === 'non-lethal' || named === 'non' || named === 'hack' ? 'yellow'
-                        : 'white';
-                gameLog.meta(`⚔ ${res.split('\n')[0]}`, c);
-                game.updateStatus();
+                const lines = res.split('\n');
+                // THE MARKER LINE refills the box (see commands/complete.ts).
+                // Everything else is the candidate list, and goes to the ticker
+                // rather than the transcript: Tab is not a turn.
+                if (lines[0]?.startsWith(COMPLETE_MARKER)) {
+                    const filled = lines[0].slice(COMPLETE_MARKER.length);
+                    game.inputBox.setValue(filled);
+                    lines.shift();
+                }
+                for (const l of lines) {
+                    if (l.trim().length > 0)
+                        gameLog.meta(l, 'white');
+                }
                 screen.render();
             })();
         });

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.206.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.",