@maka/maka-cli 5.188.0 → 5.190.0

package/bundle/typescript/package.json

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

@@ -643,8 +643,16 @@ export class HackCommand extends BypassCommand {
         // (commands/disable.ts): the key is turned from in here, the door
         // swings out there. One mark short says so.
         if (!device.isOpen()) {
+            // THE COLON BELONGS TO THE HINT, not to the sentence (seen in a
+            // bench replay, 2026-09-14). hint() returns '' when hints are off
+            // -- which is how every bench runs -- and the line printed as
+            // "That is enough to command it: " with a dangling colon and
+            // nothing after it. Cosmetic, and not harmless: a reviewer who
+            // meets a half-written sentence stops trusting the transcript,
+            // which is the one thing a bench cannot afford.
+            const command = hint(`"disable ${device.name}" (Control Device, p.238) ${device.opensExit ? `opens the ${device.opensExit} way` : `works it`} from right here.`);
             lines.push(now >= 2
-                ? `  That is enough to command it: ${hint(`"disable ${device.name}" (Control Device, p.238) ${device.opensExit ? `opens the ${device.opensExit} way` : `works it`} from right here.`)}`
+                ? `  That is enough to command it${command ? `: ${command}` : '.'}`
                 : `  One more mark and it takes orders.${hint(` ("hack ${device.name}" again, then "disable ${device.name}" -- Control Device wants 2 marks for a Simple device action, p.238.)`)}`);
         }
         this.scene.updateStatus();

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

@@ -3843,16 +3843,99 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * caller, of which there are three.
      */
     draftNextSceneInBackground(runType) {
+        // WHOSE CALL THIS IS, CAPTURED NOW (po7qSJycJrcfWbgaA: "I haven't
+        // been getting a call from mr. krow back after a while").
+        //
+        // Two ways this promise used to end in silence, and the player
+        // cannot tell them apart from the outside -- they are just still
+        // waiting for a call that never comes.
+        //
+        // 1. A THROW WAS INVISIBLE. `.catch` wrote to the debug log and
+        //    nothing reached the screen, so any unexpected failure in a
+        //    20-40 second draft cost the player the callback with no line
+        //    and no way to ask again knowingly. The comment in
+        //    draftNextScene already promised the opposite -- "the wait
+        //    resolves as HIS callback either way, success or failure" --
+        //    and that was true of a RETURNED failure and false of a thrown
+        //    one. An empty string fell through the same hole.
+        //
+        // 2. THE AMBIENT SCOPE WAS GONE BY THE TIME IT RESOLVED. Log lines
+        //    scope themselves off `currentSession().dispatch` (headless.ts
+        //    ambient), and handleInputAs MUTATES that field for the length
+        //    of one command and restores it in a `finally`. This promise
+        //    outlives its command by half a minute: at best `dispatch` is
+        //    undefined by then and the ping goes to the whole table; at
+        //    worst ANOTHER player at the table is mid-command and the ping
+        //    is scoped to THEIR room -- so the runner who made the call is
+        //    the one person who does not hear it back. Capturing the
+        //    caller's name while we are still inside the dispatch, and
+        //    scoping to them, removes the dependency on state that is torn
+        //    down before the answer arrives.
+        //
+        // Scoped to the CALLER and not the room: this is a phone call to
+        // one runner, and it lands on their link wherever they are standing
+        // by the time it comes back.
+        //
+        // The WHO and the CHANNEL are both captured here, while the call is
+        // still being made, rather than looked up when the answer lands.
+        // Logger.getInstance() resolves off the same async context as the
+        // dispatch above, and this ping is delivered from a timer as well as
+        // from a promise -- so reaching for it later means depending on that
+        // context surviving into whichever of the two gets there first. It
+        // is one session and one logger for the whole call; take both now.
+        const caller = currentSession()?.dispatch?.actorName;
+        const logger = Logger.getInstance();
+        let spoke = false;
+        const ring = (text) => {
+            spoke = true;
+            logger.logWithColor(`${CALL_ICON} ${text}`, CALL_COLOR, caller ? { actor: caller } : undefined);
+        };
+        // 3. AND A PROMISE THAT NEVER SETTLES SAYS NOTHING AT ALL. The two
+        //    holes above are both about an answer that arrived and was
+        //    dropped; this is the one where none arrives. The draft awaits a
+        //    chain of AI calls and, for a crew job, a 300-second server
+        //    round trip -- and the reporter's own server log shows the kind
+        //    of thing that stalls one (a presence change stream 30 seconds
+        //    behind). Whatever hangs, the player is left waiting on a call
+        //    with no deadline, which is the report word for word.
+        //
+        //    So the wait has an end. DELIBERATELY LONGER than the worst
+        //    legitimate draft -- the shared-session call alone is allowed
+        //    300s (shared-run.ts, and 150s was measured too short) and the
+        //    chunked generation runs minutes on top -- because a watchdog
+        //    that fires while the job is still landing would replace a real
+        //    offer with "nothing shook loose", which is worse than the
+        //    silence it set out to fix. If the draft DOES land after this
+        //    has spoken, the job is still rung through: good news is worth
+        //    saying twice, and the player is owed the run they asked for.
+        //
+        //    unref'd so a pending watchdog never holds the process open --
+        //    a solo CLI session must still exit on "quit".
+        const watchdog = setTimeout(() => {
+            if (!spoke) {
+                ring(`${FIXER_NAME}: "Still nothing I can put your name to, chummer. Call me again in a bit."`);
+            }
+        }, Game.DRAFT_PATIENCE_MS);
+        watchdog.unref?.();
         void this.continueToNextScene(runType)
             .then(nextJobText => {
-            if (nextJobText) {
-                Logger.getInstance().logWithColor(`${CALL_ICON} ${nextJobText}`, CALL_COLOR);
-            }
+            clearTimeout(watchdog);
+            if (nextJobText)
+                ring(nextJobText);
+            else if (!spoke)
+                ring(`${FIXER_NAME}: "Nothing shook loose, chummer. Call me again in a bit."`);
         })
             .catch(err => {
-            Logger.getInstance().error(`Failed to draft the next job: ${err}`);
+            clearTimeout(watchdog);
+            logger.error(`Failed to draft the next job: ${err}`);
+            if (!spoke)
+                ring(`${FIXER_NAME}: "Job fell apart on my end, chummer -- don't ask. Give me another call in a bit."`);
         });
     }
+    /** How long the runner waits on Krow before he rings back empty-handed.
+     *  See the watchdog in draftNextSceneInBackground for why it is this
+     *  far past the worst honest draft rather than close to the typical one. */
+    static DRAFT_PATIENCE_MS = 6 * 60 * 1000;
     /**
      * Drafts and loads the next job once the current scene's win condition
      * has been met. Reuses the same long-lived Player (and its inventory),

package/package.json

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