@maka/maka-cli 5.189.0 → 5.191.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.189.0",
+  "version": "5.191.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/factories/scene-seed-generator.js

@@ -7,6 +7,7 @@ import { Logger } from '../utilities/logger.js';
 import { clampDeviceKind } from '../utilities/affordances.js';
 import { GenerationCapture } from '../utilities/generation-capture.js';
 import { fetchCanonContext } from '../utilities/canon-lore.js';
+import { providerUnavailable } from '../utilities/draft-failure-note.js';
 import { SceneSynthesizer } from './scene-factory.js';
 import { buildSkeletonPrompt, buildRoomsPrompt, buildNpcsPrompt, buildDevicesPrompt, buildItemsPrompt, pickRunType, parseJsonReply, validateSkeleton, normalizeSkeleton, assembleScene, classifyRepair, VAULT_HOST_RATING, } from './scene-chunks.js';
 // The fixer name convention and the player dossier live with the prompt
@@ -169,6 +170,26 @@ export class SceneSeedGenerator {
             catch (err) {
                 carriedError = err instanceof Error ? err.message : String(err);
                 logger.write(`SceneSeedGenerator: pipeline ${pipeline} failed: ${carriedError}`);
+                // A PROVIDER THAT IS NOT ANSWERING WILL NOT ANSWER THREE TIMES
+                // (po7qSJycJrcfWbgaA, 2026-09-14). The pipeline budget exists for
+                // a model that wrote a bad SCENE -- a fresh skeleton is a real
+                // second chance at that. It is worth nothing against a provider
+                // that never started: DeepSeek refused this run's generation with
+                // "unable to start processing your request within the 900-second
+                // timeout limit", and the loop dutifully spent that wait twice
+                // more. Three-quarters of an hour, for a player standing in the
+                // hub, to arrive at the same refusal the first attempt already
+                // had in hand.
+                //
+                // So an unavailable provider ends the generation instead of
+                // re-buying it. The message survives in carriedError and reaches
+                // the player through draftFailureNote, which tells them it is the
+                // provider and not their key -- which is the whole point of
+                // stopping early rather than looking flaky for 45 minutes.
+                if (providerUnavailable(carriedError)) {
+                    logger.write(`SceneSeedGenerator: provider is not answering -- abandoning the remaining ${this.maxPipelineAttempts - pipeline} pipeline attempt(s).`);
+                    break;
+                }
             }
         }
         logger.write(`SceneSeedGenerator: giving up (${carriedError ?? 'unknown'}) -- falling back to a static scene`);
@@ -188,7 +209,7 @@ export class SceneSeedGenerator {
         let lastError = previousError;
         for (let attempt = 1; attempt <= this.maxCallAttempts; attempt++) {
             const prompt = buildSkeletonPrompt(tier, player, lastError, rumor, crew, canonBlock, runType);
-            const reply = await AI.ask(prompt, { maxTokens: this.SKELETON_TOKENS });
+            const reply = await AI.ask(prompt, { maxTokens: this.SKELETON_TOKENS, timeoutMs: AI.GENERATION_TIMEOUT_MS });
             try {
                 const skeleton = parseJsonReply(reply);
                 skeleton.devices = skeleton.devices ?? [];
@@ -231,7 +252,7 @@ export class SceneSeedGenerator {
             const fullPrompt = lastError
                 ? `${prompt}\n\nYour previous attempt failed with this error -- fix it and try again: ${lastError}`
                 : prompt;
-            const reply = await AI.ask(fullPrompt, { maxTokens });
+            const reply = await AI.ask(fullPrompt, { maxTokens, timeoutMs: AI.GENERATION_TIMEOUT_MS });
             try {
                 const parsed = parseJsonReply(reply);
                 logger.write(`SceneSeedGenerator: chunk "${label}" ok (attempt ${attempt})`);

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

@@ -191,7 +191,7 @@ import { clockTime, worldNow } from './utilities/world-clock.js';
 import { CommandFactory } from './factories/command-factory.js';
 import { SceneSynthesizer } from './factories/scene-factory.js';
 import { SceneSeedGenerator, FIXER_NAME, isFixerName } from './factories/scene-seed-generator.js';
-import { draftFailureNote } from './utilities/draft-failure-note.js';
+import { draftFailureNote, providerUnavailable } from './utilities/draft-failure-note.js';
 import { CALL_ICON, CALL_COLOR, END_CALL_SENTINEL } from './utilities/comm-style.js';
 import { AI } from '../../../tools/ai/ai.class.js';
 import { BULLET } from './utilities/log-style.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),
@@ -4563,8 +4646,25 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // caller but the ask-for-data-work door passes.
         const nextSeed = await SceneSeedGenerator.generate(this._logFilePath, nextTier, this.player, this.activeRumor, localCrew, undefined, runType);
         if (!nextSeed) {
-            const opsNote = draftFailureNote(SceneSeedGenerator.lastFailure ?? '');
-            return `Incoming call -- ${FIXER_NAME}: "Job fell through, chummer. Client got cold feet before the ink dried. Give me another call in a bit -- I'll shake something loose."${opsNote}`;
+            const why = SceneSeedGenerator.lastFailure ?? '';
+            const opsNote = draftFailureNote(why);
+            // DO NOT INVENT A CLIENT WHO GOT COLD FEET (po7qSJycJrcfWbgaA).
+            // That line is fine for a draft that came back malformed -- the
+            // fiction has to say something, and "the deal soured" is as true
+            // as anything. It is a LIE when the provider never answered: it
+            // names a cause inside the story for something that happened
+            // entirely outside it, and the advice it gives ("call me in a
+            // bit") walks the player straight back into the same wall. This
+            // codebase refuses invented causes everywhere else -- a fixer may
+            // not name a venue it does not know, an NPC may not name a runner
+            // who is not there -- and the rule holds here too.
+            //
+            // So an outage gets its own line: Krow cannot reach anyone, which
+            // is the honest shape of it in his voice, and the OOC note under
+            // it says the rest.
+            return providerUnavailable(why)
+                ? `Incoming call -- ${FIXER_NAME}: "Can't raise anybody tonight, chummer -- whole street's gone quiet on me. Sit tight; I'll call when the lines come back."${opsNote}`
+                : `Incoming call -- ${FIXER_NAME}: "Job fell through, chummer. Client got cold feet before the ink dried. Give me another call in a bit -- I'll shake something loose."${opsNote}`;
         }
         // HUB sessions: the draft lands as a MESSAGE, never a teleport (real
         // playtest note: being yanked into the run the instant generation

package/bundle/typescript/src/commands/game/sideQuest/utilities/draft-failure-note.js

@@ -23,6 +23,30 @@
  * codes need word boundaries so they can't match inside some other
  * number.
  */
+/**
+ * IS THE PROVIDER SIMPLY NOT ANSWERING? Exported because two decisions
+ * hang off the same question and must never disagree: what the player is
+ * told (below), and whether SceneSeedGenerator bothers with its remaining
+ * pipeline attempts (po7qSJycJrcfWbgaA). Two separately-written lists
+ * would drift, and the drift would be invisible -- the generator would
+ * keep re-buying a fifteen-minute wait while the note said the provider
+ * was down.
+ *
+ * Matched on PROSE, not status codes: only the prose crosses the wire,
+ * and each provider words it differently.
+ *
+ * The 2026-09-14 addition is DeepSeek's own queue refusal -- "We were
+ * unable to start processing your request within the 900-second timeout
+ * limit. Please try again later." Nothing in the old list came close to
+ * it, so a real outage read to the player as "Job fell through, chummer.
+ * Client got cold feet" with no note at all, and sent them straight back
+ * to call into the same wall. `Request timeout` is this codebase's own
+ * transport giving up (https.class.ts), which means the same thing from
+ * the other end of the socket.
+ */
+export function providerUnavailable(why) {
+    return /overloaded or down|rate-limited by its provider|took too long to answer|could not (?:complete that request|reach its ai provider)|unable to start processing|\b\d{2,4}-second timeout limit|Request timeout|ETIMEDOUT|ECONNRESET|socket hang up/i.test(why);
+}
 export function draftFailureNote(why) {
     // NAME THE CAUSE WHEN IT'S THE PROVIDER, NOT LUCK (real session: six
     // Krow calls into an out-of-credits key, indistinguishable from flaky
@@ -50,7 +74,7 @@ export function draftFailureNote(why) {
     // answering. Matched on the SITE'S OWN wording (ai-error-envelope.ts
     // classifyUpstream/classifyTransportFailure) rather than status
     // codes, since only the prose crosses the wire.
-    const providerOutage = !providerDown && /overloaded or down|rate-limited by its provider|took too long to answer|could not (?:complete that request|reach its ai provider)/i.test(why);
+    const providerOutage = !providerDown && providerUnavailable(why);
     // A structural failure is OURS, not the player's -- name it as the
     // generator's problem so nobody goes hunting their billing page, and
     // keep it short: the fiction already covers the beat.

package/bundle/typescript/src/tools/ai/ai.class.js

@@ -377,6 +377,27 @@ export class AI {
      * runs 3-5x a dialogue reply, and the old fixed caps truncated it
      * mid-string). Leave unset for ordinary dialogue-sized replies.
      */
+    /**
+     * HOW LONG A GENERATION CALL WAITS (po7qSJycJrcfWbgaA, 2026-09-14).
+     *
+     * DeepSeek answered a run's scene generation with "We were unable to
+     * start processing your request within the 900-second timeout limit"
+     * -- fifteen minutes of queue before a refusal, and the generator's
+     * pipeline budget took that three times over. Forty-five minutes of a
+     * player standing in the hub waiting for a call that, when it finally
+     * came, said the job fell through.
+     *
+     * The transport's own default is the module's TIMEOUT (300s), which
+     * is a sane ceiling for a big download and far too patient for a
+     * prompt somebody is waiting on. A scene chunk that has not started
+     * coming back in 90 seconds is not going to save the commission.
+     *
+     * Deliberately NOT applied to every AI.ask: dialogue calls are short
+     * and already bounded by the same default, and an NPC that takes an
+     * extra beat is not a player staring at nothing. Generation asks for
+     * it explicitly.
+     */
+    static GENERATION_TIMEOUT_MS = 90_000;
     static async ask(prompt, opts) {
         const config = this.resolveConfig();
         if (!config) {
@@ -384,13 +405,14 @@ export class AI {
                 'or log in to maka-cli.com (`maka login`) to use the server relay ' +
                 '(optionally MAKA_AI_PROVIDER to choose explicitly).');
         }
+        const timeoutMs = opts?.timeoutMs;
         const result = config.provider === 'openai'
-            ? await HTTPS.askGPT({ prompt, openApiKey: config.apiKey, model: config.model, maxTokens: opts?.maxTokens })
+            ? await HTTPS.askGPT({ prompt, openApiKey: config.apiKey, model: config.model, maxTokens: opts?.maxTokens, timeoutMs })
             : config.provider === 'anthropic'
-                ? await HTTPS.askClaude({ prompt, apiKey: config.apiKey, model: config.model, maxTokens: opts?.maxTokens })
+                ? await HTTPS.askClaude({ prompt, apiKey: config.apiKey, model: config.model, maxTokens: opts?.maxTokens, timeoutMs })
                 : config.provider === 'deepseek'
-                    ? await HTTPS.askDeepSeek({ prompt, apiKey: config.apiKey, model: config.model, maxTokens: opts?.maxTokens })
-                    : await HTTPS.askMakaServer({ prompt, authToken: config.apiKey, model: config.model, maxTokens: opts?.maxTokens });
+                    ? await HTTPS.askDeepSeek({ prompt, apiKey: config.apiKey, model: config.model, maxTokens: opts?.maxTokens, timeoutMs })
+                    : await HTTPS.askMakaServer({ prompt, authToken: config.apiKey, model: config.model, maxTokens: opts?.maxTokens, timeoutMs });
         // A BODY THAT IS NOT JSON IS AN HTTP PROBLEM, NOT A PARSE PROBLEM.
         // This parse used to run bare, AHEAD of the statusCode guard below
         // -- so that guard only ever protected JSON-shaped failures. When

package/bundle/typescript/src/tools/https/https.class.js

@@ -258,7 +258,7 @@ export class HTTPS {
             req.end();
         });
     }
-    static async askGPT({ prompt, openApiKey, certPath, model = 'gpt-4.1', maxTokens = 3000 }) {
+    static async askGPT({ prompt, openApiKey, certPath, model = 'gpt-4.1', maxTokens = 3000, timeoutMs }) {
         const headers = {
             'Authorization': `Bearer ${openApiKey}`,
             'Content-Type': 'application/json',
@@ -283,10 +283,11 @@ export class HTTPS {
             path: '/v1/chat/completions',
             data,
             headers,
-            cert: certPath
+            cert: certPath,
+            timeout: timeoutMs
         });
     }
-    static async askClaude({ prompt, apiKey, certPath, model = 'claude-sonnet-5', maxTokens = 4096 }) {
+    static async askClaude({ prompt, apiKey, certPath, model = 'claude-sonnet-5', maxTokens = 4096, timeoutMs }) {
         const headers = {
             'x-api-key': apiKey,
             'anthropic-version': '2023-06-01',
@@ -328,7 +329,8 @@ export class HTTPS {
             path: '/v1/messages',
             data,
             headers,
-            cert: certPath
+            cert: certPath,
+            timeout: timeoutMs
         });
     }
     /**
@@ -349,7 +351,7 @@ export class HTTPS {
      * reasoning tokens that never reach the player. The same trap the
      * Claude path above documents, sprung by a different vendor.
      */
-    static async askDeepSeek({ prompt, apiKey, certPath, model = 'deepseek-v4-flash', maxTokens = 4096 }) {
+    static async askDeepSeek({ prompt, apiKey, certPath, model = 'deepseek-v4-flash', maxTokens = 4096, timeoutMs }) {
         return await this.post({
             hostname: 'api.deepseek.com',
             path: '/anthropic/v1/messages',
@@ -364,7 +366,8 @@ export class HTTPS {
                 'anthropic-version': '2023-06-01',
                 'Content-Type': 'application/json',
             },
-            cert: certPath
+            cert: certPath,
+            timeout: timeoutMs
         });
     }
     /**
@@ -375,7 +378,7 @@ export class HTTPS {
      * resume token, not an API key. Production host only -- the relay is
      * an account nicety, not a dev-loop dependency.
      */
-    static async askMakaServer({ prompt, authToken, model, maxTokens = 4096 }) {
+    static async askMakaServer({ prompt, authToken, model, maxTokens = 4096, timeoutMs }) {
         // MAKA_DEV TARGETING (kvhsgn3ouEG2znsha). Every other maka-cli.com
         // transport in this codebase already swings to a local server --
         // backlog, canon-lore, catalog, cloud-saves, session-telemetry,
@@ -401,8 +404,10 @@ export class HTTPS {
             data: { prompt, model, maxTokens },
             headers: { 'x-auth-token': authToken },
             // Generation-length calls ride this too; outlive the server's own
-            // 150s upstream timeout so its error body reaches us.
-            timeout: 180000,
+            // 150s upstream timeout so its error body reaches us. A caller
+            // asking for LESS patience still wins -- it is the one that knows
+            // whether somebody is waiting on the answer.
+            timeout: timeoutMs ?? 180000,
         });
     }
     static async askGPTStreaming(prompt, model = 'gpt-4.1') {

package/package.json

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