@bongos/core 1.19.901 → 1.19.903

package/modules/economy/credits.js

@@ -9,7 +9,7 @@
 // (db.applyGrade/confirmTask/upsertSessionRecordWithReward) resolves these
 // through the `reward` kernel PORT rather than importing this module.
 
-const { pool, branding } = require('../../src/module-api');
+const { pool, branding, resolveOptional } = require('../../src/module-api');
 const { priceModelUsage, PRICES } = require('../../src/module-api').llmPricing; // cost-plus session reward (task 1005)
 const achievements = require('./achievements');
 
@@ -157,7 +157,7 @@ const IDEA_GOVERNANCE_PASS_FLOOR = 30;  // owner: floor ~30 — see the note on
 // Re-exported below, so this module is still the one place reward resolution lives
 // (ADR 0146) and every existing caller is unchanged.
 const {
-  REWARD_MARGIN_PCT, REWARD_MODE_DEFAULT, REWARD_MODE_COST_PLUS_ONLY, rewardPolicy,
+  REWARD_MARGIN_PCT, REWARD_MODE_DEFAULT, REWARD_MODE_COST_PLUS_ONLY, IDEA_DESCENT_DECAY, rewardPolicy,
 } = require('./reward-policy');
 
 // Per-instance reward policy, resolved over the code defaults. Stays HERE, not in
@@ -502,6 +502,40 @@ async function awardIdeaFullPassCredit(client, { ideaId, authorId, completenessS
   };
 }
 
+// descentPayoutMaxDepth — the deepest hop that can still pay a single credit.
+//
+// The decayed share is base × factor × decay^d, and the best case for factor is
+// 1 (a 100%-complete Full Idea). Once that rounds to 0 no deeper ancestor can
+// ever be paid, whatever its grade, so walking further is pure round trips.
+// Returned as a DEPTH CAP for the walk rather than a break in the payout loop,
+// because the round trips happen inside the walk, not in the loop.
+//
+// Derived, never picked: at the default half it comes out at 4, and a steeper
+// rate gives a smaller number. DESCENT_MAX_DEPTH remains the outer backstop.
+function descentPayoutMaxDepth(decay, base = IDEA_TASK_SHIP_BASE, cap = 64) {
+  if (!(decay > 0)) return 0;
+  for (let d = 1; d <= cap; d += 1) {
+    if (Math.round(base * Math.pow(decay, d)) <= 0) return d - 1;
+  }
+  return cap;
+}
+
+// ideaGradeFactor — what one shipped task under an idea is worth, BEFORE depth.
+//
+// A Full Idea earns in proportion to its completeness; a Quick or Spark idea
+// (no completeness score) earns the flat quick factor. A full idea with no score
+// yet also falls back to the quick factor rather than 0 — the work shipped, and
+// the idea is at least quick-grade.
+//
+// EXTRACTED so the direct payout and the decayed descent payout below cannot
+// disagree about what an idea's work is worth: the two differ only by the decay
+// term, and a second copy of this clamp would make them differ by more.
+function ideaGradeFactor(grade, completeness) {
+  return (grade === 'full' && completeness != null && Number.isFinite(Number(completeness)))
+    ? Math.max(0, Math.min(1, Number(completeness) / 100))
+    : QUICK_IDEA_FACTOR;
+}
+
 // Stream 1 (ADR 0172 / goal 1000067 IC4): as each task descended from an idea
 // SHIPS, pay the idea's author IDEA_TASK_SHIP_BASE credits, SCALED by the idea's
 // grade — a Full Idea by its completeness, a Quick/Spark idea by a flat factor.
@@ -560,13 +594,7 @@ async function awardIdeaTaskShipCredit(client, { taskId, config = rewardConfig()
     return { credited: 0, reason: 'no_source_idea', ideaId: null, authorId: null };
   }
   const { idea_id: ideaId, captured_by: authorId, grade, completeness, developed_by: developedBy } = rows[0];
-  // Grade factor: a Full Idea earns in proportion to its completeness; a Quick
-  // or Spark idea (no completeness score) earns the flat quick factor. A full
-  // idea with no score yet also falls back to the quick factor rather than 0 —
-  // the work shipped, the idea is at least quick-grade.
-  const factor = (grade === 'full' && completeness != null && Number.isFinite(Number(completeness)))
-    ? Math.max(0, Math.min(1, Number(completeness) / 100))
-    : QUICK_IDEA_FACTOR;
+  const factor = ideaGradeFactor(grade, completeness);
   const delta = Math.round(IDEA_TASK_SHIP_BASE * factor);
   if (delta <= 0) {
     return { credited: 0, reason: 'zero_after_scaling', ideaId: Number(ideaId), authorId: Number(authorId) };
@@ -592,6 +620,184 @@ async function awardIdeaTaskShipCredit(client, { taskId, config = rewardConfig()
     : { credited: 0, reason: 'already_paid', ideaId: Number(ideaId), authorId: Number(authorId) };
 }
 
+// awardIdeaDescentShipCredit — the same stream 1 payout, for the origins the
+// shipping task descends from RATHER THAN the one it was promoted from
+// (task 1004088, BV2.R09; ADR 0312, spec decisions 6 + 7 + 16).
+//
+// WHAT WAS MISSING. awardIdeaTaskShipCredit above pays the idea whose
+// ideas_task_lineage row names THIS task. That is one hop. A task split off a
+// task an idea produced, a cascade its ship fired, a child of a child — all of
+// them ship and pay the origin nothing, because the origin is not on their
+// lineage row and never will be. The idea's descent grew; its ledger did not.
+//
+// THE RULE: full share at the direct task, `decay` per hop below it. At the
+// default half, an unbounded descent is worth at most twice the direct task, so
+// the series converges and no hop limit has to be invented. The rate is a
+// per-instance dial (config.ideaDescentDecay; modules/economy/reward-policy.js).
+//
+// THE BOUNDARY THAT STOPS FARMING (spec decision 7): DESCENDANT WORK pays the
+// origin; a separate thought that merely cites it does not. Nothing here reads
+// an idea→idea relation — not merged_into_idea_id, not the trail's merge follow.
+// It walks ideas_task_descent, which carries only task→task edges the system
+// derived from a cascade, a split or a fold. That asymmetry is deliberate and is
+// the difference between the two surfaces: the descent DISPLAYS more than the
+// payout COUNTS.
+//
+// ONE PAYMENT PER ORIGIN PER SHIP, AT THE SHORTEST DEPTH. A merge makes the
+// descent a DAG, so one origin can sit above a shipping task by two routes of
+// different length, and two ancestors can share a source idea. Each origin is
+// therefore resolved once, at the smallest depth — the same rule the walk itself
+// applies, for the same reason: at two depths it would be paid twice for one
+// piece of work. The reason key is already per (idea, task), so the ledger would
+// have caught the duplicate; resolving it here means the RETURNED numbers are
+// right too, rather than depending on which booking ran first.
+//
+// FAIL-SOFT AROUND THE WALK, NOT AROUND THE MONEY. If the ideas module is absent
+// (no provider) or has no edges yet, this returns nothing paid and the direct
+// payout above is untouched — which is exactly today's behaviour, and is what
+// "existing first-hop behaviour preserved" means. A walk that THROWS is a
+// different matter and is left to propagate: this runs inside the ship
+// transaction beside the direct credit, and silently swallowing a failure here
+// would under-pay an origin with no record that it happened.
+//
+//   client   — pg client / pool (transaction participant)
+//   taskId   — the task that just shipped
+//   skipIdeaIds — origins already paid for this ship at depth 0, so the direct
+//                 payout always wins over a decayed one for the same idea
+//   config   — resolved reward policy; gates on config.ideatorCredit
+//
+// Returns { credited, reason, payments: [{ ideaId, depth, delta, payees }] }.
+async function awardIdeaDescentShipCredit(client, { taskId, skipIdeaIds = [], config = rewardConfig() } = {}) {
+  if (config && config.ideatorCredit === false) {
+    return { credited: 0, reason: 'ideator_lane_off', payments: [] };
+  }
+  // BOUNDED HERE TOO, not only in rewardPolicy(). This is a PORT method: the
+  // reward port hands it to any module that resolves it, and a caller may pass
+  // its own `config` object that never went through the resolver. A rate of 1
+  // or more does not converge — the comment on IDEA_DESCENT_DECAY promises it
+  // cannot happen, and a promise the function does not enforce is a promise the
+  // next caller breaks. Out of range falls back to the default, exactly as the
+  // resolver does, rather than throwing inside a ship transaction.
+  const rawDecay = (config && config.ideaDescentDecay) == null
+    ? NaN
+    : Number(config.ideaDescentDecay);
+  const decay = Number.isFinite(rawDecay) && rawDecay >= 0 && rawDecay < 1
+    ? rawDecay
+    : IDEA_DESCENT_DECAY;
+  // 0 means "only the direct task pays" — a legal instance setting, and the
+  // cheapest possible answer, so it short-circuits before the walk.
+  if (!(decay > 0)) return { credited: 0, reason: 'decay_off', payments: [] };
+
+  // The walk lives in the ideas module and is reached through the switchboard:
+  // a module may not require a sibling (ADR 0083 rule 1), and a second copy of
+  // a breadth-first shortest-depth walk would drift into a different amount of
+  // money. resolveOptional, because an instance running without the ideas
+  // module has no descent to follow and must still ship tasks.
+  const port = resolveOptional && resolveOptional('ideas.descent');
+  if (!port || typeof port.ancestorsOfTask !== 'function') {
+    return { credited: 0, reason: 'no_descent_port', payments: [] };
+  }
+  // DON'T WALK FURTHER THAN THE MONEY REACHES. Past the depth at which even a
+  // 100%-complete idea's decayed share stops rounding to a credit, every
+  // remaining hop is a round trip that provably pays nobody. The cap is derived
+  // from the rate rather than picked: at the default half it is 4, and a
+  // shallower rate makes it smaller, not larger. Bounded by the walk's own
+  // DESCENT_MAX_DEPTH, which stays the backstop.
+  const maxDepth = descentPayoutMaxDepth(decay);
+  const ancestors = await port.ancestorsOfTask(taskId, { client, maxDepth });
+  if (!ancestors || ancestors.length === 0) {
+    return { credited: 0, reason: 'no_ancestors', payments: [] };
+  }
+
+  // The shortest depth at which each ancestor TASK sits above this ship.
+  // ancestorsOfTask already returns nearest-first with each node once, so the
+  // first sighting is the shortest; the map is here so the lookup below cannot
+  // accidentally read a later one.
+  const depthByTask = new Map();
+  for (const a of ancestors) {
+    const key = String(a.id);
+    if (!depthByTask.has(key)) depthByTask.set(key, a.depth);
+  }
+
+  // Which idea each ancestor task came from — ONE query, not one per ancestor.
+  // DISTINCT ON picks the EARLIEST lineage link per task, which is the same rule
+  // awardIdeaTaskShipCredit applies to the direct task (task 1003515 / ADR 0236:
+  // a task subsumed from several ideas keeps a row for each, so the read must
+  // choose, and it must choose the way the trail and inbox.sourceIdeaForTask do
+  // or the ledger and the money name different ideas).
+  const { rows } = await client.query(
+    `SELECT DISTINCT ON (l.task_id)
+            l.task_id,
+            l.idea_id,
+            i.captured_by,
+            COALESCE(g.grade, 'quick')        AS grade,
+            g.completeness_score              AS completeness,
+            g.developed_by                    AS developed_by
+       FROM ideas_task_lineage l
+       JOIN idea_inbox i        ON i.id = l.idea_id
+       LEFT JOIN ideas_grades g ON g.idea_id = l.idea_id
+      WHERE l.task_id = ANY($1::bigint[])
+      ORDER BY l.task_id, l.created_at ASC, l.idea_id ASC`,
+    [[...depthByTask.keys()].map(Number)]
+  );
+
+  // Collapse ancestor tasks onto their ORIGINS: two ancestors can share one
+  // source idea, and that idea is owed one payment at the shallower of the two.
+  const skip = new Set((skipIdeaIds || []).map(String));
+  const byIdea = new Map();
+  for (const row of rows) {
+    if (row.captured_by == null) continue;
+    const ideaKey = String(row.idea_id);
+    if (skip.has(ideaKey)) continue;          // already paid in full at depth 0
+    const depth = depthByTask.get(String(row.task_id));
+    if (!Number.isInteger(depth) || depth < 1) continue;
+    const prev = byIdea.get(ideaKey);
+    if (prev && prev.depth <= depth) continue;
+    byIdea.set(ideaKey, { row, depth });
+  }
+
+  const payments = [];
+  let credited = 0;
+  // Nearest origins first, so a partially-booked run resumes in a stable order
+  // and the returned list reads the way the descent does.
+  const ordered = [...byIdea.values()].sort((a, b) => a.depth - b.depth || Number(a.row.idea_id) - Number(b.row.idea_id));
+  for (const { row, depth } of ordered) {
+    const { idea_id: ideaId, captured_by: authorId, grade, completeness, developed_by: developedBy } = row;
+    // The SAME grade factor the direct payout applies — a Full Idea earns in
+    // proportion to its completeness, a Quick or Spark idea the flat factor.
+    // Spelled through the shared helper so the two paths cannot disagree about
+    // what an idea's work is worth before depth is taken into account.
+    const factor = ideaGradeFactor(grade, completeness);
+    // ROUNDED ONCE, at the end. Rounding per hop would compound the error, and
+    // rounding to zero IS the floor the spec's open question asked about: a
+    // descendant stops paying when its decayed share no longer rounds to a
+    // credit, which needs no separately-chosen hop limit.
+    const delta = Math.round(IDEA_TASK_SHIP_BASE * factor * Math.pow(decay, depth));
+    if (delta <= 0) continue;
+    const payees = splitIdeaCredit(delta, { authorId, developedBy });
+    if (payees.length === 0) continue;
+    // THE SAME REASON KEY the direct payout uses — per (idea, task), not per
+    // (idea, task, depth). An origin is paid once for one ship however the
+    // descent is re-walked, and a re-run after a partial failure is safe.
+    const reason = `idea.credit.task_ship:${ideaId}:${taskId}`;
+    const gradeLabel = `${grade}${completeness != null ? ` ${Math.round(Number(completeness))}%` : ''}`;
+    const { credited: paid, payees: booked } = await bookIdeaSplit(client, {
+      payees,
+      reason,
+      taskId,
+      describe: (p) => `Task #${taskId} shipped ${depth} hop${depth === 1 ? '' : 's'} below idea #${ideaId} (${gradeLabel}) → ${p.delta}c to its ${p.role.replace(/_/g, ' ')} (ideator lane stream 1, decayed by depth, BV2.R09/ADR 0312)`,
+    });
+    credited += paid;
+    payments.push({ ideaId: Number(ideaId), depth, delta, credited: paid, payees: booked });
+  }
+
+  return {
+    credited,
+    reason: credited > 0 ? 'paid' : (payments.length > 0 ? 'already_paid' : 'nothing_to_pay'),
+    payments,
+  };
+}
+
 // Stream 3 (ADR 0172 / goal 1000067 IC5): a Full Idea that PASSES the Board
 // Room's ratification vote pays a share of a 100-credit ceiling, scaled by the
 // idea's R142 completeness — "70%-complete + passes = 70". The ideator lane, so
@@ -1059,6 +1265,7 @@ module.exports = {
   maybeAwardIdeaPromotionBonus,
   awardIdeaFullPassCredit,
   awardIdeaTaskShipCredit,
+  awardIdeaDescentShipCredit,
   awardIdeaGovernancePassCredit,
   // the spark-handoff split (task 1002923 / BV1.R147, ADR 0185)
   splitIdeaCredit,

package/modules/economy/reward-policy.js

@@ -28,6 +28,28 @@ const REWARD_MARGIN_PCT = 20;
 const REWARD_MODE_DEFAULT = 'cost-plus-and-estimate';
 const REWARD_MODE_COST_PLUS_ONLY = 'cost-plus-only';
 
+// The DEPTH DECAY on the ideator descent payout (task 1004088, BV2.R09; spec
+// decision 16). A task shipping pays the idea it came from in full; a task
+// shipping one hop BELOW that pays it this fraction, and so on down.
+//
+// WHY 0.5, AND WHY THE SERIES NEEDS NO CAP. At a half per hop an infinite
+// descent is worth at most twice the direct task, so the payout converges on
+// its own and nothing has to pick an arbitrary hop limit. A rate of 1 would not
+// converge — a wide enough descent could pay an origin without bound — so the
+// resolver refuses anything at or above 1 and falls back to the default.
+//
+// WHY IT LIVES HERE. The owner's ruling (interview Q1) is that the rate belongs
+// to the project, not to the platform, so it is a per-instance dial and this is
+// where per-instance reward policy already resolves. It is the SECOND such dial
+// (the ignite floor in modules/ideas/routing.js is the first), and BV2.R05 is
+// the task that gives the two of them one home; putting it in the existing
+// resolver now makes that a move rather than a rewrite.
+//
+// 0 IS A LEGAL SETTING and means "only the direct task pays" — an instance that
+// wants the old first-hop-only behaviour sets it and gets exactly that, with no
+// code path to disable separately.
+const IDEA_DESCENT_DECAY = 0.5;
+
 // PURE. Resolves a raw branding `reward` block over the code defaults. Every field
 // is validated rather than trusted: a malformed pack degrades to the defaults
 // instead of poisoning an award.
@@ -39,12 +61,23 @@ function rewardPolicy(rawReward) {
   const perTaskCredit = mode !== REWARD_MODE_COST_PLUS_ONLY;
   // Default-on, opt-out-only: only an explicit `false` withholds the ideator lane.
   const ideatorCredit = r.ideatorCredit !== false;
-  return { marginPct, usdPeg, mode, perTaskCredit, ideatorCredit };
+  // Validated to [0, 1): see IDEA_DESCENT_DECAY above — a rate of 1 or more does
+  // not converge, and a negative one would pay a descent backwards.
+  // ABSENT IS THE DEFAULT, NOT ZERO — and Number(null) is 0, which is a legal
+  // rate meaning "only the direct task pays". Without this guard a pack that
+  // simply omits the key, or carries an explicit null, would silently switch
+  // the whole descent payout off and look exactly like a deliberate choice.
+  const rawDecay = r.ideaDescentDecay == null ? NaN : Number(r.ideaDescentDecay);
+  const ideaDescentDecay = Number.isFinite(rawDecay) && rawDecay >= 0 && rawDecay < 1
+    ? rawDecay
+    : IDEA_DESCENT_DECAY;
+  return { marginPct, usdPeg, mode, perTaskCredit, ideatorCredit, ideaDescentDecay };
 }
 
 module.exports = {
   REWARD_MARGIN_PCT,
   REWARD_MODE_DEFAULT,
   REWARD_MODE_COST_PLUS_ONLY,
+  IDEA_DESCENT_DECAY,
   rewardPolicy,
 };

package/modules/economy/reward.js

@@ -28,6 +28,10 @@ module.exports = {
   awardIdeaFullPassCredit: (...a) => credits.awardIdeaFullPassCredit(...a),
   // ADR 0172 IC4 — stream 1: pay the idea's author per shipped task, grade-scaled (replaces the 25% slice at ship).
   awardIdeaTaskShipCredit: (...a) => credits.awardIdeaTaskShipCredit(...a),
+  // BV2.R09 / ADR 0312 — the same stream, for the origins the shipping task
+  // DESCENDS from rather than the one it was promoted from, decayed by depth.
+  // Called right after the direct payout, which always wins for the same idea.
+  awardIdeaDescentShipCredit: (...a) => credits.awardIdeaDescentShipCredit(...a),
   // ADR 0172 IC5 — stream 3: a board-ratified Full Idea pays up to 100, scaled by completeness.
   // The board's close transaction resolves this port and calls this with its own
   // `client` (docs/specs/board-room-pass-event-contract.md) — the port is how

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

@@ -1141,7 +1141,13 @@
       activeDays += 1;
       totalShips += c;
     }
-    return { counts, startSun, endOrd, weeks, activeDays, totalShips };
+    // The window's NAME belongs with the window (task 1003621, artist review of 1003583).
+    // The aria summary described it as "the last year" while the caption under the same
+    // grid said "this year" — a rolling 53 weeks and a calendar year are not the same
+    // span, and V3 asks the accessible line and the visible one to state the same fact.
+    // Both now read this.
+    const spanLabel = weeks === 53 ? 'the last year' : `the last ${weeks} week${weeks === 1 ? '' : 's'}`;
+    return { counts, startSun, endOrd, weeks, activeDays, totalShips, spanLabel };
   }
 
   // calendarGridHtml(days, opts) — a year of ship-days as a contribution calendar:
@@ -1168,7 +1174,7 @@
   function calendarGridHtml(days, opts = {}) {
     const win = calendarWindow(days, opts);
     if (!win) return ''; // nothing real to draw → caller's empty state
-    const { counts, startSun, endOrd, weeks, activeDays, totalShips } = win;
+    const { counts, startSun, endOrd, weeks, activeDays, totalShips, spanLabel } = win;
     const ordToYmd = calOrdToYmd;
 
     // level 0 = empty; 1..5 map to the anti-gaming daily cap (streak.js caps a day at
@@ -1188,10 +1194,10 @@
     }
 
     // The window is DESCRIBED, not assumed: a caller passing weeks:6 used to be handed
-    // an aria label saying "over the last year" (task 1003583).
-    const span = weeks === 53 ? 'the last year' : `the last ${weeks} week${weeks === 1 ? '' : 's'}`;
+    // an aria label saying "over the last year" (task 1003583). The phrase now comes from
+    // calendarWindow so the caption beneath the grid can say the same words.
     const summary = opts.ariaLabel
-      || `Ships per day over ${span}: ${totalShips} ship${totalShips === 1 ? '' : 's'} across ${activeDays} day${activeDays === 1 ? '' : 's'}.`;
+      || `Ships per day over ${spanLabel}: ${totalShips} ship${totalShips === 1 ? '' : 's'} across ${activeDays} day${activeDays === 1 ? '' : 's'}.`;
     // The legend is aria-hidden: it decorates the bands, it carries no fact the cell
     // titles and the summary do not already state in words.
     const legend = '<div class="kit-cal__key" aria-hidden="true"><span class="kit-cal__key-label">less</span>'

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

@@ -284,7 +284,7 @@
     // The scalars in words, in the .pchart__read slot the other figures use for their
     // crosshair readout — here it is static because the calendar's reading is per-cell.
     const read = `Current streak ${cur} day${cur === 1 ? '' : 's'} \u00b7 longest ${lng} \u00b7 `
-      + `${active} day${active === 1 ? '' : 's'} shipped this year`;
+      + `${active} day${active === 1 ? '' : 's'} shipped in ${win ? win.spanLabel : 'the last year'}`;
     const html = `<figure class="pchart" id="${esc(id)}">
       <figcaption class="pchart__title">Your shipping year</figcaption>
       <p class="pchart__read">${esc(read)}</p>

package/modules/ideas/module.json

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

package/modules/ideas/routes/inbox.js

@@ -39,6 +39,8 @@ 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');
+// 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)
 // and the deterministic scorer (R142) — both pure, both walk the declaration.
 const { validateFieldValues, templateFor, fieldOrder } = require('../templates');
@@ -61,10 +63,34 @@ const { TRIAGE_NOTE_MAX } = inbox;
 // hook that runs both in the live server AND when a test rebuilds the GDS
 // router) and hasProvider-guarded so re-instantiation never trips the seam's
 // single-provider guard. Mirrors modules/economy/routes/reward.js.
+// The `ideas.descent` kernel PORT (task 1004088, BV2.R09; ADR 0312 + ADR 0093
+// §5). The ideator payout follows the task→task descent and decays by depth, so
+// modules/economy/credits.js has to know how far a shipping task sits below the
+// task an idea was promoted into.
+//
+// WHY A PORT AND NOT A SECOND SQL READ, which is what credits.js does for the
+// lineage. A cross-table SQL read across the module wall is allowed and credits.js
+// already relies on that; a cross-module require is not. But the descent is not a
+// read, it is a WALK — breadth-first with a visited set, each node at its shortest
+// depth — and a second copy of that in economy would be free to drift from this
+// one. The payout decays by the depth the walk returns, so a drift between the two
+// copies is not a rendering difference, it is a different amount of money. One
+// implementation, reached through the switchboard.
+//
+// Registered here beside `ideas.capture` for the same reason: the route factory is
+// the one boot hook that runs both in the live server and when a test rebuilds the
+// GDS router. hasProvider-guarded so re-instantiation never trips the single-
+// provider guard.
 function registerSeams() {
   if (!api.hasProvider('ideas.capture')) {
     api.registerProvider('ideas.capture', inbox.captureIdea);
   }
+  if (!api.hasProvider('ideas.descent')) {
+    api.registerProvider('ideas.descent', {
+      ancestorsOfTask: descent.ancestorsOfTask,
+      descendantsOfTask: descent.descendantsOfTask,
+    });
+  }
 }
 
 // The author-facing shape of a ratification window this request just opened —

package/modules/lifecycle/db-ship.js

@@ -371,11 +371,26 @@ async function awardLandingCredit(client, { taskId, creditedBuilderId, creditsRe
   const ideaBonus = reward.awardIdeaTaskShipCredit
     ? await reward.awardIdeaTaskShipCredit(client, { taskId })
     : null;
+  // BV2.R09 (ADR 0312): the same stream, for the origins this task DESCENDS
+  // from. The direct payout above pays the idea whose lineage row names this
+  // task; this pays the ideas above it in the task→task descent, decayed by
+  // depth. Its skipIdeaIds carries whatever the direct payout just settled, so
+  // an idea that is both the direct source AND an ancestor's source is paid the
+  // full share once rather than the full share plus a decayed one.
+  // Guarded the same way — an older economy module without this export, or an
+  // instance with no ideas module, simply pays nothing extra.
+  const ideaDescent = reward.awardIdeaDescentShipCredit
+    ? await reward.awardIdeaDescentShipCredit(client, {
+      taskId,
+      skipIdeaIds: ideaBonus && ideaBonus.ideaId != null ? [ideaBonus.ideaId] : [],
+    })
+    : null;
   return {
     creditsAwarded: credit.creditsAwarded,
     creditsRaw: credit.raw,
     creditsMultiplier: credit.multiplier,
     ideaBonus,
+    ideaDescent,
   };
 }
 

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.901",
+  "version": "1.19.903",
   "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/scripts/gds/api.js

@@ -18,9 +18,7 @@
 // on a 2xx, 1 on any non-2xx or transport error, 2 on bad invocation.
 
 const fs = require('node:fs');
-const { cliClient, arg, stripBom, resolveQuiet, isBoxScope, printBoxScopeGuidanceAndExit, cliExit, repairMsysMangledPath,
-  instanceDevBoxSupport, devBoxUnavailableMessage } = require('./cli-lib');
-const { plainCardLines } = require('./plain-cards');
+const { cliClient, arg, stripBom, resolveQuiet, cliExit, repairMsysMangledPath } = require('./cli-lib');
 
 
 (async () => {
@@ -77,31 +75,9 @@ const { plainCardLines } = require('./plain-cards');
     return cliExit(1); // task 1002734: never process.exit() after a request
   }
   if (!quiet) console.error(`${method} ${urlPath} → ${res.status}`);
-  // task 1501: on a dev box the baked session is box-scoped (ADR 0053) and every
-  // non-bootstrap call (e.g. /me, /inbox) returns 403 box_scope. We pass
-  // allowUnauthenticated above (so a 401 stays a plain error, not the setup
-  // short-circuit), which ALSO suppresses apiCall's own box_scope guidance — so
-  // surface it here. Without this the raw {error:'box_scope'} body was dumped and
-  // rank-gated skills (/idea-triage, /blocker-review, …) read the missing `rank`
-  // as "pre-rank passthrough" and silently did nothing (reported an empty inbox
-  // on a dev box). The guided message tells the builder to /builder-reauth.
-  if (isBoxScope(res)) {
-    printBoxScopeGuidanceAndExit(); // prints the re-auth guidance + exit(10)
-  }
   if (res.data !== undefined && res.data !== null) {
     console.log(JSON.stringify(res.data, null, 2));
   }
-  // task 1003730: `bongos box` in the public CLI is this passthrough aimed at
-  // POST /box/ensure, so on an instance without the dev-box module a builder got a raw
-  // 404 body and no idea why. api.js stays generic — it just adds the one explanation
-  // that a /box/ 404 always means — and only for a reader who typed a box command.
-  if (res.status === 404 && /^\/api\/(?:bongos\/v1|bongos|gds)\/box\b/.test(urlPath)) {
-    const { available } = await instanceDevBoxSupport();
-    if (!available) {
-      console.error(`\n✖ ${devBoxUnavailableMessage()}`);
-      for (const line of plainCardLines('dev_box_unavailable')) console.error(line);
-    }
-  }
   // task 1002734: process.exit() here aborted node 5/5 on Windows —
   // "Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\win\async.c"
   // — AFTER the JSON had already printed, so every caller that checks the exit code