@maka/maka-cli 5.214.0 → 5.216.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.214.0",
+  "version": "5.216.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/complete.js

@@ -1,5 +1,6 @@
 import { Command } from './command.js';
 import { nameablesFor, whereAmI } from '../utilities/nameables.js';
+import { playerVerbs, verbShelf, helpCategories } from '../utilities/verb-index.js';
 import { normalizeLoose } from '../utilities/fuzzy-match.js';
 /**
  * TAB COMPLETION, ANSWERED BY THE ENGINE (f79LLqTerep4nKWcA: "How do I
@@ -71,6 +72,40 @@ export class CompleteCommand extends Command {
         // long one out loud.
         return all.filter(n => normalizeLoose(n.name).includes(want));
     }
+    /**
+     * THE FIRST WORD IS A VERB, NOT A NAME (yaw2btNX8aNEEF9D3, Maka: "If
+     * someone presses 'tab' with nothing in the input box, the first list
+     * to reference is the 'command' list").
+     *
+     * Tab used to answer with NAMEABLES whatever was in the box, so an
+     * empty box dumped every icon and body in reach into the Mechanics
+     * panel -- the reporter's first sentence -- and a half-typed verb
+     * matched names by accident or nothing at all. But a command line has
+     * two halves and they have different vocabularies: before the first
+     * space you are choosing a VERB, after it you are naming a TARGET.
+     *
+     * The test is the space, not the emptiness: "ha" and "" are both the
+     * verb slot, "hack " and "hack ca" are both the target slot. That is
+     * also why `head` is what it is -- with no space there is no head, so
+     * a completed verb replaces the whole box.
+     */
+    verbSlot(raw) {
+        return !raw.includes(' ');
+    }
+    /** The verb list, shaped like nameables so one renderer prints both. */
+    verbs() {
+        return playerVerbs().map(v => {
+            const shelf = verbShelf(v);
+            const primary = shelf?.primary;
+            return {
+                glyph: '›',
+                name: v,
+                what: shelf
+                    ? `${shelf.category}${primary && primary !== v ? ` -- same as "${primary}"` : ''}`
+                    : 'a command',
+            };
+        });
+    }
     async execute(args = []) {
         const actor = this.actor;
         // The client sends the box VERBATIM, so the words rebuild it exactly;
@@ -80,7 +115,20 @@ export class CompleteCommand extends Command {
         // A VERB ALONE IS NOT A NAME. With nothing typed after the verb the
         // player wants the roster, which is the `fragment === ''` case below
         // and handled by matches() returning everything.
-        const all = nameablesFor(this.scene, actor, this.rooms);
+        const onVerb = this.verbSlot(raw);
+        // AN EMPTY BOX IS NOT A QUERY, it is "what can I even do?", and the
+        // answer is not 180 verbs truncated at 12 -- that is the dump the
+        // report is about, wearing different clothes. The SHELVES are the
+        // command list at the altitude a person can read: a dozen lines,
+        // each one a place to look, and `help <shelf>` opens it.
+        if (onVerb && fragment.length === 0) {
+            const shelves = helpCategories();
+            return [
+                `Type a verb, or a letter or two and Tab again. The shelves:`,
+                ...shelves.map(c => `  › ${c.title} -- ${c.entries.length} commands ("help ${c.title}")`),
+            ].join('\n');
+        }
+        const all = onVerb ? this.verbs() : nameablesFor(this.scene, actor, this.rooms);
         if (all.length === 0) {
             return `Nothing to name from ${whereAmI(actor)}.`;
         }
@@ -90,6 +138,17 @@ export class CompleteCommand extends Command {
             return `${COMPLETE_MARKER}${head}${only.name}`;
         }
         if (hits.length === 0) {
+            // The two slots miss for different reasons and the line has to say
+            // which: a verb that does not exist is a different problem from a
+            // name that is not HERE, and telling somebody "nothing at the
+            // Night Market answers to 'inevntory'" sends them looking round
+            // the room for their own pack.
+            if (onVerb) {
+                return [
+                    `No command starts with "${fragment}". Try a shelf:`,
+                    ...helpCategories().map(c => `  › ${c.title} ("help ${c.title}")`),
+                ].join('\n');
+            }
             return [
                 `Nothing at ${whereAmI(actor)} answers to "${fragment}". You could name:`,
                 ...all.slice(0, 12).map(n => `  ${n.glyph} ${n.name} -- ${n.what}`),

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

@@ -1086,5 +1086,57 @@
 //   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';
+// 1.74.1 (2026-09-16): A PERSON MAY SAY WHAT THEY KNOW. 1.74.0's
+//   INTERIOR rule leaked onto the SPEECH channel and gagged ordinary
+//   dialogue -- an NPC saying "I know exactly what you mean" out loud
+//   was refused as mind-reading. Caught before anyone played it, by
+//   reading judgeNarration's other caller rather than by a report.
+//   THE TRAP IS WORTH RECORDING. Dialogue has run through this judge
+//   since KwiMKNMN2e8KBqTY7, and it was safe from the agency rules for
+//   an INVISIBLE reason: that caller passes an empty cast, so there is
+//   no subject to resolve and CONTACT/COMPELLED_MOVEMENT can never fire.
+//   A real guarantee, nowhere stated. INTERIOR needs no subject, so it
+//   walked straight through. judgeNarration now takes an explicit
+//   `channel` ('beat' by default, 'speech' from the dialogue call) and
+//   the beat-only rules are gated on it, so the next rule added here has
+//   to decide which channel it belongs to instead of inheriting an
+//   accident. The distinction is the rule itself: a character may SAY
+//   what they know; they may not have it NARRATED at a player who cannot
+//   hear it.
+// 1.75.0 (2026-09-16): TAB COMPLETES A VERB BEFORE THE SPACE AND A
+//   TARGET AFTER IT (yaw2btNX8aNEEF9D3, Maka: "the 'tab' key shouldn't
+//   SHOW all the things in the room in the Mechanics panel ... If
+//   someone presses 'tab' with nothing in the input box, the first list
+//   to reference is the 'command' list. Then, tab can cycle through
+//   entities. Be careful though, if I can't percieve the thing, it
+//   shouldn't be on the tab list."). Four asks, four changes.
+//   - THE SPACE IS THE BOUNDARY. `complete` answered with NAMEABLES
+//     whatever was in the box, so an empty box dumped every icon and
+//     body in reach into the panel and a half-typed verb matched entity
+//     names by accident. A command line has two halves with two
+//     vocabularies; before the first space you are choosing a verb.
+//   - AN EMPTY BOX GETS THE SHELVES, not 180 verbs truncated at 12 --
+//     that is the same dump wearing different clothes. A dozen lines,
+//     each a place to look, each with its "help <shelf>".
+//   - THE VERB TABLE MOVED OUT OF game.ts to utilities/verb-index.ts, so
+//     Tab and the help screen read ONE list. A second hand-maintained
+//     copy of ~180 verbs is a copy that drifts. Aliases complete too:
+//     somebody typing "inventor" is reaching for `inventory`, and it is
+//     an alias of `inv`. Role-aware, so Tab never offers a play-tester
+//     verb to an account the server will 403.
+//   - TAB WAS A FREE SEARCH. nameablesFor read the room's WHOLE
+//     inventory, so it offered loot nobody had found -- while `look` and
+//     `take` filter the same set and would then refuse to show or hand
+//     over the very name Tab had just typed for you. It now uses take.ts's
+//     gate exactly: cased the room, or the thing arrived in the open in
+//     front of you. Off-plane items go too, for take.ts's reason.
+//   - AND TAB AGAIN WALKS THE LIST (utilities/tab-cycle.ts, CLI only for
+//     now -- cycling is a property of an input box and only the CLI has
+//     one). Pure model, so a test can press Tab four times without a
+//     terminal. Continuation is an EXACT match on what the last press
+//     wrote: one typed letter ends the walk and asks the engine again,
+//     because that is what narrowing means. One candidate is not a
+//     cycle -- a key that rewrites the box to what it already holds
+//     looks broken.
+export const ENGINE_VERSION = '1.75.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -60,7 +60,8 @@ import { NoteCommand } from './commands/note.js';
 import { BacklogCommand } from './commands/backlog.js';
 // Whether this account may actually USE the backlog -- gates what the
 // help index offers, never what the verb accepts (item D).
-import { isPlaytester, probePlaytesterStanding } from './utilities/playtester.js';
+import { probePlaytesterStanding } from './utilities/playtester.js';
+import { HELP_CATEGORIES, HIDDEN_VERBS, PLAYTESTER_VERBS, helpCategories } from './utilities/verb-index.js';
 import { RolesCommand } from './commands/roles.js';
 import { ReviewCommand } from './commands/review.js';
 import { SinCommand } from './commands/sin.js';
@@ -6747,46 +6748,13 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * the renderer is ENTITLED to make -- the table was what lied.
      * help-taxonomy.test.ts now holds that line for the whole table.
      */
-    static HELP_CATEGORIES = [
-        { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
-        { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['loot'], ['drop'], ['give'], ['store'], ['open'], ['close'], ['put'], ['equip'], ['unequip'], ['fit'], ['unfit'], ['brandish', 'draw'], ['holster'], ['reload'], ['use'], ['read']] },
-        { title: 'combat', entries: [['attack'], ['kill'], ['subdue', 'stun', 'knock'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
-        // The party layer: everyone who walks (or flies, or manifests) at
-        // your side answers to these.
-        // "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'], ['counterspell']] },
-        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['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).
-        // `sustain` shelves here and not under magic: the command is
-        // technomancer-gated (a sprite task, SR5 p.256) and refuses anyone
-        // else, so the Emerged shelf is where its audience looks.
-        { title: 'resonance', entries: [['compile'], ['decompile'], ['thread'], ['unravel'], ['register'], ['standby'], ['sustain'], ['sprites']] },
-        { title: 'social', entries: [['say'], ['shout'], ['emote', 'me'], ['tell', 'talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
-        { title: 'street', entries: [['abandon'], ['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['garage'], ['pay']] },
-        { title: 'barriers', entries: [['pick'], ['breach'], ['dispel', 'dispell'], ['bluff'], ['unlock'], ['lock']] },
-        { title: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['sin', 'sins', 'papers'], ['initiate', 'submerge'], ['install', 'chrome']] },
-        { title: 'session', entries: [['help'], ['hints'], ['time', 'clock'], ['note'], ['backlog'], ['review'], ['roles'], ['clear'], ['quit', 'exit']] },
-    ];
-    /** Registered but deliberately UNLISTED: reachable as subcommands or
-     *  muscle-memory ("players" folded back under crew after playtesting
-     *  -- "crew players" is the advertised path; the bare verb still
-     *  answers). Without this, the uncategorized sweep resurrects them
-     *  in an "other" bucket. */
-    // 'first' and 'apply' exist ONLY to catch the two-word phrasings
-    // ("first aid", "apply first aid") that used to die at the parser. As
-    // bare words they mean nothing, so they are claimed but not advertised
-    // -- `heal` is the verb the help screen teaches.
-    // `complete` is what Tab sends (commands/complete.ts) -- a question the
-    // input box asks, not a verb anyone types, so it stays out of help.
-    static HIDDEN_VERBS = ['players', 'first', 'apply', 'complete'];
-    /** Session verbs that only a play-tester (or admin) can actually use
-     *  -- the server role-gates both and 403s everyone else. Listed in
-     *  help ONLY for a confirmed play-tester; see helpCategories. `roles`
-     *  rides along because it is admin-only, a strictly narrower group. */
-    static PLAYTESTER_VERBS = new Set(['backlog', 'review', 'roles']);
+    // THE VERB TABLES MOVED TO utilities/verb-index.ts. Tab needs the
+    // same list the help screen prints (yaw2btNX8aNEEF9D3), and two
+    // hand-maintained copies of ~180 verbs is a copy that drifts. These
+    // aliases keep every call site below reading as it did.
+    static HELP_CATEGORIES = HELP_CATEGORIES;
+    static HIDDEN_VERBS = HIDDEN_VERBS;
+    static PLAYTESTER_VERBS = PLAYTESTER_VERBS;
     /** Descriptions for the verbs handled inline in handleInput() rather than registered. */
     static BUILTIN_DESCRIPTIONS = {
         help: 'This overview. "help <category>" for one group with full descriptions; "help <command>" for one command.',
@@ -6810,12 +6778,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * and why the verb itself stays registered and usable regardless.
      */
     helpCategories() {
-        if (isPlaytester())
-            return Game.HELP_CATEGORIES;
-        return Game.HELP_CATEGORIES.map(c => c.title !== 'session' ? c : {
-            ...c,
-            entries: c.entries.filter(e => !Game.PLAYTESTER_VERBS.has(e[0])),
-        });
+        return helpCategories();
     }
     getHelpMessage(args = []) {
         const registered = Object.keys(CommandFactory.getAllRegisteredCommands());

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

@@ -2515,6 +2515,13 @@ Your objective is to drive the story line.`}
                 const placeVerdict = judgeNarration(said, this.name, [], {
                     here: this.currentLocation?.name,
                     worldRooms: Object.values(this._scene?.getRooms?.() ?? {}).map(r => r.name),
+                    // SAYS WHICH CHANNEL THIS IS, rather than relying on the empty
+                    // `others` above to keep the beat-only rules from firing. That
+                    // guarantee held for the agency rules, which need a subject to
+                    // resolve -- and broke the moment a rule arrived that does not
+                    // (INTERIOR), refusing an ordinary spoken "I know exactly what
+                    // you mean" as mind-reading. A person may SAY what they know.
+                    channel: 'speech',
                 });
                 if (placeVerdict.refused) {
                     this.logger.write(`${this.name} speech refused (claimed to be elsewhere): ${said.slice(0, 160)}`);

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

@@ -8,6 +8,7 @@ import { getArchetype, outfitArchetype } from './archetypes.js';
 import { attachLineEditor, attachArrowMovement } from './utilities/line-editor.js';
 import { attachInputHistory } from './utilities/input-history.js';
 import { COMPLETE_MARKER } from './commands/complete.js';
+import { startCycle, advance, continues } from './utilities/tab-cycle.js';
 import { TERMINAL_RESET_SEQUENCE } from './utilities/terminal-reset.js';
 import { readSave } from './utilities/persistence.js';
 import { requireCatalog, CatalogUnavailableError } from './utilities/catalog.js';
@@ -328,6 +329,10 @@ export async function main(playerName, sceneSeed, options) {
         // asked for in its place is a way to know which icon you are about
         // to hit. Bound on the input box because that's where focus lives
         // during play.
+        // The walk the previous Tab set up, if any. Lives out here so it
+        // survives between presses and nowhere else, which is the whole of
+        // its scope: no cycle outlives the input box it belongs to.
+        let tabCycle;
         game.inputBox.key(['tab'], () => {
             // Blessed's textarea reader appends the literal '\t' to the box
             // value on this same keypress (listener order isn't guaranteed
@@ -355,9 +360,26 @@ export async function main(playerName, sceneSeed, options) {
             // So: send the box, let the engine answer, on both run shapes.
             void (async () => {
                 const box = game.inputBox.getValue().replace(/\t/g, '');
+                // TAB AGAIN TAKES THE NEXT ONE (yaw2btNX8aNEEF9D3, Maka: "Then,
+                // tab can cycle through entities"). No round trip and no second
+                // copy of the list in the panel: the names from the previous
+                // press are still good, and walking them is a property of this
+                // input box rather than a question for the engine. The model is
+                // in utilities/tab-cycle.ts, pure, so a test can press Tab four
+                // times without a terminal. `continues` is an exact match on
+                // what the last press wrote, so one typed letter ends the walk
+                // and asks the engine again -- which is what narrowing means.
+                if (continues(tabCycle, box)) {
+                    const { box: filled, next } = advance(tabCycle);
+                    tabCycle = next;
+                    game.inputBox.setValue(filled);
+                    screen.render();
+                    return;
+                }
                 const res = await game.handleInput(`complete ${box}`);
                 if (!res)
                     return;
+                tabCycle = startCycle(box, res);
                 const lines = res.split('\n');
                 // THE MARKER LINE refills the box (see commands/complete.ts).
                 // Everything else is the candidate list, and goes to the ticker
@@ -365,12 +387,19 @@ export async function main(playerName, sceneSeed, options) {
                 if (lines[0]?.startsWith(COMPLETE_MARKER)) {
                     const filled = lines[0].slice(COMPLETE_MARKER.length);
                     game.inputBox.setValue(filled);
+                    // The engine may have grown the box to the common head; the
+                    // cycle has to compare against what is ACTUALLY there or the
+                    // next press would look like a player keystroke.
+                    if (tabCycle)
+                        tabCycle = { ...tabCycle, box: filled };
                     lines.shift();
                 }
                 for (const l of lines) {
                     if (l.trim().length > 0)
                         gameLog.meta(l, 'white');
                 }
+                if (tabCycle)
+                    gameLog.meta(`  (Tab again walks these.)`, 'white');
                 screen.render();
             })();
         });

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

@@ -65,7 +65,26 @@ function meatNameables(actor) {
     for (const device of room.openableDevices()) {
         push(out, seen, { glyph: '▤', name: device.name, what: 'a device' });
     }
+    // WHAT YOU HAVE ACTUALLY SEEN (yaw2btNX8aNEEF9D3, Maka: "if I can't
+    // percieve the thing, it shouldn't be on the tab list").
+    //
+    // This read the room's whole inventory, so Tab offered loot nobody had
+    // found yet -- and `look` (look.ts) and `take` (take.ts) both filter
+    // the same set and would have refused to show or hand over the very
+    // name Tab had just typed for you. Tab was a free `search`.
+    //
+    // The gate is take.ts's, verbatim in meaning: having cased the room
+    // reveals everything in it, and until then you know only what arrived
+    // in the open in front of you (Room.plainSightItems -- a dead NPC's
+    // scattered kit, a witnessed drop). Off-plane items are dropped for
+    // the same reason take.ts drops them: a matrix file on the floor is
+    // not a thing a body can pick up.
+    const cased = room.searchedBy.has(actor.name);
     for (const item of room.getItemsForActor(actor)) {
+        if (item.plane !== actor.plane)
+            continue;
+        if (!cased && !room.plainSightItems.has(item.name.toLowerCase()))
+            continue;
         push(out, seen, { glyph: '◇', name: item.name, what: 'on the ground' });
     }
     // WHAT YOU ARE CARRYING is nameable too -- "equip", "drop", "reload

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

@@ -309,6 +309,21 @@ function aimedAtAPerson(text, matches, subject) {
  * @param opts.holding  who this NPC already has a grapple on, if anyone --
  *                 narration about a hold the dice already settled is a
  *                 description, not a claim.
+ * @param opts.channel  which half of the reply this is. 'beat' (the
+ *                 default) is exposition and gets every rule. 'speech'
+ *                 is a line of DIALOGUE and gets the place rule only.
+ *
+ * WHY THE CHANNEL IS A PARAMETER AND NOT AN ACCIDENT. Dialogue has been
+ * passing through here since KwiMKNMN2e8KBqTY7 ("Whisper ... says he
+ * is"), and it survived the agency rules only because its caller passes
+ * an EMPTY `others` -- with nobody to resolve as the subject, CONTACT
+ * and COMPELLED_MOVEMENT can never fire. That is a real guarantee but an
+ * invisible one, and the INTERIOR rule broke it the moment it was
+ * written: interiority needs no subject, so a perfectly ordinary spoken
+ * "I know exactly what you mean" was refused as mind-reading. A person
+ * is allowed to say what they know. They are not allowed to have it
+ * NARRATED at a player who cannot hear it -- which is the whole
+ * distinction, and it now has a name in the signature.
  */
 export function judgeNarration(line, speaker, others, opts = {}) {
     const t = line.replace(/^[\s│|>*-]+/, '').trim();
@@ -327,8 +342,9 @@ 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)) {
+    // the SPEAKER's own head, so there is no subject to resolve -- which
+    // is exactly why it must be told to stay off the speech channel.
+    if (opts.channel !== 'speech' && INTERIOR.test(t)) {
         return {
             refused: true,
             subject: speaker,

package/bundle/typescript/src/commands/game/sideQuest/utilities/tab-cycle.js

@@ -0,0 +1,100 @@
+/**
+ * TAB AGAIN TAKES THE NEXT ONE (yaw2btNX8aNEEF9D3, Maka: "Then, tab can
+ * cycle through entities").
+ *
+ * The engine answers a Tab with the candidates and, when they share a
+ * head, fills the box as far as they agree (commands/complete.ts). That
+ * is the shell behaviour everyone has in their fingers for the FIRST
+ * press. The second press is where a shell offers the list and a good
+ * one walks it, and the report asks for the walk.
+ *
+ * WHY A PURE MODEL AND NOT A FEW LINES IN ui.ts. The whole feature is
+ * "what counts as the same Tab?" -- and that is a state question with
+ * exactly the shape that rots in an event handler: a player who types a
+ * letter, or recalls a command from history, or clears the box, must
+ * start a NEW cycle, and a player who just presses Tab again must not.
+ * Wiring belongs in ui.ts; the decision belongs here, where a test can
+ * press Tab four times in a row without a terminal.
+ *
+ * DELIBERATELY CLIENT-SIDE, AND CLI-ONLY FOR NOW. The engine stays
+ * stateless -- it answers the same question the same way however many
+ * times it is asked, which is what lets three clients share it. Cycling
+ * is a property of an input box, and only the CLI has one of these.
+ */
+/** A name the engine offered, as printed in a candidate line. */
+const CANDIDATE_LINE = /^\s{2}\S+\s+(.+?)\s+--\s/;
+/**
+ * The names out of a `complete` reply.
+ *
+ * Reads the LIST lines, not the marker line: the marker is what the box
+ * already holds. A reply with no list (one match, or a refusal) yields
+ * nothing and ends any cycle, which is correct -- there is nothing to
+ * walk.
+ */
+export function candidatesIn(reply) {
+    const out = [];
+    for (const line of reply.split('\n')) {
+        const m = CANDIDATE_LINE.exec(line);
+        if (m?.[1])
+            out.push(m[1]);
+    }
+    return out;
+}
+/**
+ * Split a box into the command so far and the fragment being typed --
+ * the SAME rule commands/complete.ts uses, deliberately duplicated
+ * rather than imported so the two can be compared by eye. A trailing
+ * space means an empty fragment.
+ */
+export function splitBox(raw) {
+    if (raw.length === 0 || raw.endsWith(' '))
+        return { head: raw, fragment: '' };
+    const cut = raw.lastIndexOf(' ');
+    return cut < 0 ? { head: '', fragment: raw } : { head: raw.slice(0, cut + 1), fragment: raw.slice(cut + 1) };
+}
+/**
+ * Begin a cycle from a reply, or return undefined when there is nothing
+ * to walk.
+ *
+ * ONE CANDIDATE IS NOT A CYCLE: the engine already filled the box with
+ * it, and a "cycle" of length one that rewrites the box on every press
+ * is just a key that appears to do nothing.
+ */
+export function startCycle(boxWhenPressed, reply) {
+    const names = candidatesIn(reply);
+    if (names.length < 2)
+        return undefined;
+    const { head } = splitBox(boxWhenPressed);
+    // `box` SEEDS TO THE BOX AS PRESSED, not to ''. The engine grows the
+    // box to the candidates' common head only when there IS one -- "hack
+    // s" with two s-names, but not "hack " with three unrelated ones. When
+    // it does not, nothing rewrites the box, so a cycle remembering ''
+    // would fail its own sameness test on the very next press and go back
+    // to the engine instead of walking. The caller overwrites this when a
+    // marker line did change the box.
+    return { head, names, index: -1, box: boxWhenPressed };
+}
+/**
+ * The next box contents, and the cycle to remember.
+ *
+ * Wraps at the end on purpose -- a walk you cannot get back to the start
+ * of is a walk you have to abandon by retyping.
+ */
+export function advance(cycle) {
+    const index = (cycle.index + 1) % cycle.names.length;
+    const box = `${cycle.head}${cycle.names[index]}`;
+    return { box, next: { ...cycle, index, box } };
+}
+/**
+ * Is this press a continuation of `cycle`?
+ *
+ * The box must be EXACTLY what the last press wrote. Not "starts with",
+ * not case-insensitive: a player who typed one more letter is narrowing
+ * their search and wants a fresh answer from the engine, and a cycle
+ * that swallowed that keystroke would be the most annoying possible
+ * version of this feature.
+ */
+export function continues(cycle, box) {
+    return cycle !== undefined && cycle.box === box && cycle.names.length > 1;
+}
+//# sourceMappingURL=tab-cycle.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/verb-index.js

@@ -0,0 +1,99 @@
+import { isPlaytester } from './playtester.js';
+/**
+ * THE VERBS A PLAYER MAY TYPE, in one place.
+ *
+ * This table WAS a private static on Game, read only by the help screen.
+ * Tab needed the same list (yaw2btNX8aNEEF9D3, Maka: "If someone presses
+ * 'tab' with nothing in the input box, the first list to reference is
+ * the 'command' list"), and a second hand-maintained copy of ~180 verbs
+ * is a copy that drifts -- so it moved here and `help` reads it from
+ * here too. There is exactly one list.
+ *
+ * ALIASES ARE FIRST-CLASS. Each entry is [primary, ...aliases], and help
+ * prints them as "primary (alias, alias)". Tab must match all of them:
+ * somebody typing "inventor<Tab>" is reaching for `inventory`, which is
+ * an alias of `inv`, and a completer that only knew primaries would
+ * leave them stuck on a word that works.
+ */
+export const HELP_CATEGORIES = [
+    { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
+    { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['loot'], ['drop'], ['give'], ['store'], ['open'], ['close'], ['put'], ['equip'], ['unequip'], ['fit'], ['unfit'], ['brandish', 'draw'], ['holster'], ['reload'], ['use'], ['read']] },
+    { title: 'combat', entries: [['attack'], ['kill'], ['subdue', 'stun', 'knock'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
+    // The party layer: everyone who walks (or flies, or manifests) at
+    // your side answers to these.
+    // "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'], ['counterspell']] },
+    { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['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).
+    // `sustain` shelves here and not under magic: the command is
+    // technomancer-gated (a sprite task, SR5 p.256) and refuses anyone
+    // else, so the Emerged shelf is where its audience looks.
+    { title: 'resonance', entries: [['compile'], ['decompile'], ['thread'], ['unravel'], ['register'], ['standby'], ['sustain'], ['sprites']] },
+    { title: 'social', entries: [['say'], ['shout'], ['emote', 'me'], ['tell', 'talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
+    { title: 'street', entries: [['abandon'], ['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['garage'], ['pay']] },
+    { title: 'barriers', entries: [['pick'], ['breach'], ['dispel', 'dispell'], ['bluff'], ['unlock'], ['lock']] },
+    { title: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['sin', 'sins', 'papers'], ['initiate', 'submerge'], ['install', 'chrome']] },
+    { title: 'session', entries: [['help'], ['hints'], ['time', 'clock'], ['note'], ['backlog'], ['review'], ['roles'], ['clear'], ['quit', 'exit']] },
+];
+/** Registered but deliberately UNLISTED: reachable as subcommands or
+ *  muscle-memory ("players" folded back under crew after playtesting
+ *  -- "crew players" is the advertised path; the bare verb still
+ *  answers). Without this, the uncategorized sweep resurrects them
+ *  in an "other" bucket. */
+// 'first' and 'apply' exist ONLY to catch the two-word phrasings
+// ("first aid", "apply first aid") that used to die at the parser. As
+// bare words they mean nothing, so they are claimed but not advertised
+// -- `heal` is the verb the help screen teaches.
+// `complete` is what Tab sends (commands/complete.ts) -- a question the
+// input box asks, not a verb anyone types, so it stays out of help.
+export const HIDDEN_VERBS = ['players', 'first', 'apply', 'complete'];
+/** Session verbs that only a play-tester (or admin) can actually use
+ *  -- the server role-gates both and 403s everyone else. Listed in
+ *  help ONLY for a confirmed play-tester; see helpCategories. `roles`
+ *  rides along because it is admin-only, a strictly narrower group. */
+export const PLAYTESTER_VERBS = new Set(['backlog', 'review', 'roles']);
+/**
+ * The help index as THIS account should see it (backlog wave 2, item
+ * D: "let's remove Seattle Backlog for non playtesters"). The backlog
+ * is role-gated on the server and 403s everyone else, so listing it
+ * for every player only advertises a refusal. Hidden unless the
+ * account is a CONFIRMED play-tester -- see utilities/playtester.ts
+ * for why "unknown" (offline, logged out) hides rather than shows,
+ * and why the verb itself stays registered and usable regardless.
+ */
+export function helpCategories() {
+    if (isPlaytester())
+        return HELP_CATEGORIES;
+    return HELP_CATEGORIES.map(c => c.title !== 'session' ? c : {
+        ...c,
+        entries: c.entries.filter(e => !PLAYTESTER_VERBS.has(e[0])),
+    });
+}
+/**
+ * EVERY WORD A PLAYER MAY TYPE AS A FIRST WORD, aliases included, in the
+ * order the help screen shelves them -- so an empty Tab reads like the
+ * help index rather than like an alphabetised dump.
+ *
+ * Role-aware through helpCategories(), for the reason given there: a
+ * completer that offers `backlog` to an account the server will 403 is
+ * advertising a refusal, and Tab is the worst place to learn about one.
+ */
+export function playerVerbs() {
+    return helpCategories().flatMap(c => c.entries.flat());
+}
+/** Which shelf a verb sits on, for the one-line hint Tab prints beside
+ *  it. Falls back to the primary spelling for an alias, because "walk"
+ *  is more useful annotated "moving -- see move" than not at all. */
+export function verbShelf(verb) {
+    for (const c of HELP_CATEGORIES) {
+        for (const entry of c.entries) {
+            if (entry.includes(verb))
+                return { category: c.title, primary: entry[0] };
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=verb-index.js.map

package/package.json

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