@bongos/core 1.19.374 → 1.19.375

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),
     },

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/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/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/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"] },

package/modules/onboarding/routes/access-requests.js

@@ -10,11 +10,21 @@
 //   POST /api/bongos/access-requests          PUBLIC (the one unauthenticated GDS
 //                                          write) — a stranger submits their
 //                                          GitHub username; a pending row lands
-//                                          in the queue.
+//                                          in the queue. Refused outright on an
+//                                          invite-only project, and on an open
+//                                          one (sign in — you're in already).
 //   GET  /api/bongos/access-requests          Archon-only — the pending queue (and
 //                                          ?status=invited|dismissed history).
 //   PATCH /api/bongos/access-requests/:id     Archon-only — resolve a request:
 //                                          { status: 'invited' | 'dismissed' }.
+//   POST /api/bongos/access-requests/invite   Archon-only — invite a GitHub
+//                                          username before any request exists:
+//                                          the way in on an invite-only project.
+//
+// Which door a project runs — open / apply / invite_only — is the owner's
+// joinability setting, read through the doorway's joinabilityMode() (task
+// 1003044, ADR 0194): the same reader the sign-in gate uses, so this route and
+// the gate never disagree about whether a stranger may ask.
 //
 // The global IP rate-limiter (mounted in routes.js before every router) guards
 // the public POST against spam. A partial unique index on lower(github_login)
@@ -30,6 +40,14 @@ const auth = { requireBuilder: api.requireBuilder, requirePermission: api.requir
 const { pool } = api;
 const { validateOrRespond, parseId } = api;
 const approvalBroadcast = require('../approval-broadcast');
+const log = api.logger('onboarding');
+
+// The public refusal each door gives a would-be applicant — plain sentences,
+// shown as written by the hall, the CLI, and the hub's join relay.
+const DOOR_REFUSAL = {
+  invite_only: { code: 'invite_only', status: 403, message: 'This project is invite-only — it doesn’t take applications. If you’ve been invited, or already have an account, sign in with GitHub to enter.' },
+  open: { code: 'open_enrollment', status: 409, message: 'This project is open — no request needed. Sign in with GitHub and you’re in.' },
+};
 
 // GitHub usernames: 1–39 chars, alphanumeric or single hyphens, no leading/
 // trailing hyphen. We accept a leading '@' and strip it (people paste "@name").
@@ -46,6 +64,12 @@ module.exports = function buildAccessRequestsRouter() {
   // rank: public — the requester is by definition outside the system (no
   // builder row yet); this is the one public write on the GDS.
   router.post('/access-requests', async (req, res) => {
+    // The door answers first — before validation and before any lookup — so a
+    // refusal costs no query and reveals nothing about who already exists.
+    const refusal = DOOR_REFUSAL[api.joinabilityMode()];
+    if (refusal) {
+      return res.fail(refusal.code, { status: refusal.status, message: refusal.message });
+    }
     if (validateOrRespond(req, res, {
       github_login: { required: true, type: 'string', minLength: 1, maxLength: 60 },
       display_name: { type: 'string', maxLength: 100 },
@@ -204,5 +228,67 @@ module.exports = function buildAccessRequestsRouter() {
     }
   });
 
+  // POST /access-requests/invite — an Archon admits a GitHub username BEFORE any
+  // request exists (task 1003044): the only way in on an invite-only project,
+  // where the public POST refuses, and a shortcut on an apply one. It writes the
+  // same access_request row the sign-in gate reads (status 'invited' —
+  // hasInvitedAccessRequest), so nothing new is consulted at sign-in; a pending
+  // request for that login is resolved in place rather than duplicated. Two
+  // Archons inviting the same login at once can each insert a row (the unique
+  // index covers pending only): harmless — the gate reads "any invited row" —
+  // and it shows as two lines in the invited history, so no lock is taken.
+  // body: { github_login }. 201 with a new row; 200 with the row when a pending
+  // request was resolved; 200 already_invited when an invite already stands;
+  // 409 already_member when they have an account.
+  // rank: archon — the same gate as resolving a request.
+  router.post('/access-requests/invite', auth.requireBuilder, auth.requirePermission('access_request.review'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      github_login: { required: true, type: 'string', minLength: 1, maxLength: 60 },
+    })) return;
+    const login = normalizeLogin(req.body.github_login);
+    if (!GITHUB_LOGIN_RE.test(login)) {
+      return res.fail('bad_github_login', { status: 400, message: 'That does not look like a GitHub username.' });
+    }
+    try {
+      const member = await pool.query(
+        `SELECT 1 FROM builders WHERE lower(github_login) = lower($1) LIMIT 1`,
+        [login]
+      );
+      if (member.rows.length > 0) {
+        return res.fail('already_member', { status: 409, message: 'They already have an account here — no invite needed.' });
+      }
+      const standing = await pool.query(
+        `SELECT 1 FROM access_requests
+          WHERE lower(github_login) = lower($1) AND status = 'invited' LIMIT 1`,
+        [login]
+      );
+      if (standing.rows.length > 0) {
+        return res.json({ ok: true, already_invited: true, github_login: login });
+      }
+      const resolved = await pool.query(
+        `UPDATE access_requests
+            SET status = 'invited',
+                resolved_by_builder_id = $1,
+                resolved_at = now()
+          WHERE lower(github_login) = lower($2) AND status = 'pending'
+          RETURNING id, github_login, status, resolved_at`,
+        [req.builder.id, login]
+      );
+      if (resolved.rows.length > 0) {
+        return res.json({ ok: true, request: resolved.rows[0] });
+      }
+      const { rows } = await pool.query(
+        `INSERT INTO access_requests (github_login, status, resolved_by_builder_id, resolved_at)
+         VALUES ($1, 'invited', $2, now())
+         RETURNING id, github_login, status, resolved_at`,
+        [login, req.builder.id]
+      );
+      return res.status(201).json({ ok: true, request: rows[0] });
+    } catch (err) {
+      log.error('[gds] POST /access-requests/invite', err);
+      return res.fail('invite_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   return router;
 };

package/modules/platform-identity/routes/my-projects.js

@@ -16,6 +16,34 @@ const pi = require('../platform-identity');
 
 const { pool, requireBuilder, validateOrRespond, userAgent } = api;
 
+// joinRelayOutcome — what the project's own admission surface answered, said in
+// the HUB's words (task 1003044). The project decides; the hub relays and must
+// never paint a refusal as "requested" — nor as "unreachable". A 2xx is a filed
+// request; 409 already_member a standing membership; the door refusals (403
+// invite_only, 409 open_enrollment) name the door; a 401 is the project's
+// member-only visibility door (ADR 0192) refusing the ask itself. The project's
+// own sentence is deliberately NOT relayed: a registered project is trusted to
+// build, not to write prose into the platform's UI. Anything else is "not
+// relayed" (null) → the caller's 502.
+const RELAY_SENTENCE = {
+  requested: 'Requested access. The project’s owner admits new builders; once approved, sign in to enter.',
+  already_member: 'You already build on this project — sign in to it to see it here.',
+  invite_only: 'This project is invite-only — it doesn’t take requests. Ask its owner for an invite; once invited, sign in to it.',
+  open_enrollment: 'This project is open — no request needed. Sign in to it and you’re in.',
+  members_only: 'This project is only visible to its members right now, so it can’t take a request from here — ask its owner.',
+};
+function joinRelayOutcome(status, body) {
+  const err = (body && body.error) || null;
+  const code = err && (err.code || err);
+  let outcome;
+  if (status >= 200 && status < 300) outcome = 'requested';
+  else if (code === 'invite_only' || code === 'open_enrollment') outcome = code;
+  else if (status === 409) outcome = 'already_member';
+  else if (status === 401) outcome = 'members_only';
+  else return null;
+  return { status: outcome, message: RELAY_SENTENCE[outcome] };
+}
+
 module.exports = function myProjectsRoutes() {
   const router = express.Router();
 
@@ -56,27 +84,24 @@ module.exports = function myProjectsRoutes() {
       // Relay an access request to the project's OWN (public) admission endpoint —
       // the project decides (open-join, or request/invite per ADR 0112). We post to
       // the registry-trusted origin, never the caller's raw input.
-      let relayed = false;
-      let alreadyMember = false;
+      let outcome = null;
       try {
         const r = await fetch(`${client.origin}/api/gds/access-requests`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json', Accept: 'application/json', 'User-Agent': userAgent() },
           body: JSON.stringify({ github_login: req.builder.github_login, note: 'via platform My Projects' }),
         });
-        alreadyMember = r.status === 409;
-        relayed = r.ok || r.status === 200 || r.status === 201 || alreadyMember;
+        const body = await r.json().catch(() => null);
+        outcome = joinRelayOutcome(r.status, body);
       } catch (e) {
         console.log('[platform-identity] join relay failed (non-fatal):', e.message);
       }
-      if (!relayed) return res.fail('join_relay_failed', { status: 502, message: 'the project could not be reached to request access' });
+      if (!outcome) return res.fail('join_relay_failed', { status: 502, message: 'the project could not be reached to request access' });
       res.json({
         ok: true,
-        status: alreadyMember ? 'already_member' : 'requested',
+        status: outcome.status,
         project: { name: client.name, origin: client.origin },
-        message: alreadyMember
-          ? 'You already build on this project — sign in to it to see it here.'
-          : 'Requested access. The project’s owner admits new builders; once approved, sign in to enter.',
+        message: outcome.message,
       });
     } catch (err) {
       console.error('[platform-identity] POST /my-projects/join', err);
@@ -138,3 +163,4 @@ module.exports = function myProjectsRoutes() {
 
   return router;
 };
+module.exports.joinRelayOutcome = joinRelayOutcome;

package/package-lock.json

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

package/package.json

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