@maka/maka-cli 5.212.0 → 5.214.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.212.0",
+  "version": "5.214.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/backlog.js

@@ -150,7 +150,7 @@ export class BacklogCommand extends Command {
         // patch-probe exists to catch. game.ts already imports this module
         // lazily for the same reason (streetTransport).
         const { cliVersion, engineVersion } = await import('../utilities/shared-run.js');
-        const outcome = await submitBacklog(text, {
+        const filed = await submitBacklog(text, {
             runnerName: this.actor?.name,
             // Links the item back to the play session it came out of -- the
             // same id the uploaded logs are keyed by, so an item and its
@@ -177,10 +177,21 @@ export class BacklogCommand extends Command {
             client: currentSession()?.client ?? 'cli',
         });
         // A real call classifies the account for free -- no second request.
-        noteBacklogOutcome(outcome);
-        if (outcome !== 'ok')
-            return this.explain(outcome);
-        return `{cyan-fg}Filed. It'll come back checked against the books.${hint(` ("backlog list" reads the board.)`)}{/cyan-fg}`;
+        noteBacklogOutcome(filed.outcome);
+        if (filed.outcome !== 'ok')
+            return this.explain(filed.outcome);
+        // NAME THE THING YOU JUST FILED (X3tZu4rspsa5CQW38, Maka: 'Let's
+        // change this to read "Logged - <ID>"'). "Filed. It'll come back
+        // checked against the books." told the reporter a report exists
+        // somewhere and gave them no way to refer to it -- and the id was on
+        // the wire the whole time, thrown away by submitBacklog.
+        //
+        // The old sentence is kept for the case where the server answered
+        // 200 with a body we could not read: the item IS filed, and saying
+        // "Logged - undefined" would be worse than saying less.
+        return filed.id
+            ? `{cyan-fg}Logged - ${filed.id}${hint(` ("backlog list" reads the board.)`)}{/cyan-fg}`
+            : `{cyan-fg}Filed. It'll come back checked against the books.${hint(` ("backlog list" reads the board.)`)}{/cyan-fg}`;
     }
     /**
      * THE REVIEW QUEUE (user request 2026-08-27). Bare "backlog review"

package/bundle/typescript/src/commands/game/sideQuest/commands/bypass-command.js

@@ -89,6 +89,15 @@ export class BypassCommand extends Command {
         }
         return { error: `There's nothing here called "${raw}".` };
     }
+    /**
+     * THE ACTION PHASE COST OF ONE ATTEMPT, charged at the moment the
+     * attempt becomes real (see execute()). Free by default; a subclass
+     * whose verb IS a canon Matrix or combat action overrides it and
+     * returns the refusal when the phase cannot pay.
+     */
+    billForAttempt() {
+        return undefined;
+    }
     async execute(args) {
         const room = this.actor.currentLocation;
         const all = room?.openableDevices() ?? [];
@@ -164,6 +173,19 @@ export class BypassCommand extends Command {
         if (reach.refusal)
             return reach.refusal;
         const crossNote = reach.line ? `${reach.line}\n` : '';
+        // THE LAST POINT BEFORE THE ATTEMPT IS REAL -- the target resolved,
+        // the verb allowed, the runner standing where the mechanism is. A
+        // subclass with an Action Phase cost pays it HERE and nowhere
+        // earlier, so every refusal above is free (GoEyGG9PSRM4mpXzG: "I
+        // shouldn't be hit on a simple/complex action if the command is
+        // rejected").
+        //
+        // Default is free: most verbs on this base (pick, breach, use) have
+        // never billed an action and this is not the change that gives them
+        // one. Only HackCommand overrides it today.
+        const billed = this.billForAttempt();
+        if (billed)
+            return billed;
         const outcome = await this.determineOutcome(device);
         if (outcome === 'progress') {
             this.logger.write(`${this.actor.name} keeps working "${device.name}" (${this.verbName}, in progress)`);

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

@@ -13,7 +13,7 @@ import { TapCommand } from './tap.js';
 import { nameableNames } from '../utilities/nameables.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS } from '../utilities/marks.js';
-import { billAction } from '../utilities/action-cost.js';
+import { actionRefusal, billAction } from '../utilities/action-cost.js';
 import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 import { declarationPenalty, parseMarkDeclaration, hostDefensePool, wanDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
 /**
@@ -54,6 +54,23 @@ export class HackCommand extends BypassCommand {
     actionName() {
         return this.mode() === 'attack' ? 'Brute Force' : 'Hack on the Fly';
     }
+    /**
+     * THE SPEND, at the moment the verb commits -- see the long note in
+     * execute() for why it is not at the top any more
+     * (GoEyGG9PSRM4mpXzG). Called immediately before a roll, or before
+     * handing off to a command that does the work. Returns the refusal
+     * when the phase cannot pay, undefined when it just did.
+     */
+    bill() {
+        return billAction(this.scene, this.actor, 'complex', this.actionName());
+    }
+    /** The meat-world barrier route (super.execute) pays at the same
+     *  moment every other route does -- once the device is resolved and
+     *  the attempt is about to happen, never for a name that matched
+     *  nothing. */
+    billForAttempt() {
+        return this.bill();
+    }
     async execute(args = []) {
         const mode = this.mode();
         const afterMode = [...(args ?? [])];
@@ -66,9 +83,26 @@ export class HackCommand extends BypassCommand {
         // BRUTE FORCE and HACK ON THE FLY are Complex Actions (p.238, p.240)
         // -- billed only inside a Combat Turn, where one intrusion is the
         // whole Action Phase.
-        const bill = billAction(this.scene, this.actor, 'complex', this.actionName());
-        if (bill)
-            return bill;
+        //
+        // ASKED HERE, PAID LATER (GoEyGG9PSRM4mpXzG, Maka: "I shouldn't be
+        // hit on a simple/complex action if the command is rejected").
+        // This used to be the spend, at the top, before a single line of
+        // target resolution had run -- so "hack camera" in a room with no
+        // camera printed "Nothing on the grid answers to 'camera'" AND ate
+        // the whole Action Phase. The player was charged an intrusion for a
+        // word the parser did not recognise.
+        //
+        // The affordability question still belongs up here: a runner with
+        // nothing left this phase should hear it before the game goes
+        // hunting through PANs, devices and hosts on their behalf. What
+        // moved is the SPEND -- down to `bill()` below, called at each point
+        // the verb actually commits: immediately before a roll, or before
+        // handing off to a command that does the work (TapCommand, the
+        // barrier bypass in super.execute). Every refusal between here and
+        // there costs nothing, which is the report.
+        const unaffordable = actionRefusal(this.scene, this.actor, 'complex');
+        if (unaffordable)
+            return unaffordable;
         // PAN warfare: "hack <name>" cracks a meat actor's personal area
         // network -- from inside the Matrix, or right here in AR with a
         // working deck in hand (which is also how enemy deckers get YOU).
@@ -99,6 +133,11 @@ export class HackCommand extends BypassCommand {
         // puzzle that happens to be named for one still falls through to
         // the bypass path below, untouched.
         if (rest.length > 0 && matchesCameraName(rest.join(' ')) && isWatched(this.actor.currentLocation)) {
+            // NOT BILLED HERE. TapCommand has its own refusals past this point
+            // -- a direct connection is a cable and wants your BODY in the
+            // room -- so it pays at its own commit point instead. Billing
+            // before the handoff charged a Complex Action for being told the
+            // route was not available (GoEyGG9PSRM4mpXzG, one layer down).
             return new TapCommand({
                 actor: this.actor,
                 scene: this.scene,
@@ -208,6 +247,12 @@ export class HackCommand extends BypassCommand {
             const burned = this.actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
             if (burned)
                 return burned;
+            // Committed: a real host, resolved by name, with marks left to
+            // take and a bracket to take them with. Every refusal above this
+            // line is free.
+            const billedHost = this.bill();
+            if (billedHost)
+                return billedHost;
             this.actor.performAction('hacks the host', room.name, { quiet: this.scene.isHumanControlled(this.actor) });
             const attempt = await this.hostIntrusionRoll(mode, declared, room);
             const success = attempt.success;
@@ -592,6 +637,13 @@ export class HackCommand extends BypassCommand {
         const burned = actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
         if (burned)
             return burned;
+        // Committed: a real slaved icon, named and reachable. Note that
+        // every `return null` above is a FALL-THROUGH, not a refusal -- it
+        // hands the query on to the host or PAN route, which pays for
+        // itself if it commits. Billing before those would charge twice.
+        const billedDevice = this.bill();
+        if (billedDevice)
+            return billedDevice;
         const declared = Math.min(declaredMarks, MAX_MARKS - held);
         const declarePenalty = declarationPenalty(declared, actor.hasQuality(GO_BIG_QUALITY));
         const silence = actor.matrixActionPenalty;
@@ -845,6 +897,10 @@ export class HackCommand extends BypassCommand {
         const burnedPan = actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
         if (burnedPan)
             return burnedPan;
+        // Committed: a real person, in reach, running a PAN worth cracking.
+        const billedPan = this.bill();
+        if (billedPan)
+            return billedPan;
         const limit = actor.matrixAttribute(mode === 'attack' ? 'attack' : 'sleaze');
         // Logic + the better of HACKING and ELECTRONIC WARFARE + gear (canon:
         // EW is the jamming-and-signals half of PAN warfare; best-of keeps

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

@@ -1,4 +1,5 @@
 import { Command } from './command.js';
+import { billAction } from '../utilities/action-cost.js';
 import { hostLabel } from '../utilities/grid-names.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { accrueOverwatch } from '../utilities/overwatch.js';
@@ -113,6 +114,21 @@ export class TapCommand extends Command {
             return burned;
         const limit = actor.matrixAttribute(mode === 'attack' ? 'attack' : 'sleaze');
         const pool = Math.max(1, actor.logic + actor.skillRating('hacking') + actor.bonus('hacking') + silence + actor.woundModifier - actor.sustainingPenalty);
+        // THE SPEND, HERE AND NOT EARLIER (GoEyGG9PSRM4mpXzG). A direct
+        // connection does not change WHICH action you are taking -- it is
+        // still Hack on the Fly or Brute Force (p.240/p.238), and both are
+        // Complex Actions -- but every refusal above this line is a reason
+        // the attempt never happened: no cameras, no cable, no host on the
+        // other end, the host already open, the ring already full, a bracket
+        // eaten to zero. None of those is an action taken.
+        //
+        // It matters twice, because hack.ts routes "hack camera" here. That
+        // route USED to bill before delegating, which meant a decker out on
+        // the grid typing "hack camera" paid a Complex Action to be told a
+        // direct connection is a CABLE and needs their body in the room.
+        const billed = billAction(this.scene, actor, 'complex', mode === 'attack' ? 'Brute Force' : 'Hack on the Fly');
+        if (billed)
+            return billed;
         actor.performAction('cables into the cameras', `${room.name} -- a hand on the housing, a filament out of their deck`);
         const roll = rollPool(pool, limit);
         if (showsMechanics(this.scene, actor)) {

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

@@ -1009,5 +1009,82 @@
 //   friction. The refusal returns before the item moves, so a runner out
 //   of actions keeps both the file and the turn, and listing what is in
 //   reach ("download" bare) still costs nothing.
-export const ENGINE_VERSION = '1.72.0';
+// 1.73.0 (2026-09-16): A REJECTED COMMAND IS FREE (GoEyGG9PSRM4mpXzG,
+//   Maka: "I shouldn't be hit on a simple/complex action if the command
+//   is rejected: 'Nothing on the grid answers to \"camera\" -- no host by
+//   that name, no PAN, no camera ...' should not count as a complex
+//   action"). hack.ts billed its Complex Action at the TOP of execute(),
+//   before one line of target resolution had run, so a name the grid
+//   does not answer to cost exactly what an intrusion costs: the player
+//   was told nothing matched and their Action Phase was gone. Canon
+//   charges for an action TAKEN (p.163-167); a sentence the parser
+//   refused is not one.
+//   - The AFFORDABILITY question stays at the top, where it belongs: a
+//     runner with nothing left this phase should hear that before the
+//     game goes hunting through PANs, devices and hosts on their behalf.
+//     That is the new actionRefusal() in utilities/action-cost.ts --
+//     billAction's question without billAction's spend, same budget,
+//     same wording, so the player cannot tell which one spoke.
+//   - The SPEND moved down to each route's commit point: immediately
+//     before the host intrusion roll, the slaved-device roll and the PAN
+//     roll, and (for the meat-world barrier route) at the new
+//     billForAttempt() hook in bypass-command.ts, which fires once the
+//     device is resolved, the verb allowed and the runner standing where
+//     the mechanism is. The hook is free by default -- pick, breach and
+//     use have never billed an action and this is not the change that
+//     gives them one.
+//   - THE SAME DEFECT WAS ONE LAYER DOWN, found by the test rather than
+//     by reading: "hack camera" RESOLVES in a watched room and hands off
+//     to TapCommand, which then refuses because a direct connection is a
+//     cable and wants your BODY in the room. Billing before the handoff
+//     charged a Complex Action for that refusal. tap.ts now pays at its
+//     own commit point, which also gives the `tap` verb the cost it
+//     always owed -- a direct connection does not change WHICH action
+//     you are taking (p.233), and both halves are Complex (p.238/p.240).
+//   Note the shape, because it is easy to write again: a verb that bills
+//   at the top of execute() has charged for the phase before it knows
+//   whether it has a target, and a verb that bills before delegating has
+//   charged for a refusal it cannot see.
+// 1.74.0 (2026-09-16): A BEAT IS WHAT THE ROOM CAN SEE AND HEAR
+//   (BDYYpN9EZJtTJ5B6A, Maka: 'I shouldn't "notice" skitter's inner
+//   monolog: "Skitter's eyes narrow--sharp as a razor. The kid just
+//   walked off with product without settling up, and now he's shouting
+//   about it like it's some kinda joke."'). The first sentence is what
+//   a beat is FOR. The second is Skitter's private assessment, printed
+//   to a player with no way to know it -- and a player who reads an
+//   NPC's judgement of them cannot un-know it.
+//   - The brief said only "Any exposition should be in 3rd person",
+//     which constrains grammatical person and says nothing about
+//     observability -- it licensed exactly this. A new bullet draws the
+//     line where it belongs: exposition is what someone standing in the
+//     room could see or hear, never what you know, have worked out,
+//     think of them, or are about to do.
+//   - An INTERIOR rule joins CONTACT, COMPELLED_MOVEMENT and
+//     SELF_LOCATION in narration-limits.ts, because an instruction is
+//     advice and this file is the engine. It catches interiority that
+//     ANNOUNCES itself: a mind named as a place ("in his head", "in her
+//     mind"), a certainty no watcher could have ("knows exactly", "knew
+//     full well"), and silent calculation as an event ("running the
+//     math").
+//   - MEASURED OVER ALL 294 exposition beats the site has stored, not a
+//     sample: five match, all five are the bug, and the newest is from
+//     TODAY ("The file updates itself quietly in his head") -- so this
+//     is live, not historical. Nothing else in the corpus matches.
+//   - THE NARROWNESS IS THE DESIGN. Good beats describe inner life
+//     constantly, from the OUTSIDE: "something behind her eyes does the
+//     arithmetic", "the math of a fixer deciding whether she's being
+//     played", "in a way that says she's heard this sound too many
+//     times". A pattern on "math", "deciding" or a bare "knows" eats
+//     every one of them, and a gate that eats those is worse than the
+//     defect. Those six lines are pinned as must-not-eat tests.
+//   - AND THE HONEST LIMIT, pinned as a test of its own: the reported
+//     sentence carries NO marker. It is free indirect discourse, a
+//     thought with the "he knows" filed off, and no regex can tell it
+//     from a statement of fact. The brief is what aims at that shape;
+//     the rule does not pretend to.
+//   (The author-voice leaks in the same corpus -- "I'll have Deacon Ruy
+//   stay guarded...", "Suspicious system-note injection detected" --
+//   are all dated 2026-08-24 and predate isOutOfCharacter, which
+//   already catches them. Checked, not assumed.)
+export const ENGINE_VERSION = '1.74.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -2353,6 +2353,7 @@ You are an NPC named ${this.name} in a gritty cyberpunk text adventure game.
 
 - Stay in character. Respond naturally based on your surroundings, personality, and the player’s message.
 - Any exposition should be in 3rd person. Keep exposition to bare minimum.
+- Exposition is ONLY what someone standing in the room could see or hear. Never your own thoughts, judgements, conclusions, or memories -- not what you know, not what you have worked out, not what you think of them, not what you are about to do. Write the OUTSIDE of it: the look, the pause, the hand that stops moving. "His eyes narrow" is yours to write. "He knows the kid never paid" is not, and neither is the same thought with the "he knows" filed off.
 - Do NOT repeat, rephrase, or re-ask anything you have already said (check the recent-activity history below). If you already asked a question and it hasn't been answered, wait for the answer -- do not ask it again in different words.
 - Silence is a valid response: if this event doesn't genuinely need words from you, do not include a say command at all.
 - Keep spoken lines SHORT -- one or two sentences. People don't monologue at strangers.

package/bundle/typescript/src/commands/game/sideQuest/utilities/action-cost.js

@@ -76,6 +76,41 @@ export function billAction(scene, actor, kind, label, opts = {}) {
     scene.updateStatus?.();
     return undefined;
 }
+/**
+ * THE SAME QUESTION, ASKED WITHOUT PAYING -- "could I afford this?"
+ *
+ * GoEyGG9PSRM4mpXzG (Maka): "I shouldn't be hit on a simple/complex
+ * action if the command is rejected: 'Nothing on the grid answers to
+ * "camera" -- no host by that name, no PAN, no camera' ... should not
+ * count as a complex action."
+ *
+ * Exactly right, and the shape of the bug is worth naming because it is
+ * easy to write again: a verb that bills at the TOP of execute() has
+ * charged for the Action Phase before it knows whether it has a target.
+ * Typing a name the grid does not answer to then costs the same as an
+ * intrusion -- the player is told "nothing answers to that" and their
+ * turn is gone. Canon charges for an action TAKEN (p.163-167); a
+ * sentence the game refused to parse is not one.
+ *
+ * But a verb still wants to say "you have nothing left this phase"
+ * BEFORE it goes hunting for a target, or the player gets a page of
+ * resolution and a refusal at the end of it. So: ask with this at the
+ * top, spend with billAction at the point the action actually commits
+ * -- after every refusal, immediately before the roll or the delegation.
+ * The pair reads the same budget and returns the same wording, so the
+ * player cannot tell which one spoke.
+ */
+export function actionRefusal(scene, actor, kind, opts = {}) {
+    const enc = encounterOf(scene, actor);
+    if (!enc || enc.ended)
+        return undefined;
+    if (!enc.isPhaseOf(actor))
+        return notYourPhase(enc, actor);
+    const budget = enc.budgetOf(actor);
+    if (!budget)
+        return notYourPhase(enc, actor);
+    return budget.refusalFor(kind, opts.attack === true);
+}
 /**
  * A verb that is refused outright mid-fight unless it is your phase --
  * for things that are not actions at all but still cannot happen while

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

@@ -65,24 +65,39 @@ function parseData(raw) {
         return undefined;
     }
 }
+/**
+ * File one, and SAY WHICH ONE (X3tZu4rspsa5CQW38, Maka: 'Let's change
+ * this to read "Logged - <ID>"').
+ *
+ * The id was always on the wire -- the route has answered
+ * `{ id, status, vetting }` since it was written -- and this function
+ * threw it away, returning a bare outcome word. So the only thing the
+ * player who filed a report could say about it afterwards was "I filed
+ * something", which is not enough to look it up, quote it, or ask about
+ * it. Returns the shape its siblings already use.
+ */
 export async function submitBacklog(text, meta) {
     const token = authToken();
     if (!token)
-        return 'no-login';
+        return { outcome: 'no-login' };
     try {
         const res = await request('POST', `/${API_BASE}/item`, token, { text, ...meta });
-        if (res.statusCode === 200)
-            return 'ok';
+        if (res.statusCode === 200) {
+            // An id we cannot read is not a failure to file -- the item IS on
+            // the board. The caller falls back to wording that does not
+            // promise one rather than reporting a filing that worked as broken.
+            return { outcome: 'ok', id: parseData(res.data)?.id };
+        }
         if (res.statusCode === 401)
-            return 'expired';
+            return { outcome: 'expired' };
         if (res.statusCode === 403)
-            return 'forbidden';
+            return { outcome: 'forbidden' };
         if (res.statusCode === 400)
-            return 'rejected';
-        return 'offline';
+            return { outcome: 'rejected' };
+        return { outcome: 'offline' };
     }
     catch {
-        return 'offline';
+        return { outcome: 'offline' };
     }
 }
 /**

package/bundle/typescript/src/commands/game/sideQuest/utilities/narration-limits.js

@@ -121,6 +121,64 @@ const SELF_LOCATION = new RegExp([
     // "I'm standing/sitting/waiting in X".
     String.raw `\bI(?:'|’)?m\s+(?:stand|sitt|wait|post|hang|hold)\w*\s+(?:up\s+|out\s+|around\s+)*(?:at|in|by|outside)\s+(?:the\s+)?([^.,;!?"'’]{2,48})`,
 ].join('|'), 'i');
+/**
+ * READING THE NPC'S MIND (BDYYpN9EZJtTJ5B6A, Maka: 'I shouldn't "notice"
+ * skitter's inner monolog: "Skitter's eyes narrow—sharp as a razor. The
+ * kid just walked off with product without settling up, and now he's
+ * shouting about it like it's some kinda joke."').
+ *
+ * A beat is what a person standing in the room can SEE and HEAR. The
+ * first sentence of that line is exactly that and is good writing. The
+ * second is Skitter's private assessment, printed to a player who has no
+ * way to know it -- and a player who reads an NPC's judgement of them
+ * cannot un-know it, which is half the game gone.
+ *
+ * WHAT THIS CATCHES AND WHAT IT CANNOT. The reported sentence carries no
+ * marker at all: it is free indirect discourse, a thought written as
+ * plain narration, and nothing short of a model could tell it from a
+ * statement of fact. So this rule does NOT claim to catch it -- the
+ * brief in models/npc.ts is what aims at that shape. What is catchable
+ * is interiority that ANNOUNCES itself: a mind named, or a mental act
+ * given as a fact.
+ *
+ * MEASURED, NOT GUESSED, over all 294 exposition beats the site has
+ * stored (GameSessionEvents, channel 'log'). Five lines match and all
+ * five are the bug:
+ *
+ *   "...already sliding out of the booth's shadow in her mind if not
+ *    her body."
+ *   "...that's not natural, and Ilsen knows exactly what it means."
+ *   "...but he's already running the math -- two of them, close
+ *    quarters, his crew somewhere outside earshot."
+ *   "Forty years on the pier means he knows exactly how far a man has
+ *    to be standing before he can lie about why he's here."
+ *   "The file updates itself quietly in his head."
+ *
+ * Nothing else in the corpus matches, and the near misses are the
+ * reason the patterns are this narrow. Good beats constantly describe
+ * inner life FROM THE OUTSIDE -- "something behind her eyes does the
+ * arithmetic", "the math of a fixer deciding whether she's being
+ * played", "like he's reading a bill of sale", "in a way that says
+ * she's heard this sound too many times". Every one of those is an
+ * observer's inference about visible behaviour, which is precisely what
+ * a beat is FOR. A pattern on the word "math" or "deciding" would eat
+ * all of them, so the anchors are the mind itself ("in his head", "in
+ * her mind"), certainty no observer could have ("knows exactly"), and
+ * the one idiom that always means silent calculation ("running the
+ * math").
+ */
+const INTERIOR = new RegExp([
+    // The mind, named as a place something happens. "in his head", "in
+    // her mind", "inside their thoughts". NOT "in the back of the shop".
+    String.raw `\b(?:in|inside|through|across)\s+(?:his|her|their|its)\s+(?:mind|head|thoughts)\b`,
+    // A certainty no watcher could have. "he knows exactly what it
+    // means", "she knows exactly how far". The adverb is load-bearing:
+    // "he knows the code" is a fact about the world a beat may state.
+    String.raw `\b(?:knows|knew)\s+(?:exactly|full\s+well|perfectly\s+well|damn\s+well)\b`,
+    // Silent calculation as an event. "already running the math",
+    // "running the numbers in his head" (caught twice over, harmlessly).
+    String.raw `\brunning\s+the\s+(?:math|numbers|odds)\b`,
+].join('|'), 'i');
 /** Every place a self-location claim names in one line. */
 function placesClaimed(line) {
     const out = [];
@@ -268,6 +326,15 @@ export function judgeNarration(line, speaker, others, opts = {}) {
             };
         }
     }
+    // ALSO BEFORE the agency rules, and for the same reason: this is about
+    // the SPEAKER's own head, so there is no subject to resolve.
+    if (INTERIOR.test(t)) {
+        return {
+            refused: true,
+            subject: speaker,
+            note: `A BEAT IS WHAT THE ROOM CAN SEE AND HEAR. Your last beat read your own mind out loud -- what you know, what you are working out, what is going on in your head -- so it did not happen and the player was not shown it. Nobody standing in front of you can see any of that. Write the OUTSIDE of it instead: the look, the pause, the hand that stops moving, the glance at the door. A player who watches you narrow your eyes and go quiet learns more than one who is handed your conclusion.`,
+        };
+    }
     const contactAt = t.match(CONTACT);
     const movedAt = t.match(COMPELLED_MOVEMENT);
     if (!contactAt && !movedAt)

package/package.json

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