@maka/maka-cli 5.145.0 → 5.147.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.145.0",
+  "version": "5.147.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/advance.js

@@ -73,6 +73,14 @@ export class AdvanceCommand extends Command {
         this.actor.performAction('trains', skill);
         this.logger.write(`${actor.name} advanced ${skill} to ${next} (spent ${cost} karma, ${actor.karma} left).`);
         this.scene.updateStatus();
+        // A DURABLE CHANGE (fDswPCSf8tGhMPMZ6, same shape as vR8ajvm3wXdexxdF2:
+        // buy/sell learned this, advance never did). Karma spent and a skill
+        // raised is exactly the kind of change equip.ts already asks for a
+        // save over -- without it, a player who trains and quits before the
+        // next autosave beat reloads to a lower skill AND the karma still
+        // gone, and the web character sheet (reading the last saved doc)
+        // shows the stale rating.
+        this.game?.requestSave('advance');
         return `You drill ${skill} until it sticks: ${current} -> ${next}. (${cost} karma spent, ${actor.karma} left.)`;
     }
     trainAttribute(attr) {
@@ -111,6 +119,7 @@ export class AdvanceCommand extends Command {
             this.actor.performAction('trains', attr);
             this.logger.write(`${actor.name} advanced ${attr} to base ${attr === 'magic' ? actor.baseMagic : actor.baseResonance} (effective ${effective}; spent ${cost} karma, ${actor.karma} left).`);
             this.scene.updateStatus();
+            this.game?.requestSave('advance');
             return `The talent deepens: ${attr} ${base} -> ${base + 1}${actor.essenceBurn > 0 ? ` (effective ${effective} after the chrome's toll)` : ''}. (${cost} karma spent, ${actor.karma} left.)`;
         }
         const current = actor[attr];
@@ -136,6 +145,7 @@ export class AdvanceCommand extends Command {
         this.actor.performAction('trains', attr);
         this.logger.write(`${actor.name} advanced ${attr} to ${next} (spent ${cost} karma, ${actor.karma} left).`);
         this.scene.updateStatus();
+        this.game?.requestSave('advance');
         const trackNote = attr === 'body' ? ` Your physical track grows with it.` : attr === 'reaction' ? ` Your stun track grows with it.` : '';
         return `Weeks of drills compressed into downtime: ${attr} ${current} -> ${next}. (${cost} karma spent, ${actor.karma} left.)${trackNote}`;
     }

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

@@ -0,0 +1,54 @@
+import { Command } from './command.js';
+/**
+ * "there should be a command for counterspelling" (3vCH5uQvpKZdjzWYQ).
+ *
+ * There already is counterspelling -- it just isn't a command. RAW
+ * (p.294) is a STANDING PARRY: a Counterspelling-skilled defender's
+ * dice roll straight into the defense test the instant a hostile spell
+ * targets them, and a co-located party caster can extend theirs over a
+ * teammate the same way ("one source, no stacking" -- the better rating
+ * covers, they don't add). combat-exchange.ts already does exactly
+ * this, automatically, on every spell strike, and narrates it on the
+ * Defense line ("+N counterspell -- Name's cover") when it bites.
+ *
+ * So the report's actual gap is not mechanics, it's that typing
+ * "counterspell" got "I don't understand the command" -- a player
+ * reaching for a verb that (correctly, per RAW) does not exist. This
+ * command answers that reach with the truth instead of a parser error:
+ * what protection they're already carrying and why nothing needs to be
+ * typed to use it.
+ *
+ * ONE HONEST GAP: canon also lets a defender who has already spent
+ * their Free Action declare protection reactively as an Interrupt
+ * Action at Initiative -5 (p.294). This engine's Action Phase economy
+ * (utilities/action-cost.ts) has no off-phase Free Action today --
+ * `IBillOptions.anyPhase` is declared and reserved for exactly this,
+ * unused by anything yet -- so the reactive-declare half of spell
+ * defense isn't modeled. What's implemented (the standing parry, which
+ * is what actually answers "I have counterspelling, why didn't it
+ * help") works with no action spent at all, which is the more common
+ * case by far.
+ */
+export class CounterspellCommand extends Command {
+    static verb = 'counterspell';
+    static description = 'Check your counterspelling cover. Nothing to spend: your Counterspelling skill (or a co-located party caster\'s, if theirs is better) automatically rolls into the defense the instant a hostile spell targets you or an ally.';
+    async execute(_args = []) {
+        const actor = this.actor;
+        if (actor.isAspected && !actor.canWorkSorcery()) {
+            return `Counterspelling is Sorcery, and your gift is aspected elsewhere -- you can see the weave, not turn it.`;
+        }
+        if (typeof actor.isCaster !== 'function' || !actor.isCaster()) {
+            return `Counterspelling takes the Art or a spell formula, grimoire, or focus on you -- you have none.`;
+        }
+        const rating = actor.skillRating('counterspelling');
+        if (rating <= 0) {
+            return `You have no Counterspelling trained -- "qualities" or "advance" at home if you want to pick it up.`;
+        }
+        return `Counterspelling isn't something you trigger -- it's a standing parry (SR5 p.294).`
+            + `\nEvery hostile spell that targets you, or a party member you're co-located with, automatically`
+            + `\nrolls your counterspelling ${rating} into their defense test -- no action spent. If more than one`
+            + `\ncaster in the room could cover the same target, the best single rating applies (it doesn't stack).`
+            + `\nWatch the Defense line for "+${rating} counterspell" when it bites.`;
+    }
+}
+//# sourceMappingURL=counterspell.js.map

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

@@ -162,6 +162,24 @@ export function buildReproScene(fixture) {
         throw new ReproFixtureError(`"${misplacedIce.name}" is ice, so it cannot also stand in a doorway, guard, circulate or carry a gun. `
             + `Ice lives in the host, not on the floor -- drop the meat-side flags, or drop "ice".`);
     }
+    // A SEED HAS ONE PLANE. astral maps to 'astral' the same way ice maps
+    // to 'matrix' (npc-seed.ts) -- asking for both is asking the builder
+    // to pick a lie.
+    const bothPlanes = npcs.find(n => n.ice && n.astral);
+    if (bothPlanes) {
+        throw new ReproFixtureError(`"${bothPlanes.name}" is asked to be both ice and astral -- an actor has one plane, pick one.`);
+    }
+    // AN ASTRAL FORM CANNOT HOLD A DOOR SHUT OR CARRY A GUN. "guarding"
+    // means blocking meat movement, and "an astral presence has no body
+    // to block with" IS the fix this flag exists to bench -- a fixture
+    // asking for both would prove the opposite of what it claims. armed
+    // hands out a pistol and a commlink, and an astral form carries no
+    // physical object (SR5 p.301-302, Spirit Basics).
+    const contradictoryAstral = npcs.find(n => n.astral && (n.guarding || n.armed));
+    if (contradictoryAstral) {
+        throw new ReproFixtureError(`"${contradictoryAstral.name}" is astral, so it cannot guard a door or carry a gun -- `
+            + `an astral form has no body to block or hold anything with. Drop the flag, or drop "astral".`);
+    }
     const barrier = fixture.barrier;
     const direction = barrier?.sealsExit ?? Direction.NORTH;
     const startSide = fixture.start ?? 'barrier';
@@ -339,6 +357,12 @@ export function buildReproScene(fixture) {
             };
         }
         return {
+            // UNLIKE ice, astral does not move the NPC anywhere -- it keeps
+            // the ordinary placement below. The whole point of the fix this
+            // flag benches is that an astral actor stands right where a meat
+            // one would and still does not block (seatingIn is unchanged by
+            // the fix; only WHETHER it blocks changed, never WHERE it sits).
+            ...(npc.astral ? { plane: 'astral' } : {}),
             description: npc.concept,
             dialogue: [],
             player: {

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

@@ -170,6 +170,7 @@ import { SneakCommand } from './commands/sneak.js';
 import { PersuadeCommand } from './commands/persuade.js';
 import { BluffCommand } from './commands/bluff.js';
 import { DispelCommand } from './commands/dispel.js';
+import { CounterspellCommand } from './commands/counterspell.js';
 import { BreachCommand } from './commands/breach.js';
 import { EmoteCommand } from './commands/emote.js';
 import { OverwatchCommand } from './commands/overwatch.js';
@@ -2648,6 +2649,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('dispel', DispelCommand);
         CommandFactory.registerCommand('dispell', DispelCommand);
         CommandFactory.registerCommand('breach', BreachCommand);
+        // "counterspell" is not an action to spend -- it explains the
+        // standing parry combat-exchange.ts already applies automatically
+        // (3vCH5uQvpKZdjzWYQ).
+        CommandFactory.registerCommand('counterspell', CounterspellCommand);
         // Free-form roleplay ("me" is the classic MUD spelling).
         CommandFactory.registerCommand('emote', EmoteCommand);
         CommandFactory.registerCommand('me', EmoteCommand);
@@ -6051,7 +6056,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // "players" folded back under crew after playtesting ("crew
         // players" / "crew street"); the bare verb still answers quietly.
         { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
-        { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense']] },
+        { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
         { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
         // The Emerged get their own shelf (player request: "there MUST be
         // resonance" -- matrix is the place, Resonance is the talent).

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

@@ -20,8 +20,11 @@
  * would themselves have been a MINOR bump had a version already
  * existed. Read it as "schema, second edition", not "second edition
  * broke something".
+ *
+ * 2.4.0 adds IReproNpc.astral -- purely additive, older drafts still
+ * valid.
  */
-export const REPRO_SCHEMA_VERSION = '2.3.0';
+export const REPRO_SCHEMA_VERSION = '2.4.0';
 /** THE LIVE REASON, from the field or the card's own words.
  *
  *  `repro.live` is authoritative -- but the server's validator must

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

@@ -70,9 +70,9 @@ import { UsageError } from '../../error.js';
  */
 const MCP_SERVER_INSTRUCTIONS = `This server exposes the game-backlog admin actions as tools. Every tool is a thin wrapper over the same REST routes the human web board and CLI already use -- role checks, evidence gates, and audit logging all apply exactly as they do for a human admin. Nothing here bypasses them.
 
-THE LOOP IS NEARLY AUTOMATED BY DESIGN -- that is the whole reason this server exists instead of a human doing this work by hand. For each item: read it in full (backlog_get), find the root cause in the relevant repo (maka-cli-src for the CLI/game engine, maka-cli.com for the site/backend -- see sources-1/CLAUDE.md for which repo owns what), fix it, write/run tests, build, lint, typecheck -- then commit, version-bump (maka-cli-src releases go through the full chain: push -> build -> publish -> GitHub release + site pin -> the pin auto-deploys the site; maka-cli.com-only changes need either the next pin or a manual "gh workflow run deploy.yml"), and once the fix is committed AND actually deployed live, call backlog_advance with the commit sha(s) to move the item to "ready-for-bench".
+THE LOOP IS NEARLY AUTOMATED BY DESIGN -- that is the whole reason this server exists instead of a human doing this work by hand. For each item: read it in full (backlog_get), find the root cause in the relevant repo (maka-cli-src for the CLI/game engine, maka-cli.com for the site/backend -- see sources-1/CLAUDE.md for which repo owns what), fix it, write/run tests, build, lint, typecheck -- then commit, version-bump (maka-cli-src releases go through the full chain: push -> build -> publish -> GitHub release + site pin -> the pin auto-deploys the site; maka-cli.com-only changes need either the next pin or a manual "gh workflow run deploy.yml"), and once the fix is committed AND actually deployed live: backlog_advance(status: "ready-for-bench", commits: [sha]) -> backlog_draft_bench -> backlog_dry_run_bench (read the transcript it returns -- this is automated QA, not the reporter's confirmation, and needs no human) -> if the transcript demonstrates the fix, backlog_advance(status: "in-review", repro: <the same spec that just dry-ran clean>), which promotes the draft to a real bench AND notifies the reporter in one call. That is as far as automation goes: only the reporter can sign off or reject from here, in-game -- see "WHAT THIS SERVER DELIBERATELY DOES NOT EXPOSE" below for why that boundary is real and the bench-verification step is not.
 
-DO NOT PAUSE TO ASK PERMISSION for a routine step in that loop -- committing a clean, tested, single-purpose change, bumping a version, pushing, or letting the release chain run. That is exactly the friction this tooling was built to remove. Reserve a real stop for a production-only action with no easy rollback, or a failure that genuinely needs human judgment to interpret.
+DO NOT PAUSE TO ASK PERMISSION for a routine step in that loop -- committing a clean, tested, single-purpose change, bumping a version, pushing, letting the release chain run, or dry-running a drafted bench. That is exactly the friction this tooling was built to remove. Reserve a real stop for a production-only action with no easy rollback, or a failure that genuinely needs human judgment to interpret.
 
 DESIGN DECISIONS THAT COME UP WHILE FIXING ARE NOT A STOP EITHER. Make the call, then record the decision and its reasoning as a backlog_comment (kind: "note") on the item itself -- that comment is the durable record a later reviewer or the reporter can read; a live question to the human is the thing this loop exists to avoid. Only escalate a design question directly to the human when the choice changes externally-visible behavior in a way nobody could reconstruct from the code and the note.
 
@@ -82,7 +82,7 @@ SWEEP THE FAMILY. If a root cause affects more than one open item (the same clam
 
 "ready-for-bench" MEANS COMMITTED *AND* DEPLOYED, not just committed -- a bench built against undeployed code would replay the old bug and report the fix as failed. Don't advance to ready-for-bench before confirming the deploy actually succeeded.
 
-WHAT THIS SERVER DELIBERATELY DOES NOT EXPOSE, and why: signoff/reject/close are the reporter's own verbs -- only the person who hit the bug can confirm it is actually gone in play, and an AI closing its own fix would be exactly the self-certification this project's design already rejects for human admins. grant/revoke/delete/top-priority are rarer, higher-blast-radius actions left to a human directly.
+WHAT THIS SERVER DELIBERATELY DOES NOT EXPOSE, and why: signoff/reject/close are the reporter's own verbs -- only the person who hit the bug can confirm it is actually gone in play, and an AI closing its own fix would be exactly the self-certification this project's design already rejects for human admins. grant/revoke/delete/top-priority are rarer, higher-blast-radius actions left to a human directly. NOTE THE DIFFERENCE FROM backlog_dry_run_bench: proving a bench SCRIPT replays correctly is a technical fact with no subjective side, and it needs no human -- it is not the same gate as the reporter deciding their own bug is gone, and must never be treated as though it were (that confusion cost a full stop the first time this loop ran for real).
 
 A "failed" vetting state means the automated vetting pipeline itself errored (no lore-search hits, or the model call failed) -- it is NOT a judgment that the item lacks merit. Treat those items as needing your own diagnosis from scratch, same as any other open item.`;
 export function registerBacklogMcp(parent) {
@@ -177,6 +177,7 @@ export function registerBacklogMcp(parent) {
         const { z } = await import('zod');
         const { ensureServiceSession } = await import('./sideQuest/utilities/service-account-auth.js');
         const { fetchBacklog, fetchBacklogItemById, patchBacklogItem, draftBacklogBench, postBacklogComment, BACKLOG_STATUSES, } = await import('./sideQuest/utilities/backlog.js');
+        const { dryRunRepro } = await import('./sideQuest/utilities/repro-launch.js');
         const statusEnum = BACKLOG_STATUSES;
         /** Every tool call goes through this: reuse the cached session, and
          *  on the first `expired` outcome, mint a fresh one and retry
@@ -236,29 +237,75 @@ export function registerBacklogMcp(parent) {
         }, async ({ itemId, text, kind, awaitingReporter }) => toolResult(await withSession(async (token) => ({
             outcome: await postBacklogComment(itemId, text, { kind, awaitingReporter }, token),
         }))));
+        // MIRRORS IRepro (types/repro.ts), LOOSELY. `steps` is the one field
+        // that actually matters to this tool and to `dryRunRepro` -- the
+        // server's own validateRepro is the real authority on the rest, so
+        // `fixture`'s rich nested shape (barrier/npcs/items/level/host) is
+        // passed through as an opaque object rather than re-declared here.
+        // Re-mirroring a shape this deep in a second place is exactly the
+        // kind of drift this codebase's own comments repeatedly warn about;
+        // letting the server validate it is the one copy that matters.
+        const reproSchema = z.object({
+            fixture: z.record(z.string(), z.unknown()).optional(),
+            steps: z.array(z.string()).min(1),
+            premise: z.string().optional(),
+            expect: z.string().optional(),
+            minVersion: z.string().optional(),
+            live: z.string().optional(),
+        });
         server.registerTool('backlog_advance', {
             title: 'Advance a backlog item (attach evidence / change status)',
-            description: `Move a backlog item's status and/or attach fix-commit evidence. This is the
-        actual resolution action -- it will be refused by the server (with a message explaining
-        why) if you try to enter "in-review" or "complete" without at least one commit attached,
-        or "complete" without the reporter's sign-off already on the item. This tool never signs
-        off or rejects a fix on the reporter's behalf -- only the person who filed the item can
-        do that, in-game.`,
+            description: `Move a backlog item's status, attach fix-commit evidence, and/or promote a
+        dry-run-verified bench (see backlog_dry_run_bench) from reproDraft to a real repro. This
+        is the actual resolution action -- it will be refused by the server (with a message
+        explaining why) if you try to enter "in-review" or "complete" without at least one commit
+        attached, or "complete" without the reporter's sign-off already on the item. This tool
+        never signs off or rejects a fix on the reporter's behalf -- only the person who filed the
+        item can do that, in-game.`,
             inputSchema: {
                 itemId: z.string(),
                 status: z.enum(statusEnum),
                 commits: z.array(z.string()).optional()
                     .describe('Fix-commit SHAs to attach (merged with whatever is already there).'),
+                repro: reproSchema.optional()
+                    .describe('Promote a bench to real: pass the exact spec that just dry-ran clean via backlog_dry_run_bench. Clears any pending reproDraft.'),
             },
-        }, async ({ itemId, status, commits }) => toolResult(await withSession((token) => patchBacklogItem(itemId, { status, commits }, token))));
+        }, async ({ itemId, status, commits, repro }) => toolResult(await withSession((token) => patchBacklogItem(itemId, { status, commits, repro }, token))));
         server.registerTool('backlog_draft_bench', {
             title: 'Draft an AI bench for a backlog item',
-            description: 'Ask the server to AI-draft a two-room repro bench for one item (lands in reproDraft, not repro -- a human has to dry-run and promote it separately via backlog_advance with a repro body). Costs a model call server-side.',
+            description: 'Ask the server to AI-draft a two-room repro bench for one item (lands in reproDraft, not repro -- dry-run it with backlog_dry_run_bench, then promote it with backlog_advance\'s repro param). Costs a model call server-side.',
             inputSchema: {
                 itemId: z.string(),
                 verbs: z.array(z.string()).optional().describe('The verbs available to reference in the bench steps.'),
             },
         }, async ({ itemId, verbs }) => toolResult(await withSession((token) => draftBacklogBench(itemId, token, verbs))));
+        server.registerTool('backlog_dry_run_bench', {
+            title: 'Dry-run a backlog item\'s bench, headlessly',
+            description: `Replay a backlog item's bench steps against a real boot of the game engine
+        -- no terminal, no login, no human -- and return the transcript (including dice/mechanics
+        lines). Proves the drafted bench (or an already-attached one) reproduces the reported
+        behavior BEFORE it is promoted or shown to the reporter. Prefers the item's pending
+        reproDraft; falls back to its attached repro if there is no draft. This is technical
+        verification, not the reporter's in-play confirmation -- reading the transcript and
+        judging whether it demonstrates the fix is exactly the kind of judgment call this tool
+        exists to let you make yourself.`,
+            inputSchema: { itemId: z.string() },
+        }, async ({ itemId }) => {
+            const result = await withSession((token) => fetchBacklogItemById(itemId, token));
+            if (result.outcome !== 'ok' || !result.item)
+                return toolResult(result);
+            const spec = result.item.reproDraft?.spec ?? result.item.repro;
+            if (!spec || !Array.isArray(spec.steps) || spec.steps.length === 0) {
+                return toolResult({ outcome: 'rejected', message: 'No reproDraft or repro on this item yet -- call backlog_draft_bench first.' });
+            }
+            try {
+                const { lines, warnings } = await dryRunRepro(spec);
+                return toolResult({ outcome: 'ok', transcript: lines.join('\n'), warnings });
+            }
+            catch (e) {
+                return toolResult({ outcome: 'rejected', message: `Dry run failed to boot: ${e.message}` });
+            }
+        });
         const transport = new StdioServerTransport();
         await server.connect(transport);
         console.error('[play:backlog:mcp] ready');

package/package.json

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