@bongos/core 1.19.1074 → 1.19.1076

package/tests/goal_advisory.mjs

@@ -72,16 +72,16 @@ await test("kind='bug' with no goal at all is quiet too — a fix needs no home
 });
 
 await test('a REAL goal is silent — null, not an empty object', () => {
-  assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, dev box, and skills' }), null);
+  assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, onboarding, and skills' }), null);
 });
 
 await test("kind='bug' under a real goal is silent too — already silent, kind changes nothing", () => {
-  assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, dev box, and skills', kind: 'bug' }), null);
+  assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, onboarding, and skills', kind: 'bug' }), null);
 });
 
 // ---- adviseGoal: the third reason — no_criterion_link (task 1003157) ----
 
-const REAL_GOAL_TITLE = 'Builder experience — hall, dev box, and skills';
+const REAL_GOAL_TITLE = 'Builder experience — hall, onboarding, and skills';
 const SOME_CRITERIA = [
   { id: 11, criterion_md: 'Every onboarding page renders under 2s' },
   { id: 12, criterion_md: 'The hall shows a builder their own karma trend' },

package/tests/goal_suggest.mjs

@@ -30,7 +30,7 @@ const { test, summary } = makeRunner();
 const V = 'BONGOS-V1';
 const GOALS = [
   { id: 1000024, title: 'Build-pipeline integrity', scope_modules: ['lifecycle', 'grading'] },
-  { id: 1000025, title: 'Builder experience — hall, dev box, and skills', scope_modules: ['hall-ui', 'dev-box'] },
+  { id: 1000025, title: 'Builder experience — hall, tool box, and skills', scope_modules: ['hall-ui', 'specialities'] },
   { id: 1000071, title: 'Idea routing — work that has a home lands in it', scope_modules: ['ideas', 'discord'] },
   { id: 1000003, title: `${V} — general`, scope_modules: [] },
 ];
@@ -76,8 +76,8 @@ await test('RANKS: ties break by ascending id so a picker renders stably', () =>
 
 await test('LIMIT (known + accepted): token overlap can match on an incidental word', () => {
   // Real example found while building this: "the goals page search BOX is broken"
-  // scores the DEV BOX goal, because both contain the token 'box'. Bag-of-words
-  // matching cannot tell "search box" from "dev box".
+  // scores the "tool box" goal, because both contain the token 'box'. Bag-of-words
+  // matching cannot tell "search box" from "tool box".
   //
   // This is NOT hidden — it is why every suggestion carries `score` and
   // `matched_terms`: a caller can show WHY it matched and a human decides. A

package/tests/government_abuse_matrix.mjs

@@ -365,9 +365,10 @@ test('V8: a forced principal grant resolves to nothing (structurally dropped)',
 });
 
 test('V9: an undeclared session source is refused outright, never treated as "full"', () => {
-  // Rows with source 'box' stay in builder_sessions until task 1003895 deletes them.
-  // They must be undeclared to BOTH loaders, which is what makes requireBuilder and
-  // the page gate refuse them (tests/government_session_scope.mjs runs the gate).
+  // core_258 (task 1003895) deleted the rows with source 'box' and narrowed the source
+  // CHECK to cli/web. 'box' must still be undeclared to BOTH loaders, so a stray row of
+  // that source is refused by requireBuilder and the page gate rather than honoured
+  // (tests/government_session_scope.mjs runs the gate).
   for (const source of ['box', 'not-a-source']) {
     assert.equal(sessionScopes.scopeFor(source), null, `"${source}" must not be a declared session source`);
   }

package/tests/hall_audit.mjs

@@ -464,7 +464,7 @@ test('the colour-literal guard CATCHES a reintroduction, and tolerates a task re
   assert.ok('a { color: #a04040; }'.match(re), 'a bare hex in a colour value is caught');
   assert.ok('x = \'<span style="color:var(--olive,#5b7a4d)">\''.match(colourLiteralRe()),
     'a hex FALLBACK behind a var() is caught — that is how --olive hid');
-  assert.equal('// #807: the dev-box panel'.match(colourLiteralRe()), null,
+  assert.equal('// #807: the ship panel'.match(colourLiteralRe()), null,
     'a task reference in a comment is not a colour');
   assert.equal('a { color: var(--ok); }'.match(colourLiteralRe()), null,
     'a token is exactly what this rule wants');

package/tests/hall_palette.mjs

@@ -28,21 +28,41 @@ const SHELL_SRC = read('shell.js');
 
 // Boot palette.js against a DOM stub whose sidebar carries `navItems`, and whose
 // `visibleIds` decide which section groups are on offer. Returns window.OTBPalette.
-function bootPalette({ navItems = [], visibleIds = ['nav-standing', 'nav-work', 'shell-user'] } = {}) {
+//
+// `registry` memoizes querySelector by selector string (keyed globally within one
+// boot, same as a real single-instance-id contract) so `build()`'s one-time
+// `root.querySelector('#palette-input')` / `'#palette-list'` calls hand back the
+// SAME stub every time — real enough to fire DOM events at and read innerHTML
+// back from, which the pure-compute-only harness never needed before task 1003460
+// wired a real fetch() into the input handler.
+function bootPalette({ navItems = [], visibleIds = ['nav-standing', 'nav-work', 'shell-user'], modules = null, fetchImpl = undefined } = {}) {
+  const registry = {};
   const makeNav = (it) => ({
     hidden: !!it.hidden,
     target: it.external ? '_blank' : '',
     getAttribute: (n) => (n === 'href' ? it.href : null),
     querySelector: (sel) => (sel === '.nav-item__label' ? { textContent: it.label } : null),
   });
-  const stubEl = () => ({
-    hidden: false, dataset: {}, textContent: '', value: '', className: '',
-    classList: { add() {}, remove() {}, contains() { return false; }, toggle() { return false; } },
-    setAttribute() {}, getAttribute() { return null; },
-    addEventListener() {}, appendChild() {}, focus() {}, querySelector() { return stubEl(); },
-    querySelectorAll() { return []; },
-    set innerHTML(_v) {}, get innerHTML() { return ''; },
-  });
+  const stubEl = (sel) => {
+    const listeners = {};
+    const el = {
+      hidden: false, dataset: {}, textContent: '', value: '', className: '',
+      classList: { add() {}, remove() {}, contains() { return false; }, toggle() { return false; } },
+      setAttribute() {}, getAttribute() { return null; },
+      addEventListener(type, fn) { (listeners[type] = listeners[type] || []).push(fn); },
+      fire(type, ev) { (listeners[type] || []).forEach((fn) => fn(ev || {})); },
+      appendChild() {}, focus() {},
+      querySelector(childSel) {
+        if (!registry[childSel]) registry[childSel] = stubEl(childSel);
+        return registry[childSel];
+      },
+      querySelectorAll() { return []; },
+      set innerHTML(v) { this._html = v; },
+      get innerHTML() { return this._html || ''; },
+    };
+    if (sel) registry[sel] = el;
+    return el;
+  };
 
   const documentObj = {
     body: { dataset: { page: 'home' }, appendChild() {} },
@@ -62,17 +82,34 @@ function bootPalette({ navItems = [], visibleIds = ['nav-standing', 'nav-work',
   const windowObj = { location: { hash: '', assign() {} }, addEventListener() {}, open() {} };
   const sandbox = {
     window: windowObj, document: documentObj, navigator: { platform: 'Win32', userAgent: 'test' },
-    console,
+    console, setTimeout, clearTimeout, Promise, JSON, Number, String, Array, Object,
   };
+  if (fetchImpl) sandbox.fetch = fetchImpl;
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
   vm.runInContext(PALETTE_SRC, sandbox, { filename: 'palette.js' });
   // Copy results across the realm boundary — a vm-created array has the sandbox's
   // Array.prototype, which deepStrictEqual rejects even when the values match.
   const P = windowObj.OTBPalette;
-  return { compute: (q) => Array.from(P.compute(q), (e) => ({ ...e })) };
+  return {
+    compute: (q) => Array.from(P.compute(q), (e) => ({ ...e })),
+    contentEntry: (hit) => { const e = P.contentEntry(hit); return e ? { ...e } : e; },
+    open: () => P.open(),
+    close: () => P.close(),
+    listEl: () => registry['#palette-list'],
+    type(value) {
+      const el = registry['#palette-input'];
+      el.value = value;
+      el.fire('input');
+    },
+  };
 }
 
+const tick = (ms = 0) => new Promise((r) => setTimeout(r, ms));
+// Real timers (palette.js's debounce is a real setTimeout) — settle past the
+// 300ms debounce plus a few microtask/macrotask turns for the fetch chain.
+async function settleSearch() { await tick(400); }
+
 const NAV_FIXTURE = [
   { label: 'Home', href: '/' },
   { label: 'Tasks', href: '/work' },
@@ -207,3 +244,179 @@ test('every page that loads the shell also loads the palette', () => {
   const missing = withShell.filter((f) => !/src="\/builders\/palette\.js/.test(read(f)));
   assert.deepEqual(missing, [], 'Ctrl-K must work on every hall page');
 });
+
+// ---- server-backed content search (task 1003460) ---------------------------
+
+const TASK_HIT = { id: 1, source_kind: 'db', source_ref: 'task:1003460', title: "Ctrl-K searches the project's memory", heading_path: null };
+const IDEA_HIT = { id: 2, source_kind: 'db', source_ref: 'idea:42', title: 'A homeless idea' };
+const BLOCKER_HIT = { id: 3, source_kind: 'db', source_ref: 'blocker:7', title: 'Needs the owner' };
+const DOC_HIT = { id: 4, source_kind: 'doc', source_ref: 'docs/adr/0060-gds-retrieval-layer.md', title: 'ADR 0060' };
+const SESSION_LOG_HIT = { id: 5, source_kind: 'db', source_ref: 'session_log:9', title: 'Session log 9 · task 1003460' };
+
+test('contentEntry resolves task/idea/blocker hits to real hall destinations', () => {
+  const P = bootPalette({ navItems: NAV_FIXTURE });
+  assert.deepEqual(
+    { label: P.contentEntry(TASK_HIT).label, href: P.contentEntry(TASK_HIT).href, overlay: !!P.contentEntry(TASK_HIT).overlay },
+    { label: "Ctrl-K searches the project's memory", href: '/task/1003460', overlay: false },
+  );
+  assert.deepEqual(
+    { href: P.contentEntry(IDEA_HIT).href, overlay: P.contentEntry(IDEA_HIT).overlay },
+    { href: '#/idea/42', overlay: true },
+  );
+  assert.deepEqual(
+    { href: P.contentEntry(BLOCKER_HIT).href, overlay: P.contentEntry(BLOCKER_HIT).overlay },
+    { href: '#/blocker/7', overlay: true },
+  );
+});
+
+test('contentEntry drops hits the hall has no page for (doc/session-log/etc)', () => {
+  const P = bootPalette({ navItems: NAV_FIXTURE });
+  assert.equal(P.contentEntry(DOC_HIT), null, 'a repo doc chunk has no hall page to jump to');
+  assert.equal(P.contentEntry(SESSION_LOG_HIT), null, 'a session-log chunk has no hall page to jump to');
+  assert.equal(P.contentEntry(null), null);
+  assert.equal(P.contentEntry({ source_kind: 'db', source_ref: 'commit:abc123' }), null, 'an unrecognized db ref resolves to nothing, not a crash');
+});
+
+test('contentEntry normalizes a dash the way cleanTitle() does everywhere else (V4, docs/voice.md)', () => {
+  // A task/idea/blocker title is quoted ledger data, not copy this project
+  // authored — V4 binds the dash ban to exactly that, enforced at render.
+  const P = bootPalette({ navItems: NAV_FIXTURE });
+  const hit = { source_kind: 'db', source_ref: 'task:99', title: 'V4.R18 — Ctrl-K searches the memory (follow-up)' };
+  assert.equal(P.contentEntry(hit).label, 'V4.R18, Ctrl-K searches the memory');
+});
+
+test('contentEntry truncates a pathologically long indexed title before it becomes markup', () => {
+  const P = bootPalette({ navItems: NAV_FIXTURE });
+  const longTitle = 'x'.repeat(400);
+  const hit = { source_kind: 'db', source_ref: 'task:1', title: longTitle };
+  const label = P.contentEntry(hit).label;
+  assert.ok(label.length <= 120, `label must be capped, got ${label.length} chars`);
+  assert.ok(label.endsWith('…'), 'a truncated label is marked as such');
+});
+
+test('typing prose merges in content matches from POST /api/bongos/search, on top of local matches', async () => {
+  const calls = [];
+  const fetchImpl = async (url, init) => {
+    calls.push({ url, body: JSON.parse(init.body) });
+    return { ok: true, json: async () => ({ query: 'ctrl-k memory', count: 1, results: [TASK_HIT] }) };
+  };
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  P.type('ctrl-k memory');
+  // Local compute() ran synchronously — pages/sections still searchable immediately.
+  assert.deepEqual(P.compute('ctrl-k memory'), [], 'sanity: no local page/section matches this prose');
+
+  await settleSearch();
+
+  assert.equal(calls.length, 1, 'exactly one debounced request, not one per keystroke');
+  assert.equal(calls[0].url, '/api/bongos/search');
+  assert.equal(calls[0].body.q, 'ctrl-k memory');
+  assert.equal(calls[0].body.source_kind, 'db', 'a doc/session-log/etc hit would only ever be dropped by contentEntry — ask the server to not spend the result budget on it');
+  assert.match(P.listEl().innerHTML, /Content/, 'the merged row carries the Content group');
+  assert.match(P.listEl().innerHTML, /Ctrl-K searches the project&#39;s memory/, 'and the task title from the server hit');
+});
+
+test('killing the search endpoint leaves the palette exactly as useful as today', async () => {
+  const fetchImpl = async () => { throw new Error('endpoint is down'); };
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  P.type('economy');
+  const beforeHtml = P.listEl().innerHTML;
+  assert.match(beforeHtml, /Economy/, 'the local page match rendered synchronously');
+
+  await settleSearch();
+
+  assert.equal(P.listEl().innerHTML, beforeHtml, 'a failed fetch changes nothing — no error row, no crash');
+});
+
+test('a 404 (endpoint removed) degrades the same as a network failure', async () => {
+  const fetchImpl = async () => ({ ok: false, status: 404, json: async () => ({ error: 'not_found' }) });
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  P.type('economy');
+  const beforeHtml = P.listEl().innerHTML;
+
+  await settleSearch();
+
+  assert.equal(P.listEl().innerHTML, beforeHtml);
+});
+
+test('a query under SEARCH_MIN_LEN never calls the endpoint at all', async () => {
+  let called = false;
+  const fetchImpl = async () => { called = true; return { ok: true, json: async () => ({ results: [] }) }; };
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  // 2 chars, not 1: the endpoint's least-selective case (falls through FTS to an
+  // unindexed trigram scan plus a zero-result corpusHealth() probe) is exactly
+  // the length this gate exists to keep off the wire.
+  P.type('ab');
+
+  await settleSearch();
+
+  assert.equal(called, false, 'two characters is not worth the endpoint\'s worst-case query plan');
+});
+
+test('closing the palette invalidates an in-flight search — it cannot land after close', async () => {
+  let resolveFetch;
+  const fetchImpl = () => new Promise((resolve) => { resolveFetch = resolve; });
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  P.type('ctrl-k memory');
+  await tick(350); // past the debounce — the request is now in flight
+  P.close();
+  resolveFetch({ ok: true, json: async () => ({ results: [TASK_HIT] }) });
+  await tick(20);
+
+  // isOpen() is false, so runSearch's own guard must have thrown the response away.
+  // (compute() is pure/local and would never carry a remote hit either way — the
+  // rendered DOM is the only place a landed-too-late merge could show up.)
+  assert.ok(!/Ctrl-K searches/.test(P.listEl().innerHTML), 'a response that lands after close must not render');
+});
+
+test('a duplicate destination (already resolved locally) is not appended twice', async () => {
+  const fetchImpl = async () => ({ ok: true, json: async () => ({ results: [TASK_HIT] }) });
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  P.type('1003460'); // id syntax already resolves this to the same /task/1003460 href
+  await settleSearch();
+
+  const rows = P.listEl().innerHTML.match(/data-i="\d+"/g) || [];
+  assert.equal(rows.length, 1, 'the server hit for the same task must not add a second row for the same href');
+  assert.match(P.listEl().innerHTML, /Task 1003460/, 'the id-syntax row is the one that stays');
+});
+
+test('a repeated query within one open() replays the cache instead of re-fetching', async () => {
+  const calls = [];
+  const fetchImpl = async () => { calls.push(1); return { ok: true, json: async () => ({ results: [TASK_HIT] }) }; };
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  P.type('ctrl-k memory');
+  await settleSearch();
+  assert.equal(calls.length, 1);
+
+  // Backspace, then retype back to the exact same query (the common case: a
+  // reader pauses mid-edit and returns to what they had).
+  P.type('ctrl-k mem');
+  P.type('ctrl-k memory');
+  await settleSearch();
+
+  assert.equal(calls.length, 1, 'the identical query was served from the per-open cache, not re-fetched');
+  assert.match(P.listEl().innerHTML, /Ctrl-K searches the project&#39;s memory/, 'the cached hit still renders');
+});
+
+test('closing and reopening clears the cache — a fresh open may see new DB state', async () => {
+  const calls = [];
+  const fetchImpl = async () => { calls.push(1); return { ok: true, json: async () => ({ results: [TASK_HIT] }) }; };
+  const P = bootPalette({ navItems: NAV_FIXTURE, fetchImpl });
+  P.open();
+  P.type('ctrl-k memory');
+  await settleSearch();
+  assert.equal(calls.length, 1);
+
+  P.close();
+  P.open();
+  P.type('ctrl-k memory');
+  await settleSearch();
+
+  assert.equal(calls.length, 2, 'a fresh open must not trust a memo carried over from the previous one');
+});

package/tests/helpers.mjs

@@ -58,7 +58,7 @@ export function makeSqlAwareClient(handler) {
 // tests/ is PUBLISHABLE, but the paths some tests assert are on
 // publish-manifest.js's PROTECTED_TOPOLOGY_EXCLUDE list (`.claude/hooks/`,
 // `.claude/settings.json`, `infra/`, `.github/`, `scripts/deploy/`) or are
-// instance-only content (`devbox-app/`, `config/<instance>.json`). A neutral
+// instance-only content (`config/<instance>.json`). A neutral
 // core checkout carries none of it, so an unconditional load CRASHED the file
 // at import and red-X'd the unit gate for every consumer.
 //

package/tests/host_topology_skips.mjs

@@ -3,7 +3,7 @@
 // tests/ is publishable, but some tests assert paths the neutral core deliberately does
 // not carry: publish-manifest.js's PROTECTED_TOPOLOGY_EXCLUDE (`.claude/hooks/`,
 // `.claude/settings.json`, `infra/`, `.github/`, `scripts/deploy/`) plus instance-only
-// content (`devbox-app/`, `config/<instance>.json`, an uninstalled module). Those files
+// content (`config/<instance>.json`, an uninstalled module). Those files
 // used to CRASH at import and red-X the unit gate for every consumer; they now skip
 // cleanly via the helpers in tests/helpers.mjs and run in full wherever the topology is
 // materialized.
@@ -33,7 +33,7 @@ const ALLOWED = {
   allow_rule_guard: '.claude/hooks/allow-rule-guard.js (package-excluded)',
   art_stage: 'scripts/gds/art-stage.js (art-pipeline tooling, not in the core)',
   bongos_downloads: 'config/bongos-cli.json (instance content)',
-  box_ship_permissions: '.claude/settings.json (package-excluded)',
+  cli_allowlist_permissions: '.claude/settings.json (package-excluded)',
   conductor: '.claude/hooks/conductor.js (package-excluded)',
   deploy_instance: 'scripts/deploy/deploy-instance.sh (host topology)',
   eviction_policy: '.claude/hooks/eviction-policy.js (package-excluded)',

package/tests/migration_namespace.mjs

@@ -46,8 +46,8 @@ t('parseMigrationName: core_NNN_slug.sql', () => {
 });
 
 t('parseMigrationName: multi-word module prefix splits at the number, not greedily', () => {
-  const p = ns.parseMigrationName('dev_box_003_add_col.sql');
-  assert.equal(p.prefix, 'dev_box', 'dev_box_003 → prefix dev_box, not dev');
+  const p = ns.parseMigrationName('platform_identity_003_add_col.sql');
+  assert.equal(p.prefix, 'platform_identity', 'platform_identity_003 → prefix platform_identity, not platform');
   assert.equal(p.number, 3);
   assert.equal(p.slug, 'add_col');
 });
@@ -114,10 +114,10 @@ t('filenameViolation: NEW module migration must be <key>_-prefixed', () => {
 });
 
 t('filenameViolation: hyphenated module key maps to underscore prefix', () => {
-  assert.equal(ns.sqlNamespace('dev-box'), 'dev_box');
-  assert.equal(ns.filenameViolation('module', 'dev_box_003_x.sql', { moduleKey: 'dev-box' }), null);
-  const v = ns.filenameViolation('module', '003_x.sql', { moduleKey: 'dev-box' });
-  assert.ok(v && /dev_box_-prefixed|dev_box_003_x/.test(v));
+  assert.equal(ns.sqlNamespace('platform-identity'), 'platform_identity');
+  assert.equal(ns.filenameViolation('module', 'platform_identity_003_x.sql', { moduleKey: 'platform-identity' }), null);
+  const v = ns.filenameViolation('module', '003_x.sql', { moduleKey: 'platform-identity' });
+  assert.ok(v && /platform_identity_-prefixed|platform_identity_003_x/.test(v));
 });
 
 // ---- stemCollisions --------------------------------------------------------

package/tests/module_api.mjs

@@ -16,8 +16,8 @@ const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
 // removing/renaming a key is normally a MAJOR bump (a breaking change to every
 // module). Exception (BV1.R68 / ADR 0091 §3): relocating a DOMAIN query whose
 // sole in-repo consumer moves in lockstep is treated as MINOR — e.g.
-// `setBuilderBoxBlocked` left for modules/dev-box/db.js at 1.5.0, when `withTx`
-// was added; no enabled module at its pinned coreVersion lost a capability.
+// a per-builder setter left the kernel for its own module's db.js at 1.5.0, when
+// `withTx` was added; no enabled module at its pinned coreVersion lost a capability.
 const PUBLISHED_SURFACE = [
   'CORE_VERSION',
   'requireBuilder', 'requireRank', 'rankMeetsThreshold', 'requireBfgPrincipal', 'allowBoxScope', 'resolveSession',

package/tests/module_cli.mjs

@@ -63,11 +63,11 @@ test('scaffoldModule: writes a valid, loader-discoverable module with no core ed
 
 test('scaffoldModule: a kebab-case key produces matching dir, route file, and title', () => {
   const root = tmpModulesRoot();
-  const { dir, manifest } = mod.scaffoldModule({ key: 'dev-box', modulesDir: root, core: '1.0.0' });
-  assert.equal(manifest.title, 'Dev Box');
-  assert.deepEqual(manifest.contributes.routes, ['dev-box']);
-  assert.ok(fs.existsSync(path.join(dir, 'routes', 'dev-box.js')));
-  assert.match(fs.readFileSync(path.join(dir, 'routes', 'dev-box.js'), 'utf8'), /devBoxRoutes/);
+  const { dir, manifest } = mod.scaffoldModule({ key: 'copy-desk', modulesDir: root, core: '1.0.0' });
+  assert.equal(manifest.title, 'Copy Desk');
+  assert.deepEqual(manifest.contributes.routes, ['copy-desk']);
+  assert.ok(fs.existsSync(path.join(dir, 'routes', 'copy-desk.js')));
+  assert.match(fs.readFileSync(path.join(dir, 'routes', 'copy-desk.js'), 'utf8'), /copyDeskRoutes/);
 });
 
 test('scaffoldModule: rejects an invalid key', () => {

package/tests/module_manifest.mjs

@@ -12,11 +12,11 @@ const { satisfies, isValidRange, parseVersion } = require(path.join(ROOT, 'src',
 const { validateManifest, assertValidManifest } = require(path.join(ROOT, 'src', 'module-loader', 'manifest-schema.js'));
 
 const baseManifest = () => ({
-  key: 'dev-box',
-  title: 'Dev boxes',
-  description: 'Per-builder cloud dev environments.',
+  key: 'discord',
+  title: 'Discord',
+  description: 'A bridge to the team chat.',
   version: '1.0.0', coreVersion: '^1.0.0',
-  contributes: { routes: ['box'], pollers: ['box-lifecycle'], uiSections: ['boxes'] },
+  contributes: { routes: ['discord'], pollers: ['discord-bot'], uiSections: ['chat'] },
 });
 
 // --- semver ---
@@ -91,7 +91,7 @@ test('missing required fields each produce an error', () => {
 });
 
 test('bad key format is rejected', () => {
-  const r = validateManifest({ ...baseManifest(), key: 'Dev_Box' });
+  const r = validateManifest({ ...baseManifest(), key: 'Discord_Bot' });
   assert.equal(r.valid, false);
   assert.ok(r.errors.some((e) => e.startsWith('key')));
 });
@@ -112,13 +112,13 @@ test('version must be an exact X.Y.Z — a range or junk is rejected (task 10037
 });
 
 test('unknown contributes key is rejected (typo guard)', () => {
-  const r = validateManifest({ ...baseManifest(), contributes: { routs: ['box'] } });
+  const r = validateManifest({ ...baseManifest(), contributes: { routs: ['discord'] } });
   assert.equal(r.valid, false);
   assert.ok(r.errors.some((e) => e.includes('contributes.routs')));
 });
 
 test('non-array contributes.routes is rejected', () => {
-  const r = validateManifest({ ...baseManifest(), contributes: { routes: 'box' } });
+  const r = validateManifest({ ...baseManifest(), contributes: { routes: 'discord' } });
   assert.equal(r.valid, false);
   assert.ok(r.errors.some((e) => e.includes('contributes.routes')));
 });
@@ -296,7 +296,7 @@ test('every bundled module declares a maintenance posture (the catalog has no un
 test('declarativeSeams: a valid exemption naming a declared seam + entry passes', () => {
   const r = validateManifest({
     ...baseManifest(),
-    declarativeSeams: { pollers: ['box-lifecycle'], uiSections: ['boxes'] },
+    declarativeSeams: { pollers: ['discord-bot'], uiSections: ['chat'] },
   });
   assert.equal(r.valid, true, r.errors.join('; '));
 });
@@ -304,8 +304,8 @@ test('declarativeSeams: a valid exemption naming a declared seam + entry passes'
 test('declarativeSeams: an exemption for a seam the module does not declare is an ERROR', () => {
   const r = validateManifest({
     ...baseManifest(),
-    contributes: { routes: ['box'] }, // no pollers declared
-    declarativeSeams: { pollers: ['box-lifecycle'] },
+    contributes: { routes: ['discord'] }, // no pollers declared
+    declarativeSeams: { pollers: ['discord-bot'] },
   });
   assert.equal(r.valid, false);
   assert.ok(r.errors.some((e) => /does not declare contributes\.pollers/.test(e)), r.errors.join('; '));
@@ -314,10 +314,10 @@ test('declarativeSeams: an exemption for a seam the module does not declare is a
 test('declarativeSeams: an exemption naming an ENTRY the module does not list is an ERROR (the typo case)', () => {
   const r = validateManifest({
     ...baseManifest(),
-    declarativeSeams: { pollers: ['box-lifecyle'] }, // transposed letters
+    declarativeSeams: { pollers: ['discord-bto'] }, // transposed letters
   });
   assert.equal(r.valid, false);
-  assert.ok(r.errors.some((e) => /"box-lifecyle" is not in contributes\.pollers/.test(e)), r.errors.join('; '));
+  assert.ok(r.errors.some((e) => /"discord-bto" is not in contributes\.pollers/.test(e)), r.errors.join('; '));
 });
 
 test('declarativeSeams: the per-entry check spans EVERY seam, not just bare string arrays', () => {
@@ -344,7 +344,7 @@ test('declarativeSeams: an unknown seam key is an ERROR, not a silent no-op', ()
 
 test('declarativeSeams: shape errors — non-object block, non-string-array entries', () => {
   assert.equal(validateManifest({ ...baseManifest(), declarativeSeams: ['pollers'] }).valid, false);
-  assert.equal(validateManifest({ ...baseManifest(), declarativeSeams: { pollers: 'box-lifecycle' } }).valid, false);
+  assert.equal(validateManifest({ ...baseManifest(), declarativeSeams: { pollers: 'discord-bot' } }).valid, false);
   assert.equal(validateManifest({ ...baseManifest(), declarativeSeams: { pollers: [''] } }).valid, false);
 });
 

package/tests/module_route_rank.mjs

@@ -91,9 +91,9 @@ test('checkRouteRanks: an absent modules/ dir leaves the core result clean (byte
 
 // ---- the grade-time trigger fires on a module route change ----
 test('ROUTE_FILE_RE matches a module route path (a module route change triggers the rank pre-pass)', () => {
-  assert.match('modules/dev-box/routes/box.js', rrc.ROUTE_FILE_RE);
+  assert.match('modules/discord/routes/discord.js', rrc.ROUTE_FILE_RE);
   assert.match('src/bongos/routes/tasks.js', rrc.ROUTE_FILE_RE); // core still matches
-  assert.ok(!rrc.ROUTE_FILE_RE.test('modules/dev-box/module.json'), 'a non-route module file does not trigger the pre-pass');
+  assert.ok(!rrc.ROUTE_FILE_RE.test('modules/discord/module.json'), 'a non-route module file does not trigger the pre-pass');
 });
 
 // ---- a rank DRIFT on a pinned MODULE route reds the build (BV1.R61) ----

package/tests/modules_route_wiring.mjs

@@ -79,7 +79,7 @@ test('1002857: POST /modules/:key/enable rejects a non-boolean before touching t
   // is why the next assertion matters more than this one.
   const router = buildModulesRouter();
   const res = await invoke(handlerFor(router, 'post', '/modules/:key/enable'), {
-    params: { key: 'dev-box' }, query: {}, body: { enabled: 'yes-please' }, builder: { id: 1 },
+    params: { key: 'discord' }, query: {}, body: { enabled: 'yes-please' }, builder: { id: 1 },
   });
   assert.equal(res.body.error, 'invalid_body');
 });

package/tests/onboarding_route_signals.mjs

@@ -137,7 +137,7 @@ await t('no live signals → discord/cli both uncleared, and no retired box step
   assert.equal(r.status, 200);
   assert.equal(stepCleared(r.json, 'join_discord'), false);
   assert.equal(stepCleared(r.json, 'cli_setup'), false);
-  assert.equal(stepCleared(r.json, 'box_connect'), undefined, 'the dev-box step left the checklist (task 1004310)');
+  assert.equal(stepCleared(r.json, 'box_connect'), undefined, 'the retired box_connect step is no longer on the checklist (task 1004310)');
 });
 
 await t('discord linked → join_discord clears from ITS OWN signal [the scootermack regression]', async () => {

package/tests/paste_token_session_store.mjs

@@ -139,7 +139,7 @@ test('pasting a token for instance B PRESERVES instance A — the bug this close
       assert.equal(stored.token, 'B'.repeat(64));
 
       // 3. The active pointer still follows the paste, in the same place every existing
-      //    reader (skills, hooks, the dev box) looks. The fix is additive or it is a
+      //    reader (skills, hooks) looks. The fix is additive or it is a
       //    different, quieter outage.
       const pointer = readJson(active);
       assert.equal(pointer.api_base, base, 'the active pointer must follow the paste');

package/tests/platform_visibility_gate.mjs

@@ -162,7 +162,7 @@ test('the exempt list: the door, the manifest, the probes, the downloads — on
     '/api/gds/instance', '/api/bongos/instance', '/api/gds/healthz',
     '/api/bongos/provisioning/tls-check', '/api/gds/provisioning/health',
     '/healthz', '/version', '/metrics', '/__stealth',
-    '/downloads/bongos/install.sh', '/downloads/devbox/latest.json',
+    '/downloads/bongos/install.sh', '/downloads/bongos/latest.json',
     // Express routes case-insensitively and with a trailing slash — the list sees what the router sees
     '/API/GDS/INSTANCE', '/api/gds/instance/', '/HEALTHZ', '/api/bongos/auth/',
   ]) assert.equal(isExempt(p), true, `${p} must answer a stranger`);