@maka/maka-cli 5.186.0 → 5.188.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.186.0",
+  "version": "5.188.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/hack.js

@@ -556,6 +556,31 @@ export class HackCommand extends BypassCommand {
             this.logger.meta(`${defense.label} (DR ${device.rating}): ${formatRoll(defenseRoll)} -- net ${netHits >= 0 ? '+' : ''}${netHits}`);
         }
         const godLines = this.godBill(overwatchFromDefense(defenseRoll.hits), `device intrusion (${mode})`);
+        // WHY THE KEYS YOU ALREADY HOLD DID NOT OPEN THIS (u8u2koi3THQM9dzSz:
+        // "I _OWN_ the host with 3 marks, I should be able to hack the
+        // maglock, or simply disable it").
+        //
+        // Checked against the books rather than the report's own reading:
+        // marks share ONE WAY. "If you get a mark on a slave you also get a
+        // mark on the master ... This doesn't work both ways" (p.233). Three
+        // marks on the host are three marks on the HOST; the lock hanging off
+        // it is still its own icon with its own monitor, and Control Device
+        // (p.238) counts marks on the thing being controlled. So the engine
+        // was right to make them roll -- and said nothing at all about why,
+        // which is the part that earned the report. A rule the player cannot
+        // see is indistinguishable from a bug.
+        //
+        // The line also names the move that DOES cash those marks in: inside
+        // the host you are directly connected to everything on its WAN, and
+        // a directly-connected slave "cannot use its master's ratings to
+        // defend itself" (p.233) -- which is exactly the pool that just beat
+        // them. Only said when they actually hold host marks and are still
+        // outside; from in here it would be telling them to walk through the
+        // door they are standing in.
+        const hostMarksHeld = viaWan && host ? host.hostMarksBy.get(actor.name) ?? 0 : 0;
+        const wanNote = hostMarksHeld > 0
+            ? hint(` (Your ${hostMarksHeld} mark${hostMarksHeld === 1 ? '' : 's'} on ${hostLabel(host)} buy nothing against the lock itself -- marks run slave-to-master, never master-to-slave (p.233). "enter ${hostLabel(host)}": from inside its WAN you are directly connected, and ${device.name} has to defend on DR ${device.rating} alone.)`)
+            : '';
         if (netHits <= 0) {
             if (mode === 'sleaze') {
                 // A blown Sleaze is NOTICED (p.236) -- and a slaved device that
@@ -565,14 +590,14 @@ export class HackCommand extends BypassCommand {
                     host.hostAlert = true;
                     this.scene.addWorldEvent(`${device.name} flags a bad handshake -- ${hostLabel(host, { capital: true })} is awake.`);
                     this.scene.updateStatus();
-                    return [`${device.name} refuses the key and SAYS SO -- the node it answers to knows something is in here.`, ...godLines].join('\n');
+                    return [`${device.name} refuses the key and SAYS SO -- the node it answers to knows something is in here.${wanNote}`, ...godLines].join('\n');
                 }
                 // A loose device has no host to wake; its owner still gets the
                 // mark on you a blown Sleaze hands over (p.240).
                 this.scene.updateStatus();
                 return [`${device.name} refuses the key and SAYS SO -- whoever owns it has your icon on file now.`, ...godLines].join('\n');
             }
-            return [`${device.name} holds against the smash -- its firewall never even flexes. Nobody upstairs noticed.`, ...godLines].join('\n');
+            return [`${device.name} holds against the smash -- its firewall never even flexes. Nobody upstairs noticed.${wanNote}`, ...godLines].join('\n');
         }
         const now = Math.min(MAX_MARKS, held + declared);
         device.marksBy.set(actor.name, now);

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-chunks.js

@@ -733,6 +733,15 @@ For EVERY item in the skeleton, expand it into a full item ("name" and "category
 Clue requirements (mechanically validated -- the exact phrase must appear in "details"):
 ${clueSpecs || '- (no clue items in this scene)'}
 
+THE ONLY PRIZE IN THIS WORLD is "${skeleton.winCondition?.item ?? ''}" -- the item
+"winCondition" is for. No other item may present itself as the thing the client wants: not
+"it's what ${skeleton.winCondition?.toNpc || skeleton.client || 'the Johnson'} is looking
+for", not "this is what the job is about", not a second set of goods that reads like the
+objective wearing a different name. The engine stars exactly one item and pays out on
+exactly one; a second item that CLAIMS the role sends the runner home with the wrong thing
+in their pack, believing they blew the job they just finished. Loot is loot -- say what it
+IS, never what it is worth to the client.
+
 THE ONLY CODES IN THIS WORLD are the clue phrases listed just above. No other item may
 carry a code-shaped string -- no serial numbers, no model numbers, no unit or locker or
 apartment numbers, no "access code" on a scrap of paper that isn't a listed clue. A player
@@ -2046,6 +2055,112 @@ export function ensureCredentialKindAgrees(details) {
     }
     return notes;
 }
+/**
+ * ONE PRIZE, AND THE PROSE HAS TO AGREE (aSpARWJXXieMAL4eM, 2026-09-14:
+ * "the item marked with the star as the mission objective was 'The
+ * Scout's Contact Sheet'. But the mission was clearly about camera
+ * data ... When I returned to the Hub, I had 'Developed Negatives',
+ * which state it's what Mr. Leger is looking for. It's like the two
+ * items got mis labeld as to what was important.").
+ *
+ * Nothing was mislabelled in the STATE. winCondition.item was the
+ * contact sheet, the star followed it (planes.ts objectiveMark), the
+ * completion check accepted it, and the payout landed. What went wrong
+ * is that the items pass wrote a SECOND item's flavour as though that
+ * one were the job -- so the run had one prize by the engine's reckoning
+ * and a different one by its own prose, and the player believed the
+ * prose. That is worse than a wrong star: they finished the job
+ * convinced they had failed it.
+ *
+ * Same family as payoutSummary and heatSummary in npc.ts -- the model
+ * inventing a fact the engine already owns -- and the same answer:
+ * state the fact in the prompt (buildItemsPrompt, "THE ONLY PRIZE IN
+ * THIS WORLD"), and enforce it here so a draft that ignores the rule
+ * costs nothing.
+ *
+ * SURGERY, narrowly, and this file's own preference is against it:
+ * ensureCredentialKindAgrees corrects "by ADDING a plain sentence rather
+ * than rewriting generated prose". That works when the generated line is
+ * merely incomplete. It cannot work here, because the line is FALSE --
+ * appending "but the client doesn't want this" under "this is what the
+ * client wants" leaves prose that argues with itself, which is exactly
+ * the confusion the report describes. So the false sentence comes out,
+ * whole, and everything around it is left byte-identical.
+ *
+ * THE BAR IS THREE THINGS IN ONE SENTENCE, because two is not enough to
+ * tell a claim from colour: someone the job is ABOUT (the client by
+ * name, or a generic for them), a verb of WANTING, and a reference back
+ * to THIS item. "Ledger drinks alone and wants nothing from anybody"
+ * keeps all three words apart and survives; "it's what Mr. Ledger is
+ * looking for" does not.
+ */
+const PRIZE_WANTING = /\b(look(?:s|ing|ed)?\s+for|after\s+(?:this|it|these|them)|want(?:s|ed|ing)?|need(?:s|ed|ing)?|ask(?:s|ed|ing)?\s+for|pay(?:s|ing)?\s+for|hir(?:ed|ing)\s+\w+\s+for|sent\s+\w+\s+for|came\s+for|is\s+the\s+(?:job|prize|objective|target))\b/i;
+const PRIZE_SELF = /\b(this|these|those|it|its|it's|the\s+one)\b/i;
+const PRIZE_GENERIC_CLIENT = /\b(the\s+client|the\s+johnson|mr\.?\s+johnson|your\s+employer|the\s+employer|the\s+buyer|the\s+job|the\s+run|the\s+contract)\b/i;
+/**
+ * Sentence-ish split that keeps the terminator with its sentence.
+ *
+ * IT DOES HAVE TO HANDLE "Mr." -- this comment first said it didn't,
+ * and the first test written against it failed. Every client in this
+ * game is "a Mr. Johnson" (canon p.27-28), so the one sentence this
+ * function exists to read -- "It's what Mr. Ledger is looking for." --
+ * is precisely the one a naive split cuts in half, into two fragments
+ * neither of which claims anything. The titles below are the ones a
+ * Shadowrun scene actually writes; a single capital initial ("J.
+ * Ledger") goes with them.
+ */
+const SENTENCE_BREAK = /(?<!\b(?:Mr|Mrs|Ms|Dr|Sr|Jr|St|Prof|Rev|Inc|Ltd|Co|vs|No|[A-Z])\.)(?<=[.!?])\s+/;
+function prizeSentences(text) {
+    return text.split(SENTENCE_BREAK).filter(s => s.length > 0);
+}
+function claimsThePrize(sentence, clientNames) {
+    if (!PRIZE_WANTING.test(sentence) || !PRIZE_SELF.test(sentence))
+        return false;
+    const named = clientNames.some(n => n.length > 0 && sentence.toLowerCase().includes(n.toLowerCase()));
+    return named || PRIZE_GENERIC_CLIENT.test(sentence);
+}
+export function ensureOnePrize(skeleton, details) {
+    const notes = [];
+    const prize = (skeleton.winCondition?.item ?? '').trim().toLowerCase();
+    if (prize.length === 0)
+        return notes;
+    // The people a claim can be made on behalf of: the client who holds
+    // the meet, and whoever the goods are owed to (usually the same
+    // person, sometimes not -- a courier job delivers to a third party).
+    // Last names alone are how these lines actually read ("Ledger takes
+    // the sleeve"), so each name contributes its words too.
+    const clientNames = [skeleton.client ?? '', skeleton.winCondition?.toNpc ?? '']
+        .flatMap(n => [n, ...n.split(/\s+/)])
+        .map(n => n.replace(/[^\w\s'-]/g, '').trim())
+        .filter(n => n.length >= 4);
+    for (const item of details.items ?? []) {
+        if ((item.name ?? '').trim().toLowerCase() === prize)
+            continue;
+        for (const field of ['description', 'details']) {
+            const text = (item[field] ?? '').trim();
+            if (text.length === 0)
+                continue;
+            const kept = prizeSentences(text).filter(s => !claimsThePrize(s, clientNames));
+            if (kept.length === prizeSentences(text).length)
+                continue;
+            const rebuilt = kept.join(' ').trim();
+            // A description is always-visible flavour and cannot be blank --
+            // an item with no line at all reads as a generator failure. A
+            // "details" that empties out simply goes away, which is what an
+            // item with nothing more to say should do.
+            if (field === 'description') {
+                item.description = rebuilt.length > 0
+                    ? rebuilt
+                    : `Someone's property once, and worth carrying if nobody's looking.`;
+            }
+            else {
+                item.details = rebuilt.length > 0 ? rebuilt : undefined;
+            }
+            notes.push(`normalized: item "${item.name}" claimed in its ${field} to be what the job is for; "${skeleton.winCondition.item}" is, so the claim was cut.`);
+        }
+    }
+    return notes;
+}
 /**
  * RESOLVE A NAME ONE LIST WROTE AGAINST THE LIST THAT OWNS IT.
  *
@@ -2110,6 +2225,7 @@ export function assembleScene(skeleton, details, playerName) {
     // The answer has to be legible before anything is assembled from it.
     ensureClueDetails(skeleton, details);
     ensureCredentialKindAgrees(details);
+    ensureOnePrize(skeleton, details);
     const roomDetail = new Map(details.rooms.map(r => [r.name, r]));
     const npcDetail = new Map(details.npcs.map(n => [n.name, n]));
     const deviceDetail = new Map(details.devices.map(d => [d.name, d]));

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-factory.js

@@ -13,6 +13,7 @@ import { Logger } from '../utilities/logger.js';
 import { migrateLegacySeed } from './seed-migration.js';
 import { Device } from '../models/device.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { adoptSeededIce } from '../utilities/ic-actors.js';
 /**
  * How many AI enrichment calls may be in flight at once.
  *
@@ -252,6 +253,17 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
             // architecture nobody wrote.
             if (isIce && npc.currentLocation?.hasNode) {
                 npc.insideHost = npc.currentLocation;
+                // ...AND THE HOST HAS TO KNOW IT IS RUNNING IT (mPCh2FJykPsyJKmcc's
+                // bench, 2026-09-14). Standing inside the node was only half the
+                // adoption: nothing registered the construct with the Host, so it
+                // was ice by every reading except the one the host itself uses.
+                // The host then launched its own twin on the first Combat Turn
+                // (p.247 forbids two of a type), the construct swung with an
+                // Attack of 0 because "IC uses the Matrix attributes of its host"
+                // is read off icHost, and the grid view listed it twice. See
+                // adoptSeededIce for the three-for-one.
+                if (npc.currentLocation.host)
+                    adoptSeededIce(npc, npc.currentLocation.host);
             }
             npc.scene = scene;
             builtNpcs.push(npc);

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

@@ -458,6 +458,28 @@ export function splitSpokenLines(lines) {
             rebuilt.push(`[COMMAND] say ${bracketed[1]}`);
             continue;
         }
+        // ...AND SO IS ONE FILED UNDER A TAG THE MODEL INVENTED
+        // (zQTWGJFWDXoLtiJX6, 2026-09-13: Whisper's whole sales line
+        // arrived as `[TALK] say Depends what you're buying or
+        // confessing. The credstick's hot and priced like it...` and
+        // printed into the world log verbatim, marker and all -- the
+        // reporter first read it as his OWN typing echoed back).
+        //
+        // Third sighting of one root: the model reaches for the bracket
+        // convention and gets the WORD inside it wrong. [say] was the
+        // second; this is the general case, and generalising beats
+        // adding [TALK] to a list that would need [DIALOGUE], [ACTION]
+        // and whatever the next model invents.
+        //
+        // The bound that holds every repair in this function holds here
+        // too: the VERB after the bracket must be `say`. `[go] north`
+        // stays exactly what it was -- only `say` carries free prose, so
+        // only `say` can be promoted without risking a silent act.
+        const tagged = t.match(/^\[\s*[A-Za-z][A-Za-z ._-]*\s*\]\s*say\s+(\S.*)$/i);
+        if (tagged) {
+            rebuilt.push(`[COMMAND] say ${tagged[1]}`);
+            continue;
+        }
         // ...AND A LINE THAT IS NOTHING BUT SPEECH MARKS IS SPEECH
         // (playtest 2026-08-27, reported twice in one session: 'the
         // "Take a seat..." comment isn't showing as he said it. It's in

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

@@ -1,5 +1,6 @@
 import { hostConcealedFrom } from './jackpoint.js';
 import { matchesHostName, hostLabel } from './grid-names.js';
+import { fuzzyPickName } from './fuzzy-match.js';
 /**
  * THE GRID HAS NO STREETS (user canon check 2026-09-02; SR5 pp.217-218,
  * p.246). Jacked in and outside a host, a persona is on its grid: "a
@@ -44,6 +45,28 @@ export function hostOver(room) {
  * anywhere on the grid. Bare "host" (or nothing) means the one over the
  * persona's vicinity, else nothing -- with several overhead, a bare word
  * cannot pick.
+ *
+ * THE ALIAS LIST IS EXACT, AND EXACT IS NOT ENOUGH (qHwKnqEGrJFn3tmF7).
+ * grid-names.ts made the printer and the resolver agree, which fixed
+ * the lie -- but it left the player typing the label back BYTE FOR
+ * BYTE. A run whose room was called "The Grinning Idol -- Back Room"
+ * refused `mark Back Room host` and accepted only
+ * `mark The Grinning Idol -- Back Room host`; the reporter's word for
+ * it was "ridiculous", and they are right. A name you can read off the
+ * screen but not shorten is a name you have to transcribe.
+ *
+ * So: aliases first, unchanged -- an exact hit still resolves exactly,
+ * and the vicinity still wins ties. Only when nothing answers does the
+ * shared fuzzy matcher get a turn, over the names the map actually
+ * printed. It is the same resolver items and NPCs go through, with the
+ * same discipline: an AMBIGUOUS guess misses rather than picking a host
+ * at random, which matters more here than anywhere -- cracking the
+ * wrong node spends the action, wakes the wrong ice and cannot be
+ * taken back.
+ *
+ * The trailing "host"/"node" comes off first: it is part of the LABEL
+ * ("the Back Room host"), never part of the room's name, and leaving it
+ * on drags every score down by a word.
  */
 export function resolveHostInReach(rooms, actor, query) {
     const q = query.trim().toLowerCase();
@@ -56,7 +79,14 @@ export function resolveHostInReach(rooms, actor, query) {
     const near = hostOver(gridVicinity(actor));
     if (near && matchesHostName(q, near))
         return near;
-    return hosts.find(r => matchesHostName(q, r));
+    const exact = hosts.find(r => matchesHostName(q, r));
+    if (exact)
+        return exact;
+    const bare = q.replace(/\s*\b(hosts?|nodes?)\s*$/, '').trim();
+    if (bare.length === 0)
+        return undefined;
+    const picked = fuzzyPickName(bare, hosts.map(r => r.name));
+    return picked ? hosts.find(r => r.name === picked) : undefined;
 }
 /** Noise between the persona and a room's icons: 0 for the vicinity (and inside a host), -DISTRICT_NOISE dice elsewhere. */
 export function noiseFor(actor, room) {

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

@@ -299,8 +299,23 @@ function hostInteriorIcons(scene, actor, room) {
     // and that would put the wrong noun on a person.
     // Inside a host, the roster is who is INSIDE it (matrix-roster.ts) -- a
     // persona's body is never in this room.
+    // THE HOST'S OWN PROGRAMS ARE LISTED ONCE, BELOW, NOT TWICE, HERE AND
+    // BELOW (mPCh2FJykPsyJKmcc's bench, 2026-09-14). A running IC is an
+    // actor inside the host AND a name in room.runningIC, and both loops
+    // printed it -- in different words, with only the second offering the
+    // verbs, so one program read as two and the reader had to guess which
+    // line was real:
+    //
+    //     ▲ Patrol IC #2 -- intrusion countermeasures, and you are inside its host.
+    //     ▲ Patrol IC #2 -- hunting, and it has your icon. (0/10) ("attack ..." crash it)
+    //
+    // hostInteriorPanel already resolved this the right way round -- it
+    // skips `a.icHost === host` in its persona list -- so this matches it
+    // rather than inventing a third rule. Everything else inside the host
+    // still comes through here: a rival decker's persona, a companion, a
+    // construct nothing registered as the host's.
     for (const a of (room.host ? personasInside(scene, room.host) : [])) {
-        if (a === actor)
+        if (a === actor || a.icHost === room.host)
             continue;
         if (a.plane === 'matrix' && sameHostSide(actor, a) && actor.canPerceive(a)) {
             const companion = scene.ownerGame?.companions.find(c => c.npc === a);
@@ -350,11 +365,16 @@ function hostInteriorIcons(scene, actor, room) {
     // game will not name, and a room that contradicts the damage log reads
     // as broken rules rather than thin prose.
     //
-    // NO VERB IS OFFERED, deliberately, because none exists yet: IC live
-    // in room.runningIC as names, not as actors, so nothing in this engine
-    // can target them -- `thread Resonance Spike` says "no hostile icon in
-    // reach" while they attack. Naming them here does not pretend
-    // otherwise; advertising a verb that refuses would be the worse lie.
+    // A VERB IS OFFERED NOW, where there is an actor to point it at. When
+    // this loop was written IC lived in room.runningIC as names only and
+    // nothing could target them, so it deliberately advertised nothing;
+    // ic-actors.ts made each running program an actor, and the line grew
+    // the monitor and the verbs to match. A kind with no actor behind it
+    // (a scene that cannot host actors at all) still gets named and still
+    // offers nothing, for the original reason.
+    //
+    // THIS IS THE ONE PLACE THE HOST'S OWN PROGRAMS ARE LISTED -- see the
+    // skip in the persona loop above.
     for (const name of room.runningIC) {
         const ice = room.host?.iceActors.get(name);
         icons.push(`▲ ${ice?.name ?? name} -- hunting, and it has your icon.${ice ? ` (${ice.conditionSummary()}) ("thread resonance-spike ${ice.name}" / "attack ${ice.name}" crash it)` : ''}`);

package/bundle/typescript/src/commands/game/sideQuest/utilities/ic-actors.js

@@ -1,6 +1,7 @@
 import { NPC } from '../models/npc.js';
 import { CommandRegistry } from '../commands/command-registry.js';
 import { Logger } from './logger.js';
+import { IC_TYPES } from './ic.js';
 /**
  * IC AS ICONS (increment 5 of the Matrix position model, 2026-09-02).
  * SR5 p.247: "Each IC program has a persona with its own Condition
@@ -95,4 +96,51 @@ export function crashedIC(host) {
     }
     return out;
 }
+/**
+ * ADOPT A SEEDED CONSTRUCT AS ONE OF ITS HOST'S PROGRAMS
+ * (mPCh2FJykPsyJKmcc's bench, 2026-09-14).
+ *
+ * scene-factory already settles what a matrix-plane NPC IS -- "a
+ * matrix-plane NPC in this engine IS intrusion countermeasures" -- and
+ * already stands it inside the node it guards. What it never did was
+ * tell the HOST. So a seeded construct was ice by every reading except
+ * the one the host itself uses, and three things went wrong at once,
+ * all of them visible in one bench transcript:
+ *
+ *   1. THE HOST LAUNCHED ITS TWIN. hostLaunchStep picks the first
+ *      IC_TYPE not in `runningIC`, and a seeded "Patrol IC" was not in
+ *      it -- so the host launched a second Patrol on the first Combat
+ *      Turn and the player fought "Patrol IC" and "Patrol IC #2" at
+ *      once. Straight against p.247: a host "can't launch more than one
+ *      of each type of IC program at once."
+ *   2. IT ATTACKED WITH NO LIMIT. "IC uses the Matrix attributes of its
+ *      host" (p.247) is read off `icHost` (Player.baseMatrixAttribute).
+ *      Unset, a construct's Attack was 0, so every swing it took
+ *      printed dice.ts's caller-bug diagnostic to the player:
+ *      `[LIMIT IGNORED -- a caller computed one that is not a limit]`.
+ *   3. IT WAS LISTED TWICE, once as an icon inside the host and again
+ *      off `runningIC` (grid-view.ts), with different words each time.
+ *
+ * One registration, three symptoms -- which is the argument for fixing
+ * it here at the seam rather than three times downstream.
+ *
+ * THE KIND IS THE CANON NAME WHEN THE SEED USED ONE. A construct called
+ * "Patrol IC" IS the host's Patrol, and registering it under its own
+ * name would leave the launch step free to add the real one beside it --
+ * the bug. A construct with a name of its own ("Sentinel", "the
+ * Gatekeeper") registers under that name: it counts against the host's
+ * Rating cap because it is a program the host is running, and it blocks
+ * no canon type, because it is not one.
+ */
+export function adoptSeededIce(npc, host) {
+    const canon = IC_TYPES.find(t => t.name.toLowerCase() === npc.name.trim().toLowerCase());
+    const kind = canon?.name ?? npc.name;
+    npc.icHost = host;
+    npc.icKind = kind;
+    npc.matrixPosition = { kind: 'host', host };
+    if (!host.iceActors.has(kind))
+        host.iceActors.set(kind, npc);
+    if (!host.runningIC.includes(kind))
+        host.runningIC.push(kind);
+}
 //# sourceMappingURL=ic-actors.js.map

package/package.json

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