@bongos/core 1.19.345 → 1.19.347

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.345",
+  "version": "1.19.347",
   "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/scripts/gds/goal-names.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+// scripts/gds/goal-names.js — give every open goal a NAME, and move its
+// explanation into `subtitle` (task 1003225, goal 1000072, criterion
+// legibility-goal-names-and-claude-text).
+//
+// Owner directive: a goal's subtitle should not sit on its title. 28 open goals
+// carried theirs after a dash and 3 more after a colon — the punctuation is not
+// the point, the jamming is. Task 1003224 gave `goals` a `subtitle` column and
+// taught the hall to render name / subtitle / Claude's prose at three weights;
+// this moves the existing text into that shape.
+//
+// WHY A MAPPING FILE AND NOT 31 AD-HOC PATCHES. A rename is a judgment call, and
+// judgment that lives only in a shell history cannot be reviewed, re-run, or
+// argued with. The table below IS the decision: it can be read in a diff, its
+// invariants are unit-tested (no duplicate names, no name still carrying its own
+// explanation, nothing dropped), and re-running is a no-op.
+//
+// IT IS NOT A MECHANICAL SPLIT, which is the whole reason this is its own task.
+// Splitting on the separator works where the head already names the thing
+// ("Findability — the grep path"). It FAILS where the head is not distinctive:
+// goals 1000038/1000039/1000040 all head "Agents module" and differ ONLY in the
+// tail, so a split would leave three identically-named goals — strictly worse
+// than today. Those three, the version catch-all, and three wordy heads get
+// written names; the rest keep theirs verbatim.
+//
+// SAFETY. Dry-run by DEFAULT (`--apply` to write). Every write goes through
+// PATCH /goals/:id, which is authorized (owner|manager|Archon) and records
+// prose-edit deltas — so the rename is audit-trailed, unlike the prod SQL UPDATE
+// that would otherwise be the only channel. It REFUSES to run at all if the
+// server does not yet return `subtitle`, because renaming titles against a
+// server that cannot store the subtitle would DELETE the explanations.
+
+'use strict';
+
+// id → { title, subtitle, why? }. `why` is recorded only where the name is
+// NEW rather than the existing head — i.e. where judgment was applied.
+const GOAL_NAMES = Object.freeze({
+  // ── names written, because the head was not usable ───────────────────────
+  1000003: { title: 'Work with no goal yet',
+    subtitle: 'The version catch-all. Tasks land here when nothing else fits — and nothing here can satisfy a criterion (ADR 0183), so it is a holding pen, not a home.',
+    why: 'was "BONGOS-V1 — general": a version id and the word general name nothing. Named for what it actually is.' },
+  1000038: { title: 'Agent framework & registry',
+    subtitle: 'The foundation — the plugin surface an agent is written against, and the registry that holds the roster.',
+    why: 'one of THREE goals heading "Agents module"; a mechanical split would have left three identically-named goals. Written without a colon on purpose: "Agents: framework" is the same name-plus-qualifier shape this task exists to remove, and the test flagged it.' },
+  1000039: { title: 'Agent authoring & first roster',
+    subtitle: 'Owner and builder authoring, plus the first real roster — event-driven and on-demand agents.',
+    why: 'second of the three "Agents module" goals. Named for what it adds — authoring and the first roster — rather than by a tail no list ever showed.' },
+  1000040: { title: 'Agent scheduling & spend limits',
+    subtitle: 'Scheduled agents, and the guardrails on what they are allowed to spend.',
+    why: 'third of the three "Agents module" goals. Scheduling and spend are what separate it from the framework and authoring goals.' },
+  1000053: { title: 'Sessions start knowing',
+    subtitle: 'Front-load auth, environment and instance facts so a session does not spend its first minutes rediscovering them.',
+    why: 'was "Session efficiency: sessions start knowing" — the head restated the tail. Kept the half that is a name.' },
+  1000064: { title: 'The hall as the room',
+    subtitle: 'Agora, Monitor & Contribute, and chat that does not care which channel it came from.',
+    why: 'colon-separated rather than dashed; same jamming, so treated identically.' },
+  1000075: { title: 'Collaboration & the social hall',
+    subtitle: 'Ask for help by craft, and let the hall become a mode rather than a page.',
+    why: 'was "Collab, then the social hall" — an ordering, not a name.' },
+  1000077: { title: 'Guards, not notes',
+    subtitle: 'The four failure modes that prose already documented and nothing refused.',
+    why: 'colon-separated; the head is already a good name, the tail is the explanation.' },
+  1000078: { title: 'Project money out',
+    subtitle: 'A funded balance, real builder payouts, visible outflows, and work that cannot outrun the money.',
+    why: 'colon-separated rather than dashed. The head is already the name; the tail is a four-part explanation that belongs underneath it.' },
+
+  // ── heads kept verbatim; only the tail moves ─────────────────────────────
+  1000025: { title: 'Builder experience', subtitle: 'Hall, dev box, and skills.' },
+  1000027: { title: 'Findability', subtitle: 'The grep path (ADR 0095).' },
+  1000029: { title: 'Module upstreaming & catalog', subtitle: 'Instances contribute modules back into core.' },
+  1000032: { title: 'Instance hosting + domains', subtitle: 'The `provisioning` module.' },
+  1000044: { title: 'Living project sky', subtitle: 'A shared, persistent, data-driven orb gate.' },
+  1000045: { title: 'Public builder profiles', subtitle: 'Track record, apply-to-project, and owner recruiting.' },
+  1000046: { title: 'Project creation', subtitle: 'Visibility and customization.' },
+  1000048: { title: 'SEO & public discoverability', subtitle: 'Rankable per-project profiles.' },
+  1000049: { title: 'Orb Physics', subtitle: 'Orb motion and space-whale flight.' },
+  1000052: { title: 'First-run onboarding', subtitle: 'From a bare machine to a first ship.' },
+  1000054: { title: 'Public distribution', subtitle: 'CLI installer and Claude plugin.' },
+  1000057: { title: 'Rank blocker matrix', subtitle: 'Empirically verify intended vs unintended blockers across xenos, thetes and metic.' },
+  1000058: { title: 'Non-cloudbongos project lifecycle', subtitle: 'Creation, governance, planning, building — the whole flow works and feels right.' },
+  1000063: { title: 'The front door', subtitle: 'Enter the Future: hero-only landing, wormhole transit, About on the map.' },
+  1000065: { title: 'Community surface', subtitle: 'Builder discovery on the hub.' },
+  1000067: { title: 'Ideator compensation', subtitle: 'The idea credit stream, separate from cost-plus.' },
+  1000068: { title: 'Government, not governance', subtitle: 'Ranks are ranks, and "role" belongs to the crafts.' },
+  1000070: { title: 'Scan-before-install', subtitle: 'First-real-run hardening.' },
+  1000071: { title: 'Idea routing', subtitle: 'Work that has a home lands in it.' },
+  1000072: { title: 'Human legibility', subtitle: 'Seeing, sorting and steering an AI-run project.' },
+  1000073: { title: 'Finish the GDS→Bongos rename', subtitle: 'Retire a legacy Primea term without rewriting history.' },
+  1000074: { title: "The artist's loop", subtitle: 'Review authority, copy an artist can change, and a place to do it.' },
+  // 1000080 already carried a subtitle, so the tail is PREPENDED to it rather than
+  // replacing it — overwriting would delete text, the exact loss this task guards.
+  1000080: { title: 'Apex UI pass 2', subtitle: 'One top bar, two dropdowns, and a project card worth opening — the chrome and the card on cloudbongos.com and /projects.' },
+});
+
+// A name must not carry its own explanation — that is the whole point.
+const SEPARATOR = / [—-] |: /;
+
+// Goals deliberately untouched: their titles are already names. Listed so the
+// coverage test can tell "already fine" from "forgotten".
+const ALREADY_NAMES = Object.freeze([1000009, 1000024, 1000028, 1000037, 1000047, 1000050]);
+
+module.exports = { GOAL_NAMES, ALREADY_NAMES, SEPARATOR };

package/scripts/gds/rename-goals.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// scripts/gds/rename-goals.js — apply the goal-names.js mapping (task 1003225).
+//
+// Usage:
+//   node scripts/gds/rename-goals.js            # DRY RUN — prints the diff, writes nothing
+//   node scripts/gds/rename-goals.js --apply    # writes, via PATCH /goals/:id
+//
+// Writes go through PATCH /goals/:id, never SQL: that route is authorized
+// (owner|manager|Archon) and records prose-edit deltas, so a rename of somebody's
+// goal is audit-trailed. A prod UPDATE would be invisible.
+//
+// THE GUARD THAT MATTERS: it refuses to run when the server does not return
+// `subtitle`. Renaming a title against a server that cannot store the subtitle
+// would DELETE the explanation — the exact data loss this task exists to avoid.
+// core_224 ships the column; a live instance one release behind does not have it.
+
+'use strict';
+
+const { cliClient, requireSession, hasFlag } = require('./cli-lib');
+const { GOAL_NAMES, SEPARATOR } = require('./goal-names.js');
+
+// Nothing to do when the goal already reads the way the mapping wants.
+function planFor(goal, want) {
+  const patch = {};
+  if ((goal.title || '') !== want.title) patch.title = want.title;
+  if ((goal.subtitle || '') !== want.subtitle) patch.subtitle = want.subtitle;
+  return patch;
+}
+
+async function main() {
+  await requireSession();
+  const apply = hasFlag('--apply');
+  const api = await cliClient();
+
+  const res = await api.goals.getGoals({ query: { version: 'BONGOS-V1' } });
+  if (!res.ok) {
+    console.error(`could not list goals: ${res.status}`);
+    process.exit(1);
+  }
+  const goals = (res.data.goals || []).filter((g) => g.status === 'open');
+  if (!goals.length) {
+    console.error('no open goals returned — refusing to act on an empty read.');
+    process.exit(1);
+  }
+
+  // The refusal above all others.
+  if (!Object.prototype.hasOwnProperty.call(goals[0], 'subtitle')) {
+    console.error('REFUSING: this server does not return `subtitle`, so it cannot store one.');
+    console.error('Renaming titles now would drop every explanation on the floor.');
+    console.error('core_224 adds the column — wait for the release carrying it to DEPLOY, then re-run.');
+    process.exit(2);
+  }
+
+  let changed = 0; let already = 0; let missing = 0; let failed = 0;
+  for (const g of goals.sort((a, b) => Number(a.id) - Number(b.id))) {
+    const want = GOAL_NAMES[Number(g.id)];
+    if (!want) {
+      // Not an error: goals whose titles were already names are deliberately absent.
+      if (SEPARATOR.test(g.title || '')) {
+        console.error(`!  ${g.id} has a jammed title but no mapping entry: ${g.title}`);
+        missing += 1;
+      }
+      continue;
+    }
+    const patch = planFor(g, want);
+    if (!Object.keys(patch).length) { already += 1; continue; }
+    console.log(`${apply ? '→' : '·'}  ${g.id}`);
+    if (patch.title) console.log(`     title    ${JSON.stringify(g.title)}  ->  ${JSON.stringify(patch.title)}`);
+    if (patch.subtitle !== undefined) console.log(`     subtitle ${JSON.stringify(g.subtitle || '')}  ->  ${JSON.stringify(patch.subtitle)}`);
+    if (!apply) { changed += 1; continue; }
+    const r = await api.goals.patchGoalsId({ id: g.id, body: patch });
+    if (!r.ok) {
+      console.error(`     FAILED ${r.status} ${JSON.stringify(r.data)}`);
+      failed += 1;
+    } else {
+      changed += 1;
+    }
+  }
+
+  console.log('');
+  console.log(`${apply ? 'applied' : 'would change'}: ${changed} · already correct: ${already}`
+    + `${missing ? ` · UNMAPPED jammed titles: ${missing}` : ''}${failed ? ` · FAILED: ${failed}` : ''}`);
+  if (!apply) console.log('dry run — re-run with --apply to write.');
+
+  // THE POST-CONDITION, CHECKED AGAINST REAL DATA — not against the mapping.
+  // The task's deliverable is a STATE of the live goal set ("no open goal's title
+  // contains a dash-appended subtitle"), and unit tests over the mapping's internal
+  // consistency cannot witness that: they would pass just as happily if --apply had
+  // never been run. This re-reads what the server actually holds now and reports it,
+  // so the claim is falsifiable by anyone re-running the command.
+  //
+  // SCOPED TO THIS VERSION, deliberately. The read above is `version: BONGOS-V1`;
+  // CB-V1 carries jammed titles of its own (id 4, 1000043, 1000066, 1000079) which
+  // are ANOTHER version's work, and sweeping them in here would rename goals this
+  // task never reviewed.
+  const stillJammed = goals.filter((g) => SEPARATOR.test(g.title || ''));
+  console.log('');
+  console.log(`post-condition (BONGOS-V1 open goals): ${goals.length} checked · `
+    + `${stillJammed.length} still carrying an explanation in the title`);
+  for (const g of stillJammed) console.log(`  ! ${g.id} ${JSON.stringify(g.title)}`);
+
+  process.exit(failed || missing ? 1 : 0);
+}
+
+if (require.main === module) {
+  main().catch((err) => { console.error('fatal:', err); process.exit(1); });
+}
+
+module.exports = { planFor };

package/src/bongos/serve-internal.js

@@ -944,8 +944,11 @@ function mountInternalSurfaces(app) {
   // URL→gate map by parsing this file statically, and a comment in that gap drops
   // the regex out of its map — which reads as "every page on this tier is
   // ungated". It fails loudly by design; keep prose above the const.
+  // task 1003172 (C02): `collab` joins the same tier — every read behind it is
+  // any-builder and scoped to the caller by the SERVER (GET /help-requests/for-me
+  // derives crafts from the viewer's own profile), so signed-in is the right floor.
   const SIGNEDIN_BUILDERS_PAGE_RE =
-    /^\/builders\/(?:work|pair|settings|atlas|modules|goals|roadmap|copy-desk|ideas|primer(?:\.md)?|diagrams)(?:\.html)?\/?$/;
+    /^\/builders\/(?:work|pair|settings|atlas|modules|goals|roadmap|copy-desk|ideas|collab|primer(?:\.md)?|diagrams)(?:\.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

@@ -1120,8 +1120,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.343 with no explicit bump. run 32799492873. (task 1002620)
 //   1.19.345 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.344 with no explicit bump. run 32800819617. (task 1002620)
+//   1.19.346 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.345 with no explicit bump. run 32801147433. (task 1002620)
+//   1.19.347 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.346 with no explicit bump. run 32802265337. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.345'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.347'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/collab_page.mjs

@@ -0,0 +1,172 @@
+// tests/collab_page.mjs — the Collab page (task 1003172 / C02, goal 1000075,
+// criterion collab-page-matches-my-craft).
+//
+// The criterion has three clauses and the third is the one that gets skipped:
+// requests match the viewer's CRAFT, are ANSWERABLE from the page, and a request
+// nobody takes is VISIBLY AGING rather than silently dead. Sorting the oldest to
+// the top does not satisfy the third — the oldest then looks exactly like the
+// newest, only lower down.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
+
+// collab-lib.js is pure, so RUN it rather than grep it.
+function lib() {
+  const src = read('modules', 'hall-ui', 'public', 'collab-lib.js');
+  const win = {};
+  new Function('window', src)(win);
+  return win.OTBCollabLib;
+}
+const NOW = Date.parse('2026-08-24T12:00:00Z');
+const daysAgo = (d) => new Date(NOW - d * 86400000).toISOString();
+
+// ---- THE AGEING CLAUSE ----------------------------------------------------
+test('age is a BAND with a label, not just a sort position', () => {
+  const L = lib();
+  assert.equal(L.ageBand(daysAgo(0), NOW).id, 'fresh');
+  assert.equal(L.ageBand(daysAgo(1), NOW).id, 'waiting');
+  assert.equal(L.ageBand(daysAgo(3), NOW).id, 'aging');
+  assert.equal(L.ageBand(daysAgo(7), NOW).id, 'stale');
+  assert.equal(L.ageBand(daysAgo(90), NOW).id, 'stale');
+  for (const b of L.BANDS) assert.ok(b.label && b.label.length > 4, `${b.id} says it in words`);
+});
+
+test('the boundaries are exact, so the bands mean something', () => {
+  const L = lib();
+  assert.equal(L.ageBand(daysAgo(0.99), NOW).id, 'fresh', 'just under a day is still fresh');
+  assert.equal(L.ageBand(daysAgo(2.99), NOW).id, 'waiting');
+  assert.equal(L.ageBand(daysAgo(6.99), NOW).id, 'aging');
+});
+
+test('an unknown age reads as fresh, never as an accusation', () => {
+  const L = lib();
+  for (const bad of [null, undefined, '', 'nonsense']) {
+    assert.equal(L.ageBand(bad, NOW).id, 'fresh', `${JSON.stringify(bad)} must not look neglected`);
+  }
+});
+
+test('ageing changes how a row LOOKS, not only where it sits', () => {
+  // The whole point of the clause. Each band must have its own visual treatment
+  // in CSS, or "visibly aging" is just a sort order with extra steps.
+  const css = read('modules', 'hall-ui', 'public', 'collab.css');
+  const L = lib();
+  for (const b of L.BANDS) {
+    assert.match(css, new RegExp(`\\.cb-item--${b.id}\\b`), `${b.id} has its own styling`);
+  }
+  assert.match(css, /\.cb-item--stale\s*\{[^}]*border-left-color/, 'the band reads down a list at a glance');
+  // Colour alone is not a message and not everyone sees it.
+  assert.match(css, /\.cb-item--stale \.cb-age/, 'and the words are emphasised too');
+});
+
+test('the row markup carries the band class and the label', () => {
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  assert.match(js, /cb-item--\$\{L\.ageBand\(/, 'the class comes from the band');
+  assert.match(js, /cb-age cb-age--\$\{band\.id\}/, 'and so does the chip');
+  assert.match(js, /escapeHtml\(band\.label\)/, 'the label is rendered, escaped');
+});
+
+test('oldest first WITHIN the page, in addition to the band', () => {
+  const L = lib();
+  const rows = [{ created_at: daysAgo(1) }, { created_at: daysAgo(9) }, { created_at: daysAgo(4) }];
+  const sorted = rows.slice().sort(L.byAgeOldestFirst);
+  assert.deepEqual(sorted.map((r) => L.ageBand(r.created_at, NOW).id), ['stale', 'aging', 'waiting']);
+});
+
+// ---- THE MATCHING CLAUSE --------------------------------------------------
+test('the page NEVER sends a craft — matching is the server\'s job', () => {
+  // C01's grader found a ?craft= param that let any builder read another craft's
+  // requests. The fix put craft derivation on the server, and this page must not
+  // reintroduce the parameter from the client side.
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  // Assert on the REQUEST, not on any occurrence of the word: the first version
+  // matched `Matching your craft: ${crafts.join(', ')}` — the page's own subtitle —
+  // which is display text, not a parameter. Fifth time this session that a source
+  // assertion has been wider than its invariant (learning 1000196).
+  assert.match(js, /getHelpRequestsForMe\(\{\}\)/, 'the read is unparameterised');
+  assert.ok(!/(query|body):\s*\{[^}]*craft/.test(js), 'craft never travels in a query or body');
+});
+
+test('a craft request and a by-name request read differently', () => {
+  const L = lib();
+  assert.match(L.addressedTo({ needs_craft: 'artist' }, 1), /artists/);
+  assert.match(L.addressedTo({ needs_builder_id: 7 }, 7), /by name/);
+  assert.match(L.addressedTo({ needs_builder_id: 7 }, 9), /one person/);
+});
+
+test('context links to the task or goal, and to neither when absent', () => {
+  const L = lib();
+  assert.equal(L.contextOf({ task_id: 5 }).kind, 'task');
+  assert.equal(L.contextOf({ goal_id: 5 }).kind, 'goal');
+  assert.equal(L.contextOf({}), null, 'no context means no element, not an empty one');
+});
+
+// ---- THE ANSWERABLE CLAUSE ------------------------------------------------
+test('the asker can settle in place, with both outcomes', () => {
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  assert.match(js, /data-settle="answered"/);
+  assert.match(js, /data-settle="withdrawn"/);
+  assert.match(js, /patchHelpRequestsId/, 'through the real API, not a local edit');
+});
+
+test('there is deliberately NO reply thread — that would reimplement the Agora', () => {
+  // The goal forbids reimplementing the Agora to get around C06's dependency.
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  for (const f of ['reply', 'comment', 'thread', 'message']) {
+    assert.ok(!new RegExp(`data-${f}|post${f}`, 'i').test(js), `no ${f} surface`);
+  }
+});
+
+// ---- placement ------------------------------------------------------------
+test('it is a PAGE, not a Home card — the actionable half is the needs roster', () => {
+  // hall-ui/CLAUDE.md's tree: an action awaiting the builder goes in the
+  // needs-attention inbox and NEVER a new card, because one landing place for
+  // everything actionable is the whole point. C01 already put it there.
+  assert.ok(fs.existsSync(path.join(HALL, 'collab.html')));
+  const builders = read('modules', 'hall-ui', 'public', 'builders.js');
+  assert.ok(!/collab/i.test(builders), 'no Home card was added');
+});
+
+test('the page is behind the signed-in gate', () => {
+  const serve = read('src', 'bongos', 'routes', '..', 'serve-internal.js');
+  const m = /const SIGNEDIN_BUILDERS_PAGE_RE =\s*(\/[^\n]+\/);/.exec(serve);
+  assert.ok(m, 'the gate const is still statically parseable');
+  assert.ok(new RegExp(m[1].slice(1, -1)).test('/builders/collab'), 'collab is gated');
+});
+
+test('every CSS token the page uses exists in style.css', () => {
+  const css = read('modules', 'hall-ui', 'public', 'collab.css');
+  const style = read('modules', 'hall-ui', 'public', 'style.css');
+  const used = new Set([...css.matchAll(/var\((--[a-z-]+)\)/g)].map((x) => x[1]));
+  assert.ok(used.size >= 5);
+  for (const t of used) {
+    assert.ok(new RegExp(`^\\s*${t}:`, 'm').test(style), `${t} must be defined (idea 1000821)`);
+  }
+});
+
+// ---- THE CLIENT ACTUALLY REACHES THE API ----------------------------------
+// The page called every endpoint through the GENERATED client (api.helpRequests.*),
+// whose methods emit API-RELATIVE paths ('/help-requests/for-me'). Combined with
+// baseUrl:'' — which the client documents as "these paths are already absolute" —
+// every request went to the SITE ROOT and 404'd, so the page would have shipped
+// dead on arrival. ideas.js and idea.js already shipped with exactly this defect.
+//
+// Grepped rather than executed on purpose: the defect is in URL CONSTRUCTION, and
+// every existing test stubs the client, which is precisely why three pages shipped
+// green while 404ing. A repo-wide version of this guard belongs in fitness.js once
+// the two idea pages are fixed — scoped here to the page this task owns.
+test('the client is not configured to send API calls to the site root', () => {
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  const namespaced = [...js.matchAll(/\bapi\.([a-zA-Z]\w*)\.([a-zA-Z]\w*)\(/g)];
+  assert.ok(namespaced.length > 0, 'this page uses the generated client');
+  assert.ok(
+    !/createClient\(\{[^}]*baseUrl:\s*(''|"")/.test(js),
+    "baseUrl:'' sends generated-client paths to the site root — drop it so they "
+    + 'resolve against /api/bongos/v1, or switch every call to api.request() with a full path',
+  );
+});

package/tests/goal_names.mjs

@@ -0,0 +1,120 @@
+// tests/goal_names.mjs — the goal rename mapping (task 1003225, goal 1000072,
+// criterion legibility-goal-names-and-claude-text).
+//
+// The mapping IS the decision, so these tests are the review that a shell
+// history could never get: no name may still carry its own explanation, no two
+// goals may end up with the same name, and re-running must be a no-op.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+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 { GOAL_NAMES, ALREADY_NAMES, SEPARATOR } = require(path.join(ROOT, 'scripts', 'gds', 'goal-names.js'));
+const { planFor } = require(path.join(ROOT, 'scripts', 'gds', 'rename-goals.js'));
+
+const entries = () => Object.entries(GOAL_NAMES).map(([id, v]) => [Number(id), v]);
+
+test('THE POINT: no new title carries its own explanation', () => {
+  // A dash or a colon in the name means the split did not happen.
+  for (const [id, v] of entries()) {
+    assert.ok(!SEPARATOR.test(v.title), `${id} still jams its explanation into the name: ${v.title}`);
+  }
+});
+
+test('no two goals end up with the same name', () => {
+  // The failure a mechanical split would have produced: 1000038/39/40 all head
+  // "Agents module", so splitting on the separator leaves three identical names.
+  const seen = new Map();
+  for (const [id, v] of entries()) {
+    const key = v.title.toLowerCase();
+    assert.ok(!seen.has(key), `${id} and ${seen.get(key)} would both be named "${v.title}"`);
+    seen.set(key, id);
+  }
+});
+
+test('the three Agents goals are genuinely distinguishable', () => {
+  const [a, b, c] = [1000038, 1000039, 1000040].map((id) => GOAL_NAMES[id]);
+  for (const g of [a, b, c]) assert.ok(g, 'all three are mapped');
+  const names = new Set([a.title, b.title, c.title]);
+  assert.equal(names.size, 3, 'three distinct names');
+  // And each says what IT is, not merely that it is an agents goal.
+  for (const g of [a, b, c]) {
+    assert.ok(g.title.length > 'Agents module'.length, `"${g.title}" must add something`);
+  }
+});
+
+test('every goal keeps an explanation — nothing is dropped', () => {
+  for (const [id, v] of entries()) {
+    assert.equal(typeof v.subtitle, 'string', `${id} has a subtitle`);
+    assert.ok(v.subtitle.trim().length >= 20, `${id}'s subtitle must carry the real explanation, not a stub`);
+    assert.notEqual(v.subtitle.trim().toLowerCase(), v.title.trim().toLowerCase(), `${id} must not restate its name`);
+  }
+});
+
+test('a name reads as a name, not a sentence', () => {
+  for (const [id, v] of entries()) {
+    assert.ok(v.title.length <= 40, `${id} "${v.title}" is ${v.title.length} chars — too long to scan in a list`);
+    assert.ok(!v.title.endsWith('.'), `${id} "${v.title}" should not be punctuated like prose`);
+  }
+});
+
+test('every name written with JUDGMENT records why', () => {
+  // Where the new name is not simply the old head, the reason is part of the
+  // artifact — that is what makes this reviewable rather than asserted.
+  for (const id of [1000003, 1000038, 1000039, 1000040, 1000053, 1000064, 1000075, 1000077, 1000078]) {
+    const v = GOAL_NAMES[id];
+    assert.ok(v, `${id} is mapped`);
+    assert.ok(v.why && v.why.length > 25, `${id} must record why its name was rewritten`);
+  }
+});
+
+test('the mapping and the leave-alone list are disjoint', () => {
+  for (const id of ALREADY_NAMES) {
+    assert.ok(!GOAL_NAMES[id], `${id} cannot be both renamed and deliberately untouched`);
+  }
+});
+
+test('mapping + leave-alone accounts for every open goal', () => {
+  // 38 = 32 mapping entries + 6 already-names. This is a fact about THIS FILE, not
+  // about how many goals are currently open — the two drifted apart and saying
+  // otherwise is how the first version of this comment became false.
+  //
+  // The live BONGOS-V1 open set is 37: goal 1000077 was mapped and renamed while
+  // open and has since been ACHIEVED, so 31 of the 32 entries have an open goal to
+  // apply to (hence the applier's 'applied: 31'), and 31 + 6 = 37 covers every open
+  // goal. A stale entry is harmless — planFor is idempotent and simply never matches.
+  //
+  // Pinned rather than derived on purpose: derived from the live set it would pass
+  // forever and never catch a NEW goal. That pin is what surfaced 1000080.
+  assert.equal(Object.keys(GOAL_NAMES).length + ALREADY_NAMES.length, 38);
+});
+
+test('re-running is a no-op — planFor is idempotent', () => {
+  const want = GOAL_NAMES[1000027];
+  const already = { id: 1000027, title: want.title, subtitle: want.subtitle };
+  assert.deepEqual(planFor(already, want), {}, 'nothing to patch when already correct');
+});
+
+test('planFor patches only what differs', () => {
+  const want = GOAL_NAMES[1000027];
+  const titleOnly = { id: 1, title: 'Findability — the grep path (ADR 0095)', subtitle: want.subtitle };
+  assert.deepEqual(Object.keys(planFor(titleOnly, want)), ['title']);
+  const subOnly = { id: 1, title: want.title, subtitle: '' };
+  assert.deepEqual(Object.keys(planFor(subOnly, want)), ['subtitle']);
+});
+
+test('a NULL subtitle is treated as absent, not as a value', () => {
+  const want = GOAL_NAMES[1000027];
+  const fresh = { id: 1, title: want.title, subtitle: null };
+  assert.deepEqual(Object.keys(planFor(fresh, want)), ['subtitle'], 'null must still be filled in');
+});
+
+test('the version catch-all is named for what it is', () => {
+  const v = GOAL_NAMES[1000003];
+  assert.ok(!/BONGOS-V1/.test(v.title), 'a version id is not a name');
+  assert.ok(!/general/i.test(v.title), '"general" names nothing');
+  assert.match(v.subtitle, /catch-all/i, 'and the subtitle says what it actually is');
+});

package/tests/hall_nav.mjs

@@ -149,7 +149,13 @@ test('sidebar groups read by audience, in order', () => {
   // Gated cosmetically to match its data endpoint — `project.curate`, floor METIC,
   // so the nav entry reads 'government' since ADR 0174 (it said 'archon', then
   // was stricter than the wall). requireProjectCuratePage is the wall server-side.
-  assert.deepEqual(nav[2].items.map((i) => i.id), ['leaderboard', 'people'], 'Community = everyone else');
+  // task 1003172 (C02 of goal 1000075): 'collab' joins Community, FIRST. The
+  // group is picked by whose data it is, and a help request is another builder
+  // reaching you — not your own numbers (that is You), and not reference (Docs).
+  // First within the group because it is the one page here you ACT on; the
+  // leaderboard and the directory are browsing surfaces. Updating this oracle is
+  // the reviewed decision the pin exists to force.
+  assert.deepEqual(nav[2].items.map((i) => i.id), ['collab', 'leaderboard', 'people'], 'Community = everyone else');
   assert.deepEqual(nav[3].items.map((i) => i.id),
     ['primer', 'ranks', 'economy', 'diagrams', 'atlas', 'modules', 'apidocs'], 'Docs = reference material');
   // 'government' (the Permissions tab, BV1.R113) is the group's one archon-gated item.