@maka/maka-cli 5.218.0 → 5.220.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.218.0",
+  "version": "5.220.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/say.js

@@ -313,10 +313,28 @@ export class SayCommand extends Command {
         // presence on the grid and is not -- "call" is still the verb that
         // reaches a body.
         if (currentPlayer.plane === 'matrix' && !(this.actor instanceof NPC)) {
-            const heard = speakOnTheGrid(this.scene, currentPlayer, '').map(a => a.name);
-            return heard.length > 0
-                ? `Your persona speaks and the grid carries it: ${heard.join(', ')} ${heard.length === 1 ? 'is' : 'are'} on this side of the architecture and hears you. Bodies in the room hear nothing -- you have no voice out there.`
-                : `Your words go out over the grid and find no persona to land on. Anyone here in the FLESH hears nothing -- a PAN icon is a commlink in somebody's pocket, not a person you can talk to. ("call <name>" reaches a body.)`;
+            const { personas, links } = speakOnTheGrid(this.scene, currentPlayer, '');
+            const iconNames = personas.map(a => a.name);
+            const linkNames = links.map(a => a.name);
+            const lines = [];
+            if (iconNames.length > 0) {
+                lines.push(`Your persona speaks and the grid carries it: ${iconNames.join(', ')} ${iconNames.length === 1 ? 'is' : 'are'} on this side of the architecture and hears you.`);
+            }
+            // A COMMLINK IS FOR TALKING (FhXadizkMCxAdMaJx). This used to be
+            // the refusal -- "a PAN icon is a commlink in somebody's pocket,
+            // not a person you can talk to" -- which had the fact right and
+            // drew the wrong conclusion. It IS a commlink in their pocket, and
+            // that is precisely a thing you can speak out of.
+            if (linkNames.length > 0) {
+                lines.push(`It comes out of ${linkNames.join(', ')}'s commlink where ${linkNames.length === 1 ? 'they stand' : 'they stand'} in the flesh -- your voice out of ${linkNames.length === 1 ? 'their' : 'their'} pocket, not out of the air.`);
+            }
+            if (lines.length === 0) {
+                return `Your words go out over the grid and land on nothing. No persona on this side of the architecture, and nobody near your body is carrying a live commlink for them to come out of. ("call <name>" reaches somebody further off.)`;
+            }
+            if (linkNames.length === 0) {
+                lines.push(`Bodies in the room hear nothing -- nobody there is carrying a live link.`);
+            }
+            return lines.join('\n');
         }
         return farOff;
     }

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

@@ -52,10 +52,21 @@ export class ShoutCommand extends Command {
             // each other or they do not, and no amount of volume crosses a
             // host wall. So this routes to the same fan-out `say` uses rather
             // than inventing a louder one.
-            const heard = speakOnTheGrid(this.scene, actor, message).map(a => a.name);
-            return heard.length > 0
-                ? `You push it out across the grid: "${message}"\n  Heard by ${heard.join(', ')}.`
-                : `You push it out across the grid -- nothing out here is listening.`;
+            // Both halves of the fan-out, named apart: a persona beside you and
+            // a commlink in somebody's pocket are two different places for your
+            // voice to come out of, and only one of them is standing in the
+            // same room as your body (FhXadizkMCxAdMaJx).
+            const { personas, links } = speakOnTheGrid(this.scene, actor, message);
+            const heard = personas.map(a => a.name);
+            const onLink = links.map(a => a.name);
+            if (heard.length === 0 && onLink.length === 0) {
+                return `You push it out across the grid -- nothing out here is listening.`;
+            }
+            const who = [
+                ...(heard.length > 0 ? [`Heard by ${heard.join(', ')}.`] : []),
+                ...(onLink.length > 0 ? [`Out of ${onLink.join(', ')}'s commlink, where they stand in the flesh.`] : []),
+            ];
+            return `You push it out across the grid: "${message}"\n  ${who.join('\n  ')}`;
         }
         const heard = actor.currentLocation.shout(actor, message);
         if (!(this.actor instanceof NPC)) {

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

@@ -1185,5 +1185,55 @@
 //   read the win condition without reading completion would make the job
 //   unwinnable, which is a worse bug than the one being fixed, and that
 //   is the load-bearing test in the file.
-export const ENGINE_VERSION = '1.77.0';
+// 1.78.0 (2026-09-16): CYBERCOMBAT IS NOT LAYING HANDS ON ANYBODY
+//   (27dAZvLuoaW4PjF6s, Maka, the whole report verbatim):
+//     "[order] Agent (Sony CIY-720): attack patrol ic ,
+//      You can't lay hands on Patrol IC: they are not present in their
+//      body, and there is nobody home to resist you."
+//   The absent-body gate in npc-authorization.ts exists for a good
+//   reason -- somebody grabbing a jacked-in runner's slumped shell is
+//   reaching for a person who is not home -- but it asked the question
+//   of every AI-driven actor on every contact verb. An Agent is a
+//   matrix-plane construct (companions.ts builds it with plane:
+//   'matrix') and Patrol IC has no body to be absent FROM, so a rule
+//   about hands fired on a program attacking a program and refused the
+//   most ordinary order anyone gives an agent. Attacking an icon is
+//   Cybercombat (Data Spike, p.239): two icons, no meat, nobody's hands
+//   anywhere near it. The question is now asked only of an actor
+//   standing in the meat; canPerceive, which is the rule that actually
+//   knows about planes, still decides whether the two can reach each
+//   other at all. The meat case is pinned in the same test file, because
+//   a fix that traded this report for the older one it was built from
+//   would be no fix.
+// 1.79.0 (2026-09-16): A COMMLINK IS FOR TALKING (FhXadizkMCxAdMaJx,
+//   Maka, rejecting the first fix: "this looks like it's backwards. If I
+//   jack in, and Grunt's icon is in reach, he SHOULD hear me through his
+//   icon when I do a 'say'"). He is right and the books agree. p.246
+//   names this as the exception to the host wall itself -- from outside
+//   a host "you can't interact directly with icons inside it, ALTHOUGH
+//   you can still send messages, make commcalls, and that sort of thing"
+//   -- and nothing anywhere requires the person on the other end to be
+//   jacked in. The old answer, "a PAN icon is a commlink in somebody's
+//   pocket, not a person you can talk to", had the fact right and drew
+//   the wrong conclusion from it: a commlink in somebody's pocket is
+//   exactly a thing a voice can come out of.
+//   - `say` and `shout` from the grid now reach the PERSONAS beside you
+//     (as always) AND the live commlinks of people standing around your
+//     BODY, delivered with hear()'s existing viaLink so the NPC knows it
+//     came out of their pocket rather than from a mouth in the room.
+//   - SCOPED TO THE VICINITY, not the district. Canon would let a
+//     persona call a commlink anywhere on the grid -- distance is noise,
+//     not range -- but a `say` that rang every commlink in the barrens
+//     is a broadcast nobody asked for. "In reach" means what it means in
+//     the icon list the reporter was reading: the room the body is in.
+//     `call <name>` still reaches further.
+//   - isLinked is the test, the same predicate that decides whether a
+//     body is a ▣ icon at all, so the icon list and the voice agree: no
+//     link, no icon, no pocket for the words to come out of -- and the
+//     refusal says which of the two reasons it was.
+//   The old test asserted the right refusal for the WRONG REASON: its
+//   comment claimed "Krow is HERE, in the flesh, with a PAN icon on the
+//   grid" while its fixture gave him no commlink at all, so there was
+//   never a PAN icon in it. Pinned properly now, both ways.
+export const ENGINE_VERSION = '1.79.0';
 //# sourceMappingURL=engine-version.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/matrix-roster.js

@@ -1,5 +1,6 @@
 import { roomsInReach } from './grid-reach.js';
 import { NPC } from '../models/npc.js';
+import { isLinked } from './comm-style.js';
 /**
  * WHO A PERSONA CAN REACH (increment 2 of the Matrix position model,
  * 2026-09-02). The persona's position is `Player.matrixPosition` -- on a
@@ -35,13 +36,62 @@ export function cybercombatCandidates(scene, actor) {
 export function speechAudience(scene, actor) {
     return personasOnMySide(scene, actor);
 }
-/** Delivers a persona's words to its audience, the way Room.say delivers a body's. */
+/**
+ * THE COMMLINKS IN EARSHOT OF YOUR BODY (FhXadizkMCxAdMaJx, Maka: "this
+ * looks like it's backwards. If I jack in, and Grunt's icon is in reach,
+ * he SHOULD hear me through his icon when I do a 'say'").
+ *
+ * He is right, and the books agree. A commlink is a COMMUNICATION
+ * device: p.246 says that even across a host wall "you can still send
+ * messages, make commcalls, and that sort of thing", and nothing
+ * anywhere requires the person on the other end to be jacked in -- a
+ * commcall rings a commlink in somebody's pocket, which is what a
+ * commlink is for. The engine's old answer, "a PAN icon is a commlink in
+ * somebody's pocket, not a person you can talk to", had the fact right
+ * and drew the wrong conclusion from it.
+ *
+ * SCOPED TO THE VICINITY, not the district. Canon would let a persona
+ * call a commlink anywhere on the grid -- distance is noise, not range
+ * -- but `say` is the verb for speaking to the people around you, and a
+ * `say` that rang every commlink in the barrens would be a broadcast
+ * nobody asked for. The room your body is slumped in is what "in reach"
+ * means in the icon list the reporter was reading, so it is what it
+ * means here. `call <name>` is still the verb for reaching somebody
+ * further off, and it still works.
+ *
+ * A PAN IS THE TEST, not a pulse: isLinked is the same predicate that
+ * decides whether a body shows up as a ▣ icon at all. Somebody with no
+ * commlink, or running silent, has nothing for your voice to come out
+ * of -- and does not appear in the icon list either, so the two answers
+ * agree.
+ */
+export function panAudience(scene, actor) {
+    const here = actor.bodyRoom ?? actor.currentLocation;
+    if (!here)
+        return [];
+    return scene.allActors.filter(a => a !== actor
+        && a.plane === 'meat'
+        && (a.bodyRoom ?? a.currentLocation) === here
+        && isLinked(a));
+}
+/**
+ * Delivers a persona's words to its audience, the way Room.say delivers
+ * a body's -- to the personas beside it, and out of the commlinks of the
+ * people standing around its body.
+ */
 export function speakOnTheGrid(scene, actor, message) {
-    const audience = speechAudience(scene, actor);
-    for (const recipient of audience) {
+    const personas = speechAudience(scene, actor);
+    for (const recipient of personas) {
         void Promise.resolve(recipient.hear(actor, message, { broadcast: true })).catch(() => undefined);
     }
-    return audience;
+    // viaLink, so the NPC knows this arrived out of their commlink rather
+    // than from a mouth in the room -- which is the whole difference, and
+    // the thing their reply has to be able to react to.
+    const links = panAudience(scene, actor);
+    for (const recipient of links) {
+        void Promise.resolve(recipient.hear(actor, message, { broadcast: true, viaLink: true })).catch(() => undefined);
+    }
+    return { personas, links };
 }
 /**
  * The combat exchange's "same place": on the matrix plane it is the

package/bundle/typescript/src/commands/game/sideQuest/utilities/npc-authorization.js

@@ -66,7 +66,26 @@ export function authorizeNpcAction(scene, actor, verb, args) {
     // which is lying right there in the room and is what the act was
     // reaching for. For a hands-on verb the absent-body reason is the one
     // that tells the fiction something it can use.
-    if (contact && !isPresentInBody(target)) {
+    // ...AND IT IS A RULE ABOUT HANDS, SO IT ONLY BINDS A BODY
+    // (27dAZvLuoaW4PjF6s, Maka -- the whole report, verbatim):
+    //
+    //   "[order] Agent (Sony CIY-720): attack patrol ic ,
+    //    You can't lay hands on Patrol IC: they are not present in their
+    //    body, and there is nobody home to resist you."
+    //
+    // An Agent is a matrix-plane construct (commands/companions.ts builds
+    // it with plane: 'matrix') and Patrol IC has no body to be absent
+    // from -- so a gate written for "somebody grabbed a jacked-in
+    // runner's slumped shell" fired on a program attacking a program,
+    // and refused the single most ordinary order anyone gives an agent.
+    //
+    // Attacking an icon is CYBERCOMBAT (Data Spike, p.239): two icons,
+    // no meat, nobody's hands anywhere near it. So the absent-body
+    // question is only asked of an actor standing in the meat. Everything
+    // else is still gated -- canPerceive below decides whether these two
+    // can reach each other at all, and it is the rule that actually knows
+    // about planes.
+    if (contact && actor.plane === 'meat' && !isPresentInBody(target)) {
         return {
             allowed: false,
             reason: `You can't lay hands on ${target.name}: they are not present in their body, and there is nobody home to resist you. Describe what you see, or wait for them to come back.`,

package/package.json

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