@bongos/core 1.19.1015 → 1.19.1016

package/modules/hall-ui/public/sky-data.js

@@ -21,10 +21,13 @@
 // instance's version ids; the goal layout; and the thoughts — their state,
 // their placement, their words.
 //
-// TWO LAYERS ARE HIDDEN UNTIL PART 5 makes them ledger facts (the README's
-// "must not ship" rows): the "claude layer" pill and every born-of mark. The
-// code that draws them is kept, and it reads `filed_via` / `bornOf` that are
-// simply absent today — so part 5 turns them on by shipping the facts.
+// TWO LAYERS BECAME LEDGER FACTS IN PART 5 (task 1004233; the README's "must
+// not ship" rows, shipped): the "claude layer" reads `filed_via` off each row of
+// GET /sky/mine — cli, api and discord wait behind the pill, hall and planning
+// always show, and a row from before the column (NULL) shows and says "filed
+// before the ledger recorded where" — and every born-of mark reads `born` off
+// GET /sky (which thoughts became goals or rings, from the ratify tables).
+// Nothing here guesses either from text.
 //
 // ONE PAGE, TWO DOORS (part 4, task 1004232). /thinking and /goal-map are the
 // same seven files over the same markup; the body's `data-sky-lens` says which
@@ -73,6 +76,15 @@
   const STOP = new Set('a an the to of in on for and or is it this that with from by as at be are was not no we you your our into onto when what how why should could would can will every each all any some one two page let me without does did has have had its their them then than but so if'.split(' '));
   function tokens(s) { return String(s || '').toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2 && !STOP.has(w)); }
   const toMs = (iso) => iso ? new Date(iso).getTime() : 0;
+  // Where an idea was filed from (task 1004233): the five doors the ledger
+  // records, which of them a SESSION files through (the "claude layer" hides
+  // these until the pill is pressed), and the words the panel says for each.
+  const SESSION_VIAS = Object.freeze(['cli', 'api', 'discord']);
+  const VIA_WORDS = { hall: 'from the hall', cli: 'from the command line', discord: 'from Discord', planning: 'in a planning session', api: 'through the API' };
+  function viaWord(v) { return v == null ? 'filed before the ledger recorded where' : (VIA_WORDS[v] || 'through ' + v); }
+  // bornFromSky — GET /sky's `born` as string-keyed, string-valued maps; absent
+  // or half-shaped is empty (no mark is drawn on a guess).
+  function bornFromSky(b) { const m = (o) => { const out = {}; if (o && typeof o === 'object') for (const [k, v] of Object.entries(o)) if (v != null) out[String(k)] = String(v); return out; }; return { goals: m(b && b.goals), criteria: m(b && b.criteria) }; }
   // The hall's own doors — the prototype linked to a fixed hall origin; the
   // page links to the hall it is served from (apex /builders or the subdomain).
   const hallBase = () => (location.hostname.startsWith('builders.') ? '' : '/builders');
@@ -125,9 +137,10 @@
       size: i.size || null,
       state: st ? { ...st, wellGoalId: st.wellGoalId != null ? String(st.wellGoalId) : null } : null,
       mergedInto: i.merged_into_idea_id != null ? String(i.merged_into_idea_id) : null,
-      // filed_via is part 5's fact. Until it exists every thought is a person's
-      // (the owner: historic ideas with no filed_via SHOW by default).
-      filedVia: i.filed_via ?? null, origin: i.filed_via === 'session' ? 'claude' : 'human',
+      // filed_via (part 5): a session's door puts the thought behind the claude
+      // layer; a person's door, and a row from before the column (NULL — the
+      // owner: historic ideas SHOW by default), do not.
+      filedVia: i.filed_via ?? null, origin: SESSION_VIAS.includes(i.filed_via) ? 'claude' : 'human',
     };
   }
 
@@ -184,6 +197,7 @@
   // Called once, after the reads; everything it derives lands on S.
   function buildWorld({ sky, mine, versions }) {
     S.ASPECT = clamp(innerWidth / Math.max(1, innerHeight), 1, 1.8);
+    S.BORN = bornFromSky(sky && sky.born);
     const BORN = S.BORN;
     const goals = ((sky && sky.goals) || []).map(goalFromSky).map((g) => ({ ...g, bornOf: BORN.goals[g.id] || null, born: toMs(g.createdAt) }));
     const goalById = new Map(goals.map((g) => [g.id, g]));
@@ -299,7 +313,7 @@
 
   Object.assign(SKY, {
     S, $, TAU, GOLDEN, reduce, NOW, hash, rng, clamp, lerp, smooth, ease, esc, fmtDate, fmtDay, ageDays, plain, short, store, tokens, toMs, hallBase, API, api,
-    OBJ, objects, goalFromSky, ideaFromMine, bandsFor, wellRadius, ringR, taskAt, buildWorld, edgesOf,
+    OBJ, objects, SESSION_VIAS, viaWord, bornFromSky, goalFromSky, ideaFromMine, bandsFor, wellRadius, ringR, taskAt, buildWorld, edgesOf,
     applyRehearsal, inLayer, shown, diameter, positionWord, brightnessWord, reach, became, temp, placeIdeas, touched, load,
   });
 })();

package/modules/hall-ui/public/sky-draw.js

@@ -7,8 +7,9 @@
 // thicker with credits), bodies are tasks past the zoom threshold and dust
 // below it, and a thought is one of the five objects — its SIZE the credits
 // its descent was paid (never smaller for being dead), its BRIGHTNESS how
-// much of that work still stands. Born-of marks and the "filed by a session"
-// accent read facts part 5 ships; until then they are simply never true.
+// much of that work still stands. Born-of marks read GET /sky's `born` and the
+// "filed by a session" accent reads `filed_via` — ledger facts since part 5
+// (task 1004233), never a guess from text.
 
 (() => {
   'use strict';

package/modules/hall-ui/public/sky-panel.js

@@ -41,7 +41,7 @@
         ${i.size ? fact('of which', esc(sizeWords(i))) : ''}
         ${bright ? fact('brightness — still alive', `<span class="bar" style="width:${Math.max(4, Math.round(i.lit * 70))}px;${i.lit > 0 ? '' : 'background:rgba(255,255,255,.2)'}"></span>${esc(bright)}`) : ''}
         ${pos ? fact('position', esc(pos)) : ''}
-        ${fact('filed', esc(fmtDate(i.capturedAt)) + (i.kind ? ` · ${esc(i.kind)}` : '') + (i.grade === 'full' ? ' · full idea' : '') + (i.origin === 'claude' ? ' · by a session, under your name' : ''))}
+        ${fact('filed', esc(fmtDate(i.capturedAt)) + (i.kind ? ` · ${esc(i.kind)}` : '') + (i.grade === 'full' ? ' · full idea' : '') + ' · ' + esc(SKY.viaWord(i.filedVia)) + (i.origin === 'claude' ? ' · by a session, under your name' : ''))}
       </div>
       ${i.fields && FIELDS.length ? `<div><span class="lbl">the five answers · ${SKY.completeness(i.fields)} of ${FIELDS.length} above the floor</span><ul class="orbit-list">${FIELDS.map((f) => `<li><span class="st">${esc(f.key.replace('_', ' '))}</span><span>${esc(i.fields[f.key] || '— skipped')}</span></li>`).join('')}</ul></div>` : ''}
       ${i.lineage.length ? `<div><span class="lbl">the descent — everything that fell out of it</span><ul class="orbit-list">${[...i.lineage, ...i.descentTasks].map((t) => `<li><span class="st${t.status === 'active' ? ' live' : ''}">${esc(t.status)}</span><span>${esc(t.title)}${t.goalId && t.goalId !== i.well && goalById.get(t.goalId) ? ` <span class="lbl">in ${esc(short(goalById.get(t.goalId).title))}</span>` : ''}</span></li>`).join('')}</ul></div>` : ''}

package/modules/ideas/born-of.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// modules/ideas/born-of.js — WHICH THOUGHTS BECAME THE STRUCTURE (task 1004233,
+// sky part 5 of 5; goal 1000095; ADR 0331 §4).
+//
+// The sky draws a goal born of a thought with a nucleus ring, a ring (a
+// criterion) born of one with an accent notch, and places the thought itself at
+// the well's core or on its ring. The prototype found "born of" by scanning goal
+// and criterion text for idea ids; this read answers it from the two tables the
+// ratify paths already write, so it is a ledger fact and never a guess:
+//   goals    — ideas_goal_ratifications (ratify.js ratifyIdeaAsGoal): one row
+//              per idea → goal
+//   criteria — criterion_proposal_audit (ratify.js ratifyCriterionProposal):
+//              one row per idea → criterion
+// The FIRST ratification names the thought (ordered by ratified_at, then id);
+// ids come back as strings keyed by the thing born, so a page looks a well or a
+// ring up directly:
+//   { goals: { [goal_id]: idea_id }, criteria: { [criterion_id]: idea_id } }
+//
+// Served through the `ideas.bornOf` PORT (registered beside `ideas.capture` in
+// routes/inbox.js) so the lifecycle module's GET /sky can fold it in as `born`
+// without importing this module or reading an ideas_-prefixed table itself
+// (ADR 0083's one-way rule). An instance without the port gets an empty map,
+// which the pages draw as "nothing is known", not "nothing was born".
+
+const api = require('../../src/module-api');
+const { pool } = api;
+
+function emptyBorn() { return { goals: {}, criteria: {} }; }
+
+// readBornOf — the two reads, folded first-wins into plain objects keyed by the
+// born thing's id. deps.pool honours the test seam.
+async function readBornOf(deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const [goals, criteria] = await Promise.all([
+    activePool.query(
+      `SELECT goal_id::text AS goal_id, idea_id::text AS idea_id
+         FROM ideas_goal_ratifications
+        ORDER BY ratified_at, id`
+    ),
+    activePool.query(
+      `SELECT criterion_id::text AS criterion_id, idea_id::text AS idea_id
+         FROM criterion_proposal_audit
+        ORDER BY ratified_at, id`
+    ),
+  ]);
+  const firstWins = (rows, key) => {
+    const m = new Map();
+    for (const r of rows) if (r && r[key] != null && r.idea_id != null && !m.has(String(r[key]))) m.set(String(r[key]), String(r.idea_id));
+    return Object.fromEntries(m);
+  };
+  return { goals: firstWins(goals.rows, 'goal_id'), criteria: firstWins(criteria.rows, 'criterion_id') };
+}
+
+module.exports = { readBornOf, emptyBorn };

package/modules/ideas/inbox.js

@@ -32,6 +32,7 @@ const {
   IDEA_COLS, IDEA_COLS_Q, GRADE_COLS_Q, IDEA_JOIN_GRADE, ungradedProjection,
   DEFAULT_GRADE, VALID_GRADES, DEFAULT_TEMPLATE_KEY, TEMPLATE_KEY_MAX, FIELD_VALUES_MAX,
   VALID_RECOMMENDATIONS, isValidRecommendation, normalizeRecommendation,
+  FILED_VIA_VALUES, isValidFiledVia, filedViaForSource, resolveFiledVia,
 } = require('./projection');
 // The carved domains. Each is re-exported at the bottom of this file, so every
 // existing caller of `require('./inbox')` keeps working unchanged — the same
@@ -170,6 +171,13 @@ async function captureIdea({
   // anything). Ignored when `goalId` is already set, so every existing caller
   // is untouched.
   suggestedGoalId = null,
+  // task 1004233 (sky part 5): WHICH DOOR the idea came through, as a ledger
+  // fact on the row — hall | cli | discord | planning | api (projection.js
+  // FILED_VIA_VALUES). The route reads it off the session; a port caller (the
+  // Discord bot, an agent poller) names its own. 'api' is the catch-all for a
+  // program that says nothing: a NEW row always records a door — NULL is
+  // reserved for rows older than the column and is never written here.
+  filedVia = 'api',
   // WHICH DOOR this filing came through; absent is UNTRUSTED and stays an inbox
   // row. Read by one rule — see routing.HOMELESS_ROUTING_VECTORS (ADR 0262).
   vector = null,
@@ -187,6 +195,9 @@ async function captureIdea({
   ) {
     throw { code: 'BAD_PRIORITY', priority: suggestedPriority };
   }
+  if (!isValidFiledVia(filedVia)) {
+    throw { code: 'BAD_FILED_VIA', filedVia, allowed: [...FILED_VIA_VALUES] };
+  }
   const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
 
   // The decision, before any write. Pure — see ./routing.js.
@@ -225,7 +236,7 @@ async function captureIdea({
   if (landing.route) {
     return routeIdeaToGoal({
       title, bodyMd, resolvedKind, suggestedVersion, suggestedPriority,
-      capturedBy, goalId, landing, filerRank, touches,
+      capturedBy, goalId, landing, filerRank, touches, filedVia,
     }, activePool);
   }
 
@@ -236,12 +247,12 @@ async function captureIdea({
   const { rows } = await activePool.query(
     `INSERT INTO idea_inbox
        (title, body_md, kind, suggested_version, suggested_priority, captured_by, status,
-        suggested_goal_id)
+        suggested_goal_id, filed_via)
      VALUES ($1, $2, $3, $4, $5, $6, 'open',
-             $7)
+             $7, $8)
      RETURNING ${IDEA_COLS}`,
     [title, bodyMd, resolvedKind, suggestedVersion, suggestedPriority, capturedBy,
-      goalId ?? suggestedGoalId ?? null]
+      goalId ?? suggestedGoalId ?? null, filedVia]
   );
   // A brand-new idea has no ideas_grades row, so it is quick by definition —
   // no join needed to know that. Grading it (R143's Full Idea capture) is a
@@ -266,7 +277,7 @@ async function captureIdea({
 // the same two-step ratifyCriterionProposal takes.
 async function routeIdeaToGoal({
   title, bodyMd, resolvedKind, suggestedVersion, suggestedPriority,
-  capturedBy, goalId, landing, filerRank = null, touches = null,
+  capturedBy, goalId, landing, filerRank = null, touches = null, filedVia = 'api',
 }, activePool) {
   const client = await activePool.connect();
   try {
@@ -326,12 +337,12 @@ async function routeIdeaToGoal({
     const { rows: ideaRows } = await client.query(
       `INSERT INTO idea_inbox
          (title, body_md, kind, suggested_version, suggested_priority, captured_by, status,
-          suggested_goal_id, reviewed_at)
+          suggested_goal_id, reviewed_at, filed_via)
        VALUES ($1, $2, $3, $4, $5, $6, 'promoted',
-               $7, now())
+               $7, now(), $8)
        RETURNING ${IDEA_COLS}`,
       [title, bodyMd, resolvedKind, suggestedVersion, suggestedPriority, capturedBy,
-        effectiveGoalId]
+        effectiveGoalId, filedVia]
     );
     const idea = ideaRows[0];
 
@@ -802,6 +813,10 @@ module.exports = {
   // the same place the SQL CHECK mirrors
   VALID_RECOMMENDATIONS,
   isValidRecommendation,
+  FILED_VIA_VALUES,
+  isValidFiledVia,
+  filedViaForSource,
+  resolveFiledVia,
   normalizeRecommendation,
   // skill-friction marker + rank visibility gate (V3.R70 / #289; the kind
   // itself landed in task 1003105 — both markers are live, see above)

package/modules/ideas/projection.js

@@ -25,6 +25,11 @@ const IDEA_COL_NAMES = [
   'id', 'title', 'body_md', 'kind', 'suggested_version', 'suggested_priority',
   'captured_at', 'captured_by', 'status', 'promoted_to_task_id', 'reviewed_at',
   'merged_into_idea_id', 'triage_note',
+  // core_253_idea_filed_via (task 1004233, sky part 5): WHICH DOOR the idea came through
+  // (hall | cli | discord | planning | api), or NULL for a row older than the
+  // column. On the shared list so every read carries it — GET /sky/mine is the
+  // trail's own projection and the sky's "claude layer" reads it off the row.
+  'filed_via',
   // core_222 (task 1003060, BV1.R02): the routing HINT — "this probably belongs
   // to goal N" — on a row that did NOT convert. Added to the shared list because
   // R02 shipped the column and nothing read it: /idea-triage (R13) cannot walk
@@ -34,6 +39,44 @@ const IDEA_COL_NAMES = [
   'suggested_goal_id',
 ];
 const IDEA_COLS = IDEA_COL_NAMES.join(', ');
+
+// -------------------------------------------------------------------------
+// Where an idea was filed from (task 1004233 / sky part 5, goal 1000095; ADR 0331 §4)
+//
+// The closed set idea_inbox_filed_via_known mirrors (core_253_idea_filed_via). NULL — a row
+// older than the column — is a sixth, honest answer the sky speaks as "filed
+// before the ledger recorded where"; it is never backfilled from text, which
+// would put the prototype's guess into the ledger.
+//
+// THE DOOR IS READ OFF THE SESSION, not claimed in the body. A web cookie is the
+// hall (the ideas form, the sky's composer), a device-flow token is the CLI
+// (capture.js, spark.js), anything else (a box token, a program on the port) is
+// the API — so a filer cannot say they came through a door they did not. The one
+// value a body may ADD is 'planning': a planning session's capture is a CLI
+// filing no session can tell apart, so capture.js --via planning names it. The
+// Discord bot names 'discord' itself: it calls the port, not the route.
+const FILED_VIA_VALUES = Object.freeze(['hall', 'cli', 'discord', 'planning', 'api']);
+const isValidFiledVia = (v) => typeof v === 'string' && FILED_VIA_VALUES.includes(v);
+function filedViaForSource(source) {
+  return source === 'web' ? 'hall' : source === 'cli' ? 'cli' : 'api';
+}
+// resolveFiledVia — the session's door, unless the body names 'planning' (or
+// repeats the session's own door, which is harmless). Anything else is refused
+// with the reason and the one value that may be named.
+function resolveFiledVia(source, claimed) {
+  const own = filedViaForSource(source);
+  if (claimed === undefined || claimed === null || claimed === own) return { ok: true, value: own };
+  if (claimed === 'planning') return { ok: true, value: 'planning' };
+  return {
+    ok: false,
+    detail: {
+      filed_via: claimed, session_door: own, allowed: ['planning', own],
+      reason: isValidFiledVia(claimed)
+        ? `filed_via is read off your session (${own}); the only door a filing may add is 'planning'.`
+        : `filed_via must be one of ${FILED_VIA_VALUES.join(', ')} — and only 'planning' may be named by a filing.`,
+    },
+  };
+}
 const IDEA_COLS_Q = IDEA_COL_NAMES.map((c) => `i.${c}`).join(', ');
 
 // -------------------------------------------------------------------------
@@ -153,6 +196,11 @@ module.exports = {
   VALID_RECOMMENDATIONS,
   isValidRecommendation,
   normalizeRecommendation,
+  FILED_VIA_VALUES,
+  isValidFiledVia,
+  filedViaForSource,
+  resolveFiledVia,
+  IDEA_COL_NAMES,
   GRADE_COLS_Q,
   IDEA_JOIN_GRADE,
   ungradedProjection,

package/modules/ideas/routes/inbox.js

@@ -35,6 +35,7 @@
 const express = require('express');
 const api = require('../../../src/module-api');
 const inbox = require('../inbox');
+const bornOf = require('../born-of');
 // The trail read to the FULL depth of the descent (task 1004089, BV2.R09). Its
 // own file because inbox.js is AT the size ratchet and because a task->task
 // walk is a different relation from the idea->task trail.
@@ -95,6 +96,12 @@ function registerSeams() {
   if (!api.hasProvider('ideas.capture')) {
     api.registerProvider('ideas.capture', inbox.captureIdea);
   }
+  // task 1004233 (sky part 5): which thoughts became goals or rings, for the
+  // lifecycle module's GET /sky to fold in as `born` — through the port, so
+  // lifecycle never reads an ideas_ table itself (./born-of.js).
+  if (!api.hasProvider('ideas.bornOf')) {
+    api.registerProvider('ideas.bornOf', bornOf.readBornOf);
+  }
   if (!api.hasProvider('ideas.descent')) {
     api.registerProvider('ideas.descent', {
       ancestorsOfTask: descent.ancestorsOfTask,
@@ -176,8 +183,19 @@ module.exports = function buildInboxRouter() {
       // turned out: 'goal' or 'criterion'. OPTIONAL, permanently (see the
       // refusal below and ideas_009's header).
       recommendation: { type: 'string', maxLength: 16 },
+      // task 1004233 (sky part 5): WHICH DOOR. Read off the session — never a
+      // claim — except 'planning' (capture.js --via planning); see below.
+      filed_via: { type: 'string', maxLength: 16 },
     })) return;
     const body = req.body || {};
+    // task 1004233 (sky part 5): the door is a FACT read off the session that
+    // made the request (projection.js resolveFiledVia: a web cookie is the hall,
+    // a device-flow token is the CLI, anything else the API). The body may add
+    // only 'planning' — the one door no session can tell from a CLI capture —
+    // and any other claim is refused, so a filer cannot say they came through a
+    // door they did not.
+    const door = inbox.resolveFiledVia(req.gdsSession && req.gdsSession.source, body.filed_via);
+    if (!door.ok) return res.fail('bad_filed_via', 400, door.detail);
     if (body.kind === 'criterion-proposal') {
       // FAIL CLOSED (task 1003197 (D)). This was inline and read
       // `if (rank && rank !== 'metic' && …)`, so an ABSENT rank ADMITTED. The
@@ -253,6 +271,7 @@ module.exports = function buildInboxRouter() {
         goalId: body.goal_id ?? null,
         filerRank: req.builder?.rank ?? null,
         grade,
+        filedVia: door.value,
         // task 1003691 (ADR 0262): the vector, hardcoded — NEVER read from the
         // body. This route is the authenticated API door, so a bug filed here
         // with no goal routes to the version's maintenance goal instead of
@@ -367,6 +386,7 @@ module.exports = function buildInboxRouter() {
           err.code === 'TITLE_REQUIRED' ? 400 :
           err.code === 'BAD_KIND' ? 400 :
           err.code === 'BAD_PRIORITY' ? 400 :
+          err.code === 'BAD_FILED_VIA' ? 400 :
           // task 1003065 (BV1.R01) — the routing refusals. A named goal that is
           // not a live home is the FILER'S mistake to fix (pick another goal, or
           // omit it and file to the inbox), so these are 4xx with the offending

package/modules/lifecycle/sky.js

@@ -137,12 +137,17 @@ function foldCriteria(rows = []) {
 //             satisfied, pending_review, task_ids }], tasks: [{ id, title, status,
 //             credits_reward, created_on, idea_id }] }]
 //   edges: [{ from, to, count }]           — `from` waits on `to`, the graph's own
+//   born:  { goals: { goal_id: idea_id }, criteria: { criterion_id: idea_id } }
+//                                          — which thoughts became the structure (task
+//                                            1004233): the ideas module's own read through the
+//                                            `ideas.bornOf` port, ids as strings; an absent
+//                                            port is an EMPTY map, never a guess
 //   counts: { goals, edges, criteria, tasks }
 //
 // A criterion or a task whose goal is not among the wells is DROPPED — the wells
 // are the graph's nodes (goals carrying at least one task, in the version asked
 // for), and a ring drawn around no well is a line pointing at nothing.
-function shapeSky({ goals = [], edges = [], extras = [], criteria = [], tasks = [] } = {}, categoryById = new Map()) {
+function shapeSky({ goals = [], edges = [], extras = [], criteria = [], tasks = [], born = null } = {}, categoryById = new Map()) {
   const graph = goalGraph.shapeGraph({ goals, edges }, categoryById);
   const visibleById = new Map(goals.map((g) => [String(g.goal_id), g.visible !== false]));
   const extraById = new Map(extras.map((x) => [String(x.goal_id), x]));
@@ -189,18 +194,34 @@ function shapeSky({ goals = [], edges = [], extras = [], criteria = [], tasks =
   return {
     goals: out,
     edges: graph.edges,
+    born: normalizeBorn(born),
     counts: { goals: out.length, edges: graph.edges.length, criteria: criteriaCount, tasks: taskCount },
   };
 }
 
+// normalizeBorn — the port's answer as string-keyed, string-valued maps; a null,
+// a throw or a half-shaped answer is the empty map (the page draws no mark).
+function normalizeBorn(born) {
+  const strMap = (o) => {
+    const out = {};
+    if (o && typeof o === 'object') for (const [k, v] of Object.entries(o)) if (v != null) out[String(k)] = String(v);
+    return out;
+  };
+  return { goals: strMap(born && born.goals), criteria: strMap(born && born.criteria) };
+}
+
 // sky — read + shape. `categoryIndex` is injectable so the whole path runs in a
 // test with a fake pool and no category table (the goal-graph.js precedent).
 async function sky(opts = {}, deps = {}) {
-  const [rows, byId] = await Promise.all([
+  // task 1004233: born of a thought is the IDEAS module's read, reached through
+  // its port — one of the two reads is enough to fail quietly into an empty map.
+  const readBorn = 'readBornOf' in deps ? deps.readBornOf : (api.resolveOptional ? api.resolveOptional('ideas.bornOf') : null);
+  const [rows, byId, born] = await Promise.all([
     skyRows(opts, deps),
     (deps.categoryIndex || goalCategory.categoryIndex)(deps),
+    typeof readBorn === 'function' ? readBorn().catch(() => null) : null,
   ]);
-  return shapeSky(rows, byId);
+  return shapeSky({ ...rows, born }, byId);
 }
 
 // skyCache — the 60-second memo, keyed by what decides what the viewer may see.
@@ -258,4 +279,4 @@ function skyHandler({ read = sky, log = console, cache = skyCache() } = {}) {
   };
 }
 
-module.exports = { sky, skyRows, shapeSky, foldCriteria, skyCache, skyHandler, SKY_CACHE_TTL_MS };
+module.exports = { sky, skyRows, shapeSky, foldCriteria, normalizeBorn, skyCache, skyHandler, SKY_CACHE_TTL_MS };

package/modules/platform-identity/activity-snapshots.js

@@ -0,0 +1,47 @@
+// modules/platform-identity/activity-snapshots.js — the windowed data plane's
+// append-only history (community spec D2, task 1002977): one row per rollup
+// report WHOSE TOTALS CHANGED, so a leaderboard window (7d/30d/...) can compute
+// "latest minus the last snapshot at-or-before the window start" without a core
+// change (option B) or an unbounded event feed (option C) — both rejected for V1.
+//
+// Reporting-time semantics, not earning-time: a builder who signs in fortnightly
+// lands two weeks of credits in the sign-in week. Honest, accepted V1 limitation
+// (see the spec); self-correcting on the builder's next report.
+//
+// Compaction (daily granularity after 90 days) is a later, volume-triggered task
+// — nothing here prunes. A disconnected/re-registered project's snapshots are
+// likewise not purged here — platform_identity_builder_project_activity (the
+// table this mirrors) has the identical gap today; the future leaderboard reader
+// is where consent (rollupVisibleSql) is enforced, per that table's own precedent.
+'use strict';
+
+const { pool: defaultPool } = require('../../src/module-api');
+
+// Append one snapshot row iff the totals differ from the last one on record for
+// this (client, builder) pair — ONE statement, not a read then a write: the CTE
+// and the conditional INSERT run in the same round trip, closing the two-round-
+// trip check-then-insert race the earlier design had. A DB-level race remains
+// under READ COMMITTED — two truly concurrent statements for the same pair can
+// each see no conflicting row and both insert — but the worst case is a harmless
+// duplicate snapshot with IDENTICAL totals, which reads the same either way in
+// the windowed-delta arithmetic. A first-ever report (no prior row) always
+// inserts — NOT EXISTS is true against an empty CTE regardless of the
+// comparison. `id DESC` breaks a tie on an identical `reported_at` so "the last
+// snapshot" is always one specific row.
+async function recordActivitySnapshot({ clientId, githubId, credits = 0, tasksShipped = 0, karma = 0 }, { pool = defaultPool } = {}) {
+  const { rows } = await pool.query(
+    `WITH last AS (
+       SELECT credits, tasks_shipped, karma FROM platform_identity_activity_snapshots
+        WHERE client_id = $1 AND github_id = $2
+        ORDER BY reported_at DESC, id DESC LIMIT 1
+     )
+     INSERT INTO platform_identity_activity_snapshots (client_id, github_id, credits, tasks_shipped, karma, reported_at)
+     SELECT $1, $2, $3, $4, $5, now()
+      WHERE NOT EXISTS (SELECT 1 FROM last WHERE credits = $3 AND tasks_shipped = $4 AND karma = $5)
+     RETURNING id, reported_at`,
+    [clientId, githubId, credits, tasksShipped, karma],
+  );
+  return rows[0] || null;
+}
+
+module.exports = { recordActivitySnapshot };

package/modules/platform-identity/migrations/platform_identity_022_activity_snapshots.sql

@@ -0,0 +1,46 @@
+-- platform_identity_022_activity_snapshots.sql — the windowed data plane's ONE
+-- new table (community spec D2, task 1002977): an append-only history of each
+-- (project, builder)'s reported totals, one row per rollup report WHOSE TOTALS
+-- CHANGED (a no-op re-report inserts nothing — upsertActivity skips it via
+-- activity-snapshots.js:recordActivitySnapshot).
+--
+-- A window's value = latest totals (platform_identity_builder_project_activity)
+-- minus the last snapshot at-or-before the window start, summed across projects;
+-- missing baseline counts as zero (D2 option A, chosen over B/C — see the spec).
+-- Reporting-time semantics, not earning-time: the honest, accepted V1 limitation.
+--
+-- Retention: nothing pruned here. A compaction pass (daily granularity after 90
+-- days) is a later, volume-triggered task, not built now.
+--
+-- Additive + platform_identity_-namespaced (ADR 0083 §5). Idempotent.
+
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS platform_identity_activity_snapshots (
+  id             bigserial PRIMARY KEY,
+
+  -- The project (the sso_client that reported) + the builder (stable github id) —
+  -- the same pair platform_identity_builder_project_activity is keyed on.
+  client_id      text NOT NULL,
+  github_id      bigint NOT NULL,
+
+  -- The reported totals AT this point in time (a snapshot, not a delta).
+  credits        integer NOT NULL DEFAULT 0,
+  tasks_shipped  integer NOT NULL DEFAULT 0,
+  karma          integer NOT NULL DEFAULT 0,
+
+  reported_at    timestamptz NOT NULL DEFAULT now()
+);
+
+-- The windowed read's whole access path: "the last snapshot at-or-before a given
+-- timestamp, for this (project, builder)". DESC so the common query (the most
+-- recent snapshot <= window start) hits the front of the index; `id DESC`
+-- matches activity-snapshots.js's own tiebreak, so its top-1 probe is a pure
+-- index-order LIMIT 1 rather than relying on an incremental sort.
+CREATE INDEX IF NOT EXISTS platform_identity_activity_snapshots_builder_time
+  ON platform_identity_activity_snapshots (client_id, github_id, reported_at DESC, id DESC);
+
+COMMENT ON TABLE platform_identity_activity_snapshots IS
+  'Append-only history of reported totals per (client_id, github_id), one row per rollup report whose totals changed (community spec D2, task 1002977). A leaderboard window computes latest minus the last snapshot at-or-before the window start; missing baseline counts as zero. Reporting-time semantics, not earning-time. Nothing pruned in V1 — a later, volume-triggered compaction task handles retention.';
+
+COMMIT;

package/modules/platform-identity/platform-identity.js

@@ -24,6 +24,9 @@ const terms = require('./terms-acceptance');
 // reads the SAME rule as a ship link instead of the "different host" check it had —
 // see origin-containment.js for why it is downward only and why it lives there.
 const { urlWithinOrigin } = require('./origin-containment');
+// The windowed data plane's append-only snapshot history (task 1002977, community
+// spec D2) — one call from upsertActivity below; the mechanism itself lives there.
+const { recordActivitySnapshot } = require('./activity-snapshots');
 
 const { pool: defaultPool } = api;
 const { ACCOUNT_VISIBILITY, accountVisibleSql, rollupVisibleSql, isRollupVisible, scoutingListableSql } = visibility;
@@ -677,6 +680,16 @@ async function upsertActivity({ clientId, githubId, credits = 0, tasksShipped =
     // Postgres ARRAY literal, which the jsonb column would reject.
     [clientId, githubId, credits | 0, tasksShipped | 0, karma | 0, safeRank, disc, JSON.stringify(ships)],
   );
+  // Windowed data plane (task 1002977): one snapshot per report whose totals
+  // changed, skipped on a no-op re-report — see activity-snapshots.js.
+  // Best-effort, the application-echo.js precedent: descriptive analytics, never
+  // authority, so a fault here (e.g. migration 022 not yet applied on this
+  // instance) must never fail the rollup report that already committed above.
+  try {
+    await recordActivitySnapshot({ clientId, githubId, credits: credits | 0, tasksShipped: tasksShipped | 0, karma: karma | 0 }, { pool });
+  } catch (err) {
+    api.logger('platform-identity').error(`activity snapshot write failed (non-fatal): ${err && err.message}`);
+  }
   return rows[0];
 }
 

package/modules/platform-identity/tests/activity-snapshots.mjs

@@ -0,0 +1,68 @@
+// modules/platform-identity/tests/activity-snapshots.mjs
+//
+// DB-free unit suite for the windowed data plane's append-only snapshot history
+// (community spec D2, task 1002977). Recording-fake-pool style, matching
+// tests/platform-identity.mjs: proves the SQL SHAPE (one statement, correct
+// table/columns, bound params, the tiebreak) — a fake pool cannot execute the
+// `WHERE NOT EXISTS` itself, so the skip-on-unchanged BEHAVIOUR is proved
+// against real Postgres in tests/activity_snapshots_db.mjs instead.
+//
+// Run standalone: node modules/platform-identity/tests/activity-snapshots.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { recordActivitySnapshot } = require('../activity-snapshots.js');
+
+let passed = 0, failed = 0;
+async function ta(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+// A recording fake pool: returns queued responses in order and records every call.
+function mockPool(responses = []) {
+  const calls = [];
+  let i = 0;
+  return {
+    calls,
+    query: async (text, params) => {
+      calls.push({ text: String(text), params: params || [] });
+      const r = responses[i++];
+      return r || { rows: [], rowCount: 0 };
+    },
+  };
+}
+
+console.log('recordActivitySnapshot (community spec D2, task 1002977):');
+
+await ta('one statement: a CTE for the last snapshot, guarding a conditional INSERT', async () => {
+  const pool = mockPool([{ rows: [{ id: '1', reported_at: 'T1' }] }]);
+  const out = await recordActivitySnapshot({ clientId: 'c1', githubId: 42, credits: 100, tasksShipped: 5, karma: 3 }, { pool });
+  assert.equal(pool.calls.length, 1, 'one round trip, not a read then a write');
+  const c = pool.calls[0];
+  assert.match(c.text, /WITH last AS/);
+  assert.match(c.text, /FROM platform_identity_activity_snapshots/);
+  assert.match(c.text, /ORDER BY reported_at DESC, id DESC LIMIT 1/, 'a deterministic tiebreak on an identical reported_at');
+  assert.match(c.text, /INSERT INTO platform_identity_activity_snapshots/);
+  assert.match(c.text, /WHERE NOT EXISTS \(SELECT 1 FROM last WHERE credits = \$3 AND tasks_shipped = \$4 AND karma = \$5\)/);
+  assert.deepEqual(c.params, ['c1', 42, 100, 5, 3]);
+  assert.deepEqual(out, { id: '1', reported_at: 'T1' });
+});
+
+await ta('a skipped report (the fake pool answers no rows, as a real WHERE NOT EXISTS would on a match) returns null', async () => {
+  const pool = mockPool([{ rows: [] }]);
+  const out = await recordActivitySnapshot({ clientId: 'c1', githubId: 42, credits: 100, tasksShipped: 5, karma: 3 }, { pool });
+  assert.equal(pool.calls.length, 1);
+  assert.equal(out, null);
+});
+
+await ta('missing totals default to zero, like upsertActivity\'s own defaults', async () => {
+  const pool = mockPool([{ rows: [{ id: '3', reported_at: 'T3' }] }]);
+  await recordActivitySnapshot({ clientId: 'c1', githubId: 42 }, { pool });
+  assert.deepEqual(pool.calls[0].params, ['c1', 42, 0, 0, 0]);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);