@maka/maka-cli 5.143.0 → 5.144.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.143.0",
+  "version": "5.144.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-chunks.js

@@ -3,6 +3,7 @@ import { spreadStationedNpcs } from './npc-spread.js';
 import { Logger } from '../utilities/logger.js';
 import { catalogAugmentations } from '../utilities/catalog.js';
 import { isOutdoorsPlace } from '../utilities/outdoors.js';
+import { clampDeviceKind } from '../utilities/affordances.js';
 /**
  * CHUNKED scene generation (see SceneSeedGenerator.generate for the
  * pipeline that drives this module). One monolithic whole-scene completion
@@ -2176,10 +2177,11 @@ export function assembleScene(skeleton, details, playerName) {
             ? detail.guardsExit.toLowerCase()
             : undefined;
         const footprint = guardsExit && detail?.footprint && VALID_FOOTPRINTS.has(detail.footprint) ? detail.footprint : undefined;
-        // KIND CLAMPS, never throws. A device whose kind we cannot read is
-        // still a device, and rejecting a whole draft over one word is a
-        // worse outcome than a panel where the model meant something else.
-        const kind = device.kind === 'lock' || device.kind === 'ward' ? device.kind : 'panel';
+        // KIND CLAMPS, never throws -- see clampDeviceKind's own doc for
+        // why, and for the incident (a "tunnel grate" clamped to `panel`
+        // and rendered hack-only) that put a name/description-aware
+        // fallback here instead of a blind default to `panel`.
+        const kind = clampDeviceKind(device.kind, device.name, detail?.description ?? device.concept);
         // A CODE ONLY BELONGS ON A PANEL -- enforced here as well as in the
         // prompt, because the prompt is advice and this is not. You cannot
         // talk at a mechanical lock.

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

@@ -4,6 +4,7 @@ import { AI } from '../../../../tools/ai/ai.class.js';
 import { Player } from '../models/player.js';
 import { Room } from '../models/room.js';
 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 { SceneSynthesizer } from './scene-factory.js';
@@ -681,17 +682,23 @@ export class SceneSeedGenerator {
      * This used to throw on an unrecognised bypassType. A kind we cannot
      * read is still a device, and rejecting a whole draft -- 20-40s of
      * generation -- over one misspelled word is a worse outcome than a
-     * panel where the model meant something else. assembleScene does the
-     * same clamp; this one catches a seed that reached us another way.
+     * guess where the model meant something else. assembleScene does the
+     * same clamp (via the same clampDeviceKind helper, so the two cannot
+     * drift); this one catches a seed that reached us another way.
+     *
+     * THE GUESS IS NAME/DESCRIPTION-AWARE, not a blind "panel" (fixed
+     * 2026-09-08, backlog 2uNPnc4L6jHaYEtnN / tuku6Z5XTtmNemkzd): a
+     * "tunnel grate" clamped to `panel` rendered as a hack-only "sealed
+     * SYSTEM", which is backwards for a physical mechanism.
      */
     static clampDeviceKinds(candidate) {
-        const allowed = new Set(['lock', 'panel', 'ward']);
         for (const room of candidate.rooms ?? []) {
             for (const device of room.devices ?? []) {
-                if (device.kind && !allowed.has(device.kind)) {
-                    Logger.getInstance().write(`scene-seed-generator: device "${device.name}" had kind "${device.kind}"; clamped to "panel".`);
-                    device.kind = 'panel';
+                const clamped = clampDeviceKind(device.kind, device.name, device.description);
+                if (device.kind && device.kind !== clamped) {
+                    Logger.getInstance().write(`scene-seed-generator: device "${device.name}" had kind "${device.kind}"; clamped to "${clamped}".`);
                 }
+                device.kind = clamped;
             }
         }
     }

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

@@ -33,4 +33,44 @@ export const AFFORDANCE_FLAVOR = {
 export function verbsFor(kind) {
     return AFFORDANCE_FLAVOR[kind]?.verbs ?? [];
 }
+/** WARD-SOUNDING NAMES, checked first: a magical barrier is rare and
+ *  specific enough here that missing one costs less than a false
+ *  positive stealing a genuine lock from `lock`. */
+const WARD_HINTS = ['ward', 'seal', 'rune', 'glyph', 'weave', 'astral', 'spell', 'enchant', 'mystic'];
+/** PHYSICAL-MECHANISM NAMES, checked second -- the actual fix
+ *  (backlog 2uNPnc4L6jHaYEtnN / tuku6Z5XTtmNemkzd, 2026-09-08). A
+ *  device that reads as a mechanism now falls back to `lock`
+ *  (pick/breach) instead of `panel` (hack): defaulting a "tunnel
+ *  grate" to panel had the game insist a metal grate was "a sealed
+ *  SYSTEM", which is exactly backwards for a physical object. */
+const LOCK_HINTS = [
+    'grate', 'gate', 'hatch', 'grille', 'grill', 'padlock', 'deadbolt',
+    'bolt', 'latch', 'mechanism', 'portcullis', 'chain', 'valve', 'hinge',
+    'tumbler', 'maglock', 'lock', 'vault', 'safe', 'cage', 'shutter',
+    'manhole', 'trapdoor', 'hasp',
+];
+/**
+ * THE ONE KIND CLAMP, shared by both scene-chunks.ts's assembleScene and
+ * scene-seed-generator.ts's clampDeviceKinds so the fallback cannot
+ * drift between them the way a bare "default to panel" already had.
+ *
+ * NEVER THROWS -- deliberately, and for the reason both call sites'
+ * own comments already gave before this existed: a kind the model got
+ * wrong is still a device, and rejecting a whole generated scene over
+ * one word costs the player a 20-40s regeneration for a mistake this
+ * heuristic can approximate better. This only changes WHAT the
+ * fallback guesses when the raw kind isn't one of the three real
+ * ones -- from a blind `panel` to a look at the device's own name and
+ * description first.
+ */
+export function clampDeviceKind(rawKind, name, description) {
+    if (rawKind === 'lock' || rawKind === 'panel' || rawKind === 'ward')
+        return rawKind;
+    const text = `${name} ${description ?? ''}`.toLowerCase();
+    if (WARD_HINTS.some(hint => text.includes(hint)))
+        return 'ward';
+    if (LOCK_HINTS.some(hint => text.includes(hint)))
+        return 'lock';
+    return 'panel';
+}
 //# sourceMappingURL=affordances.js.map

package/bundle/typescript/src/commands/game/sideQuest-backlog-mcp.sub.cmd.js

@@ -1,10 +1,17 @@
+import fs from 'fs';
 import path from 'path';
 import { Command } from '../../command.js';
+import { UsageError } from '../../error.js';
 export function registerBacklogMcp(parent) {
     return Command.create({
         name: 'mcp',
-        usage: 'maka play:backlog:mcp [--env <env>]',
-        mustBeInMakaProject: true,
+        usage: 'maka play:backlog:mcp [--env <env>] [--site <path>]',
+        // OFF, DELIBERATELY -- see the file header. The framework's own
+        // check fires before this handler runs at all and only knows how
+        // to look at process.cwd(); --site is this command's own way to
+        // satisfy the same requirement, so it needs the chance to try that
+        // first rather than being refused upstream of ever seeing it.
+        mustBeInMakaProject: false,
         // NO maxArgLength HERE, DELIBERATELY. Command's own arg-length check
         // is `args.length >= maxArgLength` (command.ts), so `maxArgLength: 0`
         // refuses EVERY invocation regardless of what was typed -- an
@@ -17,29 +24,43 @@ export function registerBacklogMcp(parent) {
                 name: 'env',
                 description: 'Which maka-cli.com config/<env>/process.env supplies the Auth0 M2M credentials (default: production).',
             },
+            {
+                name: 'site',
+                description: 'Path to a maka-cli.com checkout. Defaults to resolving one from the current working directory if omitted -- pass this explicitly when the launching MCP client does not set cwd reliably.',
+            },
         ],
         shortDesc: 'Run an MCP server exposing game-backlog admin tools, authenticated as the M2M service account.',
         description: `Starts a local MCP server (stdio transport) with tools for listing and reading
     backlog items, attaching evidence and advancing status, drafting an AI bench, and posting
     admin notes -- all against maka-cli.com's existing game-backlog REST API, authenticated as
     the claude-agent@maka-cli.com service account via the Auth0 M2M token exchange
-    (api/v1/auth/m2m-login). Must be run with its working directory set to a maka-cli.com
-    checkout, since that project's config/<env>/process.env is where AUTHZERO_DOMAIN /
-    AUTHZERO_CLIENT_ID / AUTHZERO_SECRET / AUTHZERO_AUDIENCE live.`,
+    (api/v1/auth/m2m-login). Needs a maka-cli.com checkout to read AUTHZERO_DOMAIN /
+    AUTHZERO_CLIENT_ID / AUTHZERO_SECRET / AUTHZERO_AUDIENCE from config/<env>/process.env --
+    pass --site explicitly, or run with cwd already set to one.`,
         examples: [
-            'maka play:backlog:mcp',
-            'maka play:backlog:mcp --env local',
+            'maka play:backlog:mcp --site C:\\path\\to\\maka-cli.com',
+            'maka play:backlog:mcp --env local --site C:\\path\\to\\maka-cli.com',
         ],
     }, async function (_args, opts) {
         const env = opts.env ?? 'production';
-        if (!this.cfg.checkConfigExists(env)) {
-            // Pre-handshake failure -- nothing has touched stdout as MCP
-            // protocol yet, so a plain thrown Error (which Command's own
-            // wrapper reports via Log.error) is fine here.
-            throw new Error(`No configuration: ${env}, consider running "maka g:config ${env}"`);
+        let processEnvPath;
+        if (opts.site) {
+            const siteConfigDir = path.join(path.resolve(opts.site), 'config', env);
+            processEnvPath = path.join(siteConfigDir, 'process.env');
+            if (!fs.existsSync(processEnvPath)) {
+                throw new UsageError(`No config/${env}/process.env under --site ${opts.site} (looked for ${processEnvPath}).`);
+            }
+        }
+        else {
+            if (!this.cfg.checkConfigExists(env)) {
+                // Pre-handshake failure -- nothing has touched stdout as MCP
+                // protocol yet, so a plain thrown Error (which Command's own
+                // wrapper reports via Log.error) is fine here.
+                throw new UsageError(`Not in a maka-cli.com checkout and no --site given (looked for config/${env} under ${process.cwd()}).`);
+            }
+            const configPath = this.cfg.getAppConfigPath(env);
+            processEnvPath = path.join(configPath, 'process.env');
         }
-        const configPath = this.cfg.getAppConfigPath(env);
-        const processEnvPath = path.join(configPath, 'process.env');
         const [domain, clientId, clientSecret, audience] = await Promise.all([
             this.dotenvx.get('AUTHZERO_DOMAIN', processEnvPath),
             this.dotenvx.get('AUTHZERO_CLIENT_ID', processEnvPath),

package/package.json

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