@bongos/core 1.20.52 → 1.20.54

package/migrations/core_267_page_tweak_author_of_record.sql

@@ -0,0 +1,41 @@
+-- core_267 — an approved page tweak already shipped names its artist (task 1004432,
+-- WA6.RP02, goal 1000095)
+--
+-- From this release, shipTask (modules/lifecycle/db-ship.js) writes tasks.shipped_by
+-- as the round's ARTIST when a page tweak ships, instead of the session that applied
+-- it. Everything that counts or lists shipped work reads shipped_by (the profile,
+-- the shipped count, the activity log, the status page's recent list, streaks,
+-- achievements, the hub rollup), so that one write moves every one of them.
+--
+-- The rounds that shipped BEFORE this release still name their applier, so on every
+-- one of those surfaces the artist who wrote the page is absent and the applier is
+-- credited with work that was not theirs. This brings them in line, once.
+--
+-- The artist is page-tweak-artist.js's rule, spelled out here because a migration
+-- cannot call it: the builder of the round's LATEST WEB claim (worktree_name and
+-- creator_session_id both NULL), the same person economy's awardArtistPageCredit
+-- already paid. A round with no web claim keeps its applier, exactly as the ship
+-- path does. tests/page_tweak_artist.mjs holds this predicate to the helper's.
+--
+-- Data only, no column or constraint: forward-safe against a live database, and an
+-- older release reading the rows just sees a different builder id. Idempotent: a
+-- second run matches nothing, because the IS DISTINCT FROM guard skips rows that
+-- already name their artist. Money is untouched: credit_log is not read or written,
+-- and the artist was paid at the land.
+
+UPDATE tasks t
+   SET shipped_by = w.builder_id
+  FROM (
+    SELECT DISTINCT ON (c.task_id) c.task_id, c.builder_id
+      FROM claims c
+      JOIN tasks pt ON pt.id = c.task_id
+     WHERE pt.source = 'page-tweak'
+       AND pt.status = 'shipped'
+       AND c.worktree_name IS NULL AND c.creator_session_id IS NULL
+     ORDER BY c.task_id, c.claimed_at DESC, c.id DESC
+  ) w
+ WHERE t.id = w.task_id
+   AND t.shipped_by IS DISTINCT FROM w.builder_id;
+
+INSERT INTO schema_migrations (version) VALUES ('core_267_page_tweak_author_of_record')
+  ON CONFLICT DO NOTHING;

package/modules/government/board.js

@@ -60,6 +60,7 @@ const { describeMembership } = require('./membership-predicate');
 // The genesis charter + legislation vocabulary (task 1004427): the real form
 // and variable names, and the name a constitution reads as.
 const charter = require('./charter');
+const recommendations = require('./recommendations');
 
 // ADR 0175 §5: the completeness bar a Full Idea must clear to reach the board.
 // Held equal to economy's IDEA_FULL_PASS_BAR by test — see the header.
@@ -1149,25 +1150,13 @@ async function boardRoomView({ closedLimit = 20 } = {}) {
 // day — the §7 chain, auditable end to end.
 // ── the charter ladder's recommendation (BV1.R19, criterion C5) ─────────────
 //
-// The developmental ladder from the Six Variables synthesis (Part III), as the
-// spec's task text records it: formality is adopted only where informal
-// coordination breaks. PURE and server-side so R26's proof can hold the
-// recommendation against the real headcount — the library's one live datum.
-// The bands deliberately track only the thresholds the synthesis NAMES
-// (~9 name an executive, ~50 written charter + council, ~150 adjudication
-// separates / federate beyond); everything else is reference prose, not code.
-function recommendedCharter(headcount) {
-  const n = Number(headcount) || 0;
-  if (n <= 2) return { key: 'monarchy', rung: 'solo/pair', why: 'informal coordination has nothing to break yet — the founding monarchy is the honest shape' };
-  // "all trusted members" was not expressible under the pre-1003094 exact-match
-  // grammar, so at this headcount the library recommended a charter it could not
-  // state (task 1003095). It is expressible now — `rank:xenos+` seats every
-  // builder — and the wording says the thing the predicate actually does rather
-  // than a phrase with no predicate behind it.
-  if (n <= 8) return { key: 'direct-democracy', rung: 'circle (3–8)', why: 'a consent circle of every builder (rank:xenos+) — the rung this ladder was written on' };
-  if (n <= 49) return { key: 'presidential', rung: '~9: name an executive', why: 'past ~9, naming an executive beats everyone coordinating with everyone' };
-  if (n <= 149) return { key: 'foundation', rung: '~50: written charter + council', why: 'past ~50, the charter must be written down and a council carries it' };
-  return { key: 'federation', rung: '~150: adjudication separates — federate beyond', why: 'past ~150, one body cannot both govern and adjudicate; federate' };
+// Moved to recommendations.js (task 1004400), which reads project TYPE as well
+// as size and resolves every size to a form that can actually be adopted — the
+// ladder used to name Presidential at ~9 and Federation past ~150, neither of
+// which this system can express. Kept here under its old name because the
+// constitution view and its tests read it from board.js.
+function recommendedCharter(headcount, type) {
+  return recommendations.recommendedCharter(headcount, type);
 }
 
 // ── the divergence check (task 1003739, ADR 0268) ───────────────────────────
@@ -1219,7 +1208,7 @@ function constitutionDivergence(liveBoard, history) {
   });
 }
 
-async function constitutionView({ historyLimit = 50 } = {}) {
+async function constitutionView({ historyLimit = 50, type = null, headcount: askedHeadcount = null } = {}) {
   const { board: live } = loadGovernmentConfig();
   const [rows, headcount] = await Promise.all([
     db.listAmendmentHistory(historyLimit),
@@ -1242,7 +1231,12 @@ async function constitutionView({ historyLimit = 50 } = {}) {
     board: live,
     history,
     headcount,
-    recommended: recommendedCharter(headcount),
+    recommended: recommendedCharter(askedHeadcount ?? headcount, type),
+    // Both recommendations — the charter AND the ranks — for the project type
+    // and size asked about (task 1004400). The size defaults to the live
+    // headcount; the type defaults to "not sure", because a running project
+    // does not record the type it declared at creation.
+    recommendation: recommendations.recommendationsFor({ type, headcount: askedHeadcount ?? headcount }),
     // null when the constitution in force IS the one last ratified, which is
     // the healthy answer and the one the hall renders nothing for. Computed
     // from the history already in hand — no extra query, and no second read

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/builders.js

@@ -762,7 +762,9 @@
     if (!tbody) return;
     const slice = window.OTBKit.paginate(acclaimState.tasks, acclaimPager);
     tbody.innerHTML = slice.map((t) => {
-      const by = escapeHtml(t.display_name || (t.github_login ? `@${t.github_login}` : `builder #${t.shipped_by}`));
+      // task 1004432: an approved page is its artist's; the applying session rides along as a helper.
+      const helperName = t.helper_display_name || (t.helper_login ? `@${t.helper_login}` : '');
+      const by = escapeHtml(t.display_name || (t.github_login ? `@${t.github_login}` : `builder #${t.shipped_by}`)) + (helperName ? ` <span class="acclaim__evidence">with help from ${escapeHtml(helperName)}</span>` : '');
       const net = Number(t.net_votes) || 0;
       const netCls = signClasses(net, 'acclaim__net');
       const netText = net > 0 ? `+${net}` : `${net}`;

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/modules/lifecycle/db-analytics.js

@@ -14,6 +14,7 @@ const api = require('../../src/module-api');
 const { pool, withTx } = api;
 const { SMOKE_NOT_LIKE, gradePassCount, gradeQualityWhere, median } = require('./db-shared.js');
 const { CREDITS_AWARDED_SUBQUERY } = require('./db-tasks.js');
+const { helperJoinSql } = require('./page-tweak-artist.js');
 
 // -------------------------------------------------------------------------
 // Cost log + summary carved into modules/economy/cost.js (BV1.R77 / ADR 0093
@@ -47,9 +48,13 @@ async function recentShippedTasks(limit = 30, { days = null } = {}) {
             CASE WHEN t.security_sensitive THEN NULL ELSE t.visual_url END AS visual_url, CASE WHEN t.security_sensitive THEN NULL ELSE t.visual_alt END AS visual_alt,
             ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded,
             t.est_minutes, t.actual_minutes,
-            b.github_login, b.display_name
+            b.github_login, b.display_name,
+            -- task 1004432: an approved page is its artist's (shipped_by); the session
+            -- that applied it rides along as a helper, so a reader still sees both.
+            helper.helper_login, helper.helper_display_name
        FROM tasks t
        LEFT JOIN builders b ON b.id = t.shipped_by
+       ${helperJoinSql('t')}
       WHERE ${whereClause}
       ORDER BY t.shipped_at DESC NULLS LAST
       LIMIT $1`,

package/modules/lifecycle/db-ship.js

@@ -19,6 +19,7 @@ const { THETES_GRADUATION_THRESHOLD, maybeAutoGraduateToThetes, foldWorktreeName
 const { mostRecentClaimHolderId, sealSessionLog, staleClaimHourPredicate } = require('./db-shared.js');
 const { LIVE_STATUSES } = require('./dead-deps.js');
 const { isPageTweak } = require('./page-tweak-hold.js');
+const pageTweakArtist = require('./page-tweak-artist.js');
 
 // shouldRefuseClaimResolve — may THIS caller resolve THIS claim? (task 1003767)
 //
@@ -512,6 +513,9 @@ async function needsRebaseTasksForBuilder(builderId, client = pool) {
 // The ship gate (task 1002483, ADR 0184) — see ./ship-assurance for the why.
 const { normalizeShipAssurance, assertShipAssurance, recordShipAssurance, SHIP_ASSURANCE_KINDS } = require('./ship-assurance');
 
+// The author of record (task 1004432): a page tweak names its ARTIST at this flip only.
+const SHIPPED_BY_SQL = pageTweakArtist.shippedBySql('$2');
+
 async function shipTask({ taskId, builderId, landAssurance }, deps = {}) {
   const shipAssuranceValue = assertShipAssurance(landAssurance); // FAIL-CLOSED, ADR 0184
   // #538 test seam (mirrors confirmTask): a caller-supplied pool is honored ONLY
@@ -523,7 +527,7 @@ async function shipTask({ taskId, builderId, landAssurance }, deps = {}) {
       `UPDATE tasks
           SET status = 'shipped',
               shipped_at = now(),
-              shipped_by = COALESCE(shipped_by, $2),
+              shipped_by = ${SHIPPED_BY_SQL},
               needs_rebase = false,
               needs_rebase_reason = NULL,
               needs_rebase_at = NULL,
@@ -642,10 +646,13 @@ async function shipTask({ taskId, builderId, landAssurance }, deps = {}) {
     // credit it keys off (breaking-the-100c-bar etc.) now lands here.
     let justUnlocked = [];
     const rewardPort = seams.resolveOptional('reward');
-    if (rewardPort && rewardPort.reconcileBuilderAchievements && creditedBuilderId != null) {
+    // A page tweak's ship count and credit moved to its artist (above), so the
+    // artist is whose achievements this ship can unlock; the applier's did not move.
+    const achievementBuilderId = isPageTweak(rows[0]) ? actualShipperId : creditedBuilderId;
+    if (rewardPort && rewardPort.reconcileBuilderAchievements && achievementBuilderId != null) {
       await client.query('SAVEPOINT ach_reconcile_ship');
       try {
-        justUnlocked = await rewardPort.reconcileBuilderAchievements(client, creditedBuilderId, { taskId });
+        justUnlocked = await rewardPort.reconcileBuilderAchievements(client, achievementBuilderId, { taskId });
         await client.query('RELEASE SAVEPOINT ach_reconcile_ship');
       } catch (_) {
         await client.query('ROLLBACK TO SAVEPOINT ach_reconcile_ship');