@bongos/core 1.20.55 → 1.20.56

package/modules/hall-ui/public/founding-mark.js

@@ -0,0 +1,67 @@
+// founding-mark.js — THE FOUNDING MARK in the hall (task 1004424 / BV2.PS10).
+//
+// Everyone who joined while the project was being founded carries a seed from its
+// genesis, numbered in join order; the project owner is "founder". The server works
+// that out (modules/onboarding/founding-builders.js, GET /api/bongos/founding/builders);
+// this file only shows it, in the hall's own badge grammar: a pill the height and type
+// of .rank-badge, with a seed dot in the accent. Four surfaces read it — the roster,
+// the profile, the ranks page and the founding wall on Home — and each one renders
+// exactly as before when the list is empty, which it is on every project that was
+// never founded (the blend rule: founding is a mode the hall wears, never a re-skin).
+//
+// It is a mark, not a rank: nothing here gates anything.
+(function () {
+  'use strict';
+
+  var STAGE_NAME = {
+    decide: 'decide', scope: 'scope', strategize: 'strategize',
+    charter: 'charter', legalize: 'legalize', legislation: 'legislation',
+  };
+
+  function esc(s) {
+    if (window.OTB && typeof window.OTB.escapeHtml === 'function') return window.OTB.escapeHtml(s);
+    return String(s == null ? '' : s).replace(/[&<>"']/g, function (c) {
+      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c];
+    });
+  }
+
+  // One request per page, shared by every surface on it. Any failure (signed out, the
+  // onboarding module off, a network blip) is an empty list: no marks, today's page.
+  var pending = null;
+  function load() {
+    if (pending) return pending;
+    pending = fetch('/api/bongos/founding/builders', { credentials: 'same-origin', headers: { Accept: 'application/json' } })
+      .then(function (r) { return r.ok ? r.json() : { builders: [] }; })
+      .then(function (d) { return Array.isArray(d && d.builders) ? d.builders : []; })
+      .catch(function () { return []; });
+    return pending;
+  }
+
+  // byId(list) — { builderId: mark } for the per-row surfaces.
+  function byId(list) {
+    var out = {};
+    (list || []).forEach(function (m) { if (m && m.builder_id != null) out[String(m.builder_id)] = m; });
+    return out;
+  }
+
+  // "founder" | "founding · #2" — the words on the pill.
+  function label(m) {
+    return m.founder ? 'founder' : 'founding · #' + m.number;
+  }
+
+  // "Founded the project" | "Joined at scope, day 3 of genesis" — the plain sentence.
+  function joinedLine(m) {
+    if (m.founder) return 'Founded the project';
+    var at = 'Joined at ' + (STAGE_NAME[m.stage] || m.stage || 'genesis');
+    return m.day ? at + ', day ' + m.day + ' of genesis' : at + ' during genesis';
+  }
+
+  function chipHtml(m) {
+    if (!m) return '';
+    var title = (m.founder ? 'Founder' : 'Founding builder #' + m.number) + ' — ' + joinedLine(m) + '. A mark for good; it grants nothing.';
+    return '<span class="founding-mark" title="' + esc(title) + '">'
+      + '<span class="founding-mark__seed" aria-hidden="true"></span>' + esc(label(m)) + '</span>';
+  }
+
+  window.OTBFounding = { load: load, byId: byId, label: label, joinedLine: joinedLine, chipHtml: chipHtml };
+}());

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

@@ -110,6 +110,37 @@
     '<p class="card-foot"><a href="#standing">All your work →</a></p>',
     { view: 'home', zone: 'home-main', labelledby: 'home-recent-h', hiddenByDefault: true });
 
+  // 0f. The founding wall (task 1004424) — everyone who joined while the project was
+  // being founded, founder first, each with their mark. Hidden until the founding
+  // list comes back non-empty, so a project that was never founded keeps today's Home.
+  // It fills itself rather than going through builders.js: the list is one read the
+  // other founding surfaces share (founding-mark.js), and nothing else on Home needs it.
+  reg({
+    id: 'home-founding', label: 'Founding builders', order: 30, core: true,
+    view: 'home', zone: 'home-main', labelledby: 'home-founding-h', hiddenByDefault: true,
+    mount(host) {
+      host.innerHTML =
+        '<h2 id="home-founding-h" class="scroll__h">The founding wall</h2>' +
+        '<p class="scroll__lede">Everyone who joined while this project was being founded, in the order they arrived. The mark is for good.</p>' +
+        '<ul class="founding-wall" id="founding-wall"></ul>';
+      if (!window.OTBFounding) return;
+      window.OTBFounding.load().then(function (list) {
+        if (!list.length) return;
+        var esc = window.OTB.escapeHtml;
+        var wall = host.querySelector('#founding-wall');
+        wall.innerHTML = list.map(function (m) {
+          var name = esc(m.display_name || m.github_login || 'builder');
+          var sub = m.founder ? 'founder' : '#' + m.number + ' · ' + esc(m.stage || 'genesis');
+          return '<li class="founding-wall__item">' +
+            '<span class="founding-wall__seed" aria-hidden="true"></span>' +
+            '<a class="founding-wall__name" href="/profile?id=' + encodeURIComponent(m.builder_id) + '">' + name + '</a>' +
+            '<span class="founding-wall__sub">' + sub + '</span></li>';
+        }).join('');
+        host.hidden = false;
+      });
+    },
+  });
+
   /* ---------------- Standing ---------------- */
 
   // 1. Profile — the identity band at the top of Standing (#726). No `group`:

package/modules/hall-ui/public/index-founding.states.json

@@ -0,0 +1,13 @@
+{
+  "_": "The founding wall on Home (task 1004424): the home-founding widget a founded project shows, from the kit fixture founding-builders-sample.json. The page itself is index.states.json's; only the founding read differs. The never-founded case is index.states.json, where the wall stays hidden. Run it with --states (Home has no last path segment).",
+  "page": "/builders/",
+  "surface": "hall-ui",
+  "stub": { "prefix": "/builders/", "fixtures": { "founding-builders": "founding-builders-sample" } },
+  "modeQuery": false,
+  "ignoreRequests": ["/api/(gds|bongos)/me$", "/api/(gds|bongos)/me/", "/api/(gds|bongos)/tasks", "/api/(gds|bongos)/claims", "/api/(gds|bongos)/goals", "/api/(gds|bongos)/inbox", "/api/(gds|bongos)/live", "/api/(gds|bongos)/analytics/", "/api/(gds|bongos)/achievements", "/api/(gds|bongos)/versions", "/api/(gds|bongos)/leaderboard", "/api/(gds|bongos)/removal-proposals", "/api/(gds|bongos)/blockers"],
+  "_ignored": "removal-proposals and blockers are fixtures the kit stub does not carry; index.states.json's home render reports the same two 404s, so they are not this variant's.",
+  "ignoreConsole": ["/api/(gds|bongos)/", "\\b401\\b", "\\b404\\b", "Unauthorized", "Not Found", "load failed"],
+  "states": {
+    "founding": { "auth": true, "actions": [["wait", 600], ["focus", ".founding-wall__name"]], "expect": { "visible": ["#home-founding"] } }
+  }
+}

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

@@ -119,7 +119,8 @@
      script (served only when the module is enabled) is injected by the server
      immediately before the builders.js tag below — that anchor is load-bearing
      (serve-internal.js injectModuleHallWidgets). -->
-<script src="/builders/hall-widgets.js?v=2026-06-27-r75" defer></script>
+<script src="/builders/founding-mark.js?v=2026-09-30-founding" defer></script>
+<script src="/builders/hall-widgets.js?v=2026-09-30-founding" defer></script>
 <!-- BV1.R78 (task 1694): the Goals widget registers into the same registry. -->
 <script src="/builders/goals.js?v=2026-07-01-goals" defer></script>
 <!-- task 1003455: the shared blocker-row renderer (window.OTBBlockersLib), read by

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

@@ -210,6 +210,7 @@
      exists when renderProfile runs; profile.js guards on it, so a page that
      omits this script simply has no charts section content. -->
 <script src="/builders/profile-charts.js?v=2026-09-04-calendar"></script>
-<script src="/builders/profile.js?v=2026-09-02-rail"></script>
+<script src="/builders/founding-mark.js?v=2026-09-30-founding"></script>
+<script src="/builders/profile.js?v=2026-09-30-founding"></script>
 </body>
 </html>

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

@@ -114,6 +114,23 @@
       </div>`;
   }
 
+  // ---- render: the founding mark (task 1004424) ----------------------------
+  // A builder who joined while the project was founding wears the seed badge beside
+  // their rank, and the head says when they joined. Added to the head renderHead
+  // already drew; a builder without the mark (or a project never founded) leaves the
+  // head exactly as it was.
+  function renderFoundingMark(builder) {
+    if (!window.OTBFounding || builder.id == null) return;
+    window.OTBFounding.load().then((list) => {
+      const mark = window.OTBFounding.byId(list)[String(builder.id)];
+      const row = document.querySelector('#profile-head .profile__name-row');
+      if (!mark || !row || row.querySelector('.founding-mark')) return;
+      row.insertAdjacentHTML('beforeend', window.OTBFounding.chipHtml(mark));
+      const stats = document.querySelector('#profile-head .profile__stats');
+      if (stats) stats.insertAdjacentHTML('afterend', `<p class="profile__founding">${escapeHtml(window.OTBFounding.joinedLine(mark))}</p>`);
+    });
+  }
+
   // ---- render: by the numbers ---------------------------------------------
 
   function tile(label, num, sub) {
@@ -764,6 +781,7 @@
     const shipped = Number(data.shipped_count) || 0;
     showMessage(`${name} — ${rankLabel(normalizeRank(builder.rank))} · ${fmtNum(shipped)} work${shipped === 1 ? '' : 's'} shipped`);
     renderHead(builder);
+    renderFoundingMark(builder);
     renderNumbers(data.shipped_count, data.achievements);
     // The charts (task 1003489) read the activity route and the credits ledger
     // (task 1003491), so they need the same session the ledgers do; on the

package/modules/hall-ui/public/ranks-founding.states.json

@@ -0,0 +1,12 @@
+{
+  "_": "The founding mark (task 1004424) on the Ranks page: the Founding builders ledger (builder, rank, mark) a founded project shows, from the kit fixture founding-builders-sample.json. The page itself is ranks.states.json's; only the founding read differs. The never-founded case is ranks.states.json, where the section stays hidden.",
+  "page": "/builders/ranks",
+  "surface": "hall-ui",
+  "stub": { "prefix": "/builders/", "fixtures": { "founding-builders": "founding-builders-sample" } },
+  "modeQuery": false,
+  "ignoreRequests": ["/api/(gds|bongos)/me$", "/api/(gds|bongos)/goals", "/api/(gds|bongos)/inbox/", "/api/(gds|bongos)/me/"],
+  "ignoreConsole": ["/api/(gds|bongos)/me", "\\b401\\b", "Unauthorized", "404 \\(Not Found\\)", "goals load failed"],
+  "states": {
+    "founding": { "auth": true, "actions": [["wait", 400]], "expect": { "visible": ["#founding-scroll"] } }
+  }
+}

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

@@ -39,6 +39,15 @@
           </div>
         </section>
 
+        <!-- The founding builders (task 1004424) — everyone who joined while the
+             project was founding, with their mark beside their rank. Hidden, and
+             never fetched into view, on a project that was never founded. -->
+        <section class="scroll" id="founding-scroll" aria-labelledby="founding-h" hidden>
+          <h2 id="founding-h" class="scroll__h">Founding builders</h2>
+          <p class="scroll__lede">Rank is earned by shipping work. The founding mark is for good: it is numbered in the order people joined while the project was being founded, and it grants nothing.</p>
+          <div id="founding-body"></div>
+        </section>
+
         <!-- The ladder — one card per rank. Current + next are shown in full;
              ranks beyond the next keep their unlock details hidden until the
              builder is one rank below them. -->
@@ -73,6 +82,7 @@
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB) — loaded before ranks.js, which pulls from it. -->
 <script src="/builders/dom-utils.js?v=2026-06-14-domutils"></script>
-<script src="/builders/ranks.js?v=2026-06-14-domutils"></script>
+<script src="/builders/founding-mark.js?v=2026-09-30-founding"></script>
+<script src="/builders/ranks.js?v=2026-09-30-founding"></script>
 </body>
 </html>

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

@@ -200,6 +200,31 @@
     // /me may return the builder under `.builder` or at the top level.
     const builder = (payload && payload.builder) ? payload.builder : payload;
     render(builder || {});
+    renderFounding();
+  }
+
+  // ---- the founding builders (task 1004424) ----
+  // A ledger of everyone who joined while the project was founding: builder, rank,
+  // and the mark. The section stays hidden when nobody carries one, so a project
+  // that was never founded shows today's page.
+  function renderFounding() {
+    const section = $('#founding-scroll');
+    const body = $('#founding-body');
+    if (!section || !body || !window.OTBFounding) return;
+    window.OTBFounding.load().then((list) => {
+      if (!list.length) return;
+      const rows = list.map((m) => {
+        const name = escapeHtml(m.display_name || m.github_login || 'builder');
+        return `<tr>
+            <td><a class="founding-name" href="/profile?id=${encodeURIComponent(m.builder_id)}">${name}</a>
+              <span class="founding-line">${escapeHtml(window.OTBFounding.joinedLine(m))}</span></td>
+            <td>${badge(m.rank)}</td>
+            <td>${window.OTBFounding.chipHtml(m)}</td>
+          </tr>`;
+      }).join('');
+      body.innerHTML = `<table class="ledger"><thead><tr><th>Builder</th><th>Rank</th><th>Mark</th></tr></thead><tbody>${rows}</tbody></table>`;
+      section.hidden = false;
+    });
   }
 
   load();

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

@@ -58,6 +58,7 @@
 <script src="/builders/dom-utils.js?v=2026-06-14-domutils"></script>
 <script src="/builders/brand-apply.js"></script>
 <script src="/builders/hall-kit.js"></script>
+<script src="/builders/founding-mark.js?v=2026-09-30-founding"></script>
 <script src="/builders/roster.js"></script>
 </body>
 </html>

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

@@ -157,10 +157,20 @@
     return '<span class="ledger__id">#' + esc(String(b.id)) + '</span>';
   }
 
+  // task 1004424: the founding mark — a seed badge under the builder for everyone who
+  // joined while the project was founding. Empty on a project that was never founded,
+  // so the row is exactly today's.
+  var marks = {};
+  function foundingHtml(b) {
+    var m = b.id != null ? marks[String(b.id)] : null;
+    if (!m || !window.OTBFounding) return '';
+    return '<span class="lb-founding">' + window.OTBFounding.chipHtml(m) + '</span>';
+  }
+
   function rowHtml(b) {
     return '<tr>'
       + '<td class="ledger__num ledger__place">' + esc(String(b.__place || '—')) + idHtml(b) + '</td>'
-      + '<td>' + whoHtml(b) + achRowHtml(b.achievements) + '</td>'
+      + '<td>' + whoHtml(b) + foundingHtml(b) + achRowHtml(b.achievements) + '</td>'
       + '<td class="ledger__rank">' + rankBadgeHtml(b.rank) + '</td>'
       + '<td class="ledger__num">' + esc(fmtInt(b.total_credits)) + '</td>'
       + '<td class="ledger__num">' + esc(fmtInt(b.karma)) + '</td>'
@@ -226,11 +236,17 @@
     rerender();
   }
 
+  var foundingLoad = window.OTBFounding ? window.OTBFounding.load() : Promise.resolve([]);
   fetch('/api/bongos/leaderboard', { headers: { Accept: 'application/json' } })
     .then(function (r) {
       if (!r.ok) throw new Error('http ' + r.status);
       return r.json();
     })
-    .then(function (data) { mountRoster(data && data.leaderboard); })
+    .then(function (data) {
+      return foundingLoad.then(function (list) {
+        marks = window.OTBFounding ? window.OTBFounding.byId(list) : {};
+        mountRoster(data && data.leaderboard);
+      });
+    })
     .catch(function () { notice('Couldn’t load the roster right now.'); });
 }());

package/modules/hall-ui/public/style.css

@@ -698,6 +698,41 @@ main:focus { outline: none; }
   .founding-band__desc { display: none; }
   .founding-band__stage { margin-left: 0; white-space: normal; }
 }
+/* task 1004424 (BV2.PS10): THE FOUNDING MARK. A pill in .rank-badge's grammar (same
+   height, type and radius) so it sits beside a rank without competing with it; the
+   seed is the accent, the founding band's live-state colour, because the mark is
+   that state made permanent. It confers nothing, so it is never a link. */
+.founding-mark {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  height: 24px;
+  padding: 0 9px 0 7px;
+  border-radius: 999px;
+  font-size: 11.5px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  white-space: nowrap;
+  color: var(--ink-soft);
+  background: color-mix(in srgb, var(--accent) 10%, transparent);
+  border: 1px solid color-mix(in srgb, var(--accent) 32%, transparent);
+}
+.founding-mark__seed,
+.founding-wall__seed {
+  width: 8px; height: 8px; border-radius: 50%; flex: none;
+  background: var(--accent);
+  box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 22%, transparent);
+}
+.lb-founding { display: block; margin-top: 4px; }
+.profile__founding { margin: 2px 0 0; font-size: 13px; color: var(--ink-soft); }
+/* The prose-link 24px floor: the target grows by padding, handed back by margin. */
+.founding-name { display: inline-block; padding: 3px 6px; margin: -3px -6px; }
+.founding-line { display: block; font-size: 12px; color: var(--ink-faint); }
+.founding-wall { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(auto-fill, minmax(140px, 1fr)); gap: 14px; }
+.founding-wall__item { display: grid; justify-items: center; gap: 4px; text-align: center; padding: 12px 8px; }
+.founding-wall__seed { width: 14px; height: 14px; margin-bottom: 4px; box-shadow: 0 0 0 4px color-mix(in srgb, var(--accent) 18%, transparent); }
+.founding-wall__name { padding: 4px 6px; margin: -4px -6px; font-weight: 500; color: var(--ink); }
+.founding-wall__sub { font-size: 11.5px; letter-spacing: 0.06em; text-transform: uppercase; color: var(--ink-faint); }
 .nav-item--asleep { opacity: 0.55; }
 .nav-item__wakes { display: none; margin-left: auto; font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--ink-faint); }
 .app-sidebar:hover .nav-item__wakes,

package/modules/hall-ui/records/founding-mark.md

@@ -0,0 +1,17 @@
+# The founding mark — a seed badge on the roster, the profile and the ranks page, and the founding wall on Home (task 1004424)
+
+**BV2.PS10 (goal 1000121; spec `docs/specs/<redacted>.md` D1).** The canvas frame is `docs/design/mocks/project-startup/FoundingBuilders.dc.html`. Everyone who joined while the project was being founded is a founding builder, numbered in join order; the project owner is "founder". **It is a mark, not a rank: it grants nothing**, and nothing in the hall or on the server reads it to decide anything.
+
+Files: `founding-mark.js` (`window.OTBFounding`: one shared read of `GET /api/bongos/founding/builders`, the pill, the plain "Joined at scope, day 3 of genesis" sentence), plus a few lines in `roster.js`, `profile.js`, `ranks.js` (+ a hidden `#founding-scroll` section in `ranks.html`) and the `home-founding` widget in `hall-widgets.js`. The CSS sits beside the founding band in `style.css`. The data is `modules/onboarding/founding-builders.js`.
+
+## Blended, not re-skinned
+
+The canvas draws its own hall chrome: a ranks table, seed images, an emblem wall. The live hall wins (the blend rule), so the mark is built from the hall's own parts:
+
+- **The pill is `.rank-badge`'s grammar**: the same 24px height, 11.5px/600 type and full radius, so it sits beside a rank without competing with it. The seed is a dot in `--accent`, the founding band's live-state colour, because the mark is that state made permanent. It is not a link, because it confers nothing.
+- **The ranks page has no builders table** (it shows the viewer's own standing), so the canvas's "column on the ranks page" is a `Founding builders` ledger section on that page: builder | rank | mark. It is not a new page.
+- **The wall is a core Home widget in `home-main`**, which brings that zone to its budget of three. It is hidden by default and fills itself from the shared read.
+
+## Off is today's hall
+
+A project that was never founded has no founding window, so the read returns an empty list without querying, and every surface renders exactly as before. The roster row of an unmarked builder is byte-identical, the ranks section stays `hidden`, and the wall never unhides. `tests/founding_builders.mjs` runs the real `roster.js` and `hall-widgets.js` to hold this. A signed-out viewer (the profile is public) gets a 401 on the read, which is the same empty list.

package/modules/onboarding/founding-builders.js

@@ -0,0 +1,127 @@
+'use strict';
+
+// modules/onboarding/founding-builders.js — THE FOUNDING MARK: who joined this project
+// while it was being founded, numbered in the order they arrived, and the genesis
+// stage each joined at (task 1004424 / BV2.PS10, goal 1000121; design of record
+// docs/design/mocks/project-startup/FoundingBuilders.dc.html).
+//
+// IT IS A MARK, NOT A RANK (spec D1). It confers nothing: no rank, no council seat, no
+// permission reads it. It exists to be shown — a badge on the roster and the profile,
+// a column on the ranks page, and the founding wall on the project's home.
+//
+// DERIVED, NOT STORED. The founding record founding-mode.js keeps is all the mark
+// needs: the window (founding.started_at .. founding.ended_at) and the time each stage
+// first became current (founding.stage_at.<stage>). A builder whose row was created in
+// the window joined during genesis, so their number is their place in join order and
+// their stage is the last stage stamped at or before their join. Every stamp is
+// write-once, so the mark is for good: nothing a later write does can renumber it.
+// That also means no sign-in path had to change to record a joiner.
+//
+// THE FOUNDER is the project owner (the doorway's getFoundingBuilder: the first human
+// builder) and is marked "founder" rather than numbered. Joiners count from #2, so the
+// founder is always the implied #1 and a founder who joins late cannot shift anyone.
+//
+// A project that was never founded has no window, and every read answers no marks at
+// all, so a hall that is not founding renders exactly as before.
+
+const { STAGES, KEYS, stageAtKey, dayOf } = require('./founding-mode');
+
+// A founding cohort is the people present at a project's birth — tens, not thousands.
+// The cap only bounds the query; past it the latest joiners simply go unshown.
+const MAX_MARKS = 500;
+
+const ms = (v) => {
+  if (!v) return NaN;
+  const t = new Date(v).getTime();
+  return Number.isFinite(t) ? t : NaN;
+};
+
+// stageAt(joinedAt, stageAt) — PURE. The stage that was current when a builder joined:
+// the last stage, in genesis order, first stamped at or before that moment. Before any
+// stamp (or with none recorded) it is 'decide', the pre-stage founding opens on.
+function stageAt(joinedAt, stamps) {
+  const t = ms(joinedAt);
+  let current = 'decide';
+  if (!Number.isFinite(t) || !stamps) return current;
+  for (const stage of STAGES) {
+    const s = ms(stamps[stage]);
+    if (Number.isFinite(s) && s <= t) current = stage;
+  }
+  return current;
+}
+
+// shapeFoundingBuilders({ startedAt, endedAt, stageAt, founderId, builders }) — PURE.
+// builders: rows of { id, created_at, ... } in any order. Returns the marks in join
+// order (founder first), or [] when the project was never founded.
+function shapeFoundingBuilders({ startedAt, endedAt, stageAt: stamps, founderId, builders } = {}) {
+  const start = ms(startedAt);
+  if (!Number.isFinite(start) || !Array.isArray(builders)) return [];
+  const end = ms(endedAt);
+  const inWindow = (b) => {
+    const t = ms(b.created_at);
+    return Number.isFinite(t) && t >= start && (!Number.isFinite(end) || t < end);
+  };
+  const ordered = builders
+    .filter((b) => b && b.id != null)
+    .slice()
+    .sort((a, b) => (ms(a.created_at) - ms(b.created_at)) || (Number(a.id) - Number(b.id)));
+  const pick = (b) => ({
+    builder_id: Number(b.id),
+    display_name: b.display_name || null,
+    github_login: b.github_login || null,
+    avatar_url: b.avatar_url || null,
+    rank: b.rank || null,
+  });
+  const marks = [];
+  const founder = founderId != null ? ordered.find((b) => String(b.id) === String(founderId)) : null;
+  if (founder) {
+    marks.push({ ...pick(founder), founder: true, number: 1, stage: 'decide', day: 1 });
+  }
+  let next = 2;
+  for (const b of ordered) {
+    if (founder && b === founder) continue;
+    if (!inWindow(b)) continue;
+    marks.push({
+      ...pick(b),
+      founder: false,
+      number: next++,
+      stage: stageAt(b.created_at, stamps),
+      day: dayOf(startedAt, new Date(b.created_at)),
+    });
+  }
+  return marks;
+}
+
+// foundingBuildersFor(deps) — the read behind GET /founding/builders. Never throws:
+// any failure is "no marks", which is how a hall that is not founding looks anyway.
+async function foundingBuildersFor(deps = {}) {
+  const api = deps.api || require('../../src/module-api');
+  const get = deps.getSetting || api.projectSettings.get;
+  try {
+    const value = async (key) => { const row = await get(key); return row && row.value ? row.value : null; };
+    const startedAt = await value(KEYS.STARTED_AT);
+    if (!startedAt) return [];
+    const [endedAt, ...stageValues] = await Promise.all([
+      value(KEYS.ENDED_AT), ...STAGES.map((s) => value(stageAtKey(s))),
+    ]);
+    const stamps = {};
+    STAGES.forEach((s, i) => { if (stageValues[i]) stamps[s] = stageValues[i]; });
+    const founder = await (deps.getFoundingBuilder || api.getFoundingBuilder)();
+    const founderId = founder ? founder.id : null;
+    const pool = deps.pool || api.pool;
+    const { rows } = await pool.query(
+      `SELECT id, github_login, display_name, avatar_url, rank, created_at
+         FROM builders
+        WHERE system_role IS NULL
+          AND (id = $1 OR (created_at >= $2 AND ($3::timestamptz IS NULL OR created_at < $3)))
+        ORDER BY created_at, id
+        LIMIT ${MAX_MARKS}`,
+      [founderId, startedAt, endedAt],
+    );
+    return shapeFoundingBuilders({ startedAt, endedAt, stageAt: stamps, founderId, builders: rows });
+  } catch (_) {
+    return [];
+  }
+}
+
+module.exports = { stageAt, shapeFoundingBuilders, foundingBuildersFor, MAX_MARKS };

package/modules/onboarding/founding-mode.js

@@ -47,8 +47,15 @@ const KEYS = Object.freeze({
   ACTIVE: 'founding.active',
   STAGE: 'founding.stage',
   STARTED_AT: 'founding.started_at',
+  // When the planet came alive (founding switched off). With STARTED_AT it bounds the
+  // window a builder must have joined in to carry the founding mark (task 1004424).
+  ENDED_AT: 'founding.ended_at',
 });
 
+// The key that records when a stage first became current, so a builder's join time
+// reads back as the stage they joined at (the founding mark, task 1004424).
+function stageAtKey(stage) { return `founding.stage_at.${stage}`; }
+
 // The only 'on' spelling accepted, mirroring mingle's consent-gate parse: an explicit,
 // recognised yes. Anything else is off.
 function parseActive(raw) {
@@ -160,26 +167,43 @@ function waitingOnFromGovernment(gov) {
 // (task 1004423) drives: start founding on a new project, move the stage, and switch
 // founding off when the planet comes alive. Refuses an unknown stage rather than storing
 // a value the read would then treat as OFF. Starting stamps started_at once.
+//
+// It also keeps the founding record the mark reads (task 1004424): the first time a
+// stage becomes current it is stamped (starting with no stage is 'decide'), and the
+// first switch-off after a start stamps ended_at. Every stamp is write-once, so the
+// record of who joined when is for good.
 async function setFoundingMode({ active, stage } = {}, builderId = null, deps = {}) {
   const settings = require('../../src/module-api').projectSettings;
   const get = deps.getSetting || settings.get;
   const set = deps.setSetting || settings.set;
+  const nowIso = (deps.now || new Date()).toISOString();
+  const stampOnce = async (key) => {
+    const cur = await get(key);
+    if (!cur || !cur.value) await set(key, nowIso, builderId);
+  };
   if (stage != null && !STAGES.includes(stage)) {
     const err = new Error(`unknown founding stage '${stage}'`);
     err.code = 'bad_founding_stage';
     throw err;
   }
   if (active === true) {
+    await stampOnce(KEYS.STARTED_AT);
+    if (stage == null) await stampOnce(stageAtKey('decide'));
+  }
+  if (active === false) {
     const started = await get(KEYS.STARTED_AT);
-    if (!started || !started.value) await set(KEYS.STARTED_AT, (deps.now || new Date()).toISOString(), builderId);
+    if (started && started.value) await stampOnce(KEYS.ENDED_AT);
   }
   if (typeof active === 'boolean') await set(KEYS.ACTIVE, active ? 'true' : 'false', builderId);
-  if (stage != null) await set(KEYS.STAGE, stage, builderId);
+  if (stage != null) {
+    await stampOnce(stageAtKey(stage));
+    await set(KEYS.STAGE, stage, builderId);
+  }
   return foundingModeFor({ getSetting: get, now: deps.now });
 }
 
 module.exports = {
-  STAGES, WAKES, WAKES_WHEN_ALIVE, KEYS,
+  STAGES, WAKES, WAKES_WHEN_ALIVE, KEYS, stageAtKey,
   parseActive, asleepRooms, dayOf, shapeFoundingMode, waitingOnFromGovernment,
   foundingModeFor, setFoundingMode,
 };

package/modules/onboarding/routes/onboarding.js

@@ -34,6 +34,7 @@ const express = require('express');
 const api = require('../../../src/module-api');
 const onboardingPort = require('../port');
 const buildAccessRequestsRouter = require('./access-requests');
+const foundingBuilders = require('../founding-builders');
 
 // Register the `onboarding` kernel PORT. See the header + port.js for the full
 // consumer list and the graceful-degradation contract.
@@ -50,5 +51,15 @@ module.exports = function buildOnboardingRouter() {
   // Archon-only resolve routes). Mounted on this same /api/bongos router by the
   // loader, before the public catch-all — byte-identical paths.
   router.use(buildAccessRequestsRouter());
+  // The founding mark (task 1004424): who joined while the project was founding, in
+  // join order, with the stage each joined at. Read by the roster, the profile, the
+  // ranks page and the home's founding wall; an empty list on a project that was
+  // never founded, so those surfaces render exactly as before. Signed-in, like the
+  // hall pages that read it; it carries nothing the roster does not already show.
+  router.get('/founding/builders', api.requireBuilder, async (req, res) => {
+    const builders = await foundingBuilders.foundingBuildersFor();
+    res.set('Cache-Control', 'private, max-age=60');
+    res.json({ builders });
+  });
   return router;
 };

package/modules/ui-design/kit/fixtures/founding-builders-sample.json

@@ -0,0 +1,9 @@
+{
+  "_": "The founding mark (task 1004424): GET /founding/builders on a project that was founded. Builder 1 is the kit's own signed-in builder (me.json), so the ranks and Home renders show the viewer as founder. Only the founding variant states files point at this; the default name has no file, so every other render is a never-founded project.",
+  "builders": [
+    { "builder_id": 1, "display_name": "A Builder", "github_login": "builder", "avatar_url": null, "rank": "archon", "founder": true, "number": 1, "stage": "decide", "day": 1 },
+    { "builder_id": 2, "display_name": "Avery Okonkwo-Lindqvist", "github_login": "avery", "avatar_url": null, "rank": "metic", "founder": false, "number": 2, "stage": "scope", "day": 3 },
+    { "builder_id": 3, "display_name": "Jordan", "github_login": "jordan", "avatar_url": null, "rank": "thetes", "founder": false, "number": 3, "stage": "strategize", "day": 8 },
+    { "builder_id": 4, "display_name": "Sam", "github_login": "sam", "avatar_url": null, "rank": "xenos", "founder": false, "number": 4, "stage": "legislation", "day": 19 }
+  ]
+}

package/modules/ui-design/kit/fixtures/founding-builders.json

@@ -0,0 +1,4 @@
+{
+  "_": "GET /founding/builders on a project that was never founded (task 1004424): the empty list every hall surface reads as 'no marks', so each render is today's page. The founding variants point the name at founding-builders-sample.json instead.",
+  "builders": []
+}

package/modules/ui-design/kit/serve.js

@@ -105,7 +105,10 @@ const FEEDS = {
   '/public/leaderboard': 'leaderboard',
   '/projects/featured': 'featured',
 };
-const AUTHED = { '/my-projects': 'my-projects', '/my-projects/invites': 'my-projects__invites' };
+// /founding/builders (task 1004424) answers a never-founded project's empty list by default,
+// so every existing render stays today's page; a founding variant states file points it at
+// founding-builders-sample via stub.fixtures.
+const AUTHED = { '/my-projects': 'my-projects', '/my-projects/invites': 'my-projects__invites', '/founding/builders': 'founding-builders' };
 const UNAUTH = { error: { code: 'unauthenticated', message: 'unauthenticated' } };
 
 // GET /provisioning/starter-bundles as the create wizard's module picker reads it

package/package-lock.json

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

package/package.json

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