@bongos/core 1.19.344 → 1.19.346

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.344",
-  "core_contract": "1.19.344",
-  "source_commit": "8c08be71d310a5efcda6758c75e8483382426e06",
+  "core_version": "1.19.346",
+  "core_contract": "1.19.346",
+  "source_commit": "17c6cd8e45c6d2f44d50888c8bcd9c5daa0889f3",
   "source_ref": "HEAD",
-  "built_at": "2026-08-25T01:57:13.504Z",
+  "built_at": "2026-08-25T02:22:50.262Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 328,
     "agent_docs_stubbed": 22,
-    "functional_verbatim": 1489,
+    "functional_verbatim": 1492,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1839,
-  "tree_sha256": "6cf7037df1f7ae7c712b6255408972f1e179b6487b592b76e87520344ed0756f",
+  "file_count": 1842,
+  "tree_sha256": "88d683cf1954503b8c2d4555474808840900d1b16471c26c626c53f076927df5",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -4742,12 +4742,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "ce99df6084ae3c2b151cc254d147ece750898e9d87d33fb204b32ace1a7d8029"
+      "sha256": "4f0ae4d95143c43bf5761820758130da48c40d0a2fde082d898fb6a6175ef853"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "cf51aa1815eea987d945024edc01d09faf17c7adf77ef381844d56ac096db7d9"
+      "sha256": "9ecdcc1f7c105d33b249c6953d18a6c8769d6fa767b996333a456f9b32ad141c"
     },
     {
       "path": "public-docs/index.html",
@@ -5509,6 +5509,11 @@
       "mode": "0000644",
       "sha256": "1e14a452c0ae53384facd6a20526a90106cb479c414937ebb7fe180f11c5fa31"
     },
+    {
+      "path": "scripts/gds/goal-names.js",
+      "mode": "0000644",
+      "sha256": "5a2e40573f92007c4257c497b291f168878421c60423584d4c55775cc3aaf836"
+    },
     {
       "path": "scripts/gds/goal.js",
       "mode": "0000644",
@@ -5809,6 +5814,11 @@
       "mode": "0000644",
       "sha256": "e4bd536cc2b91d2036d75ab67d53da1b67aee126e174da9dd8ac9531ae313b17"
     },
+    {
+      "path": "scripts/gds/rename-goals.js",
+      "mode": "0000644",
+      "sha256": "4cbb7baf533e1aa2eced1c828f37bbd11f7183846a0f3862f9fb72b3f504be66"
+    },
     {
       "path": "scripts/gds/render-ideas.js",
       "mode": "0000644",
@@ -6587,7 +6597,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "26318bb3c73b91064f7f85d04c66203a16da0de847993823dadf3a340db7b175"
+      "sha256": "ac7a592af3eb6de39e0a7f095d4a17bb89934aaa7064107fe0d462a0aaee4e2b"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -6847,7 +6857,7 @@
     {
       "path": "tests/baseline_staleness.mjs",
       "mode": "0000644",
-      "sha256": "44a2469b0f18c62fab6d9b3fe5a5125b8a9a351b5b1b48cb88cd812994d86b10"
+      "sha256": "2543492e930ace22ed9de1bf69c6efb5fdba265e88d322a45a35da18248a8731"
     },
     {
       "path": "tests/bfg.mjs",
@@ -7554,6 +7564,11 @@
       "mode": "0000644",
       "sha256": "bd29e6910bc741ddf18b4592eeeaeac02b45fb1dd321527a8f44203cd78bff18"
     },
+    {
+      "path": "tests/goal_names.mjs",
+      "mode": "0000644",
+      "sha256": "c93422d76ff7f0107190c6de1954f110e92a18913fabbcdea2b4f67693d538e6"
+    },
     {
       "path": "tests/goal_routes.mjs",
       "mode": "0000644",

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.344",
+  "version": "1.19.346",
   "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/module-api.js

@@ -1118,8 +1118,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.342 with no explicit bump. run 32799245758. (task 1002620)
 //   1.19.344 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         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)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.344'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.346'; // 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/baseline_staleness.mjs

@@ -165,18 +165,27 @@ test('LIVE: every floor in the shipped baseline file carries a reason', () => {
   assert.equal(r.historyAvailable, true, 'this checkout should have git history for the baseline file');
 });
 
-test('LIVE: shrink the window to 1 day and the real baselines DO get flagged', () => {
-  // Proof the check is not passing because it cannot see. Every current baseline
-  // was written days ago, so at a one-day window the reducible ones must surface —
-  // if this returns nothing, the detector is inert.
-  const r = bs.run({ maxAgeDays: 1 });
-  assert.ok(r.stale.length > 0, 'a 1-day window must flag the real baselines');
+test('LIVE: shrink the window past zero and the real baselines DO get flagged', () => {
+  // Proof the detector is not passing merely because it cannot see. A negative
+  // window makes EVERY metric with a measurable age older than the threshold, so
+  // the flagged set is decided purely by the exemption rules.
+  //
+  // This deliberately names no individual metric. The first version asserted
+  // `doc_stale_links` would be flagged; task 1003211 then reduced that metric,
+  // resetting its age to zero, and the test went red on a tree that was perfectly
+  // healthy — it had been pinned to transient state rather than to a property.
+  // Paying debt down must never break the check that watches the debt.
+  const r = bs.run({ maxAgeDays: -1 });
   const names = r.stale.map((s) => s.name);
-  assert.ok(names.includes('doc_stale_links'), `expected doc_stale_links among ${names.join(', ')}`);
-  // …and the exempt ones must STILL be exempt at a 1-day window: the exemption is
-  // the floor, not the clock.
+  assert.ok(names.length > 0, 'a negative window must flag every metric that is above its floor');
+  // The exemptions are the floor and zero, never the clock — so they hold even
+  // when the window guarantees everything else is flagged.
   assert.ok(!names.includes('require_cycle_count'), 'a metric at its declared floor must never be flagged');
   assert.ok(!names.includes('oversized_file_count'), 'a metric at zero must never be flagged');
+  assert.ok(!names.includes('excess_lines_total'), 'a metric at zero must never be flagged');
+  // Every flagged metric must genuinely be above its floor — the flag means
+  // "reducible and unmoved", not merely "old".
+  for (const s of r.stale) assert.ok(s.value > s.floor, `${s.name} flagged at or below its floor`);
 });
 
 test('LIVE: --update-baselines preserves the floors instead of overwriting them', () => {

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');
+});