@bongos/core 1.19.903 → 1.19.905

package/modules/economy/idea-size.js

@@ -0,0 +1,381 @@
+'use strict';
+
+// modules/economy/idea-size.js — SIZE: an idea's total ideator payout from its
+// descent (task 1004093, BV2.R12, goal 1000095; spec
+// docs/specs/bongos-v2-ideator-surface.md decisions 4, 5 and 7).
+//
+// WHAT SIZE IS. Stream 1 pays an idea's people every time a task under it ships
+// — the direct task at full share, and since BV2.R09 every task DESCENDED from
+// it at `decay^depth` (modules/economy/credits.js: awardIdeaTaskShipCredit and
+// awardIdeaDescentShipCredit). Size is the sum of those payouts. Nothing else:
+// not the Full-Idea pass (stream 2), not the board ratification (stream 3), not
+// the promotion bonus. Those pay for the THOUGHT; size is what its WORK earned,
+// and mixing them would make a well-written idea that caused nothing draw as
+// large as one that caused a version.
+//
+// WHY IT IS CREDITS AND NOT KARMA (spec decision 5). `karma_log` carries no task
+// key and no idea key, and migrations/040_builder_karma.sql:13 says that is
+// deliberate — so "the karma a thought caused" is not a quantity that exists to
+// be summed. Credits are already idea-attributed at the moment they are booked.
+//
+// WHY NO MIGRATION. scripts/gds/sequence.js flagged this task `needs_migration`,
+// but that flag is a keyword scan of the title and description
+// (scripts/gds/sequence.js:169), not a fact about the schema. The reason key
+// stream 1 books under ALREADY embeds the idea:
+//
+//     idea.credit.task_ship:<ideaId>:<taskId>
+//
+// so size is a pure read over credit_log, needing no column and no table. A
+// schema change of that kind would be a second copy of a fact the ledger
+// already holds, and a second copy of money is how the number and the ledger
+// drift.
+//
+// IT DOES NEED AN INDEX, though — which is a different thing from a schema
+// change and was missed on the first round of this task. credit_log is the
+// whole-instance, append-only ledger, and this read runs on every view of a
+// builder's idea trail, so unindexed it is a sequential scan of every credit
+// event the instance has ever booked. `migrations/core_251_credit_log_idea_
+// size_index.sql` adds a partial expression index matching this query exactly;
+// see the note on TASK_SHIP_PREFIX_SQL below for why the predicate has to be a
+// literal on both sides for that index to ever be chosen.
+//
+// SIZE NEVER FALLS, and the reason is in the writers, not in a clamp here.
+// credit_log is append-only; both stream-1 writers skip a payment whose rounded
+// delta is `<= 0`, and `splitIdeaCredit` independently returns no payees for a
+// non-positive total — so the property is held in TWO places and survives either
+// one being removed (probed: removing one guard reds nothing, removing both reds
+// the test below). No non-positive row is ever booked under this prefix; and
+// ADR 0313 settles that a removal claws nothing back — `shipped` stays terminal.
+// The sum is therefore monotonic by construction. This file does NOT clamp the
+// result to zero, because a clamp would hide exactly the anomaly it claims to
+// prevent: if a reversal ever appeared under this prefix, the honest answer is
+// the smaller number, not a floor that quietly disagrees with the ledger.
+// tests/idea_size.mjs drives the real writers and pins that they book nothing
+// non-positive, which is where that invariant actually lives.
+
+const api = require('../../src/module-api');
+const { pool, resolveOptional } = api;
+// The historical half (task 1004097 / BV2.R18) — the pricing of a descent the
+// ledger was never there to pay for. Its own file because it is arithmetic
+// rather than a read, and because it must import credits.js's payout helpers
+// directly rather than growing a second copy of them here.
+const { priceDescentForIdea } = require('./idea-size-historical');
+const { rewardConfig } = require('./credits');
+// The prefix, taken from the writers rather than retyped. It is the idempotency
+// predicate stream 1 books under, so a literal here that drifted from it would
+// read an empty ledger and every star would go out at once.
+const { IDEA_STREAM_REASON_PREFIXES } = require('./credits');
+
+// THE PREFIX GOES INTO THE SQL TEXT AS A LITERAL, NOT AS A PARAMETER, and that
+// is the one unobvious line in this file.
+//
+// `migrations/core_251_credit_log_idea_size_index.sql` indexes this read with a
+// PARTIAL index predicated on `reason LIKE 'idea.credit.task_ship:%'`. Postgres
+// uses a partial index only when it can prove the query's WHERE implies the
+// index predicate — and it cannot prove that about `reason LIKE $1 || '%'`,
+// because the parameter has no value when a generic plan is built. Parameterised,
+// the index is simply never chosen and the sequential scan the migration exists
+// to remove comes straight back, silently.
+//
+// Interpolating a string into SQL is the thing one does not do, so it is fenced:
+// this is a module-owned constant that never touches a request, and the assert
+// below refuses anything that is not plain prefix characters. A constant that
+// grew a quote would fail at module load — at boot, loudly — rather than
+// becoming an injection point.
+//
+// THE UNDERSCORE IN `task_ship` IS A LIKE WILDCARD. `_` matches any single
+// character, so an unescaped prefix would also match `idea.credit.taskXship:`.
+// No such key exists today, which is exactly why it would never be noticed —
+// so it is escaped, the way credits.js `creditLedger` already escapes a caller's
+// reasonPrefix. Backslash is LIKE's default escape in Postgres, so no ESCAPE
+// clause is needed; `migrations/core_251_*.sql` carries the identical string.
+if (!/^[a-z0-9_.]+:$/i.test(IDEA_STREAM_REASON_PREFIXES.task_ship)) {
+  throw new Error('economy/idea-size: the stream-1 reason prefix is not a plain literal; refusing to inline it into SQL');
+}
+const TASK_SHIP_PREFIX_SQL = `'${IDEA_STREAM_REASON_PREFIXES.task_ship.replace(/([\\%_])/g, '\\$1')}%'`;
+
+// The credits at which the drawn scale reaches 1. At the base 5c per shipped
+// task this is on the order of a hundred shipped tasks under one thought — far
+// beyond anything an instance has today, so the compression spends its range on
+// the ideas that exist rather than saturating them all at the top.
+const IDEA_SIZE_SCALE_REF = 500;
+
+// compressIdeaSize — the drawn magnitude of a size, in [0, 1]. Pure.
+//
+// Payout sums are long-tailed: most ideas cause one task and earn 5, a handful
+// cause a version and earn hundreds. Drawn linearly, the tail is the only thing
+// visible and everything else is the same dot. log1p spends the range where the
+// ideas are, and log1p (not log) is what lets an idea that earned NOTHING sit at
+// a clean 0 instead of at negative infinity.
+//
+// ABSOLUTE, NOT RELATIVE TO THE SET — and this is the decision in this file.
+// Normalising against the largest idea on screen would draw better, and it would
+// break the one property size exists to have: a thought's size would FALL the
+// moment a bigger thought appeared beside it, without a credit changing hands.
+// Size is supposed to be the channel that never falls (brightness, BV2.R16, is
+// the one that does). So the reference is a constant, the same for every idea in
+// every frame, and a set of ideas can be compared across two different pages.
+//
+// Monotonic and saturating: more credits never draws smaller, and past the
+// reference the scale holds at 1 while the TRUE figure — which the panel shows —
+// keeps climbing.
+function compressIdeaSize(credits) {
+  const c = Number(credits);
+  if (!Number.isFinite(c) || c <= 0) return 0;
+  const scale = Math.log1p(c) / Math.log1p(IDEA_SIZE_SCALE_REF);
+  return scale >= 1 ? 1 : scale;
+}
+
+// A positive integer id as it arrives off a row or a caller — where it may be a
+// bigint serialised to a string. Anything else is dropped rather than sent to
+// the database, and never coerced with Number() (bigint precision).
+function idOf(v) {
+  return /^[1-9]\d*$/.test(String(v)) ? String(v) : null;
+}
+
+// ideaSizes — size for MANY ideas in ONE query, keyed by idea id (string).
+//
+// The grouping key is split_part(reason, ':', 2), which is the idea id the
+// writer embedded. It is read INSTEAD of a per-idea LIKE for two reasons, and
+// the second is the one that would have been a bug:
+//
+//   • one scan for a whole page of ideas, not one scan per idea;
+//   • a prefix match has a boundary. `reason LIKE 'idea.credit.task_ship:1:%'`
+//     is right only because of the trailing colon — drop it and idea 1 absorbs
+//     every payout of ideas 10, 100 and 1000. Splitting on the separator has no
+//     such edge to get wrong. tests/idea_size.mjs pins the 1-vs-10 case anyway,
+//     because the next person to "simplify" this back to a LIKE needs to be
+//     told by a red test rather than by an ideator's inflated star.
+//
+// The stream-1 prefix stays in the WHERE regardless: split_part would happily
+// pull the same idea id out of an `idea.credit.full_pass:<ideaId>` row, and that
+// row is stream 2 — the thought, not the work it caused.
+//
+// Returns Map<ideaIdString, { credits, paid, estimated, payments, scale,
+// historical }>. Every id asked for is present, at zero when it has been paid
+// nothing: absent and zero are different answers to a renderer, and an idea that
+// caused nothing yet is a real state the surface has to draw, not a gap.
+//
+// THE PAID / ESTIMATED SPLIT (task 1004097 / BV2.R18, spec decision 17).
+// `paid` is money that moved. `estimated` is what an idea's descent WOULD have
+// earned for the hops that shipped before there was a descent payout to earn it
+// — real work, never paid, and deliberately never paid retroactively. `credits`
+// is the two together, which is the figure size means, and `historical` says
+// whether any of it is the second kind. A total with no marker is the quiet lie
+// the spec names; carrying the split is what lets every surface say which kind
+// of number it is showing.
+//
+// `historical` is DERIVED, never stored — it is simply `estimated > 0`. No
+// column, no cutoff date, no flag to rot: an idea stops being historical the
+// moment its descent has actually been paid for, which is the true condition and
+// not a date that approximates it. And when the descent could not be established
+// at all, `estimated` and `historical` are NULL rather than 0 and false, because
+// "nothing was estimated" and "we could not look" are different answers and only
+// one of them may be rendered as a plain figure.
+//
+//   ideaIds        — array of ids (bigint-safe strings or numbers)
+//   client         — optional tx client; falls back to the pool
+//   descentByIdea  — Map<ideaIdString, [{ task_id, depth, status }]>. The
+//                    caller's already-walked descent. The trail has one in hand
+//                    (trail-descent.js ran first), so passing it makes the
+//                    historical half cost ZERO extra round trips. Omit it and
+//                    the walk is done here, through the `ideas.descent` port.
+async function ideaSizes(ideaIds, { client = null, descentByIdea = null } = {}) {
+  const ids = [...new Set((Array.isArray(ideaIds) ? ideaIds : []).map(idOf).filter(Boolean))];
+  const out = new Map();
+  for (const id of ids) {
+    out.set(id, { credits: 0, paid: 0, estimated: 0, payments: 0, scale: 0, historical: false });
+  }
+  if (ids.length === 0) return out;
+
+  const q = client || pool;
+  // PER (idea, task), not per idea. The totals still fall out of it, and the
+  // per-task breakdown is what tells the backfill which hops the ledger already
+  // paid for — without it, an estimate would be added on top of a payment that
+  // really happened and every long-lived idea would read double.
+  const { rows } = await q.query(
+    `SELECT split_part(reason, ':', 2)       AS idea_id,
+            task_id,
+            COALESCE(SUM(delta), 0)::int     AS credits,
+            COUNT(*)::int                    AS payments
+       FROM credit_log
+      WHERE reason LIKE ${TASK_SHIP_PREFIX_SQL}
+        AND split_part(reason, ':', 2) = ANY($1::text[])
+      GROUP BY 1, 2`,
+    [ids]
+  );
+
+  // Map<ideaId, { total, payments, byTask: Map<taskId, credits> }>
+  const ledger = new Map();
+  for (const row of rows) {
+    const key = idOf(row.idea_id);
+    if (!key || !out.has(key)) continue;
+    const acc = ledger.get(key) || { total: 0, payments: 0, byTask: new Map() };
+    const credits = Number(row.credits) || 0;
+    acc.total += credits;
+    acc.payments += Number(row.payments) || 0;
+    // A stream-1 row always carries its task_id; a null would mean a row this
+    // read does not understand, and it is counted in the total but cannot key
+    // the backfill, which is the conservative direction (it can only cause an
+    // estimate to be ADDED for a task, and that is what `historical` marks).
+    if (row.task_id != null) acc.byTask.set(String(row.task_id), credits);
+    ledger.set(key, acc);
+  }
+
+  const descent = descentByIdea || await walkDescentForIdeas(ids, { client: q, ledger });
+  const grades = descent ? await ideaGradesFor(ids, q) : null;
+  const decay = rewardConfig().ideaDescentDecay;
+
+  for (const id of ids) {
+    const acc = ledger.get(id) || { total: 0, payments: 0, byTask: new Map() };
+    if (!descent) {
+      // The descent could not be established — no port, and no map from the
+      // caller. The paid figure is still true; the historical half is unknown,
+      // and says so rather than rendering as "nothing was estimated".
+      out.set(id, {
+        credits: acc.total, paid: acc.total, estimated: null,
+        payments: acc.payments, scale: compressIdeaSize(acc.total), historical: null,
+      });
+      continue;
+    }
+    const g = (grades && grades.get(id)) || { grade: 'quick', completeness: null };
+    const priced = priceDescentForIdea({
+      tasks: descent.get(id) || [],
+      grade: g.grade,
+      completeness: g.completeness,
+      decay,
+      paidByTask: acc.byTask,
+    });
+    // The PAID total comes off the ledger, not off the pricing loop: a payment
+    // for a task the descent no longer reaches (a re-parented task, a deleted
+    // edge) is still money this idea was paid, and dropping it would make size
+    // fall.
+    const credits = acc.total + priced.estimated;
+    out.set(id, {
+      credits,
+      paid: acc.total,
+      estimated: priced.estimated,
+      payments: acc.payments + priced.estimatedPayments,
+      scale: compressIdeaSize(credits),
+      historical: priced.estimated > 0,
+    });
+  }
+  return out;
+}
+
+// ideaGradesFor — what each idea's work is worth before depth, in one query.
+// LEFT JOIN + COALESCE to 'quick', the rule every idea read in the ideas module
+// is built from: an idea with no ideas_grades row IS quick, and an inner join
+// here would silently price every un-graded idea at zero.
+async function ideaGradesFor(ids, q) {
+  const out = new Map();
+  if (!ids.length) return out;
+  const { rows } = await q.query(
+    `SELECT i.id,
+            COALESCE(g.grade, 'quick') AS grade,
+            g.completeness_score       AS completeness
+       FROM idea_inbox i
+       LEFT JOIN ideas_grades g ON g.idea_id = i.id
+      WHERE i.id = ANY($1::bigint[])`,
+    [ids.map(Number)]
+  );
+  for (const row of rows) out.set(String(row.id), { grade: row.grade, completeness: row.completeness });
+  return out;
+}
+
+// walkDescentForIdeas — the fallback for a caller with no descent in hand.
+//
+// Returns null when the walk is unavailable, which is what makes `historical`
+// null rather than false upstream. The ideas module owns the walk and economy
+// reaches it through the `ideas.descent` port — never a cross-module require
+// (ADR 0083 rule 1), and never a second copy of a breadth-first shortest-depth
+// walk, because a drift there is a different amount of money.
+//
+// The trail passes its own map instead, so this path is for a single-idea panel
+// rather than a page: it is one walk per direct task, which is right for the one
+// or two an idea has and would be wrong for a page of thirty. That asymmetry is
+// why the parameter exists at all.
+// THE WALK RETURNS NO STATUS, and that is the trap in this function. Its rows
+// are { id, from_id, relation, depth } off ideas_task_descent — an edge table
+// with no join to `tasks` — so reading `row.status` gets `undefined`, every
+// descendant fails the shipped test, and the backfill silently prices nothing
+// while looking like it worked. The statuses are hydrated here in one query,
+// exactly as trail-descent.js hydrates its titles for the same reason.
+async function walkDescentForIdeas(ids, { client }) {
+  const port = resolveOptional && resolveOptional('ideas.descent');
+  if (!port || typeof port.descendantsOfTask !== 'function') return null;
+
+  const roots = await client.query(
+    `SELECT l.idea_id, l.task_id, t.status
+       FROM ideas_task_lineage l
+       JOIN tasks t ON t.id = l.task_id
+      WHERE l.idea_id = ANY($1::bigint[])`,
+    [ids.map(Number)]
+  );
+
+  const byIdea = new Map();
+  for (const id of ids) byIdea.set(id, []);
+  const rootsByIdea = new Map();
+  for (const row of roots.rows) {
+    const key = String(row.idea_id);
+    if (!byIdea.has(key)) continue;
+    byIdea.get(key).push({ task_id: String(row.task_id), depth: 0, status: row.status });
+    if (!rootsByIdea.has(key)) rootsByIdea.set(key, []);
+    rootsByIdea.get(key).push(String(row.task_id));
+  }
+
+  const bestByIdea = new Map();
+  const found = new Set();
+  for (const [ideaId, taskIds] of rootsByIdea) {
+    // Shortest depth wins when a descendant hangs below two of this idea's own
+    // tasks — the rule the walk applies within one root, applied across them.
+    const best = new Map();
+    for (const rootId of taskIds) {
+      const rows = await port.descendantsOfTask(rootId, { client });
+      for (const row of rows || []) {
+        const key = String(row.id);
+        if (taskIds.includes(key)) continue;   // a root is already a depth-0 row
+        const prev = best.get(key);
+        if (prev && prev.depth <= row.depth) continue;
+        best.set(key, { depth: row.depth });
+        found.add(key);
+      }
+    }
+    bestByIdea.set(ideaId, best);
+  }
+
+  const status = new Map();
+  if (found.size > 0) {
+    const { rows } = await client.query(
+      `SELECT id, status FROM tasks WHERE id = ANY($1::bigint[])`,
+      [[...found].map(Number)]
+    );
+    for (const row of rows) status.set(String(row.id), row.status);
+  }
+
+  for (const [ideaId, best] of bestByIdea) {
+    const rows = byIdea.get(ideaId);
+    for (const [taskId, hit] of best) {
+      rows.push({ task_id: taskId, depth: hit.depth, status: status.get(taskId) ?? null });
+    }
+  }
+  return byIdea;
+}
+
+// ideaSize — the same answer for one idea. A thin wrapper on purpose: two
+// implementations of "what is this idea's size" is two answers, and this is the
+// shape a single-idea panel wants.
+async function ideaSize(ideaId, opts = {}) {
+  const key = idOf(ideaId);
+  const zero = { credits: 0, payments: 0, scale: 0 };
+  if (!key) return zero;
+  const sizes = await ideaSizes([key], opts);
+  return sizes.get(key) || zero;
+}
+
+module.exports = {
+  ideaSize,
+  ideaSizes,
+  compressIdeaSize,
+  IDEA_SIZE_SCALE_REF,
+};

package/modules/economy/reward.js

@@ -19,6 +19,8 @@ const credits = require('./credits');
 const achievements = require('./achievements');
 const cost = require('./cost');
 const streak = require('./streak');
+const ideaSizeLib = require('./idea-size');
+const ideaSizeHistorical = require('./idea-size-historical');
 
 module.exports = {
   // credit allocation — transaction-participant: caller passes its tx `client`
@@ -93,6 +95,21 @@ module.exports = {
   // most wants it for is a HALL view — "what did this idea earn me" — and a core
   // route must reach economy through here, never by importing the module.
   creditLedger: (...a) => credits.creditLedger(...a),
+  // SIZE — an idea's total stream-1 payout (task 1004093 / BV2.R12). On the port
+  // for the same reason creditLedger is: credit_log is economy's table, the
+  // surface that wants the number is the ideas module's trail and the hall, and
+  // a module may only cross the wall through here (ADR 0083 / 0093 §2). ideas
+  // already declares `reward` in its `consumes`, so no new dependency edge is
+  // created by this — and `compressIdeaSize` rides along so a renderer draws
+  // with the SAME compression the read applied, never a second curve.
+  ideaSize: (...a) => ideaSizeLib.ideaSize(...a),
+  ideaSizes: (...a) => ideaSizeLib.ideaSizes(...a),
+  compressIdeaSize: (...a) => ideaSizeLib.compressIdeaSize(...a),
+  // BV2.R18 — the trail's already-walked descent, in the shape the pricing
+  // wants. On the port beside the read so a caller never hand-builds the
+  // projection and quietly drops a field the pricing needs.
+  descentRowsFromTrail: (...a) => ideaSizeHistorical.descentRowsFromTrail(...a),
+  get IDEA_SIZE_SCALE_REF() { return ideaSizeLib.IDEA_SIZE_SCALE_REF; },
   computeStreak: (...a) => streak.computeStreak(...a),
   wouldExtendStreak: (...a) => streak.wouldExtendStreak(...a),
 };

package/modules/hall-ui/public/collab-lib.js

@@ -313,6 +313,27 @@
     return req.needs_craft ? who + ' asked ' + req.needs_craft + 's' : who + ' asked';
   }
 
+  // "an engineer", "an artist", "an ideator" — but "a UI", which is why this cannot be a
+  // plain vowel test. roleWord() carries the same acronym exception one file over.
+  function aOrAn(word) {
+    const w = String(word || '');
+    if (/^ui$/i.test(w)) return 'a';
+    return /^[aeiou]/i.test(w) ? 'an' : 'a';
+  }
+
+  // The mingle row's sub-line (task 1003967, artist review of 1003960). Takes the two
+  // roles ALREADY RESOLVED to their sentence words, so this stays pure and the caller
+  // owns the vocabulary — and so this can be RUN in a test rather than grepped, which is
+  // the only way a swapped article gets caught. An empty side means the pair has a role
+  // nobody set: the comparison then has nothing to compare, so it is dropped rather than
+  // rendered with the database's own word in it.
+  function pairSentence(theirWord, myWord) {
+    if (!theirWord || !myWord) return 'Mingle pairs across roles.';
+    const lead = `${aOrAn(theirWord)} ${theirWord}`;
+    return `${lead.charAt(0).toUpperCase()}${lead.slice(1)} — you are ${aOrAn(myWord)} ${myWord}. `
+      + 'Mingle pairs across roles.';
+  }
+
   window.OTBCollabLib = {
     BANDS: BANDS, ageBand: ageBand, ageLabel: ageLabel,
     byAgeOldestFirst: byAgeOldestFirst, byNewestFirst: byNewestFirst,
@@ -320,5 +341,6 @@
     directionLine: directionLine, boardLine: boardLine,
     titleOf: titleOf, summaryOf: summaryOf, clipWords: clipWords, LEAD_MAX: LEAD_MAX, groupOf: groupOf,
     httpUrl: httpUrl, initialOf: initialOf, faceOf: faceOf, askers: askers, splitShown: splitShown,
+    aOrAn: aOrAn, pairSentence: pairSentence,
   };
 })();

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

@@ -418,11 +418,25 @@
     const whoName = o.name || o.login || `builder ${o.id}`;
     const who = escapeHtml(whoName);
     const face = { kind: 'person', id: o.id, name: whoName, avatar: null, initial: L.initialOf(whoName) };
+
+    // A SENTENCE TAKES roleWord() — the rule dom-utils.js writes down beside the helper
+    // (task 1004041). This row took neither helper and interpolated the raw column, so a
+    // pair whose role was unset rendered the database's own word: "A unclassified — you
+    // are a engineer", which is V2's named failure and a wrong article in the same line.
+    // Where a role is missing the comparison has nothing to compare, so the row says the
+    // one thing that is still true rather than naming a value nobody chose.
+    // roleIsUnset() is how a caller asks (dom-utils.js:198). Spelling 'unclassified' here
+    // would be a second definition of the axis in a third file — the drift V1 forbids, and
+    // the exact shape this review was filed to remove.
+    const theirs = window.OTB.roleIsUnset(o.craft) ? '' : window.OTB.roleWord(o.craft);
+    const mine = window.OTB.roleIsUnset(o.myCraft) ? '' : window.OTB.roleWord(o.myCraft);
+    const pairLine = L.pairSentence(theirs, mine);
+
     return `<li class="ov-row ov-row--lead cb-row">
       ${faceHtml(face)}
       <div class="ov-row__main">
         <a class="ov-row__title" href="/builders/profile?id=${escapeHtml(String(o.id))}">${who}</a>
-        <p class="ov-row__sub">A ${escapeHtml(String(o.craft))} — you are a ${escapeHtml(String(o.myCraft))}. Mingle pairs across roles.</p>
+        <p class="ov-row__sub">${escapeHtml(pairLine)}</p>
       </div>
       <div class="ov-row__right">
         <div class="ov-row__actions">
@@ -511,6 +525,7 @@
 
   load().catch(() => {
     const sub = $('#cb-sub');
-    if (sub) sub.textContent = 'Could not load requests.';
+    // V6: a message that stops someone points at the next move in the same breath.
+    if (sub) sub.textContent = 'Could not load requests — reload to try again.';
   });
 })();

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

@@ -419,6 +419,39 @@
       + cells + more;
   }
 
+  // SIZE — what this thought's work has actually earned (task 1004093, BV2.R12;
+  // spec decision 4). Served as `size` = { credits, payments, scale }.
+  //
+  // THE TRUE FIGURE IS WHAT PRINTS HERE. `scale` is the compressed magnitude a
+  // DRAWING uses (the sky, BV2.R18) — a person reading a number wants the number,
+  // and printing a compressed one would make an ideator's earnings unverifiable
+  // against their own ledger.
+  //
+  // It renders independently of the descent, because it has to: an idea promoted
+  // straight into one task that shipped has a size and NO descent at all, and
+  // hanging this off descentHtml would show that ideator nothing. `size: null`
+  // means the ledger could not be asked (the reward port was absent), which is
+  // not the same as zero and must not print as "earned 0".
+  // THE HISTORICAL MARKER (task 1004097, BV2.R18; spec decision 17). A thought
+  // whose work shipped before the descent payout existed has a size that is
+  // partly an ESTIMATE — real work, never paid, and deliberately never paid
+  // retroactively. The done-when is that anywhere size is shown makes clear
+  // which kind of number it is, so the split is SAID, not implied: the row names
+  // the estimated part rather than folding it into one total and hoping nobody
+  // asks. `historical: null` means the estimate could not be established at all,
+  // which is a third state and must not be drawn as either of the other two.
+  function sizeHtml(idea) {
+    const size = idea.size;
+    if (!size || typeof size.credits !== 'number' || size.credits <= 0) return '';
+    const n = size.credits;
+    const unit = n === 1 ? 'credit' : 'credits';
+    const est = typeof size.estimated === 'number' ? size.estimated : null;
+    const body = (size.historical === true && est > 0)
+      ? `Worth ${escapeHtml(String(n))} ${unit} — ${escapeHtml(String(est))} of it estimated from work that shipped before this was paid`
+      : `Earned ${escapeHtml(String(n))} ${unit} so far`;
+    return `<span style="display:block;margin-top:4px;font-size:12px;color:var(--ink-faint)">${body}</span>`;
+  }
+
   // What became of one idea, in a sentence a person can read. The four outcomes
   // the criterion names, each linked through to the thing it became.
   function ideaOutcomeHtml(idea) {
@@ -427,6 +460,10 @@
     // "nothing is lost" means), and an idea whose first task was later split
     // has a descent whatever its own status says.
     const descent = descentHtml(idea);
+    // Size rides beside the descent under every outcome, and for the same
+    // reason: a discarded or merged idea can still have earned, and ADR 0313
+    // claws nothing back when work is removed.
+    const size = sizeHtml(idea);
     const note = idea.triage_note
       ? `<span style="display:block;margin-top:2px;font-size:12px;color:var(--ink-faint)">${escapeHtml(idea.triage_note)}</span>`
       : '';
@@ -442,19 +479,19 @@
           : []);
       // 'promoted' with nothing to point at is a real (old) state, not a bug to
       // paper over — say what is known rather than inventing a link.
-      if (!links.length) return `<span class="task__tag">Promoted</span>${note}${descent}`;
-      return `<span class="task__tag">Became ${links.length === 1 ? 'a task' : `${links.length} tasks`}</span> ${links.join(' · ')}${note}${descent}`;
+      if (!links.length) return `<span class="task__tag">Promoted</span>${note}${descent}${size}`;
+      return `<span class="task__tag">Became ${links.length === 1 ? 'a task' : `${links.length} tasks`}</span> ${links.join(' · ')}${note}${descent}${size}`;
     }
     if (idea.status === 'merged') {
       const target = idea.merged_into_idea_id
         ? ` <a href="${ideaHref(idea.merged_into_idea_id)}">#${escapeHtml(String(idea.merged_into_idea_id))} ${escapeHtml(idea.merged_into_idea_title || '')}</a>`
         : '';
-      return `<span class="task__tag">Merged into</span>${target}${note}${descent}`;
+      return `<span class="task__tag">Merged into</span>${target}${note}${descent}${size}`;
     }
     if (idea.status === 'discarded') {
-      return `<span class="task__tag">Discarded</span>${note}${descent}`;
+      return `<span class="task__tag">Discarded</span>${note}${descent}${size}`;
     }
-    return `<span class="task__tag">Still open</span>${note}${descent}`;
+    return `<span class="task__tag">Still open</span>${note}${descent}${size}`;
   }
 
   // One ledger driven by one server-paged endpoint. `fetchPage(offset, perPage)`

package/modules/ideas/routes/inbox.js

@@ -39,6 +39,10 @@ const inbox = require('../inbox');
 // 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.
 const { attachDescentToTrail } = require('../trail-descent');
+// SIZE — the sum of what that descent has PAID (task 1004093, BV2.R12). Its own
+// file for the same two reasons trail-descent.js is: inbox.js is at the size
+// ratchet, and a ledger read keyed by idea is a third relation again.
+const { attachSizeToTrail } = require('../trail-size');
 // The walk itself, published as the `ideas.descent` port below.
 const descent = require('../descent');
 // Full Idea capture (task 1002919 / BV1.R143): the template validator (R141)
@@ -588,6 +592,11 @@ module.exports = function buildInboxRouter() {
     // and the walk is batched across the WHOLE page — so it stays one query per
     // level however many ideas the window carries, never one walk per idea.
     await attachDescentToTrail(ideas);
+    // SIZE — what that descent has actually PAID (BV2.R12, spec decision 4).
+    // After the descent and not inside it: the descent is the picture, size is
+    // the number, and the number is a ledger read that does not depend on the
+    // walk having run. One query for the whole page, through the `reward` port.
+    await attachSizeToTrail(ideas);
     return res.json({ builder_id: builderId, ideas, total, limit, offset });
   }, { errorCode: 'idea_trail_failed' }));