@maka/maka-cli 5.233.0 → 5.234.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.233.0",
+  "version": "5.234.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/engine-version.js

@@ -1455,5 +1455,40 @@
 //   the roll shows what the network lends it. Those are two different
 //   facts on purpose, and there is a test pinning them apart so nobody
 //   "fixes" one to match the other.
-export const ENGINE_VERSION = '1.84.0';
+// 1.85.0 (2026-09-16): SPAMMING `look` COSTS SOMETHING NOW (p.49)
+//   Asked directly, and it was the right question: "what is the penalty
+//   of just spamming 'look' to eventually get the details?"
+//   THE ANSWER WAS NONE. `look` on the grid is billed as the Complex
+//   Action it is (p.241) -- but billAction only charges inside an
+//   encounter, so out of combat a sweep cost nothing at all. A decker
+//   could stand in the dark typing `look` until the dice came up, which
+//   means every hidden icon in the game was on a TIMER rather than
+//   behind a test, and the whole of 1.80-1.84 was theatre for anyone
+//   willing to press a key four times. My own find-rate measurements
+//   said "found within 1-2 looks" and I read that as the mechanic
+//   working rather than as the mechanic being free.
+//   - TRYING AGAIN (p.49): "each attempt after the first takes a
+//     cumulative -2 dice pool penalty." Counted per room on
+//     Player.sweepAttempts, and only FAILED sweeps count -- pinning
+//     what you contested is not a retry. A 7-dice sweeper gets 7, 5, 3,
+//     1, then nothing.
+//   - AND IT REACHES ZERO. The base pool floors at 1 so wounds and
+//     noise never lock you out, but the retry penalty is allowed
+//     through that floor, because that is the part that has to stop the
+//     grind: a pool of nothing cannot be rolled. The line says so
+//     rather than printing a mystery 0d6.
+//   - THE BREAK is the one piece p.49 hands to the table ("left to
+//     gamemaster discretion"), so it was asked rather than guessed.
+//     Ruling: JACKING OUT, and nothing less -- not moving node, not
+//     spending a turn on something else. So clearing a stack of failed
+//     sweeps costs your position, your part-made marks and a fresh
+//     entry.
+//   - NO OVERWATCH COST, deliberately. OS rises on Attack and Sleaze
+//     actions (p.231-232) and Matrix Perception is neither. Charging
+//     one would be inventing a rule to fix a balance problem canon
+//     already fixes.
+//   Nothing here is new to this engine: clue-reading has used p.49 and
+//   the same -2 since 1.40. It had simply never been pointed at the one
+//   test a player can repeat by holding down a key.
+export const ENGINE_VERSION = '1.85.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -717,6 +717,37 @@ export class Player extends AbstractPlayer {
      *  (-2 per retry). In memory only: a save and reload is the "break"
      *  the rule says clears it. See utilities/clue-reading.ts. */
     readAttempts = new Map();
+    /**
+     * FAILED MATRIX PERCEPTION SWEEPS, by room name -- p.49's Trying Again
+     * pointed at the one test a player can repeat for free.
+     *
+     * Asked directly (2026-09-16): "what is the penalty of just spamming
+     * 'look' to eventually get the details?" The answer was NONE. `look`
+     * is billed as the Complex Action it is (p.241), but billAction only
+     * charges inside an encounter, so out of combat a sweep cost nothing
+     * at all and a decker could stand in the dark typing `look` until the
+     * dice came up. Every hidden icon in the game was on a timer rather
+     * than behind a test.
+     *
+     * p.49: "you can try again, but each attempt after the first takes a
+     * cumulative -2 dice pool penalty ... a sufficient break lets you
+     * begin again with no penalty." Not invented here and not new to this
+     * engine either -- clue-reading has used the same rule and the same
+     * citation since 1.40. A sweeper at 7 dice gets 7, 5, 3, 1: four looks
+     * and brute force is spent, which is the point.
+     *
+     * NO OVERWATCH COST, deliberately. OS rises on Attack and Sleaze
+     * actions (p.231-232) and Matrix Perception is neither, so charging
+     * one would be inventing a rule to solve a balance problem that canon
+     * already solves.
+     *
+     * WHAT COUNTS AS THE BREAK is the one part p.49 hands to the table
+     * ("left to gamemaster discretion"), so it was asked and ruled on
+     * rather than guessed: JACKING OUT, and nothing less (user ruling
+     * 2026-09-16). Not moving node, not spending a turn elsewhere. See
+     * planes.ts leaveMatrix, which is the only thing that clears this.
+     */
+    sweepAttempts = new Map();
     /** True for the one Electronics item that is a trode net (p.439-440). */
     static isTrodeNet(item) {
         // The item's OWN row, not Item.effects: that getter folds fitted

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

@@ -222,6 +222,19 @@ export function leaveMatrix(scene, actor, opts) {
     // bricked, Scramble, convergence -- is no longer a participant. Before
     // endPersona clears the position the arena is read off.
     scene.encounterFor?.(actor)?.leave(actor);
+    // THE BREAK p.49 DESCRIBES, and the book hands this one to the table:
+    // "if the character takes a sufficient break from the task -- the
+    // length of which is left to gamemaster discretion." Asked directly
+    // (user ruling 2026-09-16, "what is a break?"), and the answer was the
+    // strictest of the four on offer: NOTHING SHORT OF JACKING OUT.
+    //
+    // Not moving to another node, not spending a turn on something else.
+    // So a stack of failed sweeps costs you your position on the grid,
+    // whatever marks you were part-way through, and a fresh entry -- which
+    // makes a dark room genuinely expensive rather than a typing exercise.
+    // Optional-chained because leaveMatrix is reached from a dozen places
+    // with stub actors that are not full Players.
+    actor.sweepAttempts?.clear();
     if (opts?.forced) {
         lines.push(...applyDumpshock(actor, opts.reason ?? `The connection is severed from the other side.`));
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/silent-icons.js

@@ -116,8 +116,21 @@ export function spotHiddenIcons(scene, actor, room) {
     // sweeper's own silence, wounds and sustaining the way every other
     // Matrix action in this engine does.
     const computer = actor.skillRating('computer');
-    const pool = Math.max(1, actor.intuition + (computer > 0 ? computer : -1)
+    // TRYING AGAIN (p.49): "each attempt after the first takes a
+    // cumulative -2 dice pool penalty." Without it, spamming `look` was
+    // free outside a fight -- billAction charges a Complex Action only
+    // inside an encounter -- so every hidden icon was on a timer instead
+    // of behind a test. Counted per room and cleared by a break
+    // (Player.sweepAttempts).
+    const retries = actor.sweepAttempts.get(room.name) ?? 0;
+    // The base floors at 1 -- wounds and noise grind you down but never
+    // out. The RETRY penalty is allowed through that floor to zero,
+    // because that is what stops the grind: a pool reduced to nothing
+    // cannot be rolled, so after enough failures you are not looking
+    // harder, you are done looking until you take the break p.49 names.
+    const base = Math.max(1, actor.intuition + (computer > 0 ? computer : -1)
         + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty);
+    const pool = Math.max(0, base - 2 * retries);
     const roll = rollPool(pool, actor.matrixAttribute('dataProcessing'), { gremlins: actor.deckGremlins });
     const found = [];
     let missed = 0;
@@ -139,7 +152,14 @@ export function spotHiddenIcons(scene, actor, room) {
             against.push({ roll: resist });
         }
     }
-    return { found, missed, roll, against };
+    // p.49 counts FAILED attempts. A sweep that pinned everything it
+    // contested was not a failure, so it costs the next one nothing --
+    // and an icon you already found is not in `hidden` to be re-rolled.
+    if (missed > 0)
+        actor.sweepAttempts.set(room.name, retries + 1);
+    else
+        actor.sweepAttempts.delete(room.name);
+    return { found, missed, roll, retries, against };
 }
 /**
  * The mechanics lines for a sweep.
@@ -153,8 +173,15 @@ export function spotHiddenIcons(scene, actor, room) {
  * Perception HIT buys).
  */
 export function spotMechanics(outcome) {
+    // Said out loud, because a pool that quietly shrinks every time you
+    // type the same word reads as a bug rather than as p.49.
+    const again = outcome.roll.pool === 0
+        ? ` -- NO DICE LEFT (p.49: -${outcome.retries * 2} for ${outcome.retries} failed attempts). Staring harder will not do it; break off and come back.`
+        : outcome.retries > 0
+            ? ` -- trying again, -${outcome.retries * 2} (p.49: -2 per failed attempt; a break clears it)`
+            : '';
     return [
-        `Matrix Perception, silent icons (Computer + Intuition [Data Processing]): ${formatRoll(outcome.roll)}`,
+        `Matrix Perception, silent icons (Computer + Intuition [Data Processing]): ${formatRoll(outcome.roll)}${again}`,
         ...outcome.against.map(a => (a.name
             ? `  ${a.name} hides (${a.label}): ${formatRoll(a.roll)}`
             : `  something holds its cover: ${formatRoll(a.roll)}`)),

package/package.json

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