@bongos/core 1.23.6 → 1.23.7

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/bongos/package-core.js",
-  "core_version": "1.23.6",
-  "core_contract": "1.23.6",
-  "source_commit": "05ce1a9370fbfc0af9f835a707c5c9ee9988be52",
+  "core_version": "1.23.7",
+  "core_contract": "1.23.7",
+  "source_commit": "b3d8fd1d43987850a49b0262cddfb454592c3baa",
   "source_ref": "HEAD",
-  "built_at": "2026-10-26T23:35:18.876Z",
+  "built_at": "2026-10-26T23:49:17.830Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 616,
     "agent_docs_stubbed": 29,
-    "functional_verbatim": 3557,
+    "functional_verbatim": 3560,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 4203,
-  "tree_sha256": "4f3b55cbbaaa3543f5aff4f5f6e26626e2fb433745b649921fcea34837f302f2",
+  "file_count": 4206,
+  "tree_sha256": "a3771c367fe15a46a3890c73c3a51d5233d9722c445cef33b41f0c5c2689906a",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2937,12 +2937,12 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "8d3fd9e42419ebfcd1642f42725dd24c60efc03a8aafc88c9f022ab90c0152d6"
+      "sha256": "91bc98777d143a46a4acdb3afc7662f9b6069fd5d2954f6b9aefd03d1d327f87"
     },
     {
       "path": "docs/modules-contract.md",
       "mode": "0000644",
-      "sha256": "a54fc56cc901d2580c71138906b4b27eb16529438dbfc3b293a1242cab783477"
+      "sha256": "1ca002715220c25f7d270c3d87d3a5827454f4abec0f6ea813f9935d1b4ced2c"
     },
     {
       "path": "docs/onboarding/diagrams/01-task-lifecycle.mmd",
@@ -10837,12 +10837,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "d399eed08dca874f7e3a4f6daecaeebbff9d9d7d99896cfbc23c992786d0b9f5"
+      "sha256": "b2707b768f0b92534351f237e4c1f2ad46894471f0f639f770bfa0b361fa584f"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "91e4472ae55582eec26d9e0c1264e8fd5c4132441fb6bffdf10a3b90c1ddcdbb"
+      "sha256": "2e911efb9044f425ef86de18b03ccadf10913f7db81eac836fc07ab901bd2011"
     },
     {
       "path": "public-docs/index.html",
@@ -10862,7 +10862,7 @@
     {
       "path": "release-notes.json",
       "mode": "0000644",
-      "sha256": "20ffa719f32b7a90a464a880922c08e19de95ebee64d5703168ff7d2aa9db69c"
+      "sha256": "56aff299cc54f61132be2b6d1877e50cc35282ed1e759726246d0ae0f131f343"
     },
     {
       "path": "scripts/bongos/CLAUDE.md",
@@ -11734,6 +11734,11 @@
       "mode": "0000644",
       "sha256": "0334f9d2e31559bbc661ae0be5404499719d76e670560fa5f4ba72d7c14d0ac7"
     },
+    {
+      "path": "scripts/bongos/module-remove.js",
+      "mode": "0000644",
+      "sha256": "9470fb2f45b4cd1d8467bc590de324a87365b7449f0d0bf74ab9baa7b65e8585"
+    },
     {
       "path": "scripts/bongos/module-store-cli.js",
       "mode": "0000644",
@@ -11757,7 +11762,7 @@
     {
       "path": "scripts/bongos/module.js",
       "mode": "0000644",
-      "sha256": "f771cd502f959a281f4aaf60b65b19c240c5a5f7828a030001f7f01fcc75b222"
+      "sha256": "34b1c30a3192d28f0260950e88f27a2bb44077d7917987697b9cdbb4093b590b"
     },
     {
       "path": "scripts/bongos/move-escalation.js",
@@ -13404,6 +13409,11 @@
       "mode": "0000644",
       "sha256": "053d6df274f015359f4eb52361aae55857f643672fc3746c941bfed348092b21"
     },
+    {
+      "path": "scripts/gds/module-remove.js",
+      "mode": "0000644",
+      "sha256": "26c003efeb97c9ed3860dbcd9d35132828e55655b5f911bc7767aac82768b5b2"
+    },
     {
       "path": "scripts/gds/module-store-cli.js",
       "mode": "0000644",
@@ -14727,7 +14737,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "9c9c3ae365588e980585b171efb35ea63dcad8d21c8a6b8e3e5a9bf140d7dd34"
+      "sha256": "6b5b56cd550854c711eef1cd99f72c7c7f52a781bb0b6391845ff8a3fb1f78c9"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -18489,6 +18499,11 @@
       "mode": "0000644",
       "sha256": "51ba43c92ccd963cead34b5cad855fc4d19b4698e9a27bacaa904cd999776f9e"
     },
+    {
+      "path": "tests/module_remove.mjs",
+      "mode": "0000644",
+      "sha256": "c9557ecb6efe346334e6d190a41b04efad156bdf5c7ce773e01ccb35e31e5124"
+    },
     {
       "path": "tests/module_route_rank.mjs",
       "mode": "0000644",

package/docs/module-api-changelog.md

@@ -3229,5 +3229,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.23.4 with no explicit bump. run 40417462733. (task 1002620)
   1.23.6 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.23.5 with no explicit bump. run 40420658396. (task 1002620)
+  1.23.7 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.23.6 with no explicit bump. run 40422218359. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/docs/modules-contract.md

@@ -424,6 +424,8 @@ Run `bongos upgrade` to confirm coreVersion compatibility, then `node scripts/bo
 - The new version is written beside the old one and swapped in; any failure leaves the installed version in place. Files the new version dropped are gone afterwards.
 - The on/off switch is untouched. A module bundled with the core is refused; it updates with the core (`bongos upgrade`).
 
+`bongos module remove <key>` (task 1004896) takes a store module off this project. It refuses a core-shipped module, a module that is switched on (in config/env, or in the hall's Modules tab when the server answers), and a key the store does not know — that is the project's own code, not a store copy. It never deletes: the folder moves to `var/removed-modules/<key>-<version>-<stamp>/` (git-ignored), and the output says how to put it back. The module's database tables are left in place, so reinstalling brings its data back (owner, 2026-10-26), and the entitlement is untouched, so `bongos module install` puts it back without paying again. Nothing on the server is written: update checks and install reports read the modules on disk.
+
 **`bongos upgrade` says which installed modules have an update** (task 1003787), below its compatibility rows, so one command answers "what is stale here" for the core and its modules. It asks `GET /store/modules/latest?keys=…` for the newest version of every module here with an exact version — a read that takes no entitlement — and lists each newer one with `bongos module update <key>`, or says it waits for the core when that version needs a newer one. A delisted module is flagged as getting no further versions (ADR 0338 D2). None of this changes the exit code: an incompatible enabled module still blocks and nothing else does. With no session or no reachable store it says "not checked" and the pre-check stands; `--no-store` skips the read.
 
 ## Carving an existing core domain (the `db.js` per-domain pattern)

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.23.6",
+  "version": "1.23.7",
   "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

@@ -10423,5 +10423,11 @@
       "id": "1003359",
       "text": "People checking whether someone has applied to a project can no longer tell a pending, declined or never-filed request apart, and the sign-in tool no longer promises an approval that may never come."
     }
+  ],
+  "1.23.7": [
+    {
+      "id": "1004896",
+      "text": "Builders can now take a module they installed from the store back off their project with one command; its folder is kept aside so nothing is lost."
+    }
   ]
 }

package/scripts/bongos/module-remove.js

@@ -0,0 +1,122 @@
+'use strict';
+//
+// scripts/bongos/module-remove.js — `bongos module remove <key>`: take a module this
+// project installed from the store back off it (task 1004896, goal 1000091).
+//
+// WHY it moves the folder aside instead of deleting it. Install places a store
+// module under the instance's own modules/, which is also where a project keeps the
+// modules it builds itself; the only thing that tells the two apart is whether the
+// store knows the key. A wrong guess must cost nothing, so the folder is MOVED to
+// var/removed-modules/<key>-<version>-<stamp>/ and the command says where: putting it
+// back is one move, and deleting it for good is a separate, deliberate step.
+//
+// What it refuses, before touching anything:
+//   - a module the core ships (it is the core's, not this project's);
+//   - a module that is switched on — in config/env here, or in the hall's on/off
+//     switch when the server answers — because the loader would mount a module whose
+//     files are gone;
+//   - a key the store does not know: that is this project's own code, not a store copy.
+// What it leaves alone, on purpose (owner, 2026-10-26): the module's database tables
+// (reinstalling brings the data back; the output says so), and the entitlement (a
+// paid module can be installed again without paying twice). Nothing on the server is
+// written: update checks and install reports read the modules on disk, so once the
+// folder is gone they stop on their own.
+//
+// It lives in its own file because scripts/bongos/module.js sits near the 1,500-line
+// ratchet; module.js dispatches to it and re-exports cmdRemove.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { KEY_RE } = require('../../src/module-loader/manifest-schema');
+
+const REMOVE_USAGE = 'usage: bongos module remove <key>';
+
+// Where removed folders go: <instance root>/var/removed-modules (beside the other
+// instance-local state the core keeps under var/, never inside the core package).
+function removedModulesDir(instanceRoot) {
+  return path.join(instanceRoot, 'var', 'removed-modules');
+}
+
+// A filesystem-safe timestamp for the parked folder's name. Pure.
+function stamp(now) {
+  return now.toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
+}
+
+// Is the key switched on in the hall's switch? true / false, or null when the
+// server could not say (offline, older core) — then the local verdict stands.
+async function hallEnabled(call, key) {
+  try {
+    const res = await call('GET', '/modules');
+    if (!res.ok || !res.data || !Array.isArray(res.data.modules)) return null;
+    const row = res.data.modules.find((m) => m.key === key);
+    return row ? row.enabled === true : null;
+  } catch { return null; }
+}
+
+async function cmdRemove(args, {
+  log = console.log, errlog = console.error,
+  gather, request, storeRequest, storeError,
+  instanceRoot = require('../../src/instance-config').resolveInstanceRoot(),
+  now = () => new Date(),
+} = {}) {
+  const key = args[0];
+  if (!key || key.startsWith('--') || !KEY_RE.test(key)) {
+    errlog('bongos module remove: name the module — a lowercase kebab-case key');
+    errlog(REMOVE_USAGE);
+    return 2;
+  }
+
+  const dir = path.join(instanceRoot, 'modules', key);
+  let rows = [];
+  try { rows = gather().rows; } catch (e) { errlog(`bongos module remove: ${e.message}`); return 1; }
+  const row = rows.find((r) => r.key === key);
+  if (row && row.source === 'core') {
+    errlog(`REFUSING: "${key}" ships with the core, not from the store. Switch it off instead if you do not want it.`);
+    return 1;
+  }
+  if (!fs.existsSync(dir)) {
+    errlog(`REFUSING: "${key}" is not installed in this project (no modules/${key}/ folder).`);
+    return 1;
+  }
+  if (row && row.enabled) {
+    errlog(`REFUSING: "${key}" is switched on. Switch it off first — remove "${key}": true from config/modules.json (or its <PREFIX>_MODULE_ setting) — then run this again.`);
+    return 1;
+  }
+
+  let call;
+  try { call = request || storeRequest(); }
+  catch (e) { errlog(`bongos module remove: ${e.message}`); return 1; }
+  if (await hallEnabled(call, key) === true) {
+    errlog(`REFUSING: "${key}" is switched on in the hall's Modules tab. Switch it off there first, then run this again.`);
+    return 1;
+  }
+  let res;
+  try { res = await call('GET', `/store/modules/${encodeURIComponent(key)}/listing`); }
+  catch (e) { errlog(`bongos module remove: the store could not be reached — ${e.message}`); return 1; }
+  if (res.status === 404) {
+    errlog(`REFUSING: the store has no module "${key}", so modules/${key}/ is this project's own code, not a store copy. Nothing was moved; delete it by hand if you mean to.`);
+    return 1;
+  }
+  if (!res.ok) { errlog(`bongos module remove: the store answered ${storeError(res)}`); return 1; }
+
+  const version = (row && row.version) || 'unknown';
+  const parked = path.join(removedModulesDir(instanceRoot), `${key}-${version}-${stamp(now())}`);
+  try {
+    fs.mkdirSync(path.dirname(parked), { recursive: true });
+    // A `*` .gitignore, so a parked folder never dirties the instance tree that
+    // `bongos upgrade` requires clean (the var/task-visuals precedent, task 1004381).
+    const ignore = path.join(path.dirname(parked), '.gitignore');
+    if (!fs.existsSync(ignore)) fs.writeFileSync(ignore, '*\n');
+    fs.renameSync(dir, parked);
+  } catch (e) {
+    errlog(`bongos module remove: could not move modules/${key}/ aside — ${e.message}. Nothing was removed.`);
+    return 1;
+  }
+  log(`✓ Removed "${key}" ${version} from this project.`);
+  log(`  Its folder was moved to ${path.relative(instanceRoot, parked)} — move it back to modules/${key}/ to undo, or delete it when you are sure.`);
+  log('  Its database tables were left in place, so reinstalling brings its data back.');
+  log(`  You still own it: \`bongos module install ${key}\` puts it back without buying it again.`);
+  return 0;
+}
+
+module.exports = { cmdRemove };

package/scripts/bongos/module.js

@@ -1070,6 +1070,12 @@ async function cmdPublish(args, {
 // bongos module install <key> — acquire a module from the store (ADR 0338 D1)
 // ---------------------------------------------------------------------------
 
+// `bongos module remove` lives in its own file (task 1004896); this hands it the
+// catalog and the store client it needs.
+function cmdRemove(args, deps = {}) {
+  return require('./module-remove').cmdRemove(args, { gather: gatherCatalog, storeRequest, storeError, ...deps });
+}
+
 // Where install places a module: the INSTANCE's own modules/ root (ADR 0108 §1),
 // which the loader discovers. In a single checkout that is this repo's modules/.
 function instanceModulesDir() {
@@ -1333,6 +1339,7 @@ function printHelp(out = console.log) {
   out('                              What the store lists, best first: above the quality floor, ranked, ten per sub-category');
   out('  bongos module price <key> [--cents N] [--credits N]');
   out('                              Set your module\'s price in the store (0 in either makes it free)');
+  out('  bongos module remove <key>  Take a store module off this project (switch it off first; its folder is kept aside)');
   out('  bongos upgrade [--no-store] Pre-check enabled modules against the core version (fail-closed),');
   out('                              then list newer store versions of installed modules (never blocks)');
   out('  bongos module check <key> [--sign-off "Name <email>"]');
@@ -1354,6 +1361,7 @@ async function main(argv) {
   if (sub === 'list' || sub === 'ls') return cmdList(args.slice(1));
   if (sub === 'store') return cmdStore(args.slice(1));
   if (sub === 'price') return cmdPrice(args.slice(1));
+  if (sub === 'remove') return cmdRemove(args.slice(1));
   if (sub === 'upgrade') return cmdUpgrade(args.slice(1));
   if (sub === 'check') return cmdCheck(args.slice(1));
   if (sub === 'submit') return cmdSubmit(args.slice(1));
@@ -1370,7 +1378,7 @@ async function main(argv) {
 }
 
 module.exports = {
-  main, cmdNew, cmdList, cmdStore, formatStore, cmdPrice, cmdUpgrade, cmdCheck, cmdSubmit, cmdPublish, cmdInstall, cmdUpdate, printHelp,
+  main, cmdNew, cmdList, cmdStore, formatStore, cmdPrice, cmdRemove, cmdUpgrade, cmdCheck, cmdSubmit, cmdPublish, cmdInstall, cmdUpdate, printHelp,
   storeRequest,
   gatherCatalog, formatCatalog, ownProjectName,
   scaffoldModule, gatherUpgrade, evaluateUpgrade, gatherUpdates, evaluateUpdates, buildManifest,

package/scripts/gds/module-remove.js

@@ -0,0 +1,6 @@
+// scripts/gds/module-remove.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/module-remove.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'module-remove.js');

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.23.6'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.23.7'; // 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/module_remove.mjs

@@ -0,0 +1,121 @@
+// tests/module_remove.mjs — `bongos module remove <key>` takes a store module off a
+// project without losing anything (task 1004896, goal 1000091). Runs the real
+// cmdRemove against a throwaway instance folder on disk and a stand-in store: no
+// port, no real DB, no session.
+//
+// Run:  node tests/module_remove.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { cmdRemove } = require('../scripts/bongos/module-remove.js');
+const mod = require('../scripts/bongos/module.js');
+
+function instance() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'module-remove-'));
+  const dir = path.join(root, 'modules', 'weather');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'module.json'), '{"key":"weather","version":"1.2.0"}');
+  fs.writeFileSync(path.join(dir, 'index.js'), 'module.exports = {};');
+  return { root, dir };
+}
+const row = (over = {}) => ({ key: 'weather', source: 'instance', enabled: false, version: '1.2.0', ...over });
+
+// A stand-in store: GET /modules answers the hall's switch, GET .../listing whether
+// the store knows the key. Every call is recorded, so a test can prove nothing was written.
+function store({ hall = false, known = true, reachable = true } = {}) {
+  const calls = [];
+  const request = async (method, url) => {
+    calls.push(`${method} ${url}`);
+    if (!reachable) throw new Error('ECONNREFUSED');
+    if (url === '/modules') return { ok: true, status: 200, data: { modules: hall === null ? [] : [{ key: 'weather', enabled: hall }] } };
+    if (url === '/store/modules/weather/listing') {
+      return known ? { ok: true, status: 200, data: { module_key: 'weather', listed: true } } : { ok: false, status: 404, data: { error: 'module_not_found' } };
+    }
+    return { ok: false, status: 500, data: null };
+  };
+  return { request, calls };
+}
+
+async function run(args, { rows = [row()], st = store(), root } = {}) {
+  const out = [];
+  const err = [];
+  const code = await cmdRemove(args, {
+    log: (l) => out.push(l), errlog: (l) => err.push(l),
+    gather: () => ({ rows }), request: st.request, storeError: (r) => `HTTP ${r.status}`,
+    instanceRoot: root, now: () => new Date('2026-10-26T12:00:00Z'),
+  });
+  return { code, out: out.join('\n'), err: err.join('\n') };
+}
+
+test('a store module that is switched off is moved aside, not deleted, and the output says how to undo it', async () => {
+  const { root, dir } = instance();
+  const st = store();
+  const r = await run(['weather'], { st, root });
+  assert.equal(r.code, 0, r.err);
+  assert.equal(fs.existsSync(dir), false, 'modules/weather/ is gone from the project');
+  const parked = path.join(root, 'var', 'removed-modules', 'weather-1.2.0-20261026T120000Z');
+  assert.equal(fs.readFileSync(path.join(parked, 'index.js'), 'utf8'), 'module.exports = {};', 'every file kept, byte for byte');
+  assert.equal(fs.readFileSync(path.join(root, 'var', 'removed-modules', '.gitignore'), 'utf8'), '*\n', 'the parked folder never dirties the instance tree');
+  assert.match(r.out, /Removed "weather" 1\.2\.0/);
+  assert.match(r.out, /move it back to modules\/weather\/ to undo/);
+  assert.match(r.out, /database tables were left in place/, 'owner decision 2026-10-26: keep the tables');
+  assert.match(r.out, /without buying it again/, 'the entitlement is untouched');
+  assert.ok(st.calls.every((c) => c.startsWith('GET ')), 'nothing on the server is written');
+});
+
+test('a module switched on in config is refused, and nothing moves', async () => {
+  const { root, dir } = instance();
+  const r = await run(['weather'], { rows: [row({ enabled: true })], root });
+  assert.equal(r.code, 1);
+  assert.match(r.err, /is switched on\. Switch it off first/);
+  assert.ok(fs.existsSync(dir));
+});
+
+test('a module switched on only in the hall is refused too', async () => {
+  const { root, dir } = instance();
+  const r = await run(['weather'], { st: store({ hall: true }), root });
+  assert.equal(r.code, 1);
+  assert.match(r.err, /switched on in the hall's Modules tab/);
+  assert.ok(fs.existsSync(dir));
+});
+
+test('a key the store does not know is the project\'s own code: refused, nothing moved', async () => {
+  const { root, dir } = instance();
+  const r = await run(['weather'], { st: store({ known: false }), root });
+  assert.equal(r.code, 1);
+  assert.match(r.err, /this project's own code, not a store copy/);
+  assert.ok(fs.existsSync(dir));
+});
+
+test('a core module, a module not installed, and a bad key are refused', async () => {
+  const { root, dir } = instance();
+  const core = await run(['weather'], { rows: [row({ source: 'core' })], root });
+  assert.equal(core.code, 1);
+  assert.match(core.err, /ships with the core/);
+  const absent = await run(['rain'], { rows: [], root });
+  assert.equal(absent.code, 1);
+  assert.match(absent.err, /not installed in this project/);
+  for (const args of [[], ['--force'], ['Weather']]) assert.equal((await run(args, { root })).code, 2, args.join(' '));
+  assert.ok(fs.existsSync(dir));
+});
+
+test('an unreachable store refuses rather than guessing, and nothing moves', async () => {
+  const { root, dir } = instance();
+  const r = await run(['weather'], { st: store({ reachable: false }), root });
+  assert.equal(r.code, 1);
+  assert.match(r.err, /could not be reached/);
+  assert.ok(fs.existsSync(dir));
+});
+
+test('`bongos module remove` is dispatched and documented in the help', () => {
+  const out = [];
+  mod.printHelp((l) => out.push(l));
+  assert.match(out.join('\n'), /bongos module remove <key>/);
+  assert.equal(typeof mod.cmdRemove, 'function');
+});