@maka/maka-cli 5.207.0 → 5.208.0

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

@@ -1,43 +1,124 @@
 import { AttackCommand } from './attack.js';
+import { Category } from '../types/shared/item-enum.js';
+import { hint } from '../utilities/hints.js';
 /**
- * Take them alive: the same exchange machinery as attack (opposed roll,
- * retaliation, pacing, movement lock), but the damage lands on the STUN
- * track -- a full track is a live capture, not a kill. The tradeoffs that
- * keep it honest: the strike ignores your gun entirely (bare-hands pool,
- * low base damage, so it's slower than shooting), the target's retaliation
- * is fully lethal, and beating someone far past unconsciousness overflows
- * into their body -- you can still kill someone you meant to capture.
+ * TAKE THEM ALIVE -- the non-lethal half of the meat fork, and since
+ * f79LLqTerep4nKWcA the ONLY way to ask for it.
+ *
+ * It used to be half a verb and half a setting: `subdue` was bare hands
+ * and nothing else, while a lethal weapon went Stun only if your standing
+ * STANCE happened to be non-lethal when you swung it. Two places to say
+ * one thing, one of them invisible. The stance is gone; the verb says it.
+ *
+ * WHAT CANON ALLOWS, and the whole of what this verb reaches for
+ * (RAG-checked p.186 "Changing Damage Types", p.170-171, p.434):
+ *
+ *   BARE HANDS      unarmed is Stun by default -- the fallback, and what
+ *                   you get with nothing drawn.
+ *   STUN GEAR       taser, stun baton, shock gloves: electricity is Stun
+ *                   in anyone's hands, in any frame of mind (p.170-171).
+ *   STUN ROUNDS     gel, stick-n-shock: whatever the magazine holds
+ *                   (p.434). The gun fires; the rounds are the mercy.
+ *   FLAT OF THE BLADE  a lethal melee weapon used as a club -- "Accuracy
+ *                   of 3", and "blades used as a club lose all Reach due
+ *                   to the need to hit with the pommel" (p.186).
+ *
+ * AND WHAT IT REFUSES. A lethal firearm with lethal rounds has no
+ * non-lethal door in the book short of a Called Shot, which this engine
+ * does not implement. That case used to FIRE and tag the line
+ * " (LETHAL -- no stun rounds loaded)" afterwards: the player asked to
+ * take someone alive, killed them, and read about it in the past tense.
+ * A refusal costs no action and names both ways out.
+ *
+ * THE TRADEOFFS THAT KEEP IT HONEST are unchanged: the target's
+ * retaliation is fully lethal (weaponProfile is never handed this verb's
+ * intent), and beating someone far past unconsciousness overflows into
+ * their body -- you can still kill someone you meant to capture.
+ *
+ * SR5 "SUBDUING" (p.195) IS A DIFFERENT ACTION and lives next door in
+ * commands/grapple.ts -- the grapple that immobilises and deals no
+ * damage, escaped with "struggle". This verb is the knockout.
  */
 export class SubdueCommand extends AttackCommand {
     static verb = 'subdue';
     /** Touches another actor: authorized per-act for AI-driven actors
      *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
     static npcPolicy = 'authorized';
-    static description = 'Take someone down ALIVE -- stun damage with your bare hands. Slower than shooting, they fight back for real, and overdoing it can still kill them.';
+    static description = 'Take someone down ALIVE. Uses whatever you are holding that CAN go non-lethal: stun gear (taser, stun baton, shock gloves), stun rounds in the magazine, or a lethal melee weapon swung as a club -- Accuracy 3 and no Reach (p.186). Bare hands otherwise, which are Stun by default. A lethal gun with lethal rounds is refused, not fired. They fight back for real, and overdoing it can still kill them. Also "stun", "knock out". ("grapple" is the other thing: SR5 Subduing, p.195 -- hold them still, no damage.)';
+    /**
+     * How this actor can take someone alive with what is in their hands.
+     * One reader, used by the refusal, the draw decision and the profile,
+     * so the three can never disagree about what the weapon is for.
+     */
+    nonLethalRoute() {
+        const actor = this.actor;
+        const held = actor.weaponDrawn ? actor.getCarriedWeapon() : undefined;
+        if (!held)
+            return 'hands';
+        if (held.isStunWeapon())
+            return 'stun-weapon';
+        if (held.isFirearm())
+            return held.stunAmmo() ? 'stun-ammo' : 'lethal-gun';
+        if (held.category === Category.MeleeWeapon)
+            return 'club';
+        // Anything else in your hands is not a weapon this verb can pull --
+        // fall back to the hands themselves rather than inventing a rule.
+        return 'hands';
+    }
     async execute(args = []) {
-        // A chokehold needs hands and a neck: no grappling as a Matrix persona
-        // or an astral form. (Matrix "non-lethal" is meaningless anyway -- a
-        // crashed ice program isn't a corpse; and astral entities are put down
-        // with force, not wrestled.)
+        // "knock out <name>" / "knock down <name>": the verb is words[0]
+        // everywhere in this dispatcher, so the second word of a two-word
+        // spelling arrives as the first arg and would be read as part of the
+        // target's name.
+        const rest = [...(args ?? [])];
+        if (/^(out|down)$/i.test(rest[0] ?? ''))
+            rest.shift();
+        // A chokehold needs hands and a neck: no knockouts as a Matrix
+        // persona or an astral form. (Matrix "non-lethal" is meaningless
+        // anyway -- a crashed ice program isn't a corpse; and astral entities
+        // are put down with force, not wrestled.)
         if (this.actor.plane !== 'meat') {
-            return `You can't grapple anything from here -- subduing takes real hands on a real body.`;
+            return `You can't take anything alive from here -- a knockout needs real hands on a real body.`;
+        }
+        // THE REFUSAL COMES BEFORE THE ROLL, so it costs nothing. See the
+        // class comment: this case used to fire and apologise afterwards.
+        if (this.nonLethalRoute() === 'lethal-gun') {
+            const gun = this.actor.getCarriedWeapon();
+            return [
+                `${gun?.name ?? 'That gun'} is loaded with lethal rounds -- there is no way to shoot someone alive with it (p.186: short of a called shot, a firearm deals what it is loaded with).`,
+                hint(` ("reload gel" or "reload stick-n-shock" if you are carrying either, "holster" and "subdue" bare-handed, or "attack" if you meant it.)`),
+            ].join('');
         }
-        return super.execute(args);
+        return super.execute(rest);
     }
+    /** The weapon speaks unless the answer is your own hands. */
     usesEquippedWeapon() {
-        return false;
+        return this.nonLethalRoute() !== 'hands';
     }
     actionVerb() {
         return 'moves to subdue';
     }
     strikeProfile(exchange, target) {
+        const actor = this.actor;
+        // WITH SOMETHING IN YOUR HANDS the normal weapon profile builds the
+        // strike -- it already knows electricity, stun rounds and the p.186
+        // club-swing (Accuracy 3, Reach gone); all it was ever missing was
+        // being told that this swing means to leave them breathing.
+        if (this.nonLethalRoute() !== 'hands') {
+            return exchange.weaponProfile(actor, target, { nonLethal: true });
+        }
         return {
             label: 'with a subduing hold',
             // Bare-hands work: rolled on the UNARMED skill regardless of what's
             // drawn -- a pistol's quality (or your firearms training) doesn't
             // help you choke someone out. See Player.getUnarmedAttackPool.
-            pool: Math.max(0, this.actor.getUnarmedAttackPool() + this.actor.consumeEdgeBoost()),
-            damageBase: 1 + Math.floor(this.actor.strength / 2),
+            pool: Math.max(0, actor.getUnarmedAttackPool() + actor.consumeEdgeBoost()),
+            // (STR)S, p.187 -- the same number combat-exchange.ts has always
+            // used for a bare fist. This said `1 + floor(STR/2)` for no reason
+            // the file could name, so a troll's chokehold was weaker than the
+            // identical troll's punch; fixed while the verb was being rebuilt
+            // around it (f79LLqTerep4nKWcA).
+            damageBase: actor.strength + actor.bonus('unarmed-damage'),
             soakPool: target.getSoakPool(),
             dealStun: true,
         };

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

@@ -54,14 +54,25 @@ import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-aud
  */
 export class TapCommand extends Command {
     static verb = 'tap';
-    static description = 'Cable into a camera you are standing next to -- a DIRECT CONNECTION (p.232). A slaved device can\'t hide behind its host\'s ratings against a cable, so the camera fights you with its own; and a mark on a slaved device is a mark on the host it answers to (p.233), which is your way in. Needs your BODY in the room and a deck in hand. "tap" is sleaze (fail = noticed); "tap loud" is brute force (fail = unnoticed, the firewall bites).';
-    async execute(args = []) {
+    static description = 'Cable into a camera you are standing next to -- a DIRECT CONNECTION (p.232), run as HACK ON THE FLY (p.240). A slaved device can\'t hide behind its host\'s ratings against a cable, so the camera fights you with its own; and a mark on a slaved device is a mark on the host it answers to (p.233), which is your way in. Needs your BODY in the room and a deck in hand. Fail and you are noticed. To cable in loud instead, "force camera" is Brute Force over the same cable (p.238).';
+    /**
+     * WHICH INTRUSION ACTION THE CABLE CARRIES. Same rule as hack.ts:
+     * the verb decides, not a word inside the target name. `tap loud`
+     * used to scan the args for loud/force/brute/attack and flip -- so a
+     * camera named for any of those words could not be tapped quietly,
+     * and the word itself taught nothing. `force camera` routes here with
+     * the Attack mode set (commands/hack.ts), which is the same hop
+     * `hack camera` has always made.
+     */
+    modeOverride;
+    /** How `force camera` reaches the loud route over the same cable. */
+    withMode(m) { this.modeOverride = m; return this; }
+    mode() { return this.modeOverride ?? 'sleaze'; }
+    async execute() {
         const actor = this.actor;
         const room = actor.currentLocation;
         const rooms = this.rooms ?? {};
-        // Same mode vocabulary as hack.ts and mark.ts -- one fork, learned once.
-        const words = (args ?? []).map(w => w.toLowerCase());
-        const mode = words.some(w => /^(loud|force|brute|attack)$/.test(w)) ? 'attack' : 'sleaze';
+        const mode = this.mode();
         if (!isWatched(room)) {
             return `No cameras in here to cable into.${hint(` (Your overlay tags them "◎ Camera cluster" when there are.)`)}`;
         }

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

@@ -843,5 +843,66 @@
 //     about someone else's haul, on top of the feed line it already
 //     had. Scoped to the sweeper; and the two performAction calls that
 //     passed a bare "take" now pass "takes", like every sibling verb.
-export const ENGINE_VERSION = '1.67.0';
+// 1.68.0 (2026-09-16): THERE IS NO STANCE (f79LLqTerep4nKWcA). The
+//   Erase Mark bench came back rejected without the reporter ever
+//   reaching Erase Mark: the vocabulary it walked through did not
+//   survive being read. "what is 'hack quiet' -- I don't see a 'quiet',
+//   is it just 'mark'? How do I know which host/PAN/etc I'm hacking?"
+//   ... "'sealed, walls UP, over you' means nothing, it's just jargon."
+//   ... and the ruling: "Let's get rid of the stance all together --
+//   it's now confusing as we have turn-based combat. The extra
+//   'overrides' is confusing."
+//   - ONE VERB PER BOOK ACTION. `hack <target>` IS Hack on the Fly
+//     (p.240); `force <target>` (brute, smash) IS Brute Force (p.238) --
+//     commands/force.ts, which is HackCommand with one method
+//     overridden, so the entire target ladder is shared. The mode words
+//     loud/quiet/sleaze/sneak/force/brute/attack are gone from the
+//     parser: every word a player types is now part of a NAME.
+//   - `mark` STOPS BEING AN ACTION and becomes the ledger, BOTH
+//     directions -- what you hold, and what holds you. It routed into
+//     hack before, which is the "then what is mark?" in the report: two
+//     spellings of one action and no way to tell them apart. It costs
+//     nothing and bills nothing. Alias `marks`.
+//   - THE MEAT HALF MOVED ONTO ITS VERBS TOO. `attack`/`kill` deal what
+//     the gear was sold to deal; `subdue` (stun, knock out) takes them
+//     alive and now uses whatever is in your hands that CAN go Stun --
+//     stun gear, stun rounds, or a blade swung as a club at Accuracy 3
+//     with no Reach (p.186), bare hands otherwise. A lethal gun with
+//     lethal rounds is REFUSED before the dice instead of fired and
+//     labelled " (LETHAL -- no stun rounds loaded)" afterwards.
+//     combat-exchange.weaponProfile takes the intent as an argument.
+//     `grapple` is still SR5 Subduing (p.195) and is untouched.
+//   - SWEPT THE FAMILY, because a verb fixed alone reproduces the report
+//     one layer down: `tap loud` and `disable loud`/`disable quiet` were
+//     the same hidden adverb. `force <camera>` is the loud cable now,
+//     and `brick` is the only spelling of Data Spike.
+//   - SUBDUE'S DV WAS WRONG and is fixed while the file was open:
+//     `1 + floor(STR/2)` where RAW unarmed is (STR)S (p.187), the number
+//     combat-exchange has always used for a bare fist. A troll's
+//     chokehold was weaker than the same troll's punch.
+//   - "sealed, walls UP, over you" IS GONE from hostLine, and it was
+//     worse than jargon: `standing` read only the marks YOU hold, so a
+//     host holding three marks on your persona printed "sealed", the
+//     word for a node nobody has touched. Four facts, four plain
+//     clauses, swept across every host renderer (hostLine, hostDockLine,
+//     gridIcons, hostInteriorPanel): what you hold, what it holds on
+//     you, whether it knows someone is in (alert) or can see YOU
+//     (spotted), and whether it is the node overhead.
+//   - THE HUD'S FIRST LINE carried the stance so players would discover
+//     Tab. It carries the MARK LEDGER now, both counts -- the one
+//     always-visible surface, in the CLI and in the headless transcript.
+//     Only the web character sheet ever showed both directions.
+//   - TAB COMPLETES THE NAME YOU ARE TYPING, answered by the engine:
+//     Tab sends `complete <box text>` (commands/complete.ts, hidden
+//     verb, no action, no bill) and utilities/nameables.ts answers from
+//     the live scene. It has to be the engine: the condition beat
+//     carries meat-plane BODIES only, so jacked in no client knows a
+//     single icon's name, and the CLI on a shared run holds nothing but
+//     rendered text. The reply's first line is `{complete}<text>` and
+//     the client refills its box from it.
+//   SAVE SHAPE: autoStance and matrixStance are no longer written and
+//   no longer read; older saves carry them harmlessly. The condition
+//   report drops `stance` (the site and Unity drop it in the same
+//   release). REMOVED: the `stance` verb.
+export const ENGINE_VERSION = '1.68.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -1,6 +1,5 @@
 import { sustainBurden, sustainTotal } from './utilities/sustaining.js';
 import { agentRatingFromName } from './utilities/programs.js';
-import { MATRIX_STANCE_ACTION } from './models/player.js';
 import { buildDossierUrl } from './utilities/web-character-generator.js';
 import { makaHost } from '../../../tools/https/maka-host.js';
 import { openBrowser } from '../../../tools/browser/open-browser.js';
@@ -115,9 +114,10 @@ import { EndCallCommand } from './commands/end-call.js';
 import { fuzzyPickName, guessVerb } from './utilities/fuzzy-match.js';
 import { PickCommand } from './commands/pick.js';
 import { HackCommand } from './commands/hack.js';
+import { ForceCommand } from './commands/force.js';
+import { CompleteCommand } from './commands/complete.js';
 import { DisableCommand, BrickCommand } from './commands/disable.js';
 import { CastCommand } from './commands/cast.js';
-import { StanceCommand } from './commands/stance.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
 import { SurrenderCommand } from './commands/surrender.js';
 import { JackCommand } from './commands/jack.js';
@@ -2884,6 +2884,11 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('fit', FitCommand);
         CommandFactory.registerCommand('unfit', UnfitCommand);
         CommandFactory.registerCommand('subdue', SubdueCommand);
+        // The non-lethal intent is a VERB now, not a stance (f79LLqTerep4nKWcA).
+        // `knock` carries "knock out <name>" / "knock down <name>"; subdue.ts
+        // strips the second word, which the dispatcher hands it as an arg.
+        CommandFactory.registerCommand('stun', SubdueCommand);
+        CommandFactory.registerCommand('knock', SubdueCommand);
         // SUBDUING p.195 (see commands/grapple.ts): restrain without damage.
         // Canon skill hooks (see SkillName in models/player.ts).
         CommandFactory.registerCommand('palm', PalmCommand);
@@ -2923,10 +2928,14 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('end-call', EndCallCommand);
         CommandFactory.registerCommand('pick', PickCommand);
         CommandFactory.registerCommand('hack', HackCommand);
+        // BRUTE FORCE IS ITS OWN VERB (f79LLqTerep4nKWcA), not a word you add
+        // to that one -- see commands/force.ts for why.
+        CommandFactory.registerCommand('force', ForceCommand);
+        CommandFactory.registerCommand('brute', ForceCommand);
+        CommandFactory.registerCommand('smash', ForceCommand);
         CommandFactory.registerCommand('disable', DisableCommand);
         CommandFactory.registerCommand('brick', BrickCommand);
         CommandFactory.registerCommand('cast', CastCommand);
-        CommandFactory.registerCommand('stance', StanceCommand);
         CommandFactory.registerCommand('surrender', SurrenderCommand);
         CommandFactory.registerCommand('jack', JackCommand);
         CommandFactory.registerCommand('project', ProjectCommand);
@@ -3081,6 +3090,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('wipe', EraseCommand);
         // MAtrix Recognition Keys (canon p.235-236).
         CommandFactory.registerCommand('mark', MarkCommand);
+        CommandFactory.registerCommand('marks', MarkCommand);
+        CommandFactory.registerCommand('complete', CompleteCommand);
         CommandFactory.registerCommand('unmark', EraseMarkCommand);
         // SPRITE POWERS (p.256-257): one verb per power, reached as
         // "order <sprite> <power> <target>" -- see commands/sprite-power.ts.
@@ -5892,40 +5903,41 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     }
     statusLinesFor(player) {
         const lines = [];
-        // Line 1: the stance -- lethal or non-lethal in the meat (the damage
-        // type your next blow means; models/player.ts FightStance), Brute
-        // Force or Hack on the Fly on the Matrix. It lives HERE -- the
-        // shortest HUD line -- because appended to the long readiness line it
-        // wrapped out of the box on narrower terminals and effectively only
-        // ever showed in the Tab announcement. Always shown: the HUD is how
-        // players discover Tab flips it at all. Red for the lethal routes,
-        // yellow for the careful ones -- never gray, which is ANSI "bright
-        // black" and illegible on a stock dark palette.
+        // Line 1: what you are holding, and -- jacked in -- the MARK LEDGER,
+        // both directions.
+        //
+        // THIS SLOT USED TO CARRY THE STANCE, and it carried it for a reason
+        // that died with the stance: the HUD was how players discovered Tab
+        // flipped it at all. With no posture left to advertise
+        // (f79LLqTerep4nKWcA) the shortest HUD line is free, and the thing
+        // most worth putting in it is the one the same report asked for --
+        // "when I have a mark on it, show my mark on it, and vice versa --
+        // when it has a mark on me, show that."
+        //
+        // Both counts, always, on the one surface a persona cannot miss.
+        // Only the web character sheet ever printed the two ledgers side by
+        // side; the CLI and the headless transcript (headless.ts status
+        // events run through this very method) printed neither, so a runner
+        // carrying three host marks read a grid map that said "sealed".
+        // Red once anything holds a key on you -- that is the number that
+        // decides whether the ice can find you -- yellow while only you hold
+        // keys, and never gray, which is ANSI "bright black" and illegible
+        // on a stock dark palette.
         //
         // WHERE YOU ARE MOVED OUT (player ruling 2026-08-25): the room name
         // now captions the Map box and the "@ spot" captions the Room box,
         // each under the picture it belongs to, so the HUD stops repeating
-        // what two panels already show. The breadcrumb went with it -- the
-        // district map draws the way you came far better than a text trail.
-        // THE STANCE THE HUD SHOWS IS THE ONE IN FORCE (uMQAhaAysgaKpWFkn,
-        // 2026-09-03). Jacked in, the fight stance is not what Tab moves
-        // and not what your next action obeys -- the Matrix stance is
-        // (Brute Force or Hack on the Fly). Showing the meat stance to
-        // a persona would be the same class of bug as the 2026-08-27
-        // report that the HUD did not follow Tab at all: a readout naming
-        // a setting the player cannot currently change.
+        // what two panels already show.
         const onMatrix = player.plane === 'matrix';
-        const stanceWord = onMatrix ? MATRIX_STANCE_ACTION[player.matrixStance] : player.autoStance;
-        const stanceColor = onMatrix
-            ? (player.matrixStance === 'attack' ? 'red' : 'yellow')
-            : player.autoStance === 'lethal' ? 'red' : 'yellow';
-        // WHAT'S IN YOUR HANDS rides alongside the stance (player ruling
-        // 2026-08-25). The two answer the same question -- how ready are you
-        // -- and the stance line was left short and lonely once the location
-        // moved out to the map captions, while the readiness line below ran
-        // long. armedLine is built further down with the rest of the gear
-        // read; only its placement moved.
-        lines.push(`{${stanceColor}-fg}${onMatrix ? '◈' : '⚔'} ${stanceWord.toUpperCase()}{/${stanceColor}-fg}  ${this.armedLine(player)}`);
+        if (onMatrix) {
+            const held = marksPlaced(this.scene, player.name).reduce((n, m) => n + m.count, 0);
+            const on = marksOnYou(this.scene, player).reduce((n, m) => n + m.count, 0);
+            const markColor = on > 0 ? 'red' : held > 0 ? 'yellow' : 'light-blue';
+            lines.push(`{${markColor}-fg}◈ MARKS ${held} held · ${on} ON YOU{/${markColor}-fg}  ${this.armedLine(player)}`);
+        }
+        else {
+            lines.push(`{red-fg}⚔ ARMED{/red-fg}  ${this.armedLine(player)}`);
+        }
         // Line 2: both condition monitors -- in a game where a fight can kill
         // you and casting can knock you out, current damage on either track is
         // never something a player should have to ask for. Colors shift as
@@ -6738,14 +6750,14 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     static HELP_CATEGORIES = [
         { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
         { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['loot'], ['drop'], ['give'], ['store'], ['open'], ['close'], ['put'], ['equip'], ['unequip'], ['fit'], ['unfit'], ['brandish', 'draw'], ['holster'], ['reload'], ['use'], ['read']] },
-        { title: 'combat', entries: [['attack'], ['kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['stance'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
+        { title: 'combat', entries: [['attack'], ['kill'], ['subdue', 'stun', 'knock'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
         // The party layer: everyone who walks (or flies, or manifests) at
         // your side answers to these.
         // "players" folded back under crew after playtesting ("crew
         // players" / "crew street"); the bare verb still answers quietly.
         { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
         { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
-        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
         // The Emerged get their own shelf (player request: "there MUST be
         // resonance" -- matrix is the place, Resonance is the talent).
         // `sustain` shelves here and not under magic: the command is
@@ -6767,7 +6779,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     // ("first aid", "apply first aid") that used to die at the parser. As
     // bare words they mean nothing, so they are claimed but not advertised
     // -- `heal` is the verb the help screen teaches.
-    static HIDDEN_VERBS = ['players', 'first', 'apply'];
+    // `complete` is what Tab sends (commands/complete.ts) -- a question the
+    // input box asks, not a verb anyone types, so it stays out of help.
+    static HIDDEN_VERBS = ['players', 'first', 'apply', 'complete'];
     /** Session verbs that only a play-tester (or admin) can actually use
      *  -- the server role-gates both and 403s everyone else. Listed in
      *  help ONLY for a confirmed play-tester; see helpCategories. `roles`

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

@@ -16,38 +16,6 @@ import { physicalLimit } from '../utilities/grapple.js';
 import { astralLimit } from '../utilities/limits.js';
 import { Inventory } from './inventory.js';
 import { AbstractPlayer } from '../types/shared/abstracts.js';
-export const STANCE_CYCLE = ['lethal', 'non-lethal'];
-/** The old names, still accepted from saves and the stance command. */
-export const STANCE_ALIASES = {
-    guarded: 'non-lethal', aggressive: 'lethal', manual: 'lethal',
-    nonlethal: 'non-lethal', 'non lethal': 'non-lethal', stun: 'non-lethal', kill: 'lethal',
-};
-/** What each stance means, in one line -- the HUD's and the verb's. */
-export const STANCE_DESCRIPTION = {
-    lethal: 'your weapons deal the damage they were sold to deal; "attack" and "kill" mean it',
-    'non-lethal': 'Stun wherever the gear allows -- stun rounds when you reload, the flat of the blade (p.186), bare hands -- and a lethal gun with lethal rounds says so before it fires',
-};
-export const MATRIX_STANCE_CYCLE = ['attack', 'sleaze'];
-/** What each stance is CALLED in the book -- printed everywhere the
- *  engine used to say "loud"/"quiet", so the vocabulary teaches the
- *  real action names (the whole point of uMQAhaAysgaKpWFkn). */
-export const MATRIX_STANCE_ACTION = {
-    attack: 'Brute Force',
-    sleaze: 'Hack on the Fly',
-};
-/** The words a player may type, including the engine's older ones. */
-export const MATRIX_STANCE_ALIASES = {
-    loud: 'attack', force: 'attack', brute: 'attack', 'brute force': 'attack', bf: 'attack',
-    quiet: 'sleaze', sneak: 'sleaze', 'hack on the fly': 'sleaze', hotf: 'sleaze', fly: 'sleaze',
-};
-export function normalizeMatrixStance(v) {
-    const k = (v ?? 'attack').toLowerCase();
-    return MATRIX_STANCE_ALIASES[k] ?? (MATRIX_STANCE_CYCLE.includes(k) ? k : 'attack');
-}
-export function normalizeStance(v) {
-    const k = (v ?? 'lethal').toLowerCase();
-    return STANCE_ALIASES[k] ?? (STANCE_CYCLE.includes(k) ? k : 'lethal');
-}
 /** Meat and a jumped-in drone share the physical world. */
 export function isPhysicalPlane(plane) {
     return plane === 'meat' || plane === 'drone';
@@ -194,29 +162,9 @@ export class Player extends AbstractPlayer {
     // session where an NPC's overlapping AI loops fired two exchanges at
     // once and the target died TWICE (two kill events, two narrations).
     inExchange = false;
-    // The fight stance (see FightStance above): lethal or non-lethal, the
-    // damage type your next blow is meant to deal. Tab cycles it in the UI;
-    // "stance" sets it by name. Every action is still yours to type -- the
-    // Combat Turn hands you the phase and waits for "end turn".
-    // Accessor (live-sheet pass, 2026-09-01): stance is sheet-visible.
-    _autoStance = 'lethal';
-    get autoStance() { return this._autoStance; }
-    set autoStance(v) {
-        if (this._autoStance === v)
-            return;
-        this._autoStance = v;
-        this.noteConditionChanged();
-    }
-    /** Which of the book's two intrusion actions the next hack uses
-     *  (see MatrixStance). Sheet-visible, like its meat-world twin. */
-    _matrixStance = 'attack';
-    get matrixStance() { return this._matrixStance; }
-    set matrixStance(v) {
-        if (this._matrixStance === v)
-            return;
-        this._matrixStance = v;
-        this.noteConditionChanged();
-    }
+    // (No stance lives here any more -- see the note at the top of this
+    // file. The damage type a blow deals is decided by the verb that threw
+    // it, and the intrusion action by the verb that ran it.)
     // SUBDUING (RAW p.195, the "restrain" ask from a real session's runaway
     // NPC): a grapple links two actors BY NAME -- grappledBy/grappling are
     // the two ends, grappleThreshold the escape test's bar (the original

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();
             })();
         });