@bongos/core 1.20.53 → 1.20.54

package/modules/government/recommendations.js

@@ -0,0 +1,218 @@
+'use strict';
+
+// modules/government/recommendations.js — what government and which ranks this
+// project should start from, by PROJECT TYPE and SIZE (task 1004400, criterion
+// wa7-government: "Recommended base ranks and governments ship for different
+// project types and sizes").
+//
+// TWO INPUTS. `type` is one of the project types the create flow declares
+// (game / research / business / non-profit / not-sure — the vocabulary of
+// platform_identity_006 and provisioning_007; mirrored here because a module
+// may not import a sibling, ADR 0083, and held equal by
+// tests/government_recommendations.mjs). `headcount` is the live count of active
+// builders (db.countActiveBuilders) or a size the reader asks about. An unknown
+// type reads as `not-sure`, and an unreadable headcount reads as the founding
+// size. Neither ever throws.
+//
+// NEVER AN UNADOPTABLE CHARTER. The ladder this started from (the Six Variables
+// synthesis) names Presidential at ~9 and Federation past ~150, and the old
+// recommendation returned both, though neither can be adopted: they need
+// elections and federated chambers this system does not have. So the ladder now
+// resolves every size to an AVAILABLE form in charter.js FORMS, and when the
+// ladder's own shape is one that is coming later, the answer says so in
+// `later` rather than recommending it. A test walks every type × size.
+//
+// A FOUNDATION ALWAYS COMES WITH ITS COUNCIL. Foundation is governed by a
+// custom rank the project names. Wherever this file recommends it, the
+// recommended rank set carries that rank and the charter names it in
+// `council_rank`, so the recommendation can be followed end to end: add the
+// ranks, assign the council, propose the charter.
+//
+// RANK SETS ADD TO THE LADDER, NEVER REPLACE IT. The four seeded ranks are
+// every project's base (xenos → archon) and their grants come from the
+// catalog. A recommended set is the CUSTOM ranks worth adding at a type and
+// size, each with a short grant list. Every grant must be one a custom rank can
+// actually hold (catalog.isGrantableTo) — checked by test, and filtered again
+// where a set is applied, so a set can never write what the toggle refuses.
+//
+// Pure and DB-free.
+
+const charter = require('./charter');
+
+const freeze = (o) => Object.freeze(o);
+
+// ── project types ────────────────────────────────────────────────────────────
+const PROJECT_TYPES = freeze([
+  freeze({ key: 'game', name: 'Game' }),
+  freeze({ key: 'research', name: 'Research' }),
+  freeze({ key: 'business', name: 'Business' }),
+  freeze({ key: 'non-profit', name: 'Non-profit' }),
+  freeze({ key: 'not-sure', name: 'Not sure yet' }),
+]);
+const TYPE_KEYS = PROJECT_TYPES.map((t) => t.key);
+
+function normalizeType(type) {
+  return TYPE_KEYS.includes(type) ? type : 'not-sure';
+}
+
+// ── sizes ────────────────────────────────────────────────────────────────────
+// The ladder's own thresholds. `example` is the headcount a reader asking
+// "what about a project this size" is shown.
+const SIZE_BANDS = freeze([
+  freeze({ key: 'solo', name: 'Just you, or two', min: 0, max: 2, example: 1 }),
+  freeze({ key: 'circle', name: '3 to 8 builders', min: 3, max: 8, example: 5 }),
+  freeze({ key: 'team', name: '9 to 49 builders', min: 9, max: 49, example: 20 }),
+  freeze({ key: 'organisation', name: '50 to 149 builders', min: 50, max: 149, example: 80 }),
+  freeze({ key: 'large', name: '150 builders or more', min: 150, max: Infinity, example: 200 }),
+]);
+
+function sizeBandFor(headcount) {
+  const n = Math.max(0, Math.floor(Number(headcount) || 0));
+  return SIZE_BANDS.find((b) => n >= b.min && n <= b.max);
+}
+
+// ── the jobs a rank set is made of ──────────────────────────────────────────
+// Three jobs a growing project hands out beyond the ladder. The grants are the
+// operational keys that job needs — never a trust-boundary key (a custom rank
+// cannot hold one, ADR 0172).
+const JOB_GRANTS = freeze({
+  reviewer: freeze(['criterion.review', 'task.vote', 'idea.triage']),
+  lead: freeze(['task.create', 'task.edit', 'task.promote', 'task.dependency.manage',
+    'goal.manage.own', 'idea.triage', 'criterion.review']),
+  council: freeze(['board.item.open', 'idea.ratify', 'criterion.satisfy', 'criterion.unsatisfy',
+    'goal.create', 'priority.run']),
+});
+
+// What each type calls those jobs. The rank key is what gets created, so it is
+// a kebab-case slug the rank API accepts.
+const JOB_NAMES = freeze({
+  game: freeze({
+    reviewer: freeze({ key: 'playtester', label: 'Playtester', description: 'Plays the builds, checks work against what "done" means, and sorts incoming ideas.' }),
+    lead: freeze({ key: 'design-lead', label: 'Design lead', description: 'Shapes the work: writes and orders tasks and looks after the goals they own.' }),
+    council: freeze({ key: 'studio-council', label: 'Studio council', description: 'Sits on the board: decides what the game becomes and when a goal is met.' }),
+  }),
+  research: freeze({
+    reviewer: freeze({ key: 'peer-reviewer', label: 'Peer reviewer', description: 'Reviews results against the criteria and sorts incoming ideas.' }),
+    lead: freeze({ key: 'principal-investigator', label: 'Principal investigator', description: 'Shapes a line of work: writes and orders its tasks and looks after its goals.' }),
+    council: freeze({ key: 'steering-committee', label: 'Steering committee', description: 'Sits on the board: sets the research direction and decides when a goal is met.' }),
+  }),
+  business: freeze({
+    reviewer: freeze({ key: 'reviewer', label: 'Reviewer', description: 'Checks work against what "done" means and sorts incoming ideas.' }),
+    lead: freeze({ key: 'product-lead', label: 'Product lead', description: 'Shapes the product: writes and orders tasks and looks after the goals they own.' }),
+    council: freeze({ key: 'leadership-council', label: 'Leadership council', description: 'Sits on the board: sets direction and decides when a goal is met.' }),
+  }),
+  'non-profit': freeze({
+    reviewer: freeze({ key: 'reviewer', label: 'Reviewer', description: 'Checks work against what "done" means and sorts incoming ideas.' }),
+    lead: freeze({ key: 'programme-lead', label: 'Programme lead', description: 'Runs a programme: writes and orders its tasks and looks after its goals.' }),
+    council: freeze({ key: 'trustees', label: 'Trustees', description: 'Sits on the board: holds the mission and decides when a goal is met.' }),
+  }),
+  'not-sure': freeze({
+    reviewer: freeze({ key: 'reviewer', label: 'Reviewer', description: 'Checks work against what "done" means and sorts incoming ideas.' }),
+    lead: freeze({ key: 'lead', label: 'Lead', description: 'Shapes the work: writes and orders tasks and looks after the goals they own.' }),
+    council: freeze({ key: 'council', label: 'Council', description: 'Sits on the board: sets direction and decides when a goal is met.' }),
+  }),
+});
+
+// "a game project", or plain "a project" when the type is not known.
+const projectPhrase = (type) => (type === 'not-sure' ? 'a project' : `a ${PROJECT_TYPES.find((t) => t.key === type).name.toLowerCase()} project`);
+
+// ── the charter ladder, resolved to forms that can be adopted ───────────────
+// One row per size. `form` must be AVAILABLE in charter.js FORMS. `later` names
+// the ladder's own shape at that size when it is one still to come. A type may
+// override a size (a non-profit is governed by trustees early).
+const CHARTER_LADDER = freeze({
+  solo: freeze({ form: 'monarchy', rung: 'solo/pair',
+    why: 'informal coordination has nothing to break yet — the founding monarchy is the honest shape' }),
+  circle: freeze({ form: 'direct-democracy', rung: 'circle (3–8)',
+    why: 'a consent circle of every builder (rank:xenos+) — small enough that everyone can decide together' }),
+  team: freeze({ form: 'timocratic-republic', rung: '~9: the circle gets too big', later: 'presidential',
+    why: 'past ~9, everyone deciding everything stops working — the builders who have earned the trusted rank (rank:metic+) decide by consent' }),
+  organisation: freeze({ form: 'foundation', rung: '~50: written charter + council',
+    why: 'past ~50, the charter must be written down and a council you appoint carries it' }),
+  large: freeze({ form: 'foundation', rung: '~150: a council carries it', later: 'federation',
+    why: 'past ~150 the ladder federates into self-governing teams; until that exists, a council you appoint carries the charter' }),
+});
+
+const TYPE_OVERRIDES = freeze({
+  'non-profit': freeze({
+    team: freeze({ form: 'foundation', rung: '~9: trustees hold the mission',
+      why: 'a non-profit answers to its mission, so trustees you appoint carry it as soon as the circle is too big to decide together' }),
+  }),
+});
+
+const formByKey = (key) => charter.FORMS.find((f) => f.key === key) || null;
+
+function recommendedCharter(headcount, type) {
+  const t = normalizeType(type);
+  const size = sizeBandFor(headcount);
+  const row = (TYPE_OVERRIDES[t] && TYPE_OVERRIDES[t][size.key]) || CHARTER_LADDER[size.key];
+  const form = formByKey(row.form);
+  const later = row.later ? formByKey(row.later) : null;
+  const councilRank = row.form === 'foundation' ? JOB_NAMES[t].council.key : null;
+  return freeze({
+    key: row.form,
+    name: form.name,
+    rung: row.rung,
+    why: row.why,
+    type: t,
+    size: size.key,
+    council_rank: councilRank,
+    later: later ? freeze({ key: later.key, name: later.name, explanation: later.explanation }) : null,
+  });
+}
+
+// ── the rank set ─────────────────────────────────────────────────────────────
+// Which jobs a size hands out. Any size whose charter is a Foundation also gets
+// the council (that is the non-profit's team size), so the two recommendations
+// never disagree.
+const SIZE_JOBS = freeze({
+  solo: freeze([]),
+  circle: freeze(['reviewer']),
+  team: freeze(['reviewer', 'lead']),
+  organisation: freeze(['reviewer', 'lead', 'council']),
+  large: freeze(['reviewer', 'lead', 'council']),
+});
+
+function recommendedRankSet(type, headcount) {
+  const t = normalizeType(type);
+  const size = sizeBandFor(headcount);
+  const jobs = [...SIZE_JOBS[size.key]];
+  if (recommendedCharter(headcount, t).council_rank && !jobs.includes('council')) jobs.push('council');
+  const ranks = jobs.map((job) => freeze({
+    job,
+    rank_key: JOB_NAMES[t][job].key,
+    label: JOB_NAMES[t][job].label,
+    description: JOB_NAMES[t][job].description,
+    permissions: JOB_GRANTS[job],
+  }));
+  const why = ranks.length
+    ? `At this size ${projectPhrase(t)} hands out ${ranks.length === 1 ? 'one job' : `${ranks.length} jobs`} beyond the four standard ranks. Each is added as a custom rank you can edit or delete.`
+    : 'At this size the four standard ranks are enough — there is nobody yet to hand a separate job to.';
+  return freeze({ type: t, size: size.key, why, ranks: freeze(ranks) });
+}
+
+// Both recommendations for one project, plus the vocabulary a page needs to
+// let a reader ask about another type or size.
+function recommendationsFor({ type, headcount } = {}) {
+  return freeze({
+    type: normalizeType(type),
+    headcount: Math.max(0, Math.floor(Number(headcount) || 0)),
+    size: sizeBandFor(headcount).key,
+    charter: recommendedCharter(headcount, type),
+    rank_set: recommendedRankSet(type, headcount),
+    project_types: PROJECT_TYPES,
+    size_bands: SIZE_BANDS.map((b) => freeze({ key: b.key, name: b.name, example: b.example })),
+  });
+}
+
+module.exports = {
+  PROJECT_TYPES,
+  SIZE_BANDS,
+  JOB_GRANTS,
+  JOB_NAMES,
+  normalizeType,
+  sizeBandFor,
+  recommendedCharter,
+  recommendedRankSet,
+  recommendationsFor,
+};

package/modules/government/routes/government.js

@@ -25,6 +25,7 @@ const db = require('../db');
 const sessionScopes = require('../session-scopes');
 const boardMembership = require('../board-membership');
 const board = require('../board');
+const recommendations = require('../recommendations');
 // task 1003208: structured logging (pino via the doorway) — was console.*.
 const log = api.logger('government');
 
@@ -302,6 +303,45 @@ module.exports = function buildGovernmentRouter() {
     }
   });
 
+  // rank: perm government.manage — add a RECOMMENDED RANK SET (task 1004400):
+  // the custom ranks recommendations.js names for a project type and size, each
+  // with its grants. It is the create form and the grant toggle run in a loop,
+  // under the same checks: a rank that already exists is LEFT ALONE (never
+  // re-granted, never relabelled — an owner may have edited it), and every grant
+  // is re-checked with catalog.isGrantableTo, so a set can never write what the
+  // toggle would refuse. Re-applying is safe; the reply says what was added.
+  router.post('/government/rank-sets/apply', api.requireBuilder, api.requirePermission('government.manage'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      type: { type: 'string', maxLength: 32 },
+      headcount: { required: true, type: 'integer', min: 0, max: 100000 },
+    })) return;
+    const set = recommendations.recommendedRankSet(req.body.type, req.body.headcount);
+    const created = [];
+    const skipped = [];
+    try {
+      for (const r of set.ranks) {
+        if (await db.getRankByKey(r.rank_key)) { skipped.push(r.rank_key); continue; }
+        let rank;
+        try {
+          rank = await db.createRank({ rankKey: r.rank_key, label: r.label, description: r.description, createdBy: req.builder.id });
+        } catch (err) {
+          if (err && err.code === '23505') { skipped.push(r.rank_key); continue; }
+          throw err;
+        }
+        const granted = [];
+        for (const key of r.permissions) {
+          if (!catalog.byKey(key) || !catalog.isGrantableTo(key, rank)) continue;
+          if (await db.grantRankPermission({ rankKey: r.rank_key, permissionKey: key })) granted.push(key);
+        }
+        created.push({ rank_key: r.rank_key, label: r.label, permissions: granted });
+      }
+      res.json({ ok: true, type: set.type, size: set.size, created, skipped });
+    } catch (err) {
+      log.error('[gds] POST /government/rank-sets/apply', err);
+      res.fail('rank_set_apply_failed', { status: 500, message: 'internal error', details: { created, skipped } });
+    }
+  });
+
   // rank: perm government.manage — grant one permission to a rank (the toggle's ON
   // half). The order of refusals is the authority order: rank exists → rank is not
   // the Archon one → the key exists → the key is grantable TO THIS RANK.
@@ -465,7 +505,13 @@ module.exports = function buildGovernmentRouter() {
   // immediately (the same instant-effect posture as everything else here).
   router.get('/government/constitution', api.requireBuilder, api.requirePermission('board.vote.cast'), async (req, res) => {
     try {
-      res.json(await board.constitutionView({ historyLimit: 50 }));
+      // ?type= and ?headcount= ask about another project type or size (task
+      // 1004400). Both are advice-only inputs: an unknown type reads as "not
+      // sure" and the size is bounded, so neither can change what is in force.
+      const type = typeof req.query.type === 'string' ? req.query.type : null;
+      const asked = Number.parseInt(req.query.headcount, 10);
+      const headcount = Number.isFinite(asked) && asked >= 0 ? Math.min(asked, 100000) : null;
+      res.json(await board.constitutionView({ historyLimit: 50, type, headcount }));
     } catch (err) {
       log.error('[gds] GET /government/constitution', err);
       res.fail('constitution_read_failed', { status: 500, message: 'internal error' });

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

@@ -790,7 +790,7 @@
   function charterCard(c, recommendedKey) {
     const facts = [
       c.selectable ? pill('ok', 'selectable today') : pill('quiet', 'documented for later'),
-      c.key === recommendedKey ? pill('info', 'recommended at your headcount') : '',
+      c.key === recommendedKey ? pill('info', 'recommended for this type and size') : '',
     ].join('');
     const how = c.how ? `<p class="gov-charter__how">as configuration: ${escapeHtml(c.how)}</p>` : '';
     return `<li class="ov-row"><div class="ov-row__main">
@@ -820,12 +820,131 @@
     `;
   }
 
+  // ---- the recommendation (task 1004400) --------------------------------------
+
+  // What government and which ranks to start from, for a project TYPE and SIZE.
+  // Both answers come from the server (modules/government/recommendations.js),
+  // which only ever names a form that can be adopted. A running project does
+  // not record the type it declared at creation, so the reader picks it here,
+  // and the choice is remembered in this browser only — it is advice, not a
+  // setting, and changes nothing that is in force.
+  const RECO_TYPE_KEY = 'gov.reco.type';
+  let canManageRanks = false;
+  let recoAsk = { type: null, headcount: null }; // null headcount = the live team
+
+  function readSavedType() {
+    try { return window.localStorage.getItem(RECO_TYPE_KEY); } catch (_) { return null; }
+  }
+  function saveType(type) {
+    try { window.localStorage.setItem(RECO_TYPE_KEY, type); } catch (_) { /* per-viewer convenience only */ }
+  }
+
+  function constitutionPath() {
+    const q = new URLSearchParams();
+    if (recoAsk.type) q.set('type', recoAsk.type);
+    if (recoAsk.headcount !== null) q.set('headcount', String(recoAsk.headcount));
+    const qs = q.toString();
+    return `/government/constitution${qs ? `?${qs}` : ''}`;
+  }
+
+  function recoSelectsHtml(reco, liveHeadcount) {
+    const types = (reco.project_types || []).map((t) =>
+      `<option value="${escapeHtml(t.key)}"${t.key === reco.type ? ' selected' : ''}>${escapeHtml(t.name)}</option>`).join('');
+    const live = `<option value=""${recoAsk.headcount === null ? ' selected' : ''}>Your team now (${escapeHtml(String(liveHeadcount ?? '?'))} builder${liveHeadcount === 1 ? '' : 's'})</option>`;
+    const sizes = (reco.size_bands || []).map((b) =>
+      `<option value="${escapeHtml(String(b.example))}"${recoAsk.headcount === b.example ? ' selected' : ''}>${escapeHtml(b.name)}</option>`).join('');
+    return `
+      <form class="ov-form gov-reco__ask" id="gov-reco-form" autocomplete="off">
+        <div class="ov-field">
+          <label class="ov-field__l" for="gov-reco-type">Project type</label>
+          <select id="gov-reco-type">${types}</select>
+        </div>
+        <div class="ov-field">
+          <label class="ov-field__l" for="gov-reco-size">Size</label>
+          <select id="gov-reco-size">${live}${sizes}</select>
+        </div>
+      </form>`;
+  }
+
+  function recoRankRow(r) {
+    return `<li class="ov-row"><div class="ov-row__main">
+      <span class="ov-row__title">${escapeHtml(r.label)}</span>
+      <p class="ov-row__sub">${escapeHtml(r.description)}</p>
+      <p class="gov-charter__how">rank ${escapeHtml(r.rank_key)} · may: ${escapeHtml(r.permissions.join(', '))}</p>
+    </div></li>`;
+  }
+
+  function recommendationHtml(data) {
+    const reco = data.recommendation;
+    if (!reco) return '';
+    const c = reco.charter;
+    const set = reco.rank_set;
+    const council = c.council_rank
+      ? `<p class="gov-charter__how">as configuration: membership rank:${escapeHtml(c.council_rank)} — the council rank below, once you have added it and assigned its members</p>`
+      : '';
+    const later = c.later
+      ? `<p class="ov-row__sub">The ladder's own shape at this size is ${escapeHtml(c.later.name)}. ${escapeHtml(c.later.explanation)}</p>`
+      : '';
+    const apply = set.ranks.length && canManageRanks
+      ? `<div class="gov-grid-actions"><button class="btn-accent" type="button" id="gov-reco-apply">Add these ranks</button></div>`
+      : '';
+    return `
+      <section class="scroll" aria-labelledby="gov-reco-h">
+        <h2 class="scroll__h" id="gov-reco-h">Recommended for your project</h2>
+        <p class="scroll__lede">A starting point by project type and size: a government you can adopt today, and the ranks worth adding to the four standard ones.</p>
+        ${recoSelectsHtml(reco, data.headcount)}
+        <section class="ov-group">
+          ${groupHead('Government', 1, c.rung)}
+          <ul class="ov-rows"><li class="ov-row"><div class="ov-row__main">
+            <span class="ov-row__title">${escapeHtml(c.name)}</span>
+            <p class="ov-row__sub">${escapeHtml(c.why)}</p>
+            ${later}
+            <div class="ov-row__facts">${pill('ok', 'selectable today')}${pill('info', 'recommended')}</div>
+            ${council}
+          </div></li></ul>
+        </section>
+        <section class="ov-group">
+          ${groupHead('Ranks to add', set.ranks.length, 'on top of the four standard ranks')}
+          <p class="ov-row__sub">${escapeHtml(set.why)}</p>
+          ${set.ranks.length ? `<ul class="ov-rows">${set.ranks.map(recoRankRow).join('')}</ul>` : ''}
+          ${apply}
+        </section>
+      </section>`;
+  }
+
+  function wireRecommendation(data) {
+    const type = document.getElementById('gov-reco-type');
+    const size = document.getElementById('gov-reco-size');
+    if (type) type.addEventListener('change', () => { recoAsk.type = type.value; saveType(type.value); loadConstitution(); });
+    if (size) size.addEventListener('change', () => { recoAsk.headcount = size.value === '' ? null : Number(size.value); loadConstitution(); });
+    const btn = document.getElementById('gov-reco-apply');
+    if (btn) btn.addEventListener('click', () => applyRankSet(data.recommendation, btn));
+  }
+
+  async function applyRankSet(reco, btn) {
+    btn.disabled = true;
+    try {
+      const r = await sendJson('POST', '/government/rank-sets/apply', { type: reco.type, headcount: reco.headcount });
+      const made = (r.created || []).map((c) => c.label);
+      const kept = r.skipped || [];
+      toast(made.length
+        ? `Added ${made.join(', ')}.${kept.length ? ` Already here, left as they were: ${kept.join(', ')}.` : ''}`
+        : 'Those ranks are already here — nothing changed.');
+      await reloadRanks();
+    } catch (err) {
+      if (err && err.kind === '401') return;
+      toast(`Could not add the ranks: ${err.message || err}`);
+    } finally {
+      btn.disabled = false;
+    }
+  }
+
   async function loadConstitution() {
     const live = document.getElementById('gov-constitution-live');
     const box = document.getElementById('gov-constitution');
     let data;
     try {
-      data = await fetchJson('/government/constitution');
+      data = await fetchJson(constitutionPath());
     } catch (err) {
       if (err && err.kind === '401') return;
       live.innerHTML = emptyStateHtml('Could not load the constitution just now.');
@@ -855,8 +974,10 @@
           ? `<ul class="ov-rows">${history.map(historyRow).join('')}</ul>`
           : emptyStateHtml('Never amended. This project still runs its founding constitution.')}
       </section>
+      ${recommendationHtml(data)}
       ${charterLibraryHtml(data)}
     `;
+    wireRecommendation(data);
   }
 
   // ---- the Board Room: MOVED OUT (ADR 0266) ---------------------------------
@@ -931,6 +1052,8 @@
     document.getElementById('gov-sub').textContent = 'How this project is governed.';
     document.getElementById('gov-body').hidden = false;
     wireTabs({ isArchon });
+    recoAsk.type = readSavedType();
+    canManageRanks = isArchon;
     loadConstitution(); // the rule this project runs under (R18)
 
     if (!isArchon) { sealRanksPanel(); return; }

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.53",
+  "version": "1.20.54",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8435,5 +8435,11 @@
       "id": "1004432",
       "text": "An approved page now counts as the artist's own work everywhere the project shows who did what: their profile, their shipped count, their activity, the status page and the leaderboard. Before, the page was credited to the sess"
     }
+  ],
+  "1.20.54": [
+    {
+      "id": "1004400",
+      "text": "The Government page now recommends a starting government and a starting set of ranks for your kind of project (game, research, business, non-profit) and its size. It only ever recommends a form you can adopt today. A team of a"
+    }
   ]
 }

package/src/bongos/route-rank-check.js

@@ -253,6 +253,7 @@ const GOVERNMENT_PINS = {
   'PUT /government/ranks/:rankKey/permissions/:permissionKey': 'perm:government.manage',
   'DELETE /government/ranks/:rankKey/permissions/:permissionKey': 'perm:government.manage',
   'POST /government/ranks/:rankKey/reset': 'perm:government.manage',
+  'POST /government/rank-sets/apply': 'perm:government.manage',
   'POST /government/assignments': 'perm:government.manage',
   'DELETE /government/assignments/:builderId/:rankKey': 'perm:government.manage',
   // The Board Room's first route (R08 of goal 1000069 — the R04-carried pin).

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.20.53'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.54'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/government_charter_library.mjs

@@ -24,11 +24,16 @@ test('the ladder bands track exactly the thresholds the synthesis names', () =>
   assert.equal(recommendedCharter(2).key, 'monarchy', 'this project today: two builders → the founding monarchy');
   assert.equal(recommendedCharter(3).key, 'direct-democracy', 'the circle rung starts at 3');
   assert.equal(recommendedCharter(8).key, 'direct-democracy');
-  assert.equal(recommendedCharter(9).key, 'presidential', '~9: name an executive');
-  assert.equal(recommendedCharter(49).key, 'presidential');
+  // ~9 and ~150 are where the ladder's own shapes (Presidential, Federation)
+  // cannot be adopted yet, so the recommendation names the nearest form that
+  // can — and says what is coming in `later` (task 1004400).
+  assert.equal(recommendedCharter(9).key, 'timocratic-republic', '~9: the circle gets too big');
+  assert.equal(recommendedCharter(9).later.key, 'presidential');
+  assert.equal(recommendedCharter(49).key, 'timocratic-republic');
   assert.equal(recommendedCharter(50).key, 'foundation', '~50: written charter + council');
   assert.equal(recommendedCharter(149).key, 'foundation');
-  assert.equal(recommendedCharter(150).key, 'federation', '~150: adjudication separates — federate');
+  assert.equal(recommendedCharter(150).key, 'foundation', '~150: a council carries it until federation exists');
+  assert.equal(recommendedCharter(150).later.key, 'federation');
   assert.equal(recommendedCharter(0).key, 'monarchy', 'a zero/unknown headcount fails to the founding shape');
   assert.equal(recommendedCharter('nonsense').key, 'monarchy');
 });
@@ -74,7 +79,7 @@ test('the library presents all seven structures with honest selectable marks (cl
     const entry = b.split('{ key:')[0];
     assert.ok(entry.includes('how:'), 'a selectable structure names its configuration');
   }
-  assert.match(client, /recommended at your headcount/, 'the one live datum is rendered');
+  assert.match(client, /recommended for this type and size/, 'the one live datum is rendered');
   assert.match(client, /c\.key === recommendedKey/, "the pill is driven by the SERVER's recommendation, never re-derived client-side");
   for (const t of ['Locked', 'Laddered', 'Scheduled']) {
     assert.ok(client.includes(`name: '${t}'`), `trajectory ${t} present`);
@@ -171,7 +176,8 @@ test('the recommendation names a charter the config can actually express', () =>
     const rec = recommendedCharter(n);
     const charter = by[rec.key];
     assert.ok(charter, `headcount ${n} recommends "${rec.key}", which is not in the library`);
-    if (charter.selectable) {
+    assert.ok(charter.selectable, `headcount ${n} recommends "${rec.key}", which cannot be adopted (task 1004400)`);
+    {
       assert.ok(charter.predicate !== undefined,
         `headcount ${n} recommends selectable "${rec.key}" — it must carry a checkable predicate`);
     }

package/tests/government_constitution_view.mjs

@@ -82,7 +82,10 @@ test('the read rides the vote atom, and the client renders the SERVER value (sou
   assert.equal(rrc.MODULE_EXPECTED_RANKS.government['GET /government/constitution'],
     `${rrc.PERM_PIN_PREFIX}board.vote.cast`);
   const client = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'government.js'), 'utf8');
-  assert.match(client, /fetchJson\('\/government\/constitution'\)/, 'the panel loads the resolved value');
+  // Since task 1004400 the path may carry ?type= / &headcount= (advice-only
+  // inputs for the recommendation), so constitutionPath() builds it.
+  assert.match(client, /fetchJson\(constitutionPath\(\)\)/, 'the panel loads the resolved value');
+  assert.match(client, /`\/government\/constitution\$\{qs/, 'from the constitution read, nowhere else');
   assert.ok(!/'first_ratifier'[^]*hardcod/i.test(client), 'sanity');
   assert.match(client, /loadConstitution\(\)/, 'the panel loads for everyone the page admits');
 });