@bongos/core 1.24.30 → 1.24.31

package/modules/lifecycle/home-gallery.js

@@ -0,0 +1,320 @@
+'use strict';
+
+// modules/lifecycle/home-gallery.js — the works behind the artist's Home, and the
+// one heart a builder may give each (task 1005060, Home v16 step 3).
+//
+// WHY. In Artistry, Home is a bench in the museum facing a wall of the project's
+// signed works (modules/hall-ui/public/home-gallery.js, record
+// modules/hall-ui/records/home-city.md § "The gallery"). The owner's rule: "not
+// about quality but about appreciation" — each work carries how many builders
+// appreciated it and one heart to add yours; Most popular (the default) is that
+// count, Latest the ship date. No grade, rank or leaderboard reads or writes here.
+//
+// WHAT A WORK IS, and why this source. A work is a SHIPPED task of the art crafts
+// (discipline `artist` or `ui` — economy's credits-by-craft rule, the city's
+// ART_DISCIPLINES) that carries a picture of what it made:
+//   · a page tweak round (`source = 'page-tweak'`) hangs its own AFTER renders, the
+//     desktop light and dark slots /tweak attached for the Approval queue
+//     (lifecycle_task_visual_slots, TWEAK_RENDER_SLOTS) — the artist's approved page;
+//   · any other art ship hangs its ship-time visual (tasks.visual_url).
+// That is the hall's own record of finished, signed art: the artist is the task's
+// `shipped_by` (a page tweak's is its artist, page-tweak-artist.js), the date its
+// ship, the line under it its value summary. The design mocks under docs/ are drafts
+// and the page readings are words with no picture, so neither is a work.
+//
+// THE PICTURE INHERITS THE TASK'S AUDIENCE (the task-visuals rule): a
+// security-sensitive task never hangs here, and a work under a private goal the
+// viewer is neither a member of nor an Archon over is left off the wall entirely
+// (ADR 0112) — its picture is the prose. Visibility comes from the signed-in
+// viewer, never the query.
+//
+// BOUNDED. One query, LIMIT MAX_WORKS, ordered in SQL by the order asked for, with
+// the whole wall's size as a window count — the payload never grows with the corpus.
+//
+// MODULE BOUNDARY: reaches core only through the published doorway. The hearts are
+// this module's own table (lifecycle_020); lifecycle is default-on, but the table is
+// still probed with to_regclass so a database the migration has not reached answers
+// a wall with no hearts rather than failing Home.
+
+const fs = require('node:fs');
+const api = require('../../src/module-api');
+const taskVisuals = require('./task-visuals');
+
+const MAX_WORKS = 60;
+const ORDERS = Object.freeze(['popular', 'latest']);
+const ART_DISCIPLINES = Object.freeze(['artist', 'ui']);
+const SLOT_LIGHT = 'after-desktop-light';
+const SLOT_DARK = 'after-desktop-dark';
+const SMOKE_TITLE = '\\_\\_smoke\\_\\_%';
+const HEARTS = 'lifecycle_work_appreciations';
+// where a page tweak's page hangs, by the page inventory's surface (docs/page-inventory.json)
+const SURFACES = Object.freeze({ builders: 'The builders’ hall', landing: 'The public site', status: 'The status page' });
+
+// A picture whose file is gone (an old upgrade erased the store once, task 1004381)
+// would hang an empty frame; such a URL is dropped, and a work left with none is not
+// hung. The checks are async and run together (never a blocking stat in a request),
+// and each answer is held for ON_DISK_TTL_MS: a stored picture's name never changes,
+// so a wall reloaded within the window costs no file system reads.
+const ON_DISK_TTL_MS = 10 * 60 * 1000;
+const onDiskSeen = new Map();
+async function onDisk(url) {
+  const hit = onDiskSeen.get(url);
+  if (hit && Date.now() - hit.at < ON_DISK_TTL_MS) return hit.ok;
+  const p = taskVisuals.resolveSafe(String(url || '').split('/').pop());
+  let ok = false;
+  if (p) { try { await fs.promises.access(p); ok = true; } catch (_) { ok = false; } }
+  if (onDiskSeen.size > 2000) onDiskSeen.clear();
+  onDiskSeen.set(url, { ok, at: Date.now() });
+  return ok;
+}
+async function keepHung(rows, exists) {
+  const urls = [...new Set(rows.flatMap((r) => [r.light, r.dark, r.visual_url]).filter(Boolean))];
+  const there = new Set();
+  await Promise.all(urls.map(async (u) => { if (await exists(u)) there.add(u); }));
+  const keep = (u) => (u && there.has(u) ? u : null);
+  const out = rows.map((r) => Object.assign({}, r, { light: keep(r.light), dark: keep(r.dark), visual_url: keep(r.visual_url) }))
+    .filter((r) => r.light || r.dark || r.visual_url);
+  const gone = rows.length - out.length;
+  if (gone) out.forEach((r) => { r.total = Math.max(out.length, (Number(r.total) || 0) - gone); });
+  return out;
+}
+
+function cleanOrder(v) { return ORDERS.includes(v) ? v : 'popular'; }
+
+// Once the table is there it stays there, so a found table is remembered for the
+// process; an absent one is asked again (the migration may land while it runs).
+let heartsFound = false;
+async function heartsExist(pool) {
+  if (heartsFound && pool === api.pool) return true;
+  const { rows } = await pool.query('SELECT to_regclass($1) IS NOT NULL AS ok', [`public.${HEARTS}`]);
+  const ok = !!(rows[0] && rows[0].ok);
+  if (ok && pool === api.pool) heartsFound = true;
+  return ok;
+}
+
+// The WHERE that makes a task a work THIS viewer may see. Shared by the wall and the
+// heart, so a heart can only ever land on a work the wall would hang. $1 = the art
+// disciplines, $2 = the viewer is an Archon, $3 = the viewer's id.
+const WORK_WHERE = `
+       t.status = 'shipped' AND t.shipped_at IS NOT NULL
+   AND (t.discipline = ANY($1::text[]) OR t.source = 'page-tweak')
+   AND t.security_sensitive IS NOT TRUE
+   AND t.title NOT LIKE '${SMOKE_TITLE}' ESCAPE '\\'
+   AND (t.visual_url IS NOT NULL OR sl.light IS NOT NULL OR sl.dark IS NOT NULL)
+   AND (g.id IS NULL OR g.visibility IS DISTINCT FROM 'private' OR $2::boolean
+        OR EXISTS (SELECT 1 FROM goal_members gm WHERE gm.goal_id = g.id AND gm.builder_id = $3::bigint))`;
+const WORK_FROM = `
+  FROM tasks t
+  JOIN builders b ON b.id = t.shipped_by AND b.system_role IS NULL
+  LEFT JOIN goals g ON g.id = t.goal_id
+  LEFT JOIN LATERAL (
+    SELECT max(s.visual_url) FILTER (WHERE s.slot = '${SLOT_LIGHT}') AS light,
+           max(s.visual_url) FILTER (WHERE s.slot = '${SLOT_DARK}') AS dark
+      FROM lifecycle_task_visual_slots s
+     WHERE s.task_id = t.id AND t.source = 'page-tweak'
+  ) sl ON true`;
+
+function viewerOf(viewer) {
+  const id = viewer && viewer.id != null ? String(viewer.id) : null;
+  const archon = !!viewer && String(viewer.rank || '').toLowerCase() === 'archon';
+  return { id, archon };
+}
+
+// The columns a work is shaped from. `hearts` and `mine` read the table only when
+// it is there; $3 is always the viewer.
+function workCols(hearts) {
+  const count = hearts ? `(SELECT count(*) FROM ${HEARTS} h WHERE h.task_id = t.id)` : '0';
+  const mine = hearts ? `EXISTS (SELECT 1 FROM ${HEARTS} h WHERE h.task_id = t.id AND h.builder_id = $3::bigint)` : 'false';
+  return `t.id::text AS id, t.title, t.value_summary, t.shipped_at, t.source, t.source_ref,
+            t.visual_url, t.visual_alt, sl.light, sl.dark, g.title AS goal_title,
+            b.id::text AS artist_id, b.display_name, b.github_login, b.created_at AS artist_since,
+            ${count}::int AS hearts, ${mine} AS mine,
+            count(*) OVER ()::int AS total`;
+}
+
+async function readGallery({ order, viewer }, deps = {}) {
+  const pool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : api.pool;
+  const o = cleanOrder(order);
+  const v = viewerOf(viewer);
+  const hearts = await heartsExist(pool);
+  const { rows } = await pool.query(
+    `SELECT ${workCols(hearts)}
+       ${WORK_FROM}
+      WHERE ${WORK_WHERE}
+      ORDER BY ${o === 'popular' ? 'hearts DESC, ' : ''}t.shipped_at DESC, t.id DESC
+      LIMIT ${MAX_WORKS}`,
+    [ART_DISCIPLINES, v.archon, v.id],
+  );
+  return { order: o, rows: await keepHung(rows, deps.exists || onDisk) };
+}
+
+// THE STUDIO'S TWO SHELVES (task 1005061, Home v16 step 4): the works this viewer
+// appreciated on the bench (newest heart first — a heart pins a work here) and the
+// works they signed themselves (most appreciated first). Each is the wall's own
+// WHERE, so a pin never shows a work the bench would not hang, and each is LIMIT
+// MAX_SHELF with its whole size as a window count.
+const MAX_SHELF = 6;
+// A page id is <surface>:<page> (the page inventory's id rule); the easel asks for its
+// page's newest work by the round's source ref, `page-tweak/<page id>/r<n>`.
+const PAGE_ID_RE = /^[a-z0-9-]+:[a-z0-9-]+$/;
+async function readStudioWorks({ viewer, page }, deps = {}) {
+  const pool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : api.pool;
+  const v = viewerOf(viewer);
+  const exists = deps.exists || onDisk;
+  const hearts = await heartsExist(pool);
+  const args = [ART_DISCIPLINES, v.archon, v.id];
+  const easelPage = typeof page === 'string' && PAGE_ID_RE.test(page) ? page : null;
+  const [pinned, yours, easel] = await Promise.all([
+    hearts ? pool.query(
+      `SELECT ${workCols(true)}
+         ${WORK_FROM}
+         JOIN ${HEARTS} pin ON pin.task_id = t.id AND pin.builder_id = $3::bigint
+        WHERE ${WORK_WHERE}
+        ORDER BY pin.at DESC, t.id DESC
+        LIMIT ${MAX_SHELF}`,
+      args,
+    ) : Promise.resolve({ rows: [] }),
+    pool.query(
+      `SELECT ${workCols(hearts)}
+         ${WORK_FROM}
+        WHERE ${WORK_WHERE} AND t.shipped_by = $3::bigint
+        ORDER BY hearts DESC, t.shipped_at DESC, t.id DESC
+        LIMIT ${MAX_SHELF}`,
+      args,
+    ),
+    easelPage ? pool.query(
+      `SELECT ${workCols(hearts)}
+         ${WORK_FROM}
+        WHERE ${WORK_WHERE} AND t.source = 'page-tweak' AND starts_with(t.source_ref, $4)
+        ORDER BY t.shipped_at DESC, t.id DESC
+        LIMIT 1`,
+      [...args, `page-tweak/${easelPage}/r`],
+    ) : Promise.resolve({ rows: [] }),
+  ]);
+  const [p, y, e] = await Promise.all([keepHung(pinned.rows, exists), keepHung(yours.rows, exists), keepHung(easel.rows, exists)]);
+  return { pinned: p, yours: y, easel: e[0] || null };
+}
+
+function shapeShelf(rows) {
+  const works = rows.map(shapeWork);
+  return { total: rows.length ? Math.max(Number(rows[0].total) || 0, works.length) : 0, works };
+}
+
+function studioWorksHandler({ log, read = readStudioWorks } = {}) {
+  return async function homeStudioWorksRoute(req, res) {
+    try {
+      const page = req.query && typeof req.query.page === 'string' ? req.query.page : null;
+      const raw = await read({ viewer: { id: req.builder.id, rank: req.builder.rank }, page });
+      res.set('Cache-Control', 'private, no-store');
+      res.json({ pinned: shapeShelf(raw.pinned), yours: shapeShelf(raw.yours), easel: raw.easel ? shapeWork(raw.easel) : null });
+    } catch (err) {
+      if (log) log.error('GET /home/studio/works', err);
+      res.fail('home_studio_works_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+// The task title of a page tweak round is `Tweak: <page title> (<surface>:<page>)`
+// (copy-desk/pages.js); its source ref ends `/r<n>`.
+function tweakParts(row) {
+  const t = /^Tweak:\s*(.+?)\s*\(([a-z0-9-]+):([a-z0-9-]+)\)?\s*$/.exec(String(row.title || ''));
+  const r = /\/r([1-9][0-9]*)$/.exec(String(row.source_ref || ''));
+  return { title: t ? t[1] : String(row.title || ''), surface: t ? t[2] : null, page: t ? t[3] : null, round: r ? Number(r[1]) : null };
+}
+
+function isoDay(d) {
+  const x = d instanceof Date ? d : new Date(d);
+  return isNaN(x) ? null : x.toISOString().slice(0, 10);
+}
+
+// One row → one work as the wall hangs it. Pure: a test feeds it rows.
+function shapeWork(row) {
+  const tweak = row.source === 'page-tweak';
+  const p = tweak ? tweakParts(row) : null;
+  const one = row.visual_url || null;
+  return {
+    id: String(row.id),
+    page: tweak && p.surface && p.page ? `${p.surface}:${p.page}` : null,
+    // a ship's title can open with its plan code ("WA6.RP04 · "); a wall label does not
+    title: tweak ? p.title : String(row.title || '').replace(/^[A-Z][A-Z0-9]*(\.[A-Z0-9]+)*\s*·\s*/, ''),
+    medium: tweak ? (p.round > 1 ? `A page tweak, round ${p.round}` : 'A page tweak') : 'Page design',
+    place: tweak ? (SURFACES[p.surface] || null) : (row.goal_title || null),
+    words: row.value_summary || '',
+    shipped: isoDay(row.shipped_at),
+    art: { light: row.light || row.dark || one, dark: row.dark || row.light || one, alt: row.visual_alt || null },
+    artist: {
+      id: String(row.artist_id),
+      name: row.display_name || row.github_login || 'An artist',
+      login: row.github_login || '',
+      since: isoDay(row.artist_since),
+    },
+    hearts: Math.max(0, Number(row.hearts) || 0),
+    mine: row.mine === true,
+  };
+}
+
+function shapeGallery(raw) {
+  const works = raw.rows.map(shapeWork);
+  return {
+    order: raw.order,
+    total: raw.rows.length ? Math.max(Number(raw.rows[0].total) || 0, works.length) : 0,
+    works,
+  };
+}
+
+// Appreciate a work, or take it back. `on` is the state wanted, so a double click or
+// a retried request lands the same row (never a second heart). Refuses anything the
+// viewer's wall would not hang.
+async function setHeart({ taskId, on, viewer }, deps = {}) {
+  const pool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : api.pool;
+  const v = viewerOf(viewer);
+  if (!(await heartsExist(pool))) return { ok: false, code: 'gallery_unavailable', status: 503 };
+  const hit = await pool.query(
+    `SELECT t.id::text AS id ${WORK_FROM} WHERE t.id = $4::bigint AND ${WORK_WHERE}`,
+    [ART_DISCIPLINES, v.archon, v.id, taskId],
+  );
+  if (!hit.rows.length) return { ok: false, code: 'not_a_work', status: 404 };
+  if (on) {
+    await pool.query(`INSERT INTO ${HEARTS} (task_id, builder_id) VALUES ($1::bigint, $2::bigint) ON CONFLICT DO NOTHING`, [taskId, v.id]);
+  } else {
+    await pool.query(`DELETE FROM ${HEARTS} WHERE task_id = $1::bigint AND builder_id = $2::bigint`, [taskId, v.id]);
+  }
+  const { rows } = await pool.query(
+    `SELECT count(*)::int AS hearts, bool_or(builder_id = $2::bigint) AS mine FROM ${HEARTS} WHERE task_id = $1::bigint`,
+    [taskId, v.id],
+  );
+  return { ok: true, id: String(taskId), hearts: Number(rows[0] && rows[0].hearts) || 0, mine: !!(rows[0] && rows[0].mine) };
+}
+
+function galleryHandler({ log, read = readGallery } = {}) {
+  return async function homeGalleryRoute(req, res) {
+    try {
+      const viewer = req.builder ? { id: req.builder.id, rank: req.builder.rank } : null;
+      const raw = await read({ order: req.query && req.query.order, viewer });
+      res.set('Cache-Control', 'private, no-store');
+      res.json(shapeGallery(raw));
+    } catch (err) {
+      if (log) log.error('GET /home/gallery', err);
+      res.fail('home_gallery_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+function heartHandler({ log, write = setHeart } = {}) {
+  return async function homeGalleryHeartRoute(req, res) {
+    const taskId = Number(req.params && req.params.id);
+    const on = req.body && req.body.on;
+    if (!Number.isInteger(taskId) || taskId <= 0) return res.fail('bad_work_id', { status: 400, message: 'work id must be a positive integer' });
+    if (typeof on !== 'boolean') return res.fail('bad_heart', { status: 400, message: 'send { on: true } to appreciate a work, { on: false } to take it back' });
+    try {
+      const out = await write({ taskId, on, viewer: { id: req.builder.id, rank: req.builder.rank } });
+      if (!out.ok) return res.fail(out.code, { status: out.status, message: out.code === 'not_a_work' ? 'no work with that id hangs in your gallery' : 'the gallery is not set up on this project yet' });
+      res.json({ id: out.id, hearts: out.hearts, mine: out.mine });
+    } catch (err) {
+      if (log) log.error('PUT /home/gallery/:id/heart', err);
+      res.fail('home_gallery_heart_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+module.exports = { readStudioWorks, studioWorksHandler, ORDERS, ART_DISCIPLINES, SURFACES, cleanOrder, keepHung, readGallery, shapeWork, shapeGallery, setHeart, galleryHandler, heartHandler };

package/modules/lifecycle/migrations/lifecycle_020_work_appreciations.sql

@@ -0,0 +1,36 @@
+-- lifecycle_020_work_appreciations.sql — a builder may appreciate a work in the
+-- gallery, once (task 1005060, Home v16 step 3).
+--
+-- WHY. In Artistry, Home is a gallery of the project's signed works: shipped
+-- artist and ui tasks that carry a picture (modules/lifecycle/home-gallery.js says
+-- which). The owner's rule for it is "not about quality but about appreciation":
+-- a work carries how many builders appreciated it and one heart to add yours, and
+-- Most popular (the gallery's default order) is that count. It is never a grade,
+-- a vote or a rank, so it lives apart from peer_votes and task grades, and
+-- nothing reads it but the gallery.
+--
+-- ONE ROW PER (work, builder). Appreciating twice is the same row; taking it back
+-- deletes it. A work is a task, so it references tasks and goes with it.
+--
+-- A MODULE TABLE, lifecycle_-namespaced (ADR 0083): it references the core tasks
+-- and builders tables the way lifecycle_013 does and alters neither.
+--
+-- PORTABLE and replay-safe: IF NOT EXISTS throughout, no instance data.
+
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS lifecycle_work_appreciations (
+  task_id    bigint      NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  builder_id bigint      NOT NULL REFERENCES builders(id) ON DELETE CASCADE,
+  at         timestamptz NOT NULL DEFAULT now(),
+  PRIMARY KEY (task_id, builder_id)
+);
+
+-- "Your pins" in the studio reads one builder's hearts, newest first.
+CREATE INDEX IF NOT EXISTS lifecycle_work_appreciations_builder_idx
+  ON lifecycle_work_appreciations (builder_id, at DESC);
+
+COMMENT ON TABLE lifecycle_work_appreciations IS
+  'One row per builder who appreciated a gallery work (a shipped artist/ui task with a picture). Appreciation, never a grade: Most popular in the artist''s Home orders by its count (task 1005060).';
+
+COMMIT;

package/modules/lifecycle/module.json

@@ -36,6 +36,7 @@
       "goal-task-relevance",
       "moving",
       "home-city",
+      "home-gallery",
       "task-votes",
       "notes"
     ],

package/modules/lifecycle/routes/home-gallery.js

@@ -0,0 +1,37 @@
+'use strict';
+
+// modules/lifecycle/routes/home-gallery.js — the artist's Home: the gallery's works
+// and the one heart a builder may give each (task 1005060, Home v16 step 3).
+//
+// Its own route file for the reason routes/home-city.js has one: the path is
+// top-level `/home/gallery`, never under `/tasks`, whose `/:id` would swallow a
+// literal segment. The reads and handlers live in ../home-gallery.js so a test
+// drives them with no express and no database.
+//
+// MODULE BOUNDARY: reaches core only through the published doorway
+// `../../../src/module-api`; `../home-gallery` is this module's own.
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const gallery = require('../home-gallery');
+
+const log = api.logger('lifecycle');
+
+module.exports = function buildHomeGalleryRouter() {
+  const router = express.Router();
+  // rank: any-builder — GET /home/gallery?order=popular|latest, at most 60 works.
+  // Every work is a shipped task whose picture a signed-in builder can already open
+  // (the task-visuals audience); a work under a private goal the viewer cannot read
+  // is left off. Each carries its heart count and whether the viewer gave one.
+  router.get('/home/gallery', api.requireBuilder, gallery.galleryHandler({ log }));
+  // rank: any-builder — PUT /home/gallery/:id/heart { on }. Appreciation, never a
+  // grade: one heart per builder per work, given or taken back by the builder
+  // themself (the caller, never the body). Refused for anything their wall would
+  // not hang.
+  router.put('/home/gallery/:id/heart', api.requireBuilder, gallery.heartHandler({ log }));
+  // rank: any-builder — GET /home/studio/works?page=<page id>, the studio's two shelves
+  // (task 1005061): the works the CALLER appreciated and the works the caller signed,
+  // at most six each, and the easel page's newest work, all by the wall's own rule.
+  router.get('/home/studio/works', api.requireBuilder, gallery.studioWorksHandler({ log }));
+  return router;
+};

package/modules/market-watch/routes/settings.js

@@ -1,5 +1,5 @@
 // modules/market-watch/routes/settings.js — the owner's Market Watch settings (task 1004938,
-// goal 1000137). The page is the hall's /market-watch-settings, built to
+// goal 1000137). The page is the owner's Settings tab on the hall's /market-watch (task 1005045), built to
 // docs/design/mocks/market-watch/settings.html (option B, the fuel gauge).
 //
 //   GET    /market-watch/settings      the switch, cap, cadence, this month's spend, the next

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.30",
+  "version": "1.24.31",
   "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/release-notes.json

@@ -11108,7 +11108,35 @@
       "text": "Your agent settings now live in one place, My agents: Settings shows a short link there instead of repeating them, and every old Settings link to them opens My agents."
     }
   ],
-  "1.24.30": [
+  "1.24.31": [
+    {
+      "id": "1005062",
+      "text": "Releases work again: a false alarm about the GitHub logo on the new sign-in card had stopped every update from going out since this morning."
+    },
+    {
+      "id": "1005061",
+      "text": "The gallery now has a studio behind it. \"Your studio\" opens a quiet room with the page you are working on and a button back into it, the pages whose words changed since an artist last designed them, the newest words flagged on"
+    },
+    {
+      "id": "1005060",
+      "text": "In Artistry, Home is now a gallery: you sit on a bench in the museum and swipe through the project's signed works, most popular first or latest. Each work has a small museum label that opens closer on a click, the artist's sig"
+    },
+    {
+      "id": "1005059",
+      "text": "In Ideating mode, Home is now a night sky of the project's ideas over the city's real skyline. Each working area's ideas form a constellation, bigger stars have more votes, and a ringed star is waiting on you. Pointing at the"
+    },
+    {
+      "id": "1005058",
+      "text": "Home is now one city around the government's core: the new buildings lead, the core and the art museum are quiet doors, and time can be rewound smoothly from live."
+    },
+    {
+      "id": "1005045",
+      "text": "The owner's Market Watch settings are now a Settings tab on the Market Watch page, so the sidebar shows Market Watch once and old settings links still land in the right place."
+    },
+    {
+      "id": "1005057",
+      "text": "The signed-out page is now a clean sign-in screen: no side panel or top bar, just the logo, the project name, one \"Sign in with GitHub\" button and a small \"Request access\" link for newcomers."
+    },
     {
       "id": "1005056",
       "text": "The \"waiting on you\" dots on Home's project city now show every person the matters actually wait on, not just the owner."

package/scripts/bongos/leak-scan-allowlist.js

@@ -204,6 +204,14 @@ const FILE_ALLOWLIST = [
       + 'attribute, the same "why not a shape rule" secret-scrub.js records. The leading-zero guard '
       + 'catches the variants that have one; this is the residue. No topology here, only geometry.',
   },
+  {
+    path: 'modules/hall-ui/public/hall-render.js',
+    classes: ['public-ip'],
+    reason:
+      'The same inlined forge logo, on the hall\'s signed-out sign-in card (task 1005057): its SVG '
+      + 'path data carries the same "…1.08.58 1.23.82.72 1.21…" run as projects.html above. '
+      + 'Geometry, not topology (task 1005062).',
+  },
   {
     path: 'modules/security/tests/artifact_scan.mjs',
     classes: ['public-ip'],

package/scripts/hall-preview/README.md

@@ -22,6 +22,7 @@ node scripts/hall-preview/server.js                 # neutral pack, port 4600
 | `--modules-off discord,provisioning` | report those modules disabled in `window.__MODULES__` — verifies `moduleOn()` gating (the Discord links, Instances/Start-a-project widgets must vanish) |
 | `--empty` | drain every array in every fixture — the empty-state screenshot pass |
 | `--fixture-me` | don't read your own account live — serve the checked-in `me.json` snapshot (see below) |
+| `--signed-out` | answer `/me` with a 401 — preview the signed-out sign-in card |
 | `--latency 3000` | hold every data read that many ms before answering, so a page's loading state (the hall's `.hall-loading` mark) stays on screen long enough to look at |
 
 Writes are not wired: any `POST/PATCH/DELETE` answers `501 preview_readonly` — except

package/scripts/hall-preview/server.js

@@ -24,6 +24,8 @@
 //   --fixture-me   do NOT read your own account live; serve the checked-in
 //                  fixtures/me.json snapshot (deterministic screenshot passes,
 //                  and the offline/signed-out path) — task 1003315
+//   --signed-out   answer /me with a 401, so the hall renders the signed-out
+//                  sign-in card (the sign-in redesign)
 //
 // The account is YOURS: when this machine holds a GDS CLI session the me-scoped
 // reads are fetched live at boot and layered over the fixtures, so the hall
@@ -65,6 +67,8 @@ const MODULES_ON = String(arg('--modules-on') || '').split(',').map((s) => s.tri
 // own account live. The screenshot matrix in the README wants a stable subject,
 // and it is the explicit way to preview the signed-out fallback (task 1003315).
 const FIXTURE_ME = process.argv.includes('--fixture-me');
+// --signed-out: /me answers 401, the way prod answers a visitor with no session.
+const SIGNED_OUT = process.argv.includes('--signed-out');
 // --latency: hold every data read this many ms before answering (task 1005043),
 // so a page's loading state stays on screen long enough to be looked at. The
 // fixtures answer in a millisecond, which is why no loader had ever been seen.
@@ -194,6 +198,8 @@ const CANNED_WRITES = [
   ['POST', /^specialities$/, 'specialities.post'],
   // the Market Watch weekly ask's answer (task 1004940), so its "sent." state renders.
   ['POST', /^market-watch\/ask\/answer$/, 'market-watch__ask__answer.post'],
+  // the artist's Home (task 1005060): a heart given in the gallery, so it stays given.
+  ['PUT', /^home\/gallery\/\d+\/heart$/, 'home__gallery__heart.put'],
   ['PATCH', /^specialities\/\d+$/, 'specialities__12.patch'],
   // the rest of the speciality tools, now on My agents too (task 1005052): stop
   // using one, and train your own, so their toasts and redraws render here.
@@ -329,6 +335,10 @@ app.use((req, res, next) => {
     return res.status(400).json({ error: { code: 'bad_path', message: 'path escapes the fixtures' } });
   }
 
+  if (SIGNED_OUT && apiPath === 'me') {
+    return res.status(401).json({ error: { code: 'auth_required', message: 'signed out (--signed-out)' } });
+  }
+
   // SSE live channel: emit one nudge (so "live refresh" paths run once), then
   // keep-alive comments. Pages treat this exactly like prod's stream.
   if (apiPath === 'live') {

package/src/bongos/serve-internal.js

@@ -1034,6 +1034,20 @@ function mountInternalSurfaces(app) {
     return res.redirect(302, `${isBuildersHost(req) ? '' : '/builders'}/roster${qs}`);
   });
 
+  // task 1005045 (owner decision 2026-11-03, idea 1001310): the owner's Market Watch
+  // settings left their own page (task 1004938) for an owner-only Settings tab on
+  // /market-watch, so the sidebar says "Market Watch" once. The old URL lands on that
+  // tab; 302 for the same reason as the directory above, and no page gate: the redirect
+  // discloses nothing, /market-watch has its own, and the settings routes are the wall.
+  const RETIRED_MW_SETTINGS_RE = /^\/builders\/market-watch-settings(?:\.html)?\/?$/;
+  app.use((req, res, next) => {
+    if (isModuleSurfaceHost(req)) return next();
+    if (req.method !== 'GET' && req.method !== 'HEAD') return next();
+    if (!RETIRED_MW_SETTINGS_RE.test(path.posix.normalize(req.path))) return next();
+    const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
+    return res.redirect(302, `${isBuildersHost(req) ? '' : '/builders'}/market-watch${qs}#settings`);
+  });
+
   // /deploy EXISTS ONLY WHERE THE DOOR DOES (task 1004296). The owner, 2026-09-25: /deploy is
   // "only for bongos builders hall itself, not for all production ones". Every datum and
   // both acts on that page are provisioning-module routes, so a hall that does not run the
@@ -1308,13 +1322,13 @@ function mountInternalSurfaces(app) {
   // Claude works for them. Every read behind it is the viewer's own and
   // requireBuilder (GET /me and its /me/* prefs, /specialities), so sign-in is the
   // whole gate; the governing reads it adds are gated by their own routes.
-  // tasks 1004921 `ai-studio` (the viewer's own routes), 1004938 `market-watch-settings` (no data; owner-only routes).
+  // task 1004921 `ai-studio` (the viewer's own routes).
   const SIGNEDIN_BUILDERS_PAGE_RE =
-    /^\/builders\/(?:work|settings|atlas|modules|goals|goal-map|roadmap|copy-desk|studio|ai-studio|tweak-editor|ideas|thinking|collab|task|idea|primer(?:\.md)?|diagrams|my-agents|market-watch-settings|commands)(?:\.html)?\/?$/;
+    /^\/builders\/(?:work|settings|atlas|modules|goals|goal-map|roadmap|copy-desk|studio|ai-studio|tweak-editor|ideas|thinking|collab|task|idea|primer(?:\.md)?|diagrams|my-agents|commands)(?:\.html)?\/?$/;
   // The diagram image assets under /builders/diagrams/ ride the same tier as the
   // page that embeds them.
   const SIGNEDIN_BUILDERS_PREFIX_RE = /^\/builders\/diagrams\//;
-  const MARKET_WATCH_PAGE_RE = /^\/builders\/market-watch(?:-[a-z]+)?(?:\.html)?\/?$/; // task 1004941: every read behind them is requireBuilder
+  const MARKET_WATCH_PAGE_RE = /^\/builders\/market-watch(?:-(?:item|rules))?(?:\.html)?\/?$/; // task 1004941: every read behind them is requireBuilder
   app.use((req, res, next) => {
     if (isModuleSurfaceHost(req)) return next();
     // Cheap early-out: only /builders/* paths can ever be gated, so skip the

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.30'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.31'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');