@bongos/core 1.19.904 → 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/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' }));
 

package/modules/ideas/trail-size.js

@@ -0,0 +1,88 @@
+// modules/ideas/trail-size.js — SIZE on the idea trail: what each thought's
+// work has actually earned (task 1004093, BV2.R12, goal 1000095; spec
+// docs/specs/bongos-v2-ideator-surface.md decisions 4 + 5).
+//
+// The trail already answers "what became of my idea" (listIdeaTrailForBuilder)
+// and, since BV2.R09, "and what did THAT go on to cause" (trail-descent.js).
+// Size is the third column of the same sentence and the only one denominated in
+// money: the sum of every stream-1 payout the descent has produced.
+//
+// WHY IT IS A SEPARATE FILE, like trail-descent.js beside it. inbox.js is AT the
+// 1500-line size ratchet (scripts/gds/fitness-ratchets.js), so a line added
+// there fails the build. And this is a different read again: the trail is
+// idea → task, the descent is a task → task walk, and size is a read of the
+// LEDGER keyed by idea. Three relations, three files.
+//
+// WHY IT GOES THROUGH THE `reward` PORT AND NOT A SQL READ OF ITS OWN.
+// credit_log is economy's table and modules may not require each other
+// (ADR 0083 rule 1). The read is small enough that a copy here would be
+// tempting — and that is exactly the trap: the reason key `idea.credit.
+// task_ship:<idea>:<task>` is economy's idempotency predicate, economy is free
+// to change it, and a second reader of it in this module would silently start
+// summing nothing the day it did. `ideas` already declares `reward` in its
+// module.json `consumes`, so this adds no new dependency edge.
+//
+// RESOLVED OPTIONALLY EVEN SO. `consumes` means the instance will not boot
+// without the port, so in production the resolve cannot fail — but tests rebuild
+// the GDS router with an arbitrary subset of modules, and a trail read that
+// throws because economy was not mounted is a worse failure than a trail read
+// with no money on it. When the port is absent every idea gets `size: null`,
+// NOT zero: zero is a real answer meaning "this thought has earned nothing yet",
+// and rendering it for "we could not ask" would tell an ideator their work paid
+// nothing. tests/idea_size.mjs drives both branches.
+
+const api = require('../../src/module-api');
+
+// attachSizeToTrail — mutates each idea in place with `size`, and returns the
+// list, mirroring attachDescentToTrail's shape so the route composes the two the
+// same way.
+//
+// `size` is `{ credits, payments, scale }` — the TRUE figure the panel prints,
+// how many payouts made it up, and the compressed magnitude a drawing uses. Both
+// are carried because the spec asks for both: compressed for drawing, true
+// figure available (decision 4). The compression is economy's, applied once at
+// the read, so nothing downstream invents a second curve.
+//
+// ONE query for the whole page, not one per idea — the same property
+// trail-descent.js pins, for the same reason: this rides a paged trail read and
+// a per-idea round trip would make a long trail quadratic in round trips.
+async function attachSizeToTrail(ideas, { client = null } = {}) {
+  const list = Array.isArray(ideas) ? ideas : [];
+  if (list.length === 0) return list;
+
+  const reward = api.resolveOptional && api.resolveOptional('reward');
+  if (!reward || typeof reward.ideaSizes !== 'function' || typeof reward.descentRowsFromTrail !== 'function') {
+    for (const idea of list) idea.size = null;
+    return list;
+  }
+
+  // The ids are asked for as the idea's OWN id, never the id it merged into.
+  // The descent a merged idea SHOWS is inherited (trail-descent.js followMerges,
+  // ADR 0311 — nothing is lost), but the money it EARNED is its own: stream 1
+  // books against the idea whose lineage row named the shipping task, and
+  // crediting A's star with B's payouts would count B's work twice on one page.
+  // That asymmetry is the same one the payout itself draws (spec decision 7):
+  // the descent displays more than the number counts.
+  // THE DESCENT IS ALREADY IN HAND, so the historical half costs nothing
+  // (task 1004097 / BV2.R18). attachDescentToTrail ran first — the route
+  // composes them in that order — so every idea on this page already carries its
+  // own tasks and everything below them, each with a status and a shortest
+  // depth. Handing that to economy is the difference between one extra walk per
+  // page and none at all; economy falls back to walking only for a caller that
+  // has no descent, which is a single-idea panel and never this one.
+  //
+  // The SHAPE is economy's, not this module's: `descentRowsFromTrail` lives with
+  // the pricing that consumes it, so a change to what the pricing needs cannot
+  // leave a hand-built projection here quietly dropping a field.
+  const descentByIdea = new Map();
+  for (const idea of list) {
+    descentByIdea.set(String(idea.id), reward.descentRowsFromTrail(idea));
+  }
+  const sizes = await reward.ideaSizes(list.map((i) => i.id), { client, descentByIdea });
+  for (const idea of list) {
+    idea.size = sizes.get(String(idea.id)) || { credits: 0, payments: 0, scale: 0 };
+  }
+  return list;
+}
+
+module.exports = { attachSizeToTrail };

package/package-lock.json

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

package/package.json

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

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.904'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.905'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');