@bongos/core 1.20.58 → 1.20.60

package/tests/profile_role_stats.mjs

@@ -0,0 +1,416 @@
+// tests/profile_role_stats.mjs — WA6.RP03 (task 1004433): each role read by its
+// own work, behind the role-shaped profile (the owner-approved mock is
+// docs/design/mocks/profile-roles/, task 1004431).
+//
+// DONE WHEN: "the three reads are correct for fixtures of each craft, including
+// an ideator and an artist who have never shipped a task". So the centre of this
+// file is three people the mock already names, driven through the REAL profile
+// route (GET /builders/:id/profile) with the REAL role composer, the REAL
+// ideator summary over states the REAL resolver derived, the REAL artist read
+// over the REAL page inventory, and economy's REAL fold of the ledger rows:
+//
+//   Ines Varga   an artist who has never shipped a task: pages and ideas only
+//   Tobi Rahn    an ideator who has never shipped a task: thoughts only
+//   Mara Okonkwo an engineer, who also earned a little from an idea
+//
+// The SQL halves (which ledger rows the classification and the per-person
+// earnings reach) run against a real Postgres in tests/role_stats_db.mjs; here
+// the ledger answers with the grouped rows that SQL returns, and everything from
+// there to the JSON is the production path.
+//
+// Also pinned: the public answer carries counts only (decision (a)), the main
+// role's fallbacks, the exact apportioning, and the unknown-not-zero rule when a
+// port is missing.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+
+const require = createRequire(import.meta.url);
+const express = require('express');
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+// ---- the people ------------------------------------------------------------
+
+const INES = 201; const TOBI = 202; const MARA = 203; const NEW = 204; const UI = 205; const LEA = 206;
+const ROWS = {
+  [INES]: { id: INES, github_login: 'ines', display_name: 'Ines Varga', total_credits: 312, karma: 0, rank: 'thetes', preferred_disciplines: ['artist', 'ideator'], main_discipline: null },
+  [TOBI]: { id: TOBI, github_login: 'tobi', display_name: 'Tobi Rahn', total_credits: 186, karma: 0, rank: 'thetes', preferred_disciplines: ['ideator'], main_discipline: null },
+  [MARA]: { id: MARA, github_login: 'mara', display_name: 'Mara Okonkwo', total_credits: 2480, karma: 118, rank: 'metic', preferred_disciplines: ['engineer', 'ideator'], main_discipline: 'engineer' },
+  [NEW]: { id: NEW, github_login: 'new', display_name: 'Newcomer', total_credits: 0, karma: 0, rank: 'xenos', preferred_disciplines: [], main_discipline: null },
+  [UI]: { id: UI, github_login: 'priya', display_name: 'Priya Das', total_credits: 60, karma: 0, rank: 'metic', preferred_disciplines: ['engineer', 'ui'], main_discipline: 'ui' },
+  [LEA]: { id: LEA, github_login: 'lea', display_name: 'Lea Brandt', total_credits: 30, karma: 0, rank: 'thetes', preferred_disciplines: ['artist'], main_discipline: null },
+};
+const SHIPPED = { [INES]: 0, [TOBI]: 0, [MARA]: 64, [NEW]: 0, [UI]: 2, [LEA]: 0 };
+
+// What CREDITS_BY_CRAFT_SQL returns, grouped by (builder, discipline). Ines's
+// session reward was split across two tasks of different crafts, so her rows
+// arrive as halves; the fold has to make them exact again.
+const LEDGER_ROWS = [
+  { builder_id: String(INES), discipline: 'artist', amount: 120 },
+  { builder_id: String(INES), discipline: 'ideator', amount: 42 },
+  { builder_id: String(INES), discipline: 'engineer', amount: 74.5 },
+  { builder_id: String(INES), discipline: 'ui', amount: 74.5 },
+  { builder_id: String(INES), discipline: 'other', amount: 1 },
+  { builder_id: String(TOBI), discipline: 'ideator', amount: 186 },
+  { builder_id: String(MARA), discipline: 'engineer', amount: 2460 },
+  { builder_id: String(MARA), discipline: 'ideator', amount: 20 },
+  { builder_id: String(UI), discipline: 'ui', amount: 60 },
+  // a discipline nobody mapped yet counts as engineering, never vanishes
+  { builder_id: String(UI), discipline: 'some-module-craft', amount: 0 },
+];
+
+// ---- the page-tweak ledger (Ines and one other artist) ----------------------
+
+const pages = require('../modules/copy-desk/pages.js');
+const inventory = require('../docs/page-inventory.json');
+const onSurface = (s) => inventory.pages.filter((p) => p.surface === s).map((p) => p.id);
+const LANDING = onSurface('landing');
+const BUILDERS = onSurface('builders');
+const NOW = new Date();
+const DAY = 24 * 60 * 60 * 1000;
+const PAGE_WORDS = 'DO_NOT_LEAK_PAGE_WORDING';
+let tid = 9000;
+const round = (pageId, n, artistId, status) => ({
+  id: String(++tid), source: 'page-tweak', source_ref: pages.roundSourceRef(pageId, n), status, artist_id: String(artistId),
+  description: `\`\`\`page-tweak\n${PAGE_WORDS}\n\`\`\``, title: `Tweak: ${PAGE_WORDS}`,
+});
+const PAGE_TASKS = [
+  round(LANDING[0], 1, INES, 'shipped'),
+  round(LANDING[0], 2, INES, 'shipped'),   // the same page twice: two approvals, one page
+  round(LANDING[1], 1, INES, 'shipped'),
+  round(BUILDERS[0], 1, INES, 'shipped'),
+  round(BUILDERS[1], 1, INES, 'ready'),    // still being written: not approved
+  round(BUILDERS[2], 1, LEA, 'shipped'),   // someone else's page
+];
+const PAGE_CREDITS = {
+  [INES]: [
+    { reason: `tweak.page_approved:${PAGE_TASKS[0].id}`, delta: 30, recorded_at: new Date(NOW - 20 * DAY).toISOString() },
+    { reason: `tweak.page_approved:${PAGE_TASKS[1].id}`, delta: 30, recorded_at: new Date(NOW - 10 * DAY).toISOString() },
+    { reason: `tweak.page_approved:${PAGE_TASKS[2].id}`, delta: 30, recorded_at: new Date(NOW - 2 * DAY).toISOString() },
+    { reason: `tweak.page_approved:${PAGE_TASKS[3].id}`, delta: 30, recorded_at: new Date(NOW - 1 * DAY).toISOString() },
+  ],
+  [LEA]: [{ reason: `tweak.page_approved:${PAGE_TASKS[5].id}`, delta: 30, recorded_at: NOW.toISOString() }],
+};
+
+// ---- the idea trails, with states derived by the REAL resolver ---------------
+
+const { resolveIdeaState } = require('../modules/ideas/idea-state.js');
+const IDEA_WORDS = 'DO_NOT_LEAK_IDEA_TITLE';
+function thought(id, { status = 'open', grade = 'quick', credits = 0, estimated = 0, share = 1, attributable = true } = {}) {
+  const hasWork = credits > 0;
+  return {
+    id: String(id), title: `${IDEA_WORDS} ${id}`, triage_note: IDEA_WORDS, status, grade,
+    size: { credits, paid: credits - estimated, estimated, payments: hasWork ? 1 : 0, byTask: new Map() },
+    state: resolveIdeaState({ status, hasWork, share: hasWork ? share : 1, attributable, tasks: [] }),
+  };
+}
+const TRAILS = {
+  [TOBI]: [
+    thought(1, { grade: 'full', credits: 64, share: 1 }),
+    thought(2, { grade: 'full', credits: 42, share: 0.6 }),
+    thought(3),
+    thought(4, { credits: 18 }),
+    thought(5, { credits: 22, estimated: 10, share: 0 }),      // burned out; part of it historical
+    thought(6, { status: 'merged' }),
+    thought(7, { status: 'discarded' }),
+    thought(8, { grade: 'full', credits: 26, share: 0.85 }),
+  ],
+  [INES]: [thought(21, { credits: 42 }), thought(22), thought(23), thought(24)],
+  [MARA]: [thought(31, { credits: 20 })],
+};
+const RATIFIED = new Set(['1']);
+const skyCalls = [];
+const pageReads = [];
+
+// ---- the harness: real route, real composer, ports at their real seams -------
+
+const authPath = require.resolve('../src/bongos/auth.js');
+require.cache[authPath] = {
+  id: authPath, filename: authPath, loaded: true,
+  exports: {
+    requireBuilder: (_req, _res, next) => next(),
+    requirePermission: () => (_req, _res, next) => next(),
+    requireRank: () => (_req, _res, next) => next(),
+  },
+};
+const dbPath = require.resolve('../src/bongos/db.js');
+require.cache[dbPath] = {
+  id: dbPath, filename: dbPath, loaded: true,
+  exports: {
+    RANKS: ['xenos', 'thetes', 'metic', 'archon'],
+    getBuilderById: async (id) => (ROWS[id] ? { ...ROWS[id], created_at: '2026-07-01T00:00:00.000Z', avatar_url: null } : null),
+    getBuilderRoleChoice: async (id) => (ROWS[id]
+      ? { preferred_disciplines: ROWS[id].preferred_disciplines, main_discipline: ROWS[id].main_discipline }
+      : null),
+  },
+};
+
+const seams = require('../src/module-seams.js');
+seams._reset();
+const creditsByCraftLib = require('../modules/economy/credits-by-craft.js');
+const ledgerSql = [];
+const ledgerClient = {
+  async query(sql, params) {
+    ledgerSql.push({ sql, params });
+    const ids = new Set(params[0].map(String));
+    return { rows: LEDGER_ROWS.filter((r) => ids.has(r.builder_id)) };
+  },
+};
+seams.registerProvider('lifecycle', {
+  countShippedTasksForBuilder: async (id) => SHIPPED[id] || 0,
+  recentShippedTasksByBuilder: async () => [],
+  // Honours the artist scope the way the SQL does (only rounds whose latest web
+  // claim is theirs), and records it, so the read is held to asking for one
+  // artist rather than every round in the project.
+  listPageTweakTasks: async (opts = {}) => {
+    pageReads.push(opts);
+    return PAGE_TASKS.filter((r) => opts.artistId == null || r.artist_id === String(opts.artistId)).map((r) => ({ ...r }));
+  },
+});
+seams.registerProvider('reward', {
+  getBuilderAchievements: async () => [],
+  creditsByCraft: (ids) => creditsByCraftLib.creditsByCraft(ids, { client: ledgerClient }),
+  craftForPreference: (d) => creditsByCraftLib.craftForPreference(d),
+  creditLedger: async (builderId, { reasonPrefix }) => {
+    const rows = (PAGE_CREDITS[builderId] || []).filter((r) => r.reason.startsWith(reasonPrefix));
+    return { rows, total: rows.length };
+  },
+});
+seams.registerProvider('government', { boardPassForIdea: async (id) => (RATIFIED.has(String(id)) ? { outcome: 'passed' } : null) });
+const ideatorStats = require('../modules/ideas/ideator-stats.js');
+seams.registerProvider('ideas.ideatorStats', (id) => ideatorStats.readIdeatorStats(id, {
+  readSkyMine: async ({ builderId, viewerRank }) => {
+    skyCalls.push({ builderId, viewerRank });
+    const ideas = TRAILS[builderId] || [];
+    return { ideas, total: ideas.length, truncated: false };
+  },
+}));
+// The copy-desk router's factory is the production registration of its port.
+require('../modules/copy-desk/routes/copy-desk.js')();
+assert.equal(typeof seams.resolveOptional('copy-desk.artistStats'), 'function', 'copy-desk registers its read port at boot');
+
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildBuildersRouter = require('../src/bongos/routes/builders.js');
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use('/api/bongos', buildBuildersRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const port = server.address().port;
+function get(path) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({ host: '127.0.0.1', port, method: 'GET', path }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        resolve({ status: res.statusCode, json: JSON.parse(text), text });
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+const profile = async (id) => {
+  const r = await get(`/api/bongos/builders/${id}/profile`);
+  assert.equal(r.status, 200, r.text);
+  return r;
+};
+
+// ---- the artist who has never shipped a task --------------------------------
+
+await t('ARTIST, never shipped: leads with artist, by what she earned, and shows ideator beside it', async () => {
+  const { json } = await profile(INES);
+  assert.equal(json.shipped_count, 0, 'the fixture is the case the task names: no shipped task at all');
+  const r = json.roles;
+  assert.equal(r.main, 'artist');
+  assert.equal(r.main_basis, 'earned', 'no main role chosen yet, so it is inferred and says so');
+  assert.deepEqual(r.shown, ['artist', 'ideator', 'engineer'],
+    'main first, then every craft she EARNED in, in her preferred order (her session reward was part engineering)');
+  assert.equal(r.engineer.shipped, 0);
+});
+
+await t('ARTIST: pages approved, pages, N of M per surface, credits from pages and this week', async () => {
+  const a = (await profile(INES)).json.roles.artist;
+  assert.equal(a.pages_approved, 4, 'four approved rounds, each one paid');
+  assert.equal(a.pages, 3, 'on three distinct pages (one was tweaked twice)');
+  assert.equal(a.surfaces_touched, 2);
+  assert.equal(a.credits, 120, 'credits from pages are the page rows only, not her other pay');
+  assert.equal(a.this_week, 60, 'two approvals inside the trailing week');
+  const landing = a.surfaces.find((s) => s.id === 'landing');
+  const builders = a.surfaces.find((s) => s.id === 'builders');
+  assert.equal(landing.tweaked, 2);
+  assert.equal(landing.total, LANDING.length, 'M is the surface page count, the studio denominator');
+  assert.equal(landing.line, `2 of ${LANDING.length} tweaked`);
+  assert.equal(builders.tweaked, 1, 'her unapproved draft and the other artist page do not count');
+  assert.equal(builders.total, BUILDERS.length);
+  assert.equal(a.inventory_known, true);
+  assert.deepEqual(pageReads[pageReads.length - 1], { artistId: INES }, 'one artist rounds, never the whole project');
+});
+
+await t('the credit split is exact: halves rounded by largest remainder, ui folded into artist', async () => {
+  const c = (await profile(INES)).json.roles.credits_by_craft;
+  assert.deepEqual(c, { engineer: 75, artist: 194, ideator: 42, other: 1, total: 312 },
+    '74.5 + 74.5 must not round to 150 or 148; the parts equal the whole');
+  assert.equal(c.engineer + c.artist + c.ideator + c.other, c.total);
+});
+
+// ---- the ideator who has never shipped a task -------------------------------
+
+await t('IDEATOR, never shipped: leads with ideator, shows nothing it did not earn', async () => {
+  const { json } = await profile(TOBI);
+  assert.equal(json.shipped_count, 0);
+  assert.equal(json.roles.main, 'ideator');
+  assert.deepEqual(json.roles.shown, ['ideator']);
+  assert.equal(json.roles.engineer, null, 'no engineering block for someone with no engineering credit');
+  assert.equal(json.roles.artist, null);
+});
+
+await t('IDEATOR: filed, ignited, Full Ideas, ratified, total size every stream + the estimate marker, still alive', async () => {
+  const i = (await profile(TOBI)).json.roles.ideator;
+  assert.equal(i.filed, 8);
+  assert.equal(i.ignited, 5, 'the five that were paid for work, a burned-out one included');
+  assert.equal(i.full_ideas, 3);
+  assert.equal(i.ratified, 1, 'the one the board carried');
+  assert.deepEqual(i.size, { total: 196, paid: 186, estimated: 10, historical: true },
+    'the ledger ideator column (every stream) plus the historical estimate, marked');
+  const expected = (64 * 1 + 42 * 0.6 + 18 + 22 * 0 + 26 * 0.85) / (64 + 42 + 18 + 22 + 26);
+  assert.ok(Math.abs(i.alive.share - expected) < 1e-9, `size-weighted live share, got ${i.alive.share}`);
+  assert.equal(i.alive.has_work, true);
+  assert.equal(i.truncated, false);
+});
+
+await t('the trail is read at the public rank, so a count never changes with who is looking', async () => {
+  skyCalls.length = 0;
+  await profile(TOBI);
+  assert.deepEqual(skyCalls, [{ builderId: TOBI, viewerRank: 'xenos' }]);
+});
+
+// ---- the engineer ------------------------------------------------------------
+
+await t('ENGINEER: unchanged headline (works shipped), chosen main role, a little ideator beside it', async () => {
+  const r = (await profile(MARA)).json.roles;
+  assert.equal(r.main, 'engineer');
+  assert.equal(r.main_basis, 'chosen');
+  assert.deepEqual(r.shown, ['engineer', 'ideator']);
+  assert.deepEqual(r.engineer, { shipped: 64, credits: 2460 });
+  assert.equal(r.artist, null, 'no page read for someone with no artist credit');
+  assert.equal(r.ideator.filed, 1);
+  assert.equal(r.ideator.size.paid, 20);
+});
+
+// ---- the fallbacks and the boundary ------------------------------------------
+
+await t('main role: a chosen ui reads as artist; nothing chosen and nothing earned is engineering, said to be a default', async () => {
+  const ui = (await profile(UI)).json.roles;
+  assert.equal(ui.main, 'artist');
+  assert.equal(ui.main_basis, 'chosen');
+  assert.deepEqual(ui.preferred, ['engineer', 'artist']);
+  const nobody = (await profile(NEW)).json.roles;
+  assert.equal(nobody.main, 'engineer');
+  assert.equal(nobody.main_basis, 'default');
+  assert.deepEqual(nobody.shown, ['engineer']);
+  assert.equal(nobody.credits_by_craft.total, 0, 'zero credits is an answer, not a gap');
+});
+
+await t('decision (a): the public answer is counts and sums, never an idea title or a word of a page', async () => {
+  for (const id of [INES, TOBI, MARA]) {
+    const { text } = await profile(id);
+    assert.ok(!text.includes(IDEA_WORDS), 'no idea title or triage note on the public profile');
+    assert.ok(!text.includes(PAGE_WORDS), 'no page wording on the public profile');
+  }
+});
+
+await t('a missing port reads as unknown (null), never as zero', async () => {
+  const ideasPort = seams.resolveOptional('ideas.ideatorStats');
+  seams._reset();
+  seams.registerProvider('lifecycle', { countShippedTasksForBuilder: async () => 0, recentShippedTasksByBuilder: async () => [] });
+  seams.registerProvider('reward', { getBuilderAchievements: async () => [], creditsByCraft: (ids) => creditsByCraftLib.creditsByCraft(ids, { client: ledgerClient }) });
+  try {
+    const r = (await profile(TOBI)).json.roles;
+    assert.equal(r.ideator.filed, null);
+    assert.equal(r.ideator.unavailable, true);
+  } finally {
+    seams.registerProvider('ideas.ideatorStats', ideasPort);
+  }
+});
+
+// ---- the pure halves ----------------------------------------------------------
+
+await t('apportion hands out exactly the rounding left over, larger remainder first, ties to the earlier key', () => {
+  assert.deepEqual(creditsByCraftLib.apportion({ a: 1.5, b: 1.5, c: 0 }, 3), { a: 2, b: 1, c: 0 });
+  assert.deepEqual(creditsByCraftLib.apportion({ a: 0.2, b: 0.7, c: 0.1 }, 1), { a: 0, b: 1, c: 0 });
+  assert.deepEqual(creditsByCraftLib.apportion({ a: 10, b: 0 }, 10), { a: 10, b: 0 });
+});
+
+await t('the ledger statement classifies by reason, splits the session reward and escapes the artist prefix', () => {
+  const sql = creditsByCraftLib.CREDITS_BY_CRAFT_SQL;
+  assert.match(sql, /cl\.reason LIKE \$2 THEN 'artist'/);
+  assert.match(sql, /idea\.credit\.%' OR cl\.reason = 'idea_promotion_bonus' THEN 'ideator'/);
+  assert.match(sql, /GREATEST\(COALESCE\(cardinality\(sr\.task_ids\), 0\), 1\)/, 'an even split, and a session that shipped nothing still counts once');
+  const last = ledgerSql[ledgerSql.length - 1];
+  assert.equal(last.params[1], 'tweak.page\\_approved:%', 'the underscore is escaped, so it is not a LIKE wildcard');
+  assert.deepEqual(last.params[2], ['task.shipped', 'task.confirmed', 'ship.net_negative']);
+});
+
+await t('the craft split reads one person rows through existing indexes, never the whole ledger', () => {
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const mig = (f) => fs.readFileSync(path.join(path.dirname(require.resolve('../package.json')), 'migrations', f), 'utf8');
+  assert.match(mig('003_pms.sql'), /CREATE INDEX IF NOT EXISTS idx_credit_log_builder ON credit_log \(builder_id, recorded_at\)/,
+    'credit_log is indexed by builder: the WHERE cl.builder_id = ANY($1) in both branches is an index read');
+  assert.match(mig('062_session_records.sql'), /session_id\s+text NOT NULL UNIQUE/, 'the session join is a unique-index probe');
+  const sql = creditsByCraftLib.CREDITS_BY_CRAFT_SQL;
+  assert.equal((sql.match(/WHERE cl\.builder_id = ANY\(\$1::bigint\[\]\)/g) || []).length, 2, 'both branches are scoped to the builders asked for');
+});
+
+await t('the per-person fragment only takes a bind reference, and the task payout counts the artist and idea rows', () => {
+  const { creditsEarnedBySql, CREDITS_AWARDED_SUBQUERY } = require('../modules/lifecycle/db-tasks.js');
+  assert.throws(() => creditsEarnedBySql('1; DROP TABLE tasks'), /bind parameter/);
+  const frag = creditsEarnedBySql('$3');
+  assert.match(frag, /cl\.builder_id = \$3/);
+  assert.match(frag, /sr\.builder_id = \$3/);
+  assert.match(frag, /cl\.reason = 'session\.token_reward'/);
+  assert.match(CREDITS_AWARDED_SUBQUERY, /tweak\.page\\_approved:%/);
+  assert.match(CREDITS_AWARDED_SUBQUERY, /idea\.credit\.%/);
+  assert.doesNotMatch(CREDITS_AWARDED_SUBQUERY, /achievement/);
+});
+
+await t('the profile lists read what THIS person earned, not the task payout', () => {
+  const fs = require('node:fs');
+  const activity = fs.readFileSync(require.resolve('../modules/lifecycle/activity.js'), 'utf8');
+  const analytics = fs.readFileSync(require.resolve('../modules/lifecycle/db-analytics.js'), 'utf8');
+  assert.match(activity, /\$\{creditsEarnedBySql\('\$1'\)\} AS credits_awarded/);
+  const byBuilder = analytics.slice(analytics.indexOf('async function recentShippedTasksByBuilder'));
+  assert.match(byBuilder.slice(0, 1200), /\$\{creditsEarnedBySql\('\$1'\)\} AS credits_awarded/);
+});
+
+await t('the artist-scoped page read starts from that builder web claims and keeps the latest-web-claim rule', () => {
+  const fs = require('node:fs');
+  const src = fs.readFileSync(require.resolve('../modules/lifecycle/page-tweak-reads.js'), 'utf8');
+  const fn = src.slice(src.indexOf('async function listPageTweakTasks'), src.indexOf('async function shippedTasksTouchingSince'));
+  assert.match(fn, /FROM claims c JOIN tasks t ON t\.id = c\.task_id\s+WHERE \$2::bigint IS NOT NULL AND c\.builder_id = \$2::bigint/,
+    'an artist rounds are found from their own claims, not by listing every round');
+  assert.match(fn, /wc\.builder_id = \$2::bigint/, 'and a round counts only while its latest web claim is still theirs');
+  assert.match(fn, /\[prefix, artist\]/);
+});
+
+await t('summarizeIdeatorTrail: no work is no share (not zero), an unreadable thought makes the share unknown', () => {
+  const none = ideatorStats.summarizeIdeatorTrail([thought(1), thought(2)], { ideatorCredits: 0, ratifiedIds: new Set() });
+  assert.deepEqual(none.alive, { share: null, has_work: false, attributable: null });
+  const blind = ideatorStats.summarizeIdeatorTrail([thought(1, { credits: 5, attributable: false })], { ideatorCredits: 5, ratifiedIds: null });
+  assert.equal(blind.alive.share, null);
+  assert.equal(blind.alive.attributable, false);
+  assert.equal(blind.ratified, null, 'no board port: ratified is unknown, not zero');
+});
+
+server.close();
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/projects_hub.mjs

@@ -715,8 +715,9 @@ test('a renumbering of the wizard invalidates old drafts — the key carries the
   const panels = (SCRIPT.match(/var panels = \{([^}]*)\}/) || [, ''])[1];
   const count = [...panels.matchAll(/\d+:\s*'panel-/g)].length;
   // task 1004417 put the front door's two screens (terms, fork) in front: the sixth renumbering
-  assert.equal(count, 12, 'gate + the front door\'s two + eight numbered steps + done — bump DRAFT_KEY when this changes');
-  assert.equal(key, 'cb-create-draft-v6', 'and the key moved with the front door');
+  // task 1004421 put the Look step between App and Review: the seventh
+  assert.equal(count, 13, 'gate + the front door\'s two + nine numbered steps + done — bump DRAFT_KEY when this changes');
+  assert.equal(key, 'cb-create-draft-v7', 'and the key moved with the Look step');
 });
 
 test('every row lays the same five parts — the ledger has no ragged row', () => {
@@ -2137,7 +2138,7 @@ test('the wizard takes the world by scope: no card ground, the six-step strip as
   assert.match(block, /#view-new \.card\{background:none;border-radius:0;box-shadow:none;/, 'no card ground');
   // eight tracks since task 1004351 added the App step (seven since 1002339); the count is the
   // rail's own, so it moves with the panels map rather than being a magic number
-  assert.match(block, /#view-new \.steps\{display:grid;grid-template-columns:repeat\(8,1fr\);/, 'the strip lays a track per numbered step');
+  assert.match(block, /#view-new \.steps\{display:grid;grid-template-columns:repeat\(9,1fr\);/, 'the strip lays a track per numbered step');
   assert.match(block, /#view-new \.steps li::before\{content:"";position:absolute;top:-4px;left:0;right:auto;width:7px;height:7px;/, 'the connector becomes the 7px dot');
   assert.match(block, /#view-new \.steps li\.now::before\{background:var\(--accent\);border-color:var\(--accent\);outline:4px solid/, 'the lit step carries the accent and an outline halo');
   assert.match(block, /#view-new \.panel h1\{font-weight:300;[^}]*text-transform:lowercase;/, 'the step title in the display voice, lowercase');
@@ -2184,7 +2185,7 @@ test('the wizard\'s own structures wear the world: hairline fields, cells of one
   assert.match(block, /\.addrBig code\{display:block;font-family:var\(--font-display\);/, 'the address stands in the display voice');
   assert.doesNotMatch(block, /linear-gradient/, 'no tinted plates');
   assert.doesNotMatch(block, /box-shadow:(?!none)/, 'no box shadow in the wizard block');
-  assert.match(HUB, /<div class="nav">\s*<button type="button" class="btn ghost" data-back="9">← Back<\/button>\s*<button type="button" class="btn big" id="doCreate">Create my project<\/button>/, 'the review\'s doors sit on one row, back then the primary');
+  assert.match(HUB, /<div class="nav">\s*<button type="button" class="btn ghost" data-back="10">← Back<\/button>\s*<button type="button" class="btn big" id="doCreate">Create my project<\/button>/, 'the review\'s doors sit on one row, back then the primary');
   assert.match(HUB, /<h2 class="stepsHead" id="doneStepsHead">Your steps — the parts only you can play<\/h2>/, 'the steps heading is the label face by class, not an inline style (the id is where a skipped invite step hands focus on, task 1002346)');
   // what is enqueued is unchanged (ADR 0111): the filing body the control plane reads
   assert.match(SCRIPT, /body: JSON\.stringify\(\{\s*slug: state\.slug,/, 'the filing still carries the slug first');

package/tests/projects_hub_app_status.mjs

@@ -240,7 +240,7 @@ test('a repaint never lands on top of an open Retry — from this watch or a fre
 });
 
 test('both surfaces use it: the done panel and the project page', () => {
-  assert.match(HUB, /if \(box\) watchApp\(instanceId, box, function \(\) \{ return state\.step === 11; \}, 5000\);/);
+  assert.match(HUB, /if \(box\) watchApp\(instanceId, box, function \(\) \{ return state\.step === 12; \}, 5000\);/);
   assert.match(HUB, /<div id="doneApp" hidden><\/div>/);
   assert.match(HUB, /<div class="card mSec" id="mAppCard" hidden>\n\s*<h2>Where its app runs<\/h2>\n\s*<div id="mApp"><\/div>/);
   assert.match(HUB, /loadAppStatus\(inst\.id \|\| asked, inst\);/);

package/tests/projects_hub_app_step.mjs

@@ -142,16 +142,17 @@ test('the panel is real markup: Render and Decide later, Decide later the defaul
   assert.doesNotMatch(PANEL, /Coming soon/, 'and is no longer marked soon');
   assert.match(PANEL, /<input type="radio" name="appPlatform" value="later" checked>/, 'Decide later is the default');
   assert.match(PANEL, /We host your Builders' hall/, 'the step says the hall is ours to host (ADR 0345 D1), in the page\'s one spelling of it');
-  assert.match(PANEL, /<form data-next="10">/, 'Next leads to the review');
+  assert.match(PANEL, /<form data-next="10">/, 'Next leads to the Look step (task 1004421), then the review');
   assert.match(PANEL, /data-back="8"/, 'Back returns to the address step');
 });
 
-test('the step sits between Address and Review in the panels map and on the rail', () => {
-  assert.match(HUB, /8: 'panel-address', 9: 'panel-app', 10: 'panel-review', 11: 'panel-done'/);
+test('the step sits between Address and the Look step in the panels map and on the rail', () => {
+  assert.match(HUB, /8: 'panel-address', 9: 'panel-app', 10: 'panel-look', 11: 'panel-review', 12: 'panel-done'/);
   assert.match(HUB, /<li data-step="9"><span class="snum">7<\/span><span class="slbl">App<\/span><\/li>/);
-  assert.match(HUB, /<li data-step="10"><span class="snum">8<\/span><span class="slbl">Create<\/span><\/li>/);
-  assert.match(HUB, /data-back="9">← Back<\/button>\n\s*<button type="button" class="btn big" id="doCreate">/, "the review's Back returns to the app step");
-  assert.match(HUB, /if \(step === 9\) \{ syncAppStep\(\); syncRenderSetup\(\); \}\n\s*if \(step === 10\) renderReview\(\);/, 'entering the step repaints it, Render setup included');
+  assert.match(HUB, /<li data-step="10"><span class="snum">8<\/span><span class="slbl">Look<\/span><\/li>/);
+  assert.match(HUB, /<li data-step="11"><span class="snum">9<\/span><span class="slbl">Create<\/span><\/li>/);
+  assert.match(HUB, /data-back="10">← Back<\/button>\n\s*<button type="button" class="btn big" id="doCreate">/, "the review's Back returns to the Look step");
+  assert.match(HUB, /if \(step === 9\) \{ syncAppStep\(\); syncRenderSetup\(\); \}\n\s*if \(step === 10\) renderLook\(\);\n\s*if \(step === 11\) renderReview\(\);/, 'entering the step repaints it, Render setup included');
   assert.match(HUB, /if \(step === 9\) return validateRender\(\);/, 'Next on the step runs the Render check');
 });
 
@@ -455,5 +456,5 @@ test('the review names exactly what was chosen, prices included', () => {
 });
 
 test('Create hands the app to Render straight after the project is filed', () => {
-  assert.match(HUB, /show\(11, true\);\n\s*sendRenderSetup\(data\.instance && data\.instance\.id\);/);
+  assert.match(HUB, /show\(12, true\);\n\s*sendRenderSetup\(data\.instance && data\.instance\.id\);/);
 });