@bongos/core 1.20.57 → 1.20.59

package/modules/ideas/ideator-stats.js

@@ -0,0 +1,149 @@
+'use strict';
+
+// modules/ideas/ideator-stats.js — THE IDEATOR'S NUMBERS for the profile
+// (task 1004433 / WA6.RP03, goal 1000095, criterion wa6-roles-read-true-in-public;
+// the owner-approved mock is docs/design/mocks/profile-roles/, task 1004431).
+//
+// The profile's header and "By the numbers" lead with each person's own craft.
+// For an ideator that is six numbers, and every one of them is a COUNT or a SUM
+// over the sky's own derivation, never a second one:
+//
+//   filed      thoughts filed (the person's trail, skill-friction rows left out)
+//   ignited    thoughts that became paid work (state.hasWork, the sky's ignition)
+//   full       Full Ideas (grade 'full')
+//   ratified   Full Ideas the Board Room carried (government.boardPassForIdea)
+//   size       credits earned from ideas across EVERY idea stream, plus the
+//              historical estimate, with the marker that says so
+//   alive      the share of the work their thoughts caused that is still alive
+//
+// WHERE EACH COMES FROM. The trail is `readSkyMine` (./sky-mine.js), which walks
+// the whole trail and runs the three attachers in the trail route's order, so a
+// thought's size, brightness and state here are the ones the sky draws. Nothing
+// in this file derives a state.
+//
+// SIZE IS EVERY STREAM, NOT STREAM 1. A thought's drawn size is its stream-1
+// payout (economy/idea-size.js: the work it caused). The PERSON's total is a
+// different question, "what has thinking earned you", and the owner's mock
+// answers it across every way ideas are paid: the task ship and its descent, the
+// Full Idea pass, the board pass and the spark/developer split. That is the
+// ledger's ideator column (economy/credits-by-craft.js, through the `reward`
+// port), so the headline agrees with the earnings chart to the credit. The
+// historical estimate (spec decision 17) rides on top, from the per-thought
+// sizes the sky already priced: money the ledger was never there to pay, so it
+// is reported apart as `size.estimated` and marked, never folded in silently.
+//
+// ALIVE IS WEIGHTED BY SIZE, like a single thought's brightness: the live
+// credits over all credits, across every thought that ignited. A thought that
+// could not be read (`attributable: false`) makes the whole share unknown
+// (null) rather than quietly counting it as alive, and a person whose thoughts
+// caused nothing yet has no share at all (null, `has_work: false`): zero over
+// zero is not "nothing survived". The two nulls are told apart by `has_work`.
+//
+// PUBLIC BY THE OWNER'S DECISION (a) of 2026-09-30: the identity band, the
+// tally and "By the numbers" stay public, the trail itself does not. So these
+// are counts and sums only. No title, no id, no triage note leaves this file,
+// and the read is the same for every viewer: the skill-friction gate is applied
+// at the least-privileged real rank, because those rows are a routine's
+// filings, not a person's thoughts, and a count must not change with who looks.
+
+const api = require('../../src/module-api');
+const { readSkyMine } = require('./sky-mine');
+
+// The rank the counts are read at. xenos is the one rank the skill-friction gate
+// hides those rows from (./skill-friction.js); reading at it makes the public
+// count the count of the person's own thoughts.
+const PUBLIC_VIEWER_RANK = 'xenos';
+
+function int(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? Math.round(n) : 0;
+}
+
+// summarizeIdeatorTrail — the six numbers from a trail that already carries
+// size and state. Pure. `ideatorCredits` is the ledger's ideator column (null
+// when economy could not be asked), `ratifiedIds` the set of idea ids the board
+// carried (null when the government port is absent).
+function summarizeIdeatorTrail(ideas, { ideatorCredits = null, ratifiedIds = null, truncated = false, total = null } = {}) {
+  const list = Array.isArray(ideas) ? ideas : [];
+  let ignited = 0;
+  let full = 0;
+  let ratified = 0;
+  let estimated = 0;
+  let estimateKnown = true;
+  let credits = 0;
+  let live = 0;
+  let attributable = true;
+  for (const idea of list) {
+    if (!idea) continue;
+    const st = idea.state || {};
+    if (st.hasWork === true) ignited++;
+    if (idea.grade === 'full') {
+      full++;
+      if (ratifiedIds && ratifiedIds.has(String(idea.id))) ratified++;
+    }
+    const size = idea.size;
+    if (!size) { estimateKnown = false; continue; }
+    if (size.estimated == null) estimateKnown = false;
+    else estimated += int(size.estimated);
+    if (st.hasWork === true) {
+      const c = Number(size.credits) || 0;
+      credits += c;
+      if (st.attributable !== true || st.brightness == null) attributable = false;
+      else live += c * Number(st.brightness);
+    }
+  }
+  const paid = ideatorCredits == null ? null : int(ideatorCredits);
+  const est = estimateKnown ? estimated : null;
+  return {
+    // The trail's own count, not the page in hand: past the sky's cap the list
+    // is the newest thousand and `truncated` says the other numbers are partial.
+    filed: Number.isInteger(total) ? total : list.length,
+    ignited,
+    full_ideas: full,
+    ratified: ratifiedIds ? ratified : null,
+    size: {
+      total: paid == null ? null : paid + (est || 0),
+      paid,
+      estimated: est,
+      historical: est == null ? null : est > 0,
+    },
+    alive: {
+      share: credits > 0 && attributable ? live / credits : null,
+      has_work: credits > 0,
+      attributable: credits > 0 ? attributable : null,
+    },
+    truncated: truncated === true,
+  };
+}
+
+// readIdeatorStats — the async half: the trail, the ledger column, the board.
+// `deps` lets a test hand in each port; production resolves them optionally, so
+// an instance without economy or the board reads `null` for those numbers
+// (could not ask) rather than 0 (asked, and nothing was there).
+async function readIdeatorStats(builderId, deps = {}) {
+  const read = deps.readSkyMine || readSkyMine;
+  const reward = 'reward' in deps ? deps.reward : (api.resolveOptional && api.resolveOptional('reward'));
+  const government = 'government' in deps ? deps.government : (api.resolveOptional && api.resolveOptional('government'));
+
+  const sky = await read({ builderId, viewerRank: PUBLIC_VIEWER_RANK });
+  const ideas = (sky && sky.ideas) || [];
+
+  let ideatorCredits = null;
+  if (reward && typeof reward.creditsByCraft === 'function') {
+    const byCraft = await reward.creditsByCraft([builderId]);
+    const row = byCraft.get(String(builderId));
+    ideatorCredits = row ? row.ideator : 0;
+  }
+
+  let ratifiedIds = null;
+  if (government && typeof government.boardPassForIdea === 'function') {
+    ratifiedIds = new Set();
+    const fulls = ideas.filter((i) => i && i.grade === 'full');
+    const passes = await Promise.all(fulls.map((i) => government.boardPassForIdea(i.id)));
+    fulls.forEach((i, k) => { if (passes[k]) ratifiedIds.add(String(i.id)); });
+  }
+
+  return summarizeIdeatorTrail(ideas, { ideatorCredits, ratifiedIds, truncated: sky && sky.truncated, total: sky && sky.total });
+}
+
+module.exports = { readIdeatorStats, summarizeIdeatorTrail, PUBLIC_VIEWER_RANK };

package/modules/ideas/module.json

@@ -21,7 +21,8 @@
   },
   "provides": [
     "ideas.capture",
-    "ideas.descent"
+    "ideas.descent",
+    "ideas.ideatorStats"
   ],
   "consumes": [
     "reward",

package/modules/ideas/routes/inbox.js

@@ -36,6 +36,7 @@ const express = require('express');
 const api = require('../../../src/module-api');
 const inbox = require('../inbox');
 const bornOf = require('../born-of');
+const ideatorStats = require('../ideator-stats');
 // The trail read to the FULL depth of the descent (task 1004089, BV2.R09). Its
 // own file because inbox.js is AT the size ratchet and because a task->task
 // walk is a different relation from the idea->task trail.
@@ -108,6 +109,12 @@ function registerSeams() {
       descendantsOfTask: descent.descendantsOfTask,
     });
   }
+  // task 1004433 (WA6.RP03): the ideator's numbers for the profile, counts and
+  // sums only, so core's profile route can show them without reading an ideas_
+  // table or deriving a state (../ideator-stats.js).
+  if (!api.hasProvider('ideas.ideatorStats')) {
+    api.registerProvider('ideas.ideatorStats', ideatorStats.readIdeatorStats);
+  }
 }
 
 // The author-facing shape of a ratification window this request just opened —

package/modules/lifecycle/activity.js

@@ -36,7 +36,10 @@
 const api = require('../../src/module-api');
 const { pool } = api;
 const { SMOKE_NOT_LIKE } = require('./db-shared.js');
-const { CREDITS_AWARDED_SUBQUERY } = require('./db-tasks.js');
+// What THIS person was paid for each row, not the task's whole payout (task
+// 1004433): on a page tweak the artist and the applier are two people's pay, and
+// under cost-plus-only the per-task estimate books nothing at all.
+const { creditsEarnedBySql } = require('./db-tasks.js');
 
 // The craft vocabulary this read accepts. Mirrors tasks_discipline_check
 // (migrations 086 + 176). Anything else is treated as "no filter" rather than
@@ -97,7 +100,7 @@ async function activityTasksByBuilder(builderId, { role = null, limit = DEFAULT_
     `SELECT t.id, t.title, t.value_summary, t.visual_url, t.visual_alt,
             t.version_id, t.goal_id, t.kind, t.status, t.shipped_at,
             COALESCE(t.discipline, 'unclassified') AS discipline,
-            t.credits_reward, ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded
+            t.credits_reward, ${creditsEarnedBySql('$1')} AS credits_awarded
        FROM tasks t
       WHERE ${where}
       ORDER BY t.shipped_at DESC NULLS LAST, t.id DESC

package/modules/lifecycle/db-analytics.js

@@ -13,7 +13,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 { CREDITS_AWARDED_SUBQUERY, creditsEarnedBySql } = require('./db-tasks.js');
 const { helperJoinSql } = require('./page-tweak-artist.js');
 
 // -------------------------------------------------------------------------
@@ -137,8 +137,10 @@ async function estimationDriftSummary() {
 
 async function recentShippedTasksByBuilder(builderId, limit = 10) {
   const { rows } = await pool.query(
+    // task 1004433: the profile's recent works show what THIS builder was paid
+    // (creditsEarnedBySql), not the task's whole payout across everyone.
     `SELECT t.id, t.title, t.value_summary, t.visual_url, t.visual_alt, t.version_id, t.status, t.shipped_at, t.credits_reward,
-            ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded
+            ${creditsEarnedBySql('$1')} AS credits_awarded
        FROM tasks t
       WHERE t.shipped_by = $1
         AND t.status = 'shipped'

package/modules/lifecycle/db-tasks.js

@@ -676,14 +676,61 @@ async function updateTaskModuleKey(id, moduleKey) { return updateTaskColumn(id,
 // CASE still short-circuits to 0 for unsettled tasks; note a 'confirmed' task
 // now shows 0 until it LANDS (the credit no longer exists at confirm) — the UI
 // renders the "Est." label until the 'task.shipped' row books at land.
+//
+// task 1004433 (WA6.RP03): the allowlist missed two of the per-task streams, so
+// an approved page read "0 credits" and an idea's payout for the task it caused
+// never counted. Both are booked against the task's own id and are payment FOR
+// that task: `tweak.page_approved:<task>` (the artist lane, ADR 0341 D10, paid
+// INSTEAD of the per-task estimate) and every `idea.credit.*` row carrying this
+// task_id (stream 1 and its descent, ADR 0172 / 0312). Streams 2 and 3 carry no
+// task_id and stay out, as they pay for the thought, not for any task. Matched
+// as prefixes, never by equality: each key embeds the ids it was paid for.
+const TASK_PAYOUT_REASON_SQL =
+  `(cl.reason IN ('task.confirmed', 'task.shipped', 'idea_promotion_bonus', 'ship.net_negative')
+                   OR cl.reason LIKE 'tweak.page\\_approved:%'
+                   OR cl.reason LIKE 'idea.credit.%')`;
 const CREDITS_AWARDED_SUBQUERY =
   `CASE WHEN t.status IN ('confirmed', 'shipped')
         THEN (SELECT COALESCE(SUM(cl.delta), 0)::int
                 FROM credit_log cl
                WHERE cl.task_id = t.id
-                 AND cl.reason IN ('task.confirmed', 'task.shipped', 'idea_promotion_bonus', 'ship.net_negative'))
+                 AND ${TASK_PAYOUT_REASON_SQL})
         ELSE 0 END`;
 
+// creditsEarnedBySql — what ONE person earned for a task, for the lists that
+// say "this is what <person> was paid" (the profile's recent works and its
+// Activity tab). CREDITS_AWARDED_SUBQUERY above is the TASK's payout across
+// everyone, which was the wrong number there twice over: on a page tweak the
+// artist's page credit and the applier's session reward are two people's pay,
+// and under cost-plus-only (ADR 0146) the per-task estimate books nothing, so a
+// builder who was paid normally read 0 on every row.
+//
+// Two halves, the two attribution keys sumSessionEarnings names (task 1003634):
+//   • every per-task payout row this builder holds against the task;
+//   • the cost-plus SESSION reward (task_id NULL, keyed by session) for each of
+//     this builder's sessions that shipped the task, split evenly across the
+//     tasks that session shipped. The session pays for its whole token spend,
+//     not for one task, so an even share is the honest per-task figure.
+// `builderRef` is a bound parameter reference such as '$1', never a value.
+// session_records is read through idx_session_records_builder.
+function creditsEarnedBySql(builderRef) {
+  if (!/^\$\d+$/.test(builderRef)) throw new Error('creditsEarnedBySql: builderRef must be a bind parameter like $1');
+  return `CASE WHEN t.status IN ('confirmed', 'shipped')
+        THEN (COALESCE((SELECT SUM(cl.delta)
+                          FROM credit_log cl
+                         WHERE cl.task_id = t.id
+                           AND cl.builder_id = ${builderRef}
+                           AND ${TASK_PAYOUT_REASON_SQL}), 0)
+            + COALESCE((SELECT ROUND(SUM(cl.delta::numeric / GREATEST(cardinality(sr.task_ids), 1)))
+                          FROM session_records sr
+                          JOIN credit_log cl ON cl.session_id = sr.session_id
+                                            AND cl.reason = 'session.token_reward'
+                                            AND cl.builder_id = ${builderRef}
+                         WHERE sr.builder_id = ${builderRef}
+                           AND t.id = ANY(sr.task_ids)), 0))::int
+        ELSE 0 END`;
+}
+
 async function getTask(id) {
   const { rows } = await pool.query(
     `SELECT t.*, ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded,
@@ -1343,6 +1390,7 @@ async function listOpenArtistReviews({ source, refPrefix, resolvedStatuses = [],
 
 module.exports = {
   CREDITS_AWARDED_SUBQUERY,
+  creditsEarnedBySql,
   REWARD_SUGGESTION_CAP,
   createCriterion,
   createTask,

package/modules/lifecycle/db.js

@@ -123,15 +123,16 @@ const {
 // the next setter costs nothing.
 //
 // TASK_FACADE_OMIT is what keeps this surface-PRESERVING rather than quietly
-// wider. Two of db-tasks.js's 33 exports were deliberately never re-exported
+// wider. Three of db-tasks.js's 34 exports were deliberately never re-exported
 // here, and a bare spread would publish them — which ADR 0091 §3 treats as a
 // real surface change, not a tidy-up. Naming them means dropping one has to be
 // somebody's decision. tests/lifecycle_facade_surface.mjs pins the resulting key
 // set, so this can never silently widen or narrow.
 const dbTasks = require('./db-tasks.js');
 const TASK_FACADE_OMIT = new Set([
-  // Internal to db-tasks.js's own queries — a SQL fragment, not a callable.
+  // Internal to the lifecycle's own queries — SQL fragments, not callables.
   'CREDITS_AWARDED_SUBQUERY',
+  'creditsEarnedBySql',
   // The version-gate predicate; routes reach it through db-versions, not here.
   'versionAcceptsNewWork',
 ]);

package/modules/lifecycle/kickoff-checklist.js

@@ -131,4 +131,57 @@ function kickoffChecklist(spec = {}, { provisioned = false, firstSignIn = false
   return tasks.map((t) => ({ ...t }));
 }
 
-module.exports = { kickoffChecklist, productionTopologyKickoff };
+// ── genesis (task 1004423 / BV2.PS08) ───────────────────────────────────────
+// The five genesis stages are worked as REAL tasks on the new project's board, filed
+// by the same seeder as the kickoff checklist (kickoff-seed.js seedGenesisStages) the
+// moment the founder settles the plan. Each stage closes only when its tasks are
+// finished AND the constitution in force decides it (spec D7), so these are the tasks
+// the Board Room's genesis-stage sitting checks. Ideator decisions, because a stage is
+// a decision written down; an AI session can draft each one the way it drafts any task.
+//
+// A project that already exists (the brownfield path) is asked for what it has first,
+// so its scope stage opens with gathering the existing documents.
+const GENESIS_STEPS = Object.freeze({
+  scope: [
+    { title: 'Write the project scope: what we are making, for whom, and what is out of scope',
+      description: 'Genesis stage 1 (scope). One page the whole team can read: the thing being made, who it is for, what done looks like for the first version, and what is deliberately left out. When it is written, Goals and the Roadmap wake.' },
+  ],
+  strategize: [
+    { title: 'Write out the strategy, or link the one you already have',
+      description: 'Genesis stage 2 (strategize). How the project gets from here to its first version: the order of the big pieces, the risks, and what gets tried first. A strategy that already exists can be linked instead. When it is done, Tasks wake.' },
+  ],
+  charter: [
+    { title: 'Choose the starting government and write the bylaws',
+      description: 'Genesis stage 3 (charter). Pick the form of government the project starts under (the genesis plan recommends one from the team size) and write the short bylaws and code of conduct it runs by. When it is done, the Board Room wakes.' },
+  ],
+  legalize: [
+    { title: 'Decide how contributors are rewarded and who can be paid',
+      description: 'Genesis stage 4 (legalize). Whether builders earn credits, money or nothing, and the limits that apply (age, country, the entity behind the project). When it is done, the Economy wakes.' },
+  ],
+  legislation: [
+    { title: 'Set the voting rules: who votes and how many must agree',
+      description: 'Genesis stage 5 (legislation). Who has a say, and the rule a decision passes by. When it is done, Ranks wake, and the project can come alive.' },
+  ],
+});
+const GENESIS_EXISTING_FIRST = {
+  title: 'Gather what already exists: link the documents, code and notes the project has',
+  description: 'Genesis stage 1 (scope), for a project that already exists. Before writing anything new, link what is already there, so the scope is written from it rather than beside it.',
+};
+
+// genesisChecklist({ existing }) → { stageKey: [{ title, description, kind, discipline, ref }] }
+// in genesis order. `ref` is the stable per-task key the seeder dedups on, so filing
+// twice files nothing new. Pure — no I/O.
+function genesisChecklist({ existing = false } = {}) {
+  const out = {};
+  for (const [stage, steps] of Object.entries(GENESIS_STEPS)) {
+    const list = stage === 'scope' && existing ? [GENESIS_EXISTING_FIRST, ...steps] : steps;
+    // The ref names the step, never its position, so the brownfield step slotting in
+    // ahead of scope's own cannot re-key it into a duplicate.
+    out[stage] = list.map((t) => ({
+      ...t, kind: 'decision', discipline: 'ideator', ref: t === GENESIS_EXISTING_FIRST ? 'genesis:scope:existing' : `genesis:${stage}`,
+    }));
+  }
+  return out;
+}
+
+module.exports = { kickoffChecklist, productionTopologyKickoff, genesisChecklist };

package/modules/lifecycle/kickoff-seed.js

@@ -20,7 +20,7 @@
 
 const api = require('../../src/module-api');
 const db = require('./db');
-const { kickoffChecklist } = require('./kickoff-checklist');
+const { kickoffChecklist, genesisChecklist } = require('./kickoff-checklist');
 
 // The spec the checklist reads, from the instance's own branding pack. `modules` is
 // empty on purpose: a hub-provisioned project is scaffolded with every optional module
@@ -71,4 +71,63 @@ async function seedKickoffIfEmpty({ builderId = null } = {}, deps = {}) {
   return { seeded, versionId };
 }
 
-module.exports = { seedKickoffIfEmpty, specFromBranding, FIRST_VERSION_SQL };
+// ── genesis (task 1004423 / BV2.PS08) ───────────────────────────────────────
+// The same seeder files the five genesis stages as real tasks when the founder settles
+// the genesis plan — one seeder, not a second one (spec reuse table). The kickoff seed
+// is idempotent by emptiness, which cannot work here: by genesis the board already
+// holds the kickoff checklist. So each genesis task carries source 'genesis' and a
+// stable source_ref per step (genesisChecklist's `ref`), and a step already filed is
+// skipped. Filing twice files nothing new.
+const GENESIS_SOURCE = 'genesis';
+
+// seedGenesisStages({ builderId, existing }, deps) → { seeded, versionId } | { seeded: 0, skipped }
+async function seedGenesisStages({ builderId = null, existing = false } = {}, deps = {}) {
+  const pool = deps.pool || api.pool;
+  const insert = deps.createTask || ((row) => db.createTask(row));
+  const find = deps.findTaskBySourceRef || ((q) => db.findTaskBySourceRef(q));
+  const { rows: versions } = await pool.query(FIRST_VERSION_SQL);
+  if (!versions.length) return { seeded: 0, skipped: 'no_version' };
+  const versionId = versions[0].id;
+  let seeded = 0;
+  for (const steps of Object.values(genesisChecklist({ existing }))) {
+    for (const t of steps) {
+      if (await find({ source: GENESIS_SOURCE, sourceRef: t.ref })) continue;
+      await insert({
+        versionId,
+        title: t.title,
+        description: t.description,
+        status: 'ready',
+        kind: t.kind,
+        discipline: t.discipline,
+        source: GENESIS_SOURCE,
+        sourceRef: t.ref,
+        createdBy: builderId,
+        // As the kickoff checklist: a project in genesis has no goals yet (Goals wake
+        // only when scope is done), so the catch-all is the honest home.
+        allowCatchAll: true,
+      });
+      seeded += 1;
+    }
+  }
+  return { seeded, versionId };
+}
+
+// genesisStageTasks(deps) → { stageKey: [{ id, title, status }] } for every genesis
+// task on the board, grouped by the stage its source_ref names. The genesis home lists
+// them, and a stage close hands their ids to the Board Room's finished-tasks gate.
+async function genesisStageTasks(deps = {}) {
+  const pool = deps.pool || api.pool;
+  const { rows } = await pool.query(
+    `SELECT id, title, status, source_ref FROM tasks WHERE source = $1 ORDER BY id ASC`,
+    [GENESIS_SOURCE],
+  );
+  const out = {};
+  for (const r of rows) {
+    const stage = String(r.source_ref || '').split(':')[1];
+    if (!stage) continue;
+    (out[stage] = out[stage] || []).push({ id: String(r.id), title: r.title, status: r.status });
+  }
+  return out;
+}
+
+module.exports = { seedKickoffIfEmpty, specFromBranding, FIRST_VERSION_SQL, seedGenesisStages, genesisStageTasks, GENESIS_SOURCE };

package/modules/lifecycle/page-tweak-reads.js

@@ -45,11 +45,27 @@ const artistRule = require('./page-tweak-artist');
 // autosave runs this on every debounced save, and a page's rounds are a handful
 // while the instance's grow without bound. The prefix is matched with left(),
 // not LIKE, the page claim's own rule (an `_` in an id is never a wildcard).
-async function listPageTweakTasks({ pageId = null } = {}) {
+//
+// `artistId` narrows it to ONE artist's rounds (task 1004433 / WA6.RP03): the
+// profile's artist numbers read this on a public page, and an artist's rounds
+// are a handful while the instance's grow without bound. The rounds are found
+// FROM that builder's own web claims (claims by builder_id), never by listing
+// every round and filtering, and a round counts only while its LATEST web
+// claim is still theirs: the D10 payee rule the unscoped read applies.
+// `client` lets a caller run it inside its own transaction (tests/role_stats_db.mjs
+// runs the artist branch against real Postgres, rolled back); default the pool.
+async function listPageTweakTasks({ pageId = null, artistId = null, client = null } = {}) {
   const prefix = pageId ? `page-tweak/${pageId}/` : null;
-  const { rows } = await api.pool.query(
+  const artist = artistId == null ? null : String(artistId);
+  const { rows } = await (client || api.pool).query(
     `WITH pt AS (
-       SELECT t.id FROM tasks t WHERE t.source = 'page-tweak'
+       SELECT t.id FROM tasks t WHERE $2::bigint IS NULL AND t.source = 'page-tweak'
+          AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
+       UNION
+       SELECT t.id FROM claims c JOIN tasks t ON t.id = c.task_id
+        WHERE $2::bigint IS NOT NULL AND c.builder_id = $2::bigint
+          AND ${artistRule.webClaimPredicate('c')}
+          AND t.source = 'page-tweak'
           AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
      ), web AS (
        SELECT DISTINCT ON (c.task_id) c.task_id, c.builder_id
@@ -63,7 +79,8 @@ async function listPageTweakTasks({ pageId = null } = {}) {
             ac.builder_id AS holder_id, hb.github_login AS holder_login,
             (ac.worktree_name IS NOT NULL) AS holder_worktree,
             wc.builder_id AS artist_id, ab.github_login AS artist_login
-       FROM tasks t
+       FROM pt
+       JOIN tasks t ON t.id = pt.id
        LEFT JOIN task_grades g ON g.task_id = t.id
        LEFT JOIN claims ac ON ac.task_id = t.id AND ac.released_at IS NULL
        LEFT JOIN builders hb ON hb.id = ac.builder_id
@@ -71,8 +88,9 @@ async function listPageTweakTasks({ pageId = null } = {}) {
        LEFT JOIN builders ab ON ab.id = wc.builder_id
       WHERE t.source = 'page-tweak'
         AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
+        AND ($2::bigint IS NULL OR wc.builder_id = $2::bigint)
       ORDER BY t.id ASC`,
-    [prefix]
+    [prefix, artist]
   );
   return rows;
 }

package/modules/lifecycle/routes/kickoff-seed.js

@@ -3,7 +3,8 @@
 // modules/lifecycle/routes/kickoff-seed.js — registers the `lifecycle.kickoffSeed` port
 // (task 1003239): the founder's first board, filed the moment the kernel seats them.
 //
-// Resolved by ONE caller — the first-admin bootstrap in src/bongos/auth-admission.js —
+// Resolved by two callers — the first-admin bootstrap in src/bongos/auth-admission.js
+// (seedIfEmpty) and the genesis home in modules/onboarding (seedGenesis, genesisTasks) —
 // through resolveOptional, so an instance without this module signs in exactly as
 // before. A route factory for a routeless capability, for the reason routes/lifecycle.js
 // and routes/rank-sync.js give: mountModuleRoutes is the boot hook that runs in the live
@@ -17,6 +18,11 @@ const seed = require('../kickoff-seed');
 // Delegates at call time (never spreads) so a stubbed seed still bites.
 const kickoffSeedPort = {
   seedIfEmpty: (...a) => seed.seedKickoffIfEmpty(...a),
+  // task 1004423: the genesis home files the five stages through the same seeder, and
+  // reads them back by stage. Still no HTTP surface here: the genesis home's own routes
+  // (modules/onboarding) gate who may file them.
+  seedGenesis: (...a) => seed.seedGenesisStages(...a),
+  genesisTasks: (...a) => seed.genesisStageTasks(...a),
 };
 
 module.exports = function buildLifecycleKickoffSeedRouter() {