@bongos/core 1.19.372 → 1.19.374

package/docs/copy-registry.json

@@ -3,17 +3,17 @@
   "generator": "scripts/gds/copy-inventory.js",
   "goal": 1000074,
   "counts": {
-    "strings": 1400,
-    "unique_ids": 1241,
-    "certain": 1400,
+    "strings": 1403,
+    "unique_ids": 1244,
+    "certain": 1403,
     "heuristic": 0,
     "duplicate_ids": 129
   },
   "surfaces": {
     "builders-hall": {
       "at": "modules/hall-ui/public",
-      "files": 70,
-      "strings": 1110
+      "files": 71,
+      "strings": 1113
     },
     "status-dashboard": {
       "at": "modules/status-ui/public",
@@ -1846,6 +1846,15 @@
       "origin": "html-text",
       "confidence": "certain"
     },
+    {
+      "id": "62eded408097",
+      "surface": "builders-hall",
+      "text": "Add {…}",
+      "file": "modules/hall-ui/public/profile-nudge.js",
+      "line": 68,
+      "origin": "js-markup",
+      "confidence": "certain"
+    },
     {
       "id": "7cf0163d4cde",
       "surface": "builders-hall",
@@ -2764,6 +2773,15 @@
       "origin": "html-title",
       "confidence": "certain"
     },
+    {
+      "id": "cfc287c42263",
+      "surface": "builders-hall",
+      "text": "Complete your profile",
+      "file": "modules/hall-ui/public/profile-nudge.js",
+      "line": 62,
+      "origin": "js-markup",
+      "confidence": "certain"
+    },
     {
       "id": "2867c85d196d",
       "surface": "builders-hall",
@@ -7552,6 +7570,15 @@
       "origin": "js-markup",
       "confidence": "certain"
     },
+    {
+      "id": "838b17fa8d93",
+      "surface": "builders-hall",
+      "text": "Shown on your public profile — it helps others know what you work on.",
+      "file": "modules/hall-ui/public/profile-nudge.js",
+      "line": 69,
+      "origin": "js-markup",
+      "confidence": "certain"
+    },
     {
       "id": "2f12d46f96ca",
       "surface": "builders-hall",

package/modules/builder-settings/profile-nudge-prefs.js

@@ -0,0 +1,125 @@
+// modules/builder-settings/profile-nudge-prefs.js — the "Complete your profile"
+// nudge dismissal (task 1002802 / P06, goal 1000045).
+//
+// WHY A KNOB AND NOT A WIZARD. Decision 2 of the builder-profile spec
+// (docs/specs/bongos-v1-builder-profile-page.md) rejected a profile-setup
+// wizard: profiles are auto-created at first sign-in and enriched
+// progressively, and an interstitial between sign-in and the hall adds friction
+// at exactly the drop-off point. The replacement is a DISMISSIBLE line item in
+// the needs-attention inbox — the hall's placement rule (modules/hall-ui/
+// CLAUDE.md → Placement: an action awaiting the builder is an inbox line, never
+// a new Home card).
+//
+// Dismissible has to mean dismissed-for-good, across devices: a builder who has
+// decided not to write a bio should not be asked again on their laptop. So the
+// flag is SERVER-side, not localStorage.
+//
+// Storage: one reserved key ('profile_nudge_dismissed') inside the
+// `behavior_prefs` jsonb on `builders` (migration 119 — the same blob the
+// wandering/render/interaction knobs use), so this adds NO migration. Value is
+// a scalar boolean; a missing key means "not dismissed", which keeps the column
+// sparse. applyPatch leaves sibling keys alone.
+//
+// This module is the single source of truth: GET/PATCH /api/gds/me/profile-nudge
+// read and write it, and the hall's attention-card slice reads the resolved
+// boolean to decide whether to render the line at all.
+
+const RESERVED_KEY = 'profile_nudge_dismissed';
+const DEFAULT_DISMISSED = false; // never dismissed until the builder says so
+
+// ---- pure helpers ----
+
+// The raw override a builder has stored, or null when unset/invalid. Kept
+// separate from the effective value so a caller can tell "chose to keep it" from
+// "never answered" (mirrors render-prefs' overrideEnabled).
+function overrideDismissed(behaviorPrefs) {
+  const raw = behaviorPrefs && behaviorPrefs[RESERVED_KEY];
+  return typeof raw === 'boolean' ? raw : null;
+}
+
+// The resolved boolean — the value the hall acts on.
+function nudgeDismissed(behaviorPrefs) {
+  const o = overrideDismissed(behaviorPrefs);
+  return o === null ? DEFAULT_DISMISSED : o;
+}
+
+// Which profile fields are still empty. PURE over the two inputs the nudge
+// cares about, so the decision is testable without a DB or an HTTP round-trip.
+// `bio` lives on the platform-identity account (hub-side), `preferred_disciplines`
+// on `builders` — the caller passes both; this file never reaches for either.
+// Whitespace-only bio counts as empty: a space is not a bio.
+function missingProfileFields({ bio, preferredDisciplines } = {}) {
+  const missing = [];
+  if (typeof bio !== 'string' || bio.trim() === '') missing.push('bio');
+  if (!Array.isArray(preferredDisciplines) || preferredDisciplines.length === 0) missing.push('disciplines');
+  return missing;
+}
+
+// Should the nudge render? Only when something is actually missing AND the
+// builder has not dismissed it. The two halves are deliberately separate above
+// so a caller can say WHAT is missing even when the nudge is dismissed.
+function shouldNudge({ behaviorPrefs, bio, preferredDisciplines } = {}) {
+  if (nudgeDismissed(behaviorPrefs)) return false;
+  return missingProfileFields({ bio, preferredDisciplines }).length > 0;
+}
+
+// Everything the API + the hall slice need in one object.
+function describeForApi(behaviorPrefs, { bio, preferredDisciplines } = {}) {
+  const missing = missingProfileFields({ bio, preferredDisciplines });
+  return {
+    dismissed: nudgeDismissed(behaviorPrefs),
+    default_dismissed: DEFAULT_DISMISSED,
+    override: overrideDismissed(behaviorPrefs),
+    missing,
+    show: !nudgeDismissed(behaviorPrefs) && missing.length > 0,
+  };
+}
+
+// Validate a PATCH body: { dismissed: <bool> | null }. `null` clears the
+// override (back to not-dismissed, so the nudge can return — the "undismiss"
+// path a Settings toggle would use). Unknown keys / non-booleans → 422. An empty
+// body is a valid no-op.
+function validatePatch(body) {
+  if (body == null || typeof body !== 'object' || Array.isArray(body)) {
+    return { ok: false, errors: [{ error: 'body_must_be_object' }] };
+  }
+  const errors = [];
+  const patch = {};
+  for (const [key, value] of Object.entries(body)) {
+    if (key !== 'dismissed') {
+      errors.push({ key, error: 'unknown_key', allowed: ['dismissed'] });
+      continue;
+    }
+    if (value === null || typeof value === 'boolean') {
+      patch[RESERVED_KEY] = value; // null = clear → default (not dismissed)
+      continue;
+    }
+    errors.push({ key, error: 'invalid_value', value, allowed: 'boolean or null' });
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, patch };
+}
+
+// Apply a validated patch to a builder's existing behavior_prefs. Pure. null
+// deletes the key; a boolean overwrites. Sibling keys (wandering, widgets,
+// interaction) are left untouched.
+function applyPatch(existing, patch) {
+  const next = { ...(existing || {}) };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === null) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+
+module.exports = {
+  RESERVED_KEY,
+  DEFAULT_DISMISSED,
+  overrideDismissed,
+  nudgeDismissed,
+  missingProfileFields,
+  shouldNudge,
+  describeForApi,
+  validatePatch,
+  applyPatch,
+};

package/modules/builder-settings/routes/settings.js

@@ -28,6 +28,7 @@ const wanderingPrefs = require('../wandering-prefs');
 const interactionPrefs = require('../interaction-prefs');
 const modelAllocPrefs = require('../model-alloc-prefs');
 const renderPrefs = require('../render-prefs');
+const profileNudgePrefs = require('../profile-nudge-prefs');
 const displayName = require('../display-name');
 // task 1003208: structured logging (pino via the doorway) — was console.*.
 const log = api.logger('builder-settings');
@@ -378,6 +379,53 @@ module.exports = function buildBuilderSettingsRouter() {
     }
   });
 
+  // The "Complete your profile" nudge dismissal (task 1002802 / P06). The nudge
+  // itself is a DISMISSIBLE line item in the hall's needs-attention inbox — the
+  // replacement for the profile-setup wizard Decision 2 rejected. These two
+  // routes own only the dismissal FLAG; whether anything is actually missing is
+  // composed by the caller, which already holds both inputs (preferred_disciplines
+  // from GET /me, bio from GET /me/cross-project — bio lives on the platform
+  // identity account, and this module must never reach across to that one).
+  //
+  // rank: any-builder — own profile config; same posture as /me/render.
+  router.get('/me/profile-nudge', api.requireBuilder, async (req, res) => {
+    try {
+      // preferred_disciplines is NOT on req.builder (requireBuilder attaches an
+      // identity+rank subset), so read the row through the doorway — the same
+      // getBuilderById the wandering/interaction routes above use.
+      const [stored, builder] = await Promise.all([
+        db.getBuilderBehaviorPrefs(req.builder.id),
+        api.getBuilderById(req.builder.id),
+      ]);
+      res.json(profileNudgePrefs.describeForApi(stored, {
+        preferredDisciplines: builder && builder.preferred_disciplines,
+      }));
+    } catch (err) {
+      log.error('GET /me/profile-nudge', err);
+      res.fail('read_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  // PATCH the dismissal. Body: { dismissed: <bool> | null } — null clears the
+  // override so the nudge can come back (the undismiss path). Sibling behavior
+  // keys are preserved by applyPatch.
+  router.patch('/me/profile-nudge', api.requireBuilder, async (req, res) => {
+    try {
+      const v = profileNudgePrefs.validatePatch(req.body || {});
+      if (!v.ok) return res.fail('invalid_patch', 422, { errors: v.errors });
+      const existing = await db.getBuilderBehaviorPrefs(req.builder.id);
+      const next = profileNudgePrefs.applyPatch(existing, v.patch);
+      const saved = await db.setBuilderBehaviorPrefs(req.builder.id, next);
+      const builder = await api.getBuilderById(req.builder.id);
+      res.json(profileNudgePrefs.describeForApi(saved, {
+        preferredDisciplines: builder && builder.preferred_disciplines,
+      }));
+    } catch (err) {
+      log.error('PATCH /me/profile-nudge', err);
+      res.fail('write_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // Per-builder DISPLAY NAME (task 1669). The free label shown next to a
   // builder's work in the hall (header, leaderboard, work feed — all already read
   // display_name, so a DB update propagates). Seeded once from GitHub at account

package/modules/dev-box/app/src/vendor/bongos-client.cjs

@@ -500,6 +500,10 @@ function createClient(opts = {}) {
       patchMeModelAllocation: (args) => request("PATCH", "/me/model-allocation", { hasBody: true }, args),
       // PATCH /me/profile — rank: any-builder — PATCH /me/profile
       patchMeProfile: (args) => request("PATCH", "/me/profile", { hasBody: true }, args),
+      // GET /me/profile-nudge — rank: any-builder — GET /me/profile-nudge
+      getMeProfileNudge: (args) => request("GET", "/me/profile-nudge", { hasBody: false }, args),
+      // PATCH /me/profile-nudge — rank: any-builder — PATCH /me/profile-nudge
+      patchMeProfileNudge: (args) => request("PATCH", "/me/profile-nudge", { hasBody: true }, args),
       // GET /me/recent-ships — rank: any-builder — GET /me/recent-ships
       getMeRecentShips: (args) => request("GET", "/me/recent-ships", { hasBody: false }, args),
       // GET /me/render — rank: any-builder — GET /me/render

package/modules/hall-ui/public/goal-inbox.js

@@ -273,6 +273,13 @@
     host.innerHTML =
       '<h2 id="attention-h" class="scroll__h">Needs your attention<span class="count-pill" id="attention-count" hidden></span></h2>' +
       '<div id="attention-goals"></div>' +
+      // task 1002802 (P06): "Complete your profile" — a DISMISSIBLE nudge when
+      // bio or preferred_disciplines are empty. Rendered by builders.js (which
+      // already holds the /me state the condition reads), exactly like the
+      // ideas slice. Placement rule: an action awaiting the builder is an inbox
+      // LINE, never a new Home card — that is why the rejected profile wizard
+      // (task 1002783) became this.
+      '<div id="attention-profile"></div>' +
       '<div id="attention-ideas"></div>' +
       // task 1003066 (BV1.R05): routed filings that SOFT-LANDED — a reported bug
       // now sitting at 'backlog' in a real goal, one Metic+ nod from claimable.
@@ -284,6 +291,9 @@
     host.addEventListener('click', onClick);
     load();
     loadNodQueue();
+    // task 1002802 (P06): the profile slice lives in its own file (builders.js is
+    // over the size budget); this card owns its div, so it boots it here.
+    window.OTBProfileNudge?.load();
   }
 
   // The card's shared visibility contract: any slice renderer calls refresh()

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

@@ -123,6 +123,10 @@
      hall-widget tags the server injects still anchor on builders.js's tag
      below (it matches by filename), so they land between the two. -->
 <script src="/builders/hall-render.js?v=2026-08-24-hallrender1" defer></script>
+<!-- task 1002802 (P06): the profile-completion nudge slice. Exposes
+     window.OTBProfileNudge; goal-inbox.js's mount() calls it once it has
+     created the #attention-profile div, so load order is not load-bearing. -->
+<script src="/builders/profile-nudge.js?v=2026-08-25-profile-nudge" defer></script>
 <script src="/builders/builders.js?v=2026-06-27-r75" defer></script>
 <script src="/builders/copy-on-click.js?v=2026-06-01-copy-1" defer></script>
 </body>

package/modules/hall-ui/public/profile-nudge.js

@@ -0,0 +1,122 @@
+// profile-nudge.js — the "Complete your profile" slice of the hall's
+// "Needs your attention" card (task 1002802 / P06, goal 1000045).
+//
+// Its own file rather than a block inside builders.js: the slice needs no state
+// from that file (both its inputs come from its own two fetches), and builders.js
+// is already far over the 1,500-line budget the quality ratchets enforce.
+//
+// goal-inbox.js owns the CARD (id 'attention-scroll') and creates this slice's
+// div (#attention-profile); card visibility + the headline count derive from
+// every slice via window.OTBAttention.refresh().
+(function () {
+  'use strict';
+  if (!window.OTB) return;
+  const { escapeHtml } = window.OTB;
+  const API = '/api/bongos';
+  // Result-mode client: a 401/404 must be inspectable control flow, never a throw
+  // that breaks a sibling slice (the goal-inbox.js pattern).
+  const api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
+
+  async function getJSON(path) {
+    const res = await api.request('GET', path);
+    if (!res.ok) { const e = new Error(`${path} → ${res.status}`); e.status = res.status; throw e; }
+    return res.data;
+  }
+  async function patchJSON(path, body) {
+    const res = await api.request('PATCH', path, { body: body || {} });
+    if (!res.ok) { const e = new Error(`${path} → ${res.status}`); e.status = res.status; throw e; }
+    return res.data;
+  }
+
+
+  // Renders the PROFILE slice of the "Needs your attention" card. goal-inbox.js
+  // owns the card (id 'attention-scroll') + the slice div; visibility and the
+  // headline count derive from every slice via OTBAttention.
+  //
+  // WHY A LINE AND NOT A CARD OR A WIZARD: spec Decision 2 rejected a
+  // profile-setup wizard (profiles are auto-created and enriched
+  // progressively; an interstitial after sign-in adds friction at the drop-off
+  // point). The hall's placement rule then puts an action awaiting the builder
+  // in the inbox as a LINE, never a new Home card.
+  //
+  // The two inputs live in different places — preferred_disciplines on the
+  // builder row (already in the /me payload this file holds) and bio on the
+  // platform-identity account (GET /me/cross-project) — so the SHOW decision is
+  // composed here. The server owns only the dismissal flag.
+  // Uses .ginbox__item so OTBAttention.refresh() counts it with no selector change.
+  function renderProfileNudge(state) {
+    const box = document.getElementById('attention-profile');
+    if (!box) return;
+    if (!state || !state.show) {
+      box.innerHTML = '';
+      window.OTBAttention?.refresh();
+      return;
+    }
+    // Name what is actually missing: "add a bio" is actionable, "complete your
+    // profile" is a chore of unknown size.
+    const missing = Array.isArray(state.missing) ? state.missing : [];
+    const parts = [];
+    if (missing.includes('bio')) parts.push('a short bio');
+    if (missing.includes('disciplines')) parts.push('the kinds of work you want');
+    const what = parts.length === 2 ? `${parts[0]} and ${parts[1]}` : (parts[0] || 'a detail or two');
+    box.innerHTML = '<h3 class="ginbox__sec-h">Complete your profile</h3>'
+      + '<ul class="ginbox">'
+      + '<li class="ginbox__item">'
+      // .ginbox__body / .ginbox__actions are the classes style.css actually
+      // defines (the body is the flex column that stacks label over sub-line).
+      + '<div class="ginbox__body">'
+      + `<a class="ginbox__goal" href="/settings">Add ${escapeHtml(what)}</a>`
+      + '<span class="ginbox__sub">Shown on your public profile — it helps others know what you work on.</span>'
+      + '</div>'
+      + '<div class="ginbox__actions">'
+      + '<button class="btn-ghost" type="button" data-profile-nudge-dismiss="1">Dismiss</button>'
+      + '</div>'
+      + '</li></ul>';
+    window.OTBAttention?.refresh();
+  }
+
+  // Fetch the dismissal flag + the bio in parallel, then compose. Any failure
+  // renders NOTHING (a nudge is the most skippable thing on the page — it must
+  // never surface an error card or break a sibling slice).
+  async function loadProfileNudge() {
+    try {
+      const [nudge, cross] = await Promise.all([
+        getJSON(`${API}/me/profile-nudge`),
+        getJSON(`${API}/me/cross-project`).catch(() => null),
+      ]);
+      if (!nudge) return;
+      // The server computed `missing` from preferred_disciplines only (bio is not
+      // its to read — different module). Fold the bio in here.
+      const missing = Array.isArray(nudge.missing) ? nudge.missing.slice() : [];
+      const bio = cross && typeof cross.bio === 'string' ? cross.bio : '';
+      const bioMissing = bio.trim() === '';
+      // A null cross-project (older server, or a principal with no platform
+      // identity) means "cannot tell" — do not invent a missing bio from it.
+      if (bioMissing && cross && !missing.includes('bio')) missing.push('bio');
+      if (!bioMissing) { const i = missing.indexOf('bio'); if (i !== -1) missing.splice(i, 1); }
+      renderProfileNudge({ ...nudge, missing, show: !nudge.dismissed && missing.length > 0 });
+    } catch (_) {
+      /* signed out, older server, or a hiccup: the nudge simply does not appear */
+    }
+  }
+
+  // task 1002802 (P06): dismiss the profile nudge. Delegated for the same reason
+  // as the triage verb above — the slice re-renders. Optimistic: the line goes
+  // away immediately (a dismissal that appears to fail is worse than one that
+  // silently retries), and the server flag makes it stay gone on every device.
+  document.addEventListener('click', (e) => {
+    const btn = e.target.closest('[data-profile-nudge-dismiss]');
+    if (!btn) return;
+    btn.disabled = true;
+    renderProfileNudge({ show: false });
+    patchJSON(`${API}/me/profile-nudge`, { dismissed: true })
+      .catch(() => loadProfileNudge()); // write failed → put the line back, honestly
+  });
+
+  // The CARD OWNER boots its slices: goal-inbox.js's mount() creates
+  // #attention-profile and then calls this, exactly as it calls its own load()
+  // and loadNodQueue(). No DOMContentLoaded race and no polling for the div —
+  // the widget registry mounts asynchronously after /me resolves, so a
+  // load-time call would reliably find nothing.
+  window.OTBProfileNudge = { load: loadProfileNudge, render: renderProfileNudge };
+})();

package/modules/lifecycle/goal-category.js

@@ -134,6 +134,33 @@ async function setGoalCategory({ goalId, categoryId }, deps = {}) {
   return rows[0] ?? null;
 }
 
+// -------------------------------------------------------------------------
+// The advisory (task 1003277)
+// -------------------------------------------------------------------------
+
+// adviseCategory — PURE, FAIL-OPEN (the goal-advisory.js posture: this is advice
+// appended to a request that ALREADY SUCCEEDED, so a wrong guess must nag nobody).
+// Returns null when the goal is categorised, or the advisory body when it is not.
+//
+// The criterion is explicit about what an uncategorised goal IS: "Claude assigns
+// where it can; where it cannot, the human is prompted to create a new category —
+// that failure is a designed prompt, not an error." So the advisory carries the
+// live SET (so the client can offer real choices, never hard-coded labels) and
+// names the create endpoint (so the prompt has somewhere to write into). It never
+// escalates past advice — the moment a missing category can refuse a write, the
+// label has become a gate (ADR 0192).
+function adviseCategory({ categoryId, categories = [] } = {}) {
+  if (categoryId != null) return null;
+  return {
+    reason: 'uncategorised',
+    message: 'This goal has no human category yet. A category orients a person scanning the board '
+      + '(it gates nothing — ADR 0192). Pick one from the set below via PATCH /goals/:id/category, '
+      + 'or — if none fits — ask the human to name a new one and create it with POST /work-categories: '
+      + 'that failure is a designed prompt, not an error.',
+    categories: categories.map((c) => ({ id: String(c.id), slug: c.slug, label: c.label })),
+  };
+}
+
 // -------------------------------------------------------------------------
 // Decoration
 // -------------------------------------------------------------------------
@@ -263,6 +290,7 @@ module.exports = {
   isValidSlug,
   listCategories,
   getCategory,
+  adviseCategory,
   createCategory,
   setGoalCategory,
   decorateGoalCategory,

package/modules/lifecycle/routes/goals.js

@@ -129,7 +129,16 @@ module.exports = function buildGoalsRouter() {
       if (succeedsId != null) {
         await db.setGoalSuccessor({ goalId: succeedsId, successorId: goal.id });
       }
-      return res.status(201).json({ ok: true, goal, succeeds_goal_id: succeedsId });
+      // task 1003277 — the category advisory, the goal_advisory precedent: advice
+      // on a request that already succeeded, null when the goal has a category.
+      // Best-effort: a failed set read must not turn advice into a 500.
+      let category_advisory = null;
+      if (categoryId === null) {
+        try {
+          category_advisory = goalCategory.adviseCategory({ categoryId, categories: await goalCategory.listCategories() });
+        } catch (_) { /* fail-open — advice only */ }
+      }
+      return res.status(201).json({ ok: true, goal, succeeds_goal_id: succeedsId, category_advisory });
     } catch (err) {
       log.error('[gds] POST /goals', err);
       return res.fail('goal_create_failed', { status: 500, message: 'internal error' });

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.372",
+  "version": "1.19.374",
   "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/bump-version.js

@@ -86,5 +86,45 @@ function isReleaseCommit(subject) {
   return RELEASE_COMMIT_RE.test(String(subject == null ? '' : subject));
 }
 
-module.exports = { bumpPatch, CONST_RE, RELEASE_COMMIT_RE, isReleaseCommit };
+// laneReleasedVersions — every version THIS lane has announced it published, read
+// from its own release commits (task 1003202).
+//
+// WHY THIS EXISTS. publish.yml used to answer "is HEAD's version already on the
+// registry?" with `npm view @bongos/core@<v>`. That needs a credential:
+// @bongos/core is PRIVATE, so an unauthenticated read is a flat E404, not a
+// "no". Moving the lane to OIDC trusted publishing removes the token — and OIDC
+// only authenticates `npm publish`, nothing else — so the old check would have
+// silently reported "not taken" on EVERY run, skipped the auto-bump, and then
+// collided on the already-published version. It would have looked fine for
+// exactly one release.
+//
+// The answer is already in the repo. Every version this lane ships is announced
+// by a `release: core X.Y.Z — CI auto-patch carrier` commit it writes itself, and
+// RELEASE_COMMIT_RE above is that contract. So the registry is not the only place
+// that knows; git knows too, needs no auth, and is the same source the cascade
+// terminator already trusts.
+//
+// Deliberately shares RELEASE_COMMIT_RE with isReleaseCommit, so a HUMAN release
+// commit ("release: core 1.19.2 — carrier for the init-blocker fixes") is NOT
+// counted here either — that version is new and still needs publishing, which is
+// exactly the distinction the constant was written to make.
+//
+// BOTH failure directions are safe, which is what makes this acceptable on a
+// release-critical lane:
+//   • commit written, publish then failed  → version looks taken, next run bumps
+//     past it. A gap in the version sequence; harmless.
+//   • published, commit push then failed   → version looks free, the publish
+//     retries and npm refuses with EPUBLISHCONFLICT. Loud, and nothing wrong ships.
+function laneReleasedVersions(subjects = []) {
+  const out = new Set();
+  for (const subject of subjects) {
+    const line = String(subject == null ? '' : subject);
+    if (!RELEASE_COMMIT_RE.test(line)) continue;
+    const m = /^release: core (\d+\.\d+\.\d+) /.exec(line);
+    if (m) out.add(m[1]);
+  }
+  return out;
+}
+
+module.exports = { bumpPatch, CONST_RE, RELEASE_COMMIT_RE, isReleaseCommit, laneReleasedVersions };
 if (require.main === module) main();

package/scripts/gds/fitness-checks-write-validation.js

@@ -41,6 +41,7 @@ const WRITE_VALIDATION_EXEMPT = new Set([
   'PATCH /me/model-allocation',   // per-slot tiers                — modelAllocPrefs.validatePatch
   'PATCH /me/render',             // { widgets: <bool>|null }      — renderPrefs.validatePatch
   'PATCH /me/display-name',       // { display_name }              — displayName.validate
+  'PATCH /me/profile-nudge',      // { dismissed: <bool>|null }    — profileNudgePrefs.validatePatch
 ]);
 
 // KNOWN GAPS, NOT EXEMPTIONS (task 1002551 / BV1.R109b → tracked by task 1002552).