@bongos/core 1.19.373 → 1.19.375

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

@@ -90,6 +90,8 @@ function createClient(opts = {}) {
       postAccessRequests: (args) => request("POST", "/access-requests", { hasBody: true }, args),
       // PATCH /access-requests/{id} — rank: archon — PATCH /access-requests/:id
       patchAccessRequestsId: (args) => request("PATCH", "/access-requests/{id}", { hasBody: true }, args),
+      // POST /access-requests/invite — rank: archon — POST /access-requests/invite
+      postAccessRequestsInvite: (args) => request("POST", "/access-requests/invite", { hasBody: true }, args),
       // GET /access-requests/status — rank: public — GET /access-requests/status
       getAccessRequestsStatus: (args) => request("GET", "/access-requests/status", { hasBody: false }, args),
     },
@@ -500,6 +502,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/government/catalog.js

@@ -127,7 +127,7 @@ const PERMISSIONS = [
   // one of them would make this delegation self-reversible.
   { key: 'builder.status.set', system: false, floor: 'archon', guards: 'PATCH /builders/:id/status — offboard / (de)activate' },
   { key: 'auth.session.revoke', system: false, floor: 'archon', guards: 'POST /auth/revoke, /auth/revoke-all' },
-  { key: 'access_request.review', system: false, floor: 'archon', guards: 'GET/PATCH /access-requests/:id — admit a builder' },
+  { key: 'access_request.review', system: false, floor: 'archon', guards: 'GET/PATCH /access-requests/:id, POST /access-requests/invite — admit a builder' },
 
   // ── operational — floor metic (the working rank's review/triage/authoring) ────
   { key: 'idea.triage', system: false, floor: 'metic', guards: 'PATCH /inbox/:id' },

package/modules/hall-ui/public/builders.js

@@ -79,9 +79,11 @@
       let code = null;
       try {
         const j = res.data;
-        // Prefer the human-facing message; fall back to the machine code.
-        detail = j.message || j.detail || j.error || detail;
-        code = j.error || null;
+        // Prefer the human-facing message; fall back to the machine code. The
+        // envelope (ADR 0116) nests both under `error`; older handlers answer flat.
+        const env = j.error && typeof j.error === 'object' ? j.error : null;
+        detail = (env && env.message) || j.message || j.detail || (typeof j.error === 'string' ? j.error : detail);
+        code = (env && env.code) || (typeof j.error === 'string' ? j.error : null);
       } catch (_) { /* keep default */ }
       const err = new Error(detail);
       err.status = res.status;

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/hall-render.js

@@ -238,23 +238,43 @@
       else standingRail = window.OTBKit.makeSectionRail({ mount: rail, items, mode: 'scrollspy' });
     }
   }
-  function renderLanding() {
-    // task 1723: collapse the shell nav to the signed-out minimum (Home + a
-    // Sign-in button). Cosmetic — the server gates every page regardless.
-    window.OTBShell?.applyAccess({ authed: false });
-
-    const welcome = $('#welcome-line');
-    if (welcome) welcome.textContent = '';
+  // The project's door, as the platform pushed it into this instance's pack
+  // (window.__BRANDING__.project.joinability, task 1003044): what a stranger is
+  // told to do next depends on it. An older pack reports none → 'apply', today's
+  // behaviour. Cosmetic — the server refuses on its own terms either way.
+  function joinabilityMode() {
+    const p = window.__BRANDING__ && window.__BRANDING__.project;
+    const v = p && p.joinability;
+    return v === 'open' || v === 'invite_only' ? v : 'apply';
+  }
 
-    const landing = $('#landing-root');
-    if (landing) {
-      landing.hidden = false;
-      landing.innerHTML = `
-        <div class="scroll landing">
-          <h2 class="scroll__h">Welcome</h2>
+  // One landing per door: open → sign in and you're in; invite_only → nothing to
+  // apply for, sign in once invited; apply → the request form.
+  function landingDoorHtml(mode) {
+    const hub = `This is the builders' hub for ${brandWorld()} — where builders claim work, earn ${curLabel()}, and track their standing.`;
+    const admitter = escapeHtml(rankLabel('archon'));
+    const signIn = `<p class="landing__cta"><a class="landing__btn" href="${API}/auth/web/start">Sign in with GitHub</a></p>`;
+    if (mode === 'open') {
+      return `
+          <p class="landing__lede">${hub} Anyone with a GitHub account can join: sign in and you're in, starting at the newcomer rank.</p>
+          <div class="landing__request" id="landing-request">
+            <h3 class="landing__request-h">New here — sign in to join</h3>
+            <p class="landing__request-lede">No request and no invite needed. Sign in with GitHub, and a step-by-step guide takes you the rest of the way.</p>
+            ${signIn}
+          </div>`;
+    }
+    if (mode === 'invite_only') {
+      return `
+          <p class="landing__lede">${hub} This project is invite-only: the ${admitter} invites each builder, and there is nothing to apply for here.</p>
+          <div class="landing__request" id="landing-request">
+            <h3 class="landing__request-h">Invited? Sign in</h3>
+            <p class="landing__request-lede">If the ${admitter} has invited you, sign in with GitHub and you're in. If not, ask them for an invite — this project doesn't take requests.</p>
+            ${signIn}
+          </div>`;
+    }
+    return `
           <p class="landing__lede">
-            This is the builders' hub for ${brandWorld()} — where builders claim
-            work, earn ${curLabel()}, and track their standing. Access is
+            ${hub} Access is
             invite-based: an Archon approves each new builder. To begin, request
             access below.
           </p>
@@ -290,7 +310,24 @@
               <button type="submit" class="landing__btn landing__btn--request" id="ar-submit">Request access</button>
               <p class="landing__request-status" id="ar-status" aria-live="polite"></p>
             </form>
-          </div>
+          </div>`;
+  }
+
+  function renderLanding() {
+    // task 1723: collapse the shell nav to the signed-out minimum (Home + a
+    // Sign-in button). Cosmetic — the server gates every page regardless.
+    window.OTBShell?.applyAccess({ authed: false });
+
+    const welcome = $('#welcome-line');
+    if (welcome) welcome.textContent = '';
+
+    const landing = $('#landing-root');
+    if (landing) {
+      landing.hidden = false;
+      landing.innerHTML = `
+        <div class="scroll landing">
+          <h2 class="scroll__h">Welcome</h2>
+          ${landingDoorHtml(joinabilityMode())}
 
           <p class="landing__signin-note">
             Already a member? <a href="${API}/auth/web/start">Sign in with GitHub</a>.
@@ -346,15 +383,19 @@
             </p>`;
         }
       } catch (err) {
-        // Already known to the city — they don't need a request, they need to
-        // sign in. Both the "already a builder" and "already approved" cases
-        // collapse the form into a sign-in prompt rather than a red error.
-        if (err && (err.code === 'already_member' || err.code === 'already_approved')) {
+        // The door's own answers — already a builder, already approved, or a
+        // project that takes no requests (invite-only) / needs none (open) —
+        // collapse the form into what to do instead: sign in. Never a red error.
+        const code = err && err.code;
+        if (code === 'already_member' || code === 'already_approved' || code === 'invite_only' || code === 'open_enrollment') {
           const req = $('#landing-request');
           if (req) {
+            const heading = code === 'invite_only' ? 'This project is invite-only'
+              : code === 'open_enrollment' ? 'No request needed'
+                : 'You already have access ✓';
             req.innerHTML = `
-              <h3 class="landing__request-h">You already have access ✓</h3>
-              <p class="landing__request-lede">${escapeHtml(err.message || 'You already have access.')}</p>
+              <h3 class="landing__request-h">${heading}</h3>
+              <p class="landing__request-lede">${escapeHtml(err.message || 'Sign in with GitHub to continue.')}</p>
               <p class="landing__cta">
                 <a class="landing__btn" href="${API}/auth/web/start">Sign in with GitHub</a>
               </p>`;

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/my-projects.js

@@ -130,7 +130,12 @@
       .then(function (r) { return r.json().then(function (b) { return { ok: r.ok, body: b }; }); })
       .then(function (res) {
         joinBtn.disabled = false;
-        if (res.ok && res.body && res.body.message) { joinNote.textContent = res.body.message; joinInput.value = ''; load(); }
+        if (res.ok && res.body && res.body.message) {
+          joinNote.textContent = res.body.message;
+          /* a door refusal rides a 200 (task 1003044): keep the address, and don't repaint as if a request went out */
+          var refused = res.body.status === 'invite_only' || res.body.status === 'open_enrollment' || res.body.status === 'members_only';
+          if (!refused) { joinInput.value = ''; load(); }
+        }
         else if (res.body && res.body.error && res.body.error.code === 'unknown_project') { joinNote.textContent = 'That project isn’t on the platform.'; }
         else { joinNote.textContent = 'Could not request access right now.'; }
       })

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/hall-ui/public/watch.css

@@ -182,3 +182,11 @@ table.watch tr:hover td { background: var(--surface-2); }
   font-size: 13px; font-weight: 500;
   color: var(--accent-text);
 }
+
+/* Invite by GitHub username (task 1003044) — the Access requests section's own
+   form: the way in on an invite-only project, a shortcut on an apply one. */
+.watch-invite { margin: 0 0 14px; padding: 12px 14px; border: 1px solid var(--line, #e5e0d6); border-radius: 10px; }
+.watch-invite__label { display: block; font-weight: 600; margin-bottom: 6px; }
+.watch-invite__row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.watch-invite__row input[type="text"] { flex: 1 1 200px; min-width: 0; }
+.watch-invite__why { margin: 8px 0 0; font-size: 13px; opacity: .8; }

package/modules/hall-ui/public/watch.js

@@ -88,7 +88,11 @@
     const res = await api.request('POST', `${API}${path}`, { body: body || {} });
     if (res.status === 401) { window.location.assign(`${API}/auth/web/start`); throw { kind: '401' }; }
     const data = res.data || {};
-    if (!res.ok) throw new Error(data.message || data.error || `${path} → ${res.status}`);
+    if (!res.ok) {
+      // the envelope (ADR 0116) nests the sentence under `error`; older handlers answer flat
+      const env = data.error && typeof data.error === 'object' ? data.error : null;
+      throw new Error((env && env.message) || data.message || (typeof data.error === 'string' ? data.error : '') || `${path} → ${res.status}`);
+    }
     return data;
   }
 
@@ -183,14 +187,62 @@
   // 1. GATE — access requests (pending)
   // =========================================================================
 
+  // Invite by GitHub username (task 1003044): admits someone BEFORE any request
+  // exists — the only way in on an invite-only project, where nobody can apply,
+  // and a shortcut on an apply one. POST /access-requests/invite writes the same
+  // 'invited' row the sign-in gate reads. The door the project runs comes from
+  // the pack the server injected (window.__BRANDING__.project.joinability).
+  function inviteFormHtml() {
+    const p = window.__BRANDING__ && window.__BRANDING__.project;
+    const mode = (p && p.joinability) || 'apply';
+    const why = mode === 'invite_only'
+      ? 'This project is invite-only — nobody can apply, so this is how people get in.'
+      : mode === 'open'
+        ? 'This project is open — anyone who signs in is admitted, so an invite is rarely needed.'
+        : 'Admit someone before they ask — once invited, their sign-in gets in.';
+    return (
+      '<form class="watch-invite" id="gate-invite" novalidate>' +
+      '<label class="watch-invite__label" for="gate-invite-login">Invite by GitHub username</label>' +
+      '<div class="watch-invite__row">' +
+      '<input type="text" id="gate-invite-login" name="github_login" autocomplete="off" placeholder="e.g. octocat" maxlength="40">' +
+      '<button type="submit" class="watch-btn">Invite</button>' +
+      '</div>' +
+      `<p class="watch-invite__why">${escapeHtml(why)}</p>` +
+      '</form>'
+    );
+  }
+
+  function wireInviteForm(target) {
+    const form = target.querySelector('#gate-invite');
+    if (!form) return;
+    form.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      const input = form.querySelector('#gate-invite-login');
+      const login = ((input && input.value) || '').trim().replace(/^@/, '');
+      if (!login) { toast('A GitHub username is needed.'); return; }
+      const btn = form.querySelector('button[type="submit"]');
+      if (btn) btn.disabled = true;
+      try {
+        const r = await postJson('/access-requests/invite', { github_login: login });
+        toast(r.already_invited ? `@${login} is already invited.` : `@${login} invited — their sign-in gets in.`);
+        await loadGate();
+      } catch (err) {
+        if (err && err.kind === '401') return;
+        if (btn) btn.disabled = false;
+        toast(`Could not invite: ${err.message || err}`);
+      }
+    });
+  }
+
   function renderGate(data, target) {
     const requests = Array.isArray(data.requests) ? data.requests : [];
     setAttention('att-access', requests.length); // tile count = table content
     if (!requests.length) {
-      target.innerHTML = emptyStateHtml('No pending access requests.');
+      target.innerHTML = inviteFormHtml() + emptyStateHtml('No pending access requests.');
+      wireInviteForm(target);
       return;
     }
-    target.innerHTML = requests
+    target.innerHTML = inviteFormHtml() + requests
       .map((r) => {
         const who = r.display_name
           ? `${escapeHtml(r.display_name)} <span class="watch-mono">@${escapeHtml(r.github_login)}</span>`
@@ -221,6 +273,7 @@
       toast(status === 'invited' ? 'Builder invited.' : 'Request dismissed.');
       await loadGate();
     }, 'Could not resolve');
+    wireInviteForm(target);
   }
 
   function loadGate() {

package/modules/onboarding/module.json

@@ -2,7 +2,7 @@
   "key": "onboarding",
   "title": "Onboarding (admission · setup · newcomer floor)",
   "description": "The newcomer ADMISSION + ORIENTATION domain — the public access-request → Archon-approval gate, the server-ticked onboarding state machine (the 'Path into the City' checklist that graduates a Xenos to Thetes), the friction analyzer (feedback-without-asking on consented onboarding transcripts), and the evergreen newcomer-chore restock (a fresh first-builder task is always waiting). A core-domain module carved out of the GDS core in BV1.R81 (ADR 0093 §1); default-on because every instance onboards its own builders. The access-requests admission routes mount here; the core lifecycle (db.js claim/ship), auth callbacks, and the me/builders profile readers resolve the `onboarding` kernel PORT for the state-machine + restock surface they need — never importing the module.",
-  "coreVersion": "^1.9.0",
+  "coreVersion": "^1.19.374",
   "default": true,
   "maintenance": { "status": "core-maintained" },
   "contributes": { "routes": ["onboarding"] },