@bongos/core 1.19.1015 → 1.19.1017

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/account-visibility.js

@@ -32,8 +32,13 @@
 //   recruiterReachSql / isRecruiterDiscoverable  REACH — the COALESCE, privacy
 //       spec D1. A reach predicate only: it never buys addressability.
 //   scoutingListableSql                    THE DIRECTORY — numbers AND reach,
-//       the ONE predicate the recruiting directory joins (ADR 0210, task
-//       1002290). Composed, never restated.
+//       the predicate the recruiting directory's ranked tier joins (ADR 0210,
+//       task 1002290). Composed, never restated.
+//   scoutingNameOnlySql                    THE DIRECTORY'S NAME-ONLY TIER —
+//       existence AND hidden AND reach (ADR 0334, task 1002291; privacy spec D2:
+//       a hidden builder is "listed name-only (if not opted out)"). The same
+//       predicate as the one above with the hide term flipped, so the two tiers
+//       partition the directory: hide decides a row's SHAPE, reach its presence.
 //   recruiterSliverVisibleSql / isRecruiterSliverVisible  THE PRE-ACCEPT
 //       SLIVER — consent AND reach, WITHOUT the existence axis (ADR 0215, task
 //       1002968; privacy spec D3). The one predicate that deliberately does not
@@ -205,6 +210,31 @@ function scoutingListableSql(alias) {
   return `(${rollupVisibleSql(alias)} AND ${recruiterReachSql(alias)})`;
 }
 
+// scoutingNameOnlySql — WHO the recruiting directory lists by NAME ALONE: a
+// publicly visible, reachable account that hid its cross-project record (ADR
+// 0334, task 1002291). Privacy spec D2's recruiter column lists that account
+// "name-only (if not opted out)"; before this the directory dropped it outright,
+// reading hide as a second opt-out while Settings told the builder recruiters
+// would see their name and picture.
+//
+// It is scoutingListableSql with the hide term FLIPPED and nothing else, shaped
+// identically so the two tiers cannot overlap or leave a gap
+// (tests/effective_visibility_predicate.mjs holds that). It keeps the EXISTENCE
+// floor, so a private account is never listed even by name — that is the D3
+// sliver's subject, at the archon floor (ADR 0215/0217).
+//
+// DANGEROUS OUTSIDE ITS ONE READER. It admits hidden accounts by design, so a
+// read that joined it and returned a number would hand out exactly the record
+// hide_stats withholds. scouting-name-only.js is its only reader and selects
+// three identity columns; the guard pins both.
+function scoutingNameOnlySql(alias) {
+  if (alias && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(String(alias))) {
+    throw new Error('scoutingNameOnlySql: alias must be a bare SQL identifier');
+  }
+  const q = alias ? `${alias}.` : '';
+  return `((${accountVisibleSql(alias)} AND ${q}hide_stats) AND ${recruiterReachSql(alias)})`;
+}
+
 // recruiterSliverVisibleSql — THE predicate the PRE-ACCEPT recruiter sliver
 // joins: the CONSENT floor AND the reach axis (ADR 0215, privacy spec D3; task
 // 1002968). modules/platform-identity/recruiter-sliver.js is its one reader.
@@ -256,6 +286,7 @@ module.exports = {
   isRecruiterDiscoverable,
   recruiterReachSql,
   scoutingListableSql,
+  scoutingNameOnlySql,
   recruiterSliverVisibleSql,
   isRecruiterSliverVisible,
 };

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 };