@bongos/core 1.20.44 → 1.20.45

package/modules/hall-ui/public/shell.js

@@ -303,6 +303,9 @@
       // stays right whatever `branding.currency.label` is set to. Page is public
       // like /ranks — 'signed' is the same cosmetic "show it once you're in".
       { id: 'economy', label: 'Economy', icon: 'docs', href: '/drachmae', gate: 'signed' },
+      // task 1004473: every skill and every bongos CLI verb, read live. Its page and
+      // both reads behind it are sign-in gated, so 'signed' is the real floor here.
+      { id: 'commands', label: 'Commands', icon: 'docs', href: '/commands', gate: 'signed' },
       { id: 'diagrams', label: 'Diagrams', icon: 'docs', href: '/diagrams', gate: 'signed' },
       { id: 'atlas', label: 'Repo Atlas', icon: 'docs', href: '/atlas', gate: 'member' },
       { id: 'modules', label: 'Modules', icon: 'docs', href: '/modules', gate: 'member' },

package/modules/hall-ui/public/studio.html

@@ -176,7 +176,7 @@
 
 <div id="toast" class="toast" role="status" aria-live="polite" data-visible="0"></div>
 
-<script src="/builders/shell.js?v=2026-09-29-renderdeploy"></script>
+<script src="/builders/shell.js?v=2026-09-30-commands"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/dom-utils.js?v=2026-06-23-contrib"></script>
 <!-- The kit, for its ONE renderer: the full-size ship-time visual figure

package/modules/hall-ui/public/task.html

@@ -57,7 +57,7 @@
 
 <!-- The app shell (sidebar + top bar + footer). Dependency-free; runs at parse
      time so the chrome exists before the deferred page scripts execute. -->
-<script src="/builders/shell.js?v=2026-09-29-renderdeploy"></script>
+<script src="/builders/shell.js?v=2026-09-30-commands"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB) — loaded FIRST so task.js can pull from it. -->

package/modules/hall-ui/public/thinking.html

@@ -138,7 +138,7 @@
   </div>
 </div>
 
-<script src="/builders/shell.js?v=2026-09-29-renderdeploy"></script>
+<script src="/builders/shell.js?v=2026-09-30-commands"></script>
 <script src="/builders/palette.js" defer></script>
 
 <script src="/builders/idea-objects.js?v=2026-09-27-split"></script>

package/modules/hall-ui/public/tweak-editor.html

@@ -140,7 +140,7 @@
 
 <div id="toast" class="toast" role="status" aria-live="polite" data-visible="0"></div>
 
-<script src="/builders/shell.js?v=2026-09-29-renderdeploy"></script>
+<script src="/builders/shell.js?v=2026-09-30-commands"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/dom-utils.js?v=2026-06-23-contrib"></script>
 <script src="/builders/brand-holes.js?v=2026-09-29-aqfix"></script>

package/modules/hall-ui/public/watch.html

@@ -162,7 +162,7 @@
 
 <!-- The app shell (sidebar + top bar). Dependency-free; loaded FIRST so the
      chrome exists before the page script runs. -->
-<script src="/builders/shell.js?v=2026-09-29-renderdeploy"></script>
+<script src="/builders/shell.js?v=2026-09-30-commands"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB) — loaded before watch.js, which pulls from it. -->

package/modules/hall-ui/public/work.html

@@ -171,7 +171,7 @@
 
 <!-- The app shell (sidebar + top bar + footer). Dependency-free; runs at parse
      time so the chrome exists before the deferred page scripts execute. -->
-<script src="/builders/shell.js?v=2026-09-29-renderdeploy"></script>
+<script src="/builders/shell.js?v=2026-09-30-commands"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB) — loaded FIRST so work.js can pull from it. -->

package/modules/hall-ui/records/commands.md

@@ -0,0 +1,11 @@
+# The Commands page, at /commands (task 1004473)
+
+**Every skill and every `bongos` CLI verb on one Docs page, read from the live sources so it cannot drift.** The owner asked for it once task 1004471 hid the rarely used skills from Claude's menu: a skill nobody can see in the menu needs somewhere to be discovered. Five things it settled:
+
+- **Two reads, no list in the page.** The skills come from `GET /specialities/installed-skills` (the specialities module's `installedSkills()`: core + instance + ENABLED-module skills, so a default-off module such as `pixel-art` or `design-styles` shows only where it is on); the verbs from the new core `GET /cli/commands`, which hands over `bin/bongos.js` `VERBS` grouped by its `GROUPS` — the order `bongos --help` prints. Core may not import a module, which is why the page asks for the two halves separately; each fails on its own, so a missing skills list does not take the CLI table down.
+- **The only hand-written thing is the skill GROUP.** `commands-lib.js` `SKILL_GROUPS` places a skill by name or by the module it came from; a skill no group names lands under "Everything else", so a new skill always gets a row. Rows follow the order the group names them (the daily loop reads start → claim → ship), then A–Z.
+- **"Shown to Claude" vs "Type it yourself" is `disable-model-invocation`.** `skills.js` now carries it (`typedOnly`), and `explainSkill()` reports `listed`. Only the literal `true` hides a skill, which is how Claude Code reads the key.
+- **Sign-in is the whole gate.** The page joins `SIGNEDIN_BUILDERS_PAGE_RE`, its nav item is `signed` in Docs, and both reads are `requireBuilder`. Reading the list grants nothing (ADR 0310 §1): every command still meets the server's own rank checks when it runs.
+- **At 760px and below each row is a small card.** Five columns cannot fit a phone and a sideways-scrolling table hides the costs, so `commands.css` stacks the cells under their column names (`data-label`). The CLI tables are `table-layout: fixed` with a 220px command column so the help lines align across the three groups.
+
+Tests: `tests/hall_commands.mjs` (every SKILL.md and every VERBS entry exactly once, against the real tree; the typed-only marker per skill; the default-off modules absent; the route's gate). `docs/onboarding/slash-commands.md` now points here for the project's own list instead of keeping a second, hand-typed one.

package/modules/specialities/skills.js

@@ -92,6 +92,10 @@ function collect(out, dir, source) {
     const entry = { name, description: typeof fm.description === 'string' ? fm.description : '', source };
     for (const [key, field] of Object.entries(PEOPLE_KEYS)) if (typeof fm[key] === 'string' && fm[key]) entry[field] = fm[key];
     if (Array.isArray(fm.requires) && fm.requires.length) entry.requires = fm.requires;
+    // `disable-model-invocation: true` (task 1004471) keeps a skill out of the
+    // menu Claude reads; a person still runs it by typing /name. Only the literal
+    // `true` hides it, which is how Claude Code reads the key (task 1004473).
+    if (fm['disable-model-invocation'] === 'true') entry.typedOnly = true;
     out.set(name, entry);
   }
 }
@@ -150,6 +154,8 @@ function explainSkill(entry) {
     commands,
     needs: Array.isArray(e.requires) ? e.requires : [],
     rank,
+    // Shown to Claude (it can start the skill from plain English) vs typed-only.
+    listed: e.typedOnly !== true,
     derived: { does: !e.plain, reachFor: !e.reachFor, cost: !e.cost },
   };
 }

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.44",
+  "version": "1.20.45",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.20.44",
+      "version": "1.20.45",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.44",
+  "version": "1.20.45",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8377,5 +8377,11 @@
       "id": "1004365",
       "text": "Every store module now comes with a how-to page, and the store refuses to publish one without it."
     }
+  ],
+  "1.20.45": [
+    {
+      "id": "1004473",
+      "text": "The Builders Hall now has a Commands page listing every slash command and every terminal command, with what each does, when to use it and what it costs, including the ones hidden from Claude's menu."
+    }
   ]
 }

package/src/bongos/routes/cli-commands.js

@@ -0,0 +1,49 @@
+// src/bongos/routes/cli-commands.js — every `bongos <verb>` the CLI answers,
+// for the hall's Commands page (task 1004473).
+//
+// WHY A ROUTE. The page is the one place a builder sees every skill AND every
+// CLI command, and both halves must be read from their live source so the list
+// cannot drift from what the tools actually do. The verb table is bin/bongos.js
+// `VERBS` (grouped by its `GROUPS`, the order `bongos --help` prints); the
+// browser cannot read that file, so this hands it over as data. The skills half
+// comes from the specialities module's GET /specialities/installed-skills —
+// core must not import a module, so the page asks for the two halves separately.
+//
+// Reading the list grants nothing (ADR 0310 §1): every verb still runs against
+// the server's own rank checks. Sign-in is the floor only because the page it
+// feeds sits on the hall's signed-in tier.
+
+const express = require('express');
+const auth = require('../auth');
+// Side-effect-free: bin/bongos.js only dispatches when it is the main module.
+const cli = require('../../../bin/bongos.js');
+
+/** The CLI's verbs as `bongos --help` groups them: [{ key, label, commands: [{ verb, summary }] }]. */
+function cliCommands(source = cli) {
+  const verbs = Object.entries(source.VERBS || {});
+  const groups = (source.GROUPS || []).map(([key, label]) => ({
+    key,
+    label,
+    commands: verbs.filter(([, def]) => def.group === key).map(([verb, def]) => ({ verb, summary: def.summary })),
+  }));
+  // A verb whose group `GROUPS` does not name still exists, so it still gets a row.
+  const known = new Set(groups.map((g) => g.key));
+  const stray = verbs.filter(([, def]) => !known.has(def.group));
+  if (stray.length) groups.push({ key: 'other', label: 'Other', commands: stray.map(([verb, def]) => ({ verb, summary: def.summary })) });
+  return groups.filter((g) => g.commands.length);
+}
+
+function buildCliCommandsRouter() {
+  const router = express.Router();
+
+  // GET /cli/commands — the bongos CLI's verbs, grouped like `bongos --help`.
+  // rank: any builder — read-only reference; the hall's Commands page is sign-in gated.
+  router.get('/cli/commands', auth.requireBuilder, (_req, res) => {
+    res.json({ version: cli.VERSION, groups: cliCommands() });
+  });
+
+  return router;
+}
+
+module.exports = buildCliCommandsRouter;
+module.exports.cliCommands = cliCommands;

package/src/bongos/routes.js

@@ -56,6 +56,8 @@ const buildSecurityRouter = require('./routes/security');
 // the submit-for-review front door. Core (not module-owned): it manages
 // EVERY module's enablement, including modules it must not import.
 const buildModulesRouter = require('./routes/modules');
+// The hall Commands page's CLI half (task 1004473): bin/bongos.js VERBS as data.
+const buildCliCommandsRouter = require('./routes/cli-commands');
 // The access-request ADMISSION routes carved to modules/onboarding/ (BV1.R81 /
 // ADR 0093 §1); moduleLoader.mountModuleRoutes (below) mounts them via the
 // onboarding module's route factory — no core require.
@@ -159,6 +161,7 @@ function buildGdsRouter() {
   router.use(buildAuditLogRouter());
   router.use(buildSecurityRouter());
   router.use(buildModulesRouter());
+  router.use(buildCliCommandsRouter());
   // access-requests (admission) is now mounted by the onboarding module via
   // moduleLoader.mountModuleRoutes below (BV1.R81) — still BEFORE the public
   // router, so its paths are byte-identical. The /sessions data plane is

package/src/bongos/serve-internal.js

@@ -1210,8 +1210,11 @@ function mountInternalSurfaces(app) {
   // own room beside the studio, on the studio's tier. Its read (GET
   // /copy-desk/pages/:pageId/draft) is any-builder like the .docx download, and
   // every write is the page claim's holder only, checked server-side.
+  // task 1004473: `commands`, the Commands page — every skill and every bongos CLI
+  // verb. Both reads behind it are requireBuilder, so it sits on this tier;
+  // reading the list grants nothing (ADR 0310 §1).
   const SIGNEDIN_BUILDERS_PAGE_RE =
-    /^\/builders\/(?:work|settings|atlas|modules|goals|goal-map|roadmap|copy-desk|studio|tweak-editor|ideas|thinking|collab|task|idea|primer(?:\.md)?|diagrams)(?:\.html)?\/?$/;
+    /^\/builders\/(?:work|settings|atlas|modules|goals|goal-map|roadmap|copy-desk|studio|tweak-editor|ideas|thinking|collab|task|idea|primer(?:\.md)?|diagrams|commands)(?:\.html)?\/?$/;
   // The diagram image assets under /builders/diagrams/ ride the same tier as the
   // page that embeds them.
   const SIGNEDIN_BUILDERS_PREFIX_RE = /^\/builders\/diagrams\//;

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.20.44'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.45'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/hall_commands.mjs

@@ -0,0 +1,162 @@
+// tests/hall_commands.mjs — the hall's Commands page (task 1004473): one table
+// of every skill and one of every bongos CLI verb, read from live sources.
+//
+// The done-when pins: every SKILL.md the instance has, and every bin/bongos.js
+// VERBS entry, appears on the page EXACTLY once. They are checked against the
+// real tree — the same installedSkills()+explainSkill() the
+// /specialities/installed-skills route serves, and the same cliCommands() the
+// /cli/commands route serves — rendered through the page's own lib.
+//
+// Run:  node --test tests/hall_commands.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const lib = require('../modules/hall-ui/public/commands-lib.js');
+const kit = require('../modules/hall-ui/public/hall-kit.js');
+const skills = require('../modules/specialities/skills.js');
+const { VERBS, GROUPS } = require('../bin/bongos.js');
+const esc = kit.esc;
+
+// Every SKILL.md on disk, by name: core .claude/skills/ plus every module's skills/.
+function skillDirsOnDisk({ modules = () => true } = {}) {
+  const out = [];
+  const scan = (dir) => {
+    let names = [];
+    try { names = fs.readdirSync(dir); } catch { return; }
+    for (const n of names) if (fs.existsSync(path.join(dir, n, 'SKILL.md'))) out.push({ name: n, md: path.join(dir, n, 'SKILL.md') });
+  };
+  scan(path.join(ROOT, '.claude', 'skills'));
+  for (const key of fs.readdirSync(path.join(ROOT, 'modules'))) if (modules(key)) scan(path.join(ROOT, 'modules', key, 'skills'));
+  return out;
+}
+
+// What the route hands the page: installedSkills() explained, exactly as
+// GET /specialities/installed-skills builds it.
+function servedSkills(isModuleEnabled) {
+  return [...skills.installedSkills({ coreRoot: ROOT, isModuleEnabled })]
+    .map(([name, entry]) => skills.explainSkill({ name, ...entry }));
+}
+
+const count = (html, attr, value) => html.split(`${attr}="${value}"`).length - 1;
+
+test('every SKILL.md in the tree appears on the page exactly once (every module on)', () => {
+  const html = lib.skillsTableHtml(lib.groupSkills(servedSkills(() => true)), { esc });
+  const onDisk = skillDirsOnDisk();
+  assert.ok(onDisk.length >= 48, `expected the real skill tree, found ${onDisk.length}`);
+  for (const { name } of onDisk) assert.equal(count(html, 'data-skill', name), 1, `/${name} should appear exactly once`);
+  assert.equal(count(html, 'data-skill', ''), 0, 'no nameless row');
+  assert.equal(html.split('data-skill="').length - 1, new Set(onDisk.map((s) => s.name)).size, 'no row that is not a SKILL.md');
+});
+
+test('a default instance shows its enabled modules\' skills and NOT a disabled module\'s', () => {
+  const defaults = (key) => {
+    try { return JSON.parse(fs.readFileSync(path.join(ROOT, 'modules', key, 'module.json'), 'utf8')).default === true; } catch { return false; }
+  };
+  const html = lib.skillsTableHtml(lib.groupSkills(servedSkills(defaults)), { esc });
+  for (const { name } of skillDirsOnDisk({ modules: defaults })) assert.equal(count(html, 'data-skill', name), 1, `/${name} should appear exactly once`);
+  for (const { name } of skillDirsOnDisk({ modules: (k) => k === 'pixel-art' || k === 'design-styles' })) {
+    if (fs.existsSync(path.join(ROOT, '.claude', 'skills', name, 'SKILL.md'))) continue;
+    assert.equal(count(html, 'data-skill', name), 0, `/${name} ships in a default-off module, so it must not be listed`);
+  }
+});
+
+test('each row carries the SKILL.md plain / reach-for / cost words', () => {
+  const served = servedSkills(() => true);
+  const html = lib.skillsTableHtml(lib.groupSkills(served), { esc });
+  const ship = served.find((s) => s.name === 'builder-ship');
+  const fm = skills.parseFrontmatter(fs.readFileSync(path.join(ROOT, '.claude/skills/builder-ship/SKILL.md'), 'utf8'));
+  assert.equal(ship.does, fm.plain);
+  assert.equal(ship.reachFor, fm['reach-for']);
+  assert.equal(ship.cost, fm.cost);
+  for (const v of [fm.plain, fm['reach-for'], fm.cost]) assert.ok(html.includes(esc(v)), `page shows: ${v}`);
+});
+
+test('the "type it yourself" marker follows disable-model-invocation, skill by skill', () => {
+  const served = servedSkills(() => true);
+  const html = lib.skillsTableHtml(lib.groupSkills(served), { esc });
+  let typed = 0;
+  for (const { name, md } of skillDirsOnDisk()) {
+    const hidden = skills.parseFrontmatter(fs.readFileSync(md, 'utf8'))['disable-model-invocation'] === 'true';
+    if (hidden) typed++;
+    const row = html.slice(html.indexOf(`data-skill="${name}"`)).split('</tr>')[0];
+    assert.match(row, hidden ? /cmd-how--typed/ : /cmd-how--listed/, `/${name}: ${hidden ? 'typed-only' : 'shown to Claude'}`);
+  }
+  assert.ok(typed > 0, 'the tree has typed-only skills (task 1004471), so the marker is exercised');
+});
+
+test('a skill no group names still gets a row, under Everything else', () => {
+  const groups = lib.groupSkills([{ name: 'brand-new-skill', source: 'core', does: 'x' }, { name: 'builder-ship', source: 'core' }]);
+  assert.deepEqual(groups.map((g) => g.key), ['loop', 'other']);
+  assert.equal(lib.groupKeyOf({ name: 'otb-tile-generate', source: 'module:pixel-art' }), 'design', 'a module\'s skills land in its group');
+  const loop = lib.groupSkills([{ name: 'builder-ship' }, { name: 'builder-claim' }, { name: 'builder-start' }].map((x) => ({ ...x, source: 'core' })));
+  assert.deepEqual(loop[0].skills.map((x) => x.name), ['builder-start', 'builder-claim', 'builder-ship'], 'the loop reads in the order you work it');
+});
+
+test('row text is escaped — a skill cannot inject markup into the hall', () => {
+  const html = lib.skillsTableHtml(lib.groupSkills([{ name: 'x', source: 'core', does: '<img src=x onerror=alert(1)>' }]), { esc });
+  assert.ok(!html.includes('<img'), html);
+});
+
+const { cliCommands } = require('../src/bongos/routes/cli-commands.js');
+
+test('every bin/bongos.js VERBS entry appears exactly once, grouped like `bongos --help`', () => {
+  const groups = cliCommands();
+  const html = lib.cliTableHtml(groups, { esc });
+  for (const verb of Object.keys(VERBS)) assert.equal(count(html, 'data-verb', verb), 1, `bongos ${verb} should appear exactly once`);
+  assert.equal(html.split('data-verb="').length - 1, Object.keys(VERBS).length, 'no row that is not a verb');
+  assert.deepEqual(groups.map((g) => g.label), GROUPS.map(([, label]) => label), 'the help\'s group order');
+  for (const g of groups) for (const c of g.commands) assert.equal(c.summary, VERBS[c.verb].summary, `${c.verb}: the help line, verbatim`);
+});
+
+test('a verb in a group GROUPS does not name is still listed', () => {
+  const groups = cliCommands({ GROUPS: [['work', 'Work']], VERBS: { a: { group: 'work', summary: 'A' }, b: { group: 'new', summary: 'B' } } });
+  assert.deepEqual(groups.map((g) => [g.key, g.commands.map((c) => c.verb)]), [['work', ['a']], ['other', ['b']]]);
+});
+
+test('GET /cli/commands serves the verbs to a signed-in builder and refuses a stranger', async () => {
+  const auth = require('../src/bongos/auth.js');
+  const express = require('express');
+  const build = require('../src/bongos/routes/cli-commands.js');
+  const serve = async (app, fn) => {
+    const server = http.createServer(app);
+    await new Promise((r) => server.listen(0, '127.0.0.1', r));
+    try { return await fn(`http://127.0.0.1:${server.address().port}`); } finally { server.close(); }
+  };
+
+  const saved = auth.requireBuilder;
+  auth.requireBuilder = (req, _res, next) => { req.builder = { id: 1, rank: 'xenos' }; next(); };
+  let signedIn;
+  try {
+    const app = express();
+    app.use(build());
+    signedIn = await serve(app, async (base) => { const r = await fetch(`${base}/cli/commands`); return { status: r.status, body: await r.json() }; });
+  } finally { auth.requireBuilder = saved; }
+  assert.equal(signedIn.status, 200);
+  assert.deepEqual(signedIn.body.groups.flatMap((g) => g.commands.map((c) => c.verb)).sort(), Object.keys(VERBS).sort());
+
+  const gated = express();
+  gated.use((req, res, next) => { res.fail = (code, st) => res.status(typeof st === 'number' ? st : 401).json({ error: code }); next(); });
+  gated.use(build());
+  const stranger = await serve(gated, async (base) => (await fetch(`${base}/cli/commands`)).status);
+  assert.ok(stranger === 401 || stranger === 403, `no session → refused (got ${stranger})`);
+});
+
+test('the page is wired: nav entry in Docs, sign-in gated, both reads, no hand-typed command', () => {
+  const page = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/commands.html'), 'utf8');
+  const js = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/commands.js'), 'utf8');
+  assert.match(js, /\/api\/bongos\/specialities\/installed-skills/);
+  assert.match(js, /\/api\/bongos\/cli\/commands/);
+  assert.ok(!/data-skill=|data-verb=|\/builder-ship|bongos claim/.test(page), 'the HTML names no command — the rows are generated');
+  const shell = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/shell.js'), 'utf8');
+  assert.match(shell, /id: 'commands', label: 'Commands', icon: 'docs', href: '\/commands', gate: 'signed'/);
+  const serveInternal = fs.readFileSync(path.join(ROOT, 'src/bongos/serve-internal.js'), 'utf8');
+  assert.match(serveInternal.match(/const SIGNEDIN_BUILDERS_PAGE_RE =\s*(\/.*\/);/)[1], /\|commands\)/);
+});

package/tests/hall_nav.mjs

@@ -285,8 +285,10 @@ test('sidebar groups read by audience, in order', () => {
   // what made this group read as one real page plus a link into the home page.
   assert.deepEqual(nav[2].items.map((i) => i.id), ['collab', 'roster'], 'Community = everyone else, in this project');
   assert.ok(!nav.flatMap((g) => g.items).some((i) => /^\/people\b/.test(i.href)), 'no nav item points at the deleted /people');
+  // task 1004473: 'commands' — every skill and CLI verb, read live — is reference
+  // material that reads the same for every builder, so it joins Docs.
   assert.deepEqual(nav[3].items.map((i) => i.id),
-    ['primer', 'ranks', 'economy', 'diagrams', 'atlas', 'modules', 'apidocs'], 'Docs = reference material');
+    ['primer', 'ranks', 'economy', 'commands', 'diagrams', 'atlas', 'modules', 'apidocs'], 'Docs = reference material');
   // 'government' (the Permissions tab, BV1.R113) is the group's one archon-gated item.
   // 'project-settings' joins the Government group at the metic floor (task 1003280,
   // goal 1000072) — it sits before 'government', which is the one archon-only item.

package/tests/hall_page_gate_map.mjs

@@ -46,6 +46,9 @@ const ORACLE = {
   '/builders/settings': 'requireBuilderPage',
   '/builders/atlas': 'requireBuilderPage',
   '/builders/modules': 'requireBuilderPage',
+  // task 1004473: the Commands page — its two reads (installed skills, CLI verbs)
+  // are requireBuilder, so sign-in is the whole gate.
+  '/builders/commands': 'requireBuilderPage',
   '/builders/goals': 'requireBuilderPage',
   // task 1003479: the goal map, on the goal board's tier. task 1004232 (sky part 4):
   // the URL now serves THE PROJECT SKY (the same page as /thinking, in its whole-project

package/tests/hall_tweak_editor.mjs

@@ -635,7 +635,7 @@ try {
     assert.match(HTML, /<body data-page="tweak-editor"[^>]*data-fullscreen-switch/);
     assert.equal((HTML.match(/<h1\b/g) || []).length, 1);
     assert.ok(HTML.indexOf('tweak-editor-lib.js') < HTML.indexOf('tweak-editor.js?'), 'the lib loads first');
-    assert.match(HTML, /shell\.js\?v=2026-09-29-renderdeploy/);
+    assert.match(HTML, /shell\.js\?v=2026-09-30-commands/);
     assert.equal(/fonts\.googleapis\.com\/css/.test(HTML), false);
     for (const id of ['tw-bar', 'tw-counter', 'tw-open', 'tw-open-more', 'tw-divider', 'tw-openwrap', 'tw-open-menu', 'tw-open-tab', 'tw-open-split', 'tw-frame', 'tw-frame-view', 'tw-split-close', 'tw-download', 'tw-upload', 'tw-file', 'tw-submit', 'tw-paper', 'tw-doc', 'tw-notice', 'tw-done', 'tw-take', 'tw-pick', 'tw-picks', 'tw-refused', 'tw-refused-title', 'tw-refused-list', 'tw-refused-next', 'tw-refused-download', 'tw-refused-close']) {
       assert.ok(new RegExp(`id="${id}"`).test(HTML), `#${id} is in the markup`);

package/tests/nav_permission_atoms.mjs

@@ -87,7 +87,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the file and left the query alone, so a returning browser kept the cached copy —
 // a fix that reaches nobody looks identical to a fix that does not work.
 
-const SHELL_SHA = 'dd33737d54dccbb4';
+const SHELL_SHA = '4e14115a3737db9a';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);