@bongos/core 1.19.544 → 1.19.546

package/scripts/gds/spike-task-map.js

@@ -139,24 +139,160 @@ function buildSynthetic({ nodes, goals, density, seed = 1003282 }) {
   return tasks;
 }
 
+// depIdsOf — the dependency ids on one row of a real dump, whatever the API called
+// them. This is load-bearing and was WRONG until task 1003477: `GET /tasks?include=deps`
+// answers with `blocked_by` (an array of {id,title,status,goal_id,satisfied} — see
+// db.attachTaskDepSummaries), and this loader only ever looked for `dependencies`/`deps`.
+// A real dump therefore parsed as a corpus with ZERO edges, and every --from number
+// would have described an empty graph while looking perfectly plausible — the exact
+// failure a spike must not have, because nothing about the output says "no edges here
+// because the field was misnamed". All three spellings are accepted now, and each may
+// hold bare ids or objects carrying one.
+function depIdsOf(row) {
+  // First NON-EMPTY array wins, not the first field present: a dump carrying both an
+  // empty `blocked_by` and a populated `dependencies` would otherwise read as edgeless,
+  // which is the same silent zero this function was written to stop.
+  const raw = [row.blocked_by, row.dependencies, row.deps]
+    .find((v) => Array.isArray(v) && v.length > 0) || [];
+  return raw
+    .map((d) => Number(d && typeof d === 'object' ? d.id : d))
+    .filter(Number.isFinite);
+}
+
 // loadReal — the same shape from a real `GET /tasks?include=deps` dump, so the next
 // session with DB access can replace every synthetic number in the verdict with a
 // measured one by re-running with --from.
+//
+// GOALS: a task with no goal does NOT share a bucket with the other ungoaled tasks —
+// "no goal" is not a goal they have in common, and pooling them would silently turn
+// every dependency between two ungoaled tasks into a WITHIN-goal edge, understating
+// the one number this loader exists to produce. Each gets its own bucket instead;
+// `goalId: null` marks them so census() can report them apart from real goals.
 function loadReal(file) {
   const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
   const rows = Array.isArray(raw) ? raw : (raw.tasks || raw.rows || []);
   const goalIndex = new Map();
+  let nextBucket = 0;
   return rows.map((r) => {
-    const g = r.goal_id == null ? '__none__' : String(r.goal_id);
-    if (!goalIndex.has(g)) goalIndex.set(g, goalIndex.size);
+    const gid = r.goal_id == null || r.goal_id === '' ? null : String(r.goal_id);
+    let bucket;
+    if (gid === null) {
+      bucket = nextBucket++;                      // ungoaled: a bucket of one
+    } else {
+      if (!goalIndex.has(gid)) goalIndex.set(gid, nextBucket++);
+      bucket = goalIndex.get(gid);
+    }
     return {
       id: Number(r.id),
-      goal: goalIndex.get(g),
-      deps: (r.dependencies || r.deps || []).map(Number).filter(Number.isFinite),
+      goal: bucket,
+      goalId: gid,
+      deps: depIdsOf(r),
     };
   });
 }
 
+// census — THE TWO NUMBERS task 1003477 exists to measure, plus the three that decide
+// what they mean. ADR 0227 deferred items 3 (the goal graph) and 4 (the dependency
+// forest) on a SYNTHETIC density sweep and said the live corpus must settle them.
+//
+//   with_dependency_pct — the share of tasks carrying at least one dependency row.
+//                         Item 4's question: is there a forest, or is the corpus
+//                         confetti? Note this is OUT-degree (what a task waits on),
+//                         not the degree-0 count the table's `isol%` reports — a task
+//                         that only BLOCKS others declares no row of its own but is
+//                         still drawn, so the two numbers differ and mean different
+//                         things.
+//   cross_goal_pct      — the share of dependency edges whose two ends sit in
+//                         different goals. Item 3's question: does the goal graph
+//                         have EDGES, or is it forty disconnected dots?
+//
+// And what turns those into a verdict: how many goals are left with no cross-goal edge
+// at all (isolated dots a node-link layout has nothing to say about), how many separate
+// components the forest breaks into, and how big the typical one is — a forest of 128
+// four-node trees is a drill-down, not a map, however many edges it contains.
+function census(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const edges = [];
+  let withDep = 0;
+  for (const t of tasks) {
+    const live = t.deps.filter((d) => byId.has(d));
+    if (t.deps.length > 0) withDep += 1;
+    for (const d of live) edges.push([t.id, d]);
+  }
+
+  let crossGoal = 0;
+  let touchingUngoaled = 0;
+  const goalPairs = new Set();
+  const goalsWithEdge = new Set();
+  for (const [a, b] of edges) {
+    const ga = byId.get(a).goalId;
+    const gb = byId.get(b).goalId;
+    if (ga === null || gb === null) { touchingUngoaled += 1; continue; }
+    if (ga === gb) continue;
+    crossGoal += 1;
+    goalPairs.add(`${ga}>${gb}`);
+    goalsWithEdge.add(ga);
+    goalsWithEdge.add(gb);
+  }
+
+  const realGoals = new Set(tasks.map((t) => t.goalId).filter((g) => g !== null));
+  const ungoaled = tasks.filter((t) => t.goalId === null).length;
+
+  // The forest: only the tasks with an edge in either direction, and how it breaks up.
+  const degree = new Map(tasks.map((t) => [t.id, 0]));
+  for (const [a, b] of edges) {
+    degree.set(a, degree.get(a) + 1);
+    degree.set(b, degree.get(b) + 1);
+  }
+  const connected = tasks.filter((t) => degree.get(t.id) > 0).map((t) => t.id);
+  const comp = components(connected, edges);
+  const sizes = componentSizes(connected, edges);
+  const median = sizes.length ? sizes[Math.floor(sizes.length / 2)] : 0;
+
+  // THE DRILL-DOWN, which is the shape item 4 is actually scoped as ("queried when a
+  // goal is opened") — not the whole-corpus forest. Per goal: the tasks with an edge
+  // whose OTHER end sits in the same goal. Its WORST case is the number that decides
+  // the item, because a drill-down has to survive its biggest goal, not its median one.
+  const perGoal = new Map();
+  for (const [a, b] of edges) {
+    const ga = byId.get(a).goalId;
+    if (ga === null || ga !== byId.get(b).goalId) continue;
+    if (!perGoal.has(ga)) perGoal.set(ga, new Set());
+    perGoal.get(ga).add(a);
+    perGoal.get(ga).add(b);
+  }
+  const perGoalSizes = [...perGoal.values()].map((v) => v.size).sort((x, y) => y - x);
+  const perGoalMax = perGoalSizes[0] || 0;
+  const perGoalMedian = perGoalSizes.length ? perGoalSizes[Math.floor(perGoalSizes.length / 2)] : 0;
+
+  const pct = (n, d) => (d ? Number(((n / d) * 100).toFixed(2)) : 0);
+  return {
+    tasks: tasks.length,
+    edges: edges.length,
+    with_dependency: withDep,
+    with_dependency_pct: pct(withDep, tasks.length),
+    connected: connected.length,
+    connected_pct: pct(connected.length, tasks.length),
+    cross_goal: crossGoal,
+    cross_goal_pct: pct(crossGoal, edges.length),
+    edges_touching_ungoaled: touchingUngoaled,
+    goals: realGoals.size,
+    ungoaled_tasks: ungoaled,
+    goal_pairs: goalPairs.size,
+    goals_with_cross_goal_edge: goalsWithEdge.size,
+    goals_isolated: realGoals.size - goalsWithEdge.size,
+    goals_isolated_pct: pct(realGoals.size - goalsWithEdge.size, realGoals.size),
+    forest_components: comp.count,
+    forest_largest: comp.largest,
+    forest_median_component: median,
+    per_goal_forests: perGoalSizes.length,
+    per_goal_largest: perGoalMax,
+    per_goal_median: perGoalMedian,
+    // The drill-down clears the bar only if its BIGGEST goal still fits labels.
+    per_goal_largest_labels: inkBudget(perGoalMax || 1).fits_with_label,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // graph views — the literal ask, and the two shapes it could become
 // ---------------------------------------------------------------------------
@@ -223,7 +359,11 @@ function viewsOf(tasks) {
 
 // weakly-connected components, ignoring edge direction — a reader does not perceive
 // arrow direction when deciding "are these two blobs the same thing".
-function components(nodes, edges) {
+// componentSizes — the same union-find, returning the raw sizes largest-first. Split
+// out because "how many components" and "how big is the typical one" are different
+// questions: 128 components says a view is fragmented, but only the MEDIAN size says
+// whether each fragment is a readable little tree or a hairball of its own (census()).
+function componentSizes(nodes, edges) {
   const idx = new Map(nodes.map((n, i) => [n, i]));
   const parent = nodes.map((_, i) => i);
   const find = (x) => { while (parent[x] !== x) { parent[x] = parent[parent[x]]; x = parent[x]; } return x; };
@@ -238,7 +378,11 @@ function components(nodes, edges) {
     const r = find(i);
     sizes.set(r, (sizes.get(r) || 0) + 1);
   }
-  const all = [...sizes.values()].sort((a, b) => b - a);
+  return [...sizes.values()].sort((a, b) => b - a);
+}
+
+function components(nodes, edges) {
+  const all = componentSizes(nodes, edges);
   return { count: all.length, largest: all[0] || 0, singletons: all.filter((s) => s === 1).length };
 }
 
@@ -658,11 +802,34 @@ function measure(label, view, { render: doRender, file, radius = 3 } = {}) {
   };
 }
 
+// printCensus — the two gating numbers first and in words, because a reader who
+// stops after the first screen must still leave with the answer ADR 0227 asked for.
+function printCensus(c) {
+  const cg = c.goals_with_cross_goal_edge;
+  console.log('live corpus census — the numbers ADR 0227 items 3 and 4 wait on');
+  console.log(`  corpus                     ${c.tasks} tasks, ${c.goals} goals`
+    + (c.ungoaled_tasks ? `, ${c.ungoaled_tasks} task(s) with no goal` : ''));
+  console.log(`  Q1 tasks with a dependency ${c.with_dependency} (${c.with_dependency_pct}%)  → item 4, the dependency forest`);
+  console.log(`  Q2 cross-goal edges        ${c.cross_goal} of ${c.edges} (${c.cross_goal_pct}%)  → item 3, the goal graph`);
+  if (c.edges_touching_ungoaled) {
+    console.log(`     (${c.edges_touching_ungoaled} edge(s) touch a task with no goal and are counted as neither)`);
+  }
+  console.log(`  goal graph shape           ${c.goal_pairs} distinct goal pairs; ${cg} goal(s) carry an edge, `
+    + `${c.goals_isolated} isolated (${c.goals_isolated_pct}%)`);
+  console.log(`  forest shape               ${c.connected} tasks with any edge (${c.connected_pct}%) in `
+    + `${c.forest_components} components; largest ${c.forest_largest}, median ${c.forest_median_component}`);
+  console.log(`  per-goal drill-down        ${c.per_goal_forests} goal(s) have one; largest ${c.per_goal_largest}, `
+    + `median ${c.per_goal_median} — worst case ${c.per_goal_largest_labels ? 'still carries labels' : 'CANNOT carry labels'}`);
+  console.log('');
+}
+
 function main() {
   const results = [];
+  let realCensus = null;
 
   if (FROM) {
     const tasks = loadReal(path.resolve(REPO_ROOT, FROM));
+    realCensus = census(tasks);
     const v = viewsOf(tasks);
     results.push(measure('real', v.A, { render: RENDER, file: path.join(OUT_DIR, 'real-a-every-task.png') }));
     results.push(measure('real', v.B, { render: RENDER, file: path.join(OUT_DIR, 'real-b-dependency-forest.png') }));
@@ -688,13 +855,14 @@ function main() {
   }
 
   if (AS_JSON) {
-    process.stdout.write(`${JSON.stringify({ canvas: [CANVAS_W, CANVAS_H], nodes: N_TASKS, goals: N_GOALS, results }, null, 2)}\n`);
+    process.stdout.write(`${JSON.stringify({ canvas: [CANVAS_W, CANVAS_H], nodes: N_TASKS, goals: N_GOALS, census: realCensus, results }, null, 2)}\n`);
     return;
   }
 
   const pad = (s, n) => String(s).padEnd(n);
   const rpad = (s, n) => String(s).padStart(n);
-  console.log(`task-network-map spike — ${N_TASKS} tasks over ${N_GOALS} goals, drawn at ${CANVAS_W}×${CANVAS_H}`);
+  if (realCensus) printCensus(realCensus);
+  console.log(`task-network-map spike — ${realCensus ? realCensus.tasks : N_TASKS} tasks over ${realCensus ? realCensus.goals : N_GOALS} goals, drawn at ${CANVAS_W}×${CANVAS_H}`);
   console.log(`ink floor: a legible dot needs ${MIN_DOT_PITCH}px of pitch; a label needs ${MIN_LABEL_W}×${MIN_LABEL_H}px `
     + `(${inkBudget(1).labels_that_fit} labels fit on this canvas, total)`);
   console.log('');
@@ -725,6 +893,7 @@ if (require.main === module) main();
 // alpha-blend bug would quietly corrupt the evidence rather than fail loudly.
 // Exported = coverable; see tests/spike_task_map.mjs.
 module.exports = {
-  buildSynthetic, viewsOf, components, layout, crossingCount, inkBudget, mulberry32,
+  buildSynthetic, loadReal, depIdsOf, census, viewsOf, components, componentSizes,
+  layout, crossingCount, inkBudget, mulberry32,
   crc32, chunk, writePng, canvas, goalColor, render,
 };

package/src/bongos/serve-internal.js

@@ -1033,7 +1033,7 @@ function mountInternalSurfaces(app) {
   // any-builder and scoped to the caller by the SERVER (GET /help-requests/for-me
   // derives crafts from the viewer's own profile), so signed-in is the right floor.
   const SIGNEDIN_BUILDERS_PAGE_RE =
-    /^\/builders\/(?:work|pair|settings|atlas|modules|goals|roadmap|copy-desk|ideas|collab|primer(?:\.md)?|diagrams)(?:\.html)?\/?$/;
+    /^\/builders\/(?:work|pair|settings|atlas|modules|goals|roadmap|copy-desk|studio|ideas|collab|primer(?:\.md)?|diagrams)(?:\.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\//;

package/src/module-api.js

@@ -49,7 +49,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.544'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.546'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/hall_kit_charts.mjs

@@ -623,3 +623,62 @@ test('CAL: the grid gets its own horizontal strip — it never widens the docume
   const html = kit.calendarGridHtml([{ local_date: '2026-09-03', count: 1 }], { today: '2026-09-03' });
   assert.match(html, /kit-cal__scroll/, 'the wide grid scrolls inside its own strip');
 });
+
+// --- task 1003583: the summary and the caption must describe the DRAWN window ------
+
+test('CAL: a narrowed window is described as weeks, not as "the last year"', () => {
+  // The bug: the default aria summary hardcoded "over the last year" whatever
+  // opts.weeks said, so a caller asking for six weeks was handed a label describing
+  // fifty-three.
+  const html = kit.calendarGridHtml([{ local_date: '2026-09-03', count: 2 }], { today: '2026-09-03', weeks: 6 });
+  assert.match(html, /over the last 6 weeks/, 'the aria summary still claims a year');
+  assert.doesNotMatch(html, /over the last year/);
+});
+
+test('CAL: a one-week window says "week", and the full window still says "the last year"', () => {
+  const one = kit.calendarGridHtml([{ local_date: '2026-09-03', count: 1 }], { today: '2026-09-03', weeks: 1 });
+  assert.match(one, /over the last 1 week:/, 'singular grammar');
+  const full = kit.calendarGridHtml([{ local_date: '2026-09-03', count: 1 }], { today: '2026-09-03', weeks: 53 });
+  assert.match(full, /over the last year/, 'the 53-week window is a year and should read like one');
+});
+
+test('CAL: the summary counts only the days the grid actually draws', () => {
+  // 2026-09-03 is a Thursday, so a 2-week grid starts at Sunday 2026-08-23. A ship on
+  // 2026-08-01 is real history the caller supplied, but it is off this picture, and it
+  // used to be counted in this picture's summary anyway.
+  const days = [
+    { local_date: '2026-08-01', count: 4 },   // before the first column
+    { local_date: '2026-08-30', count: 2 },   // inside
+    { local_date: '2026-09-03', count: 1 },   // inside
+  ];
+  const html = kit.calendarGridHtml(days, { today: '2026-09-03', weeks: 2 });
+  assert.match(html, /3 ships across 2 days/, 'the out-of-window day leaked into the summary');
+});
+
+test('CAL: calendarWindow is the one source of truth the caller reads too', () => {
+  // profile-charts.js used to recompute "N days shipped" with its own filter over the
+  // whole array; it now reads activeDays from here, so the caption and the picture
+  // cannot disagree.
+  const days = [
+    { local_date: '2026-08-01', count: 4 },
+    { local_date: '2026-08-30', count: 2 },
+    { local_date: '2026-09-03', count: 1 },
+  ];
+  const opts = { today: '2026-09-03', weeks: 2 };
+  const win = kit.calendarWindow(days, opts);
+  assert.equal(win.activeDays, 2);
+  assert.equal(win.totalShips, 3);
+  assert.equal(win.weeks, 2);
+  // The window's own bounds are what the grid iterates, so the naive filter the caller
+  // used to run disagrees with it — which is exactly the bug.
+  assert.notEqual(days.filter((d) => d.count > 0).length, win.activeDays);
+  const html = kit.calendarGridHtml(days, opts);
+  assert.match(html, new RegExp(`across ${win.activeDays} days`), 'grid and window disagree');
+});
+
+test('CAL: calendarWindow returns null on nothing to draw, matching the grid empty state', () => {
+  assert.equal(kit.calendarWindow([], {}), null);
+  assert.equal(kit.calendarWindow(null, {}), null);
+  assert.equal(kit.calendarWindow([{ local_date: '2026-09-03', count: 0 }], {}), null,
+    'a zero-count day is not a ship day');
+});

package/tests/hall_nav.mjs

@@ -149,7 +149,12 @@ test('sidebar groups read by audience, in order', () => {
   // pages followed by the two CRAFT surfaces side by side: the ideator's queue and
   // the artist's. Same reasoning as copy-desk for why it is here rather than Docs
   // (a place you act, not reference material) or You (its subject is the project).
-  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'work', 'ideas', 'copy-desk'],
+  // task 1003117 (R06 of goal 1000074): 'studio' — the Studio, artist mode —
+  // joins the same group AFTER copy-desk, so the two artist surfaces (the calm
+  // room and the flag table) sit side by side, both with the project's own work
+  // rather than in Docs (reference) or You (a person). Pinning the order keeps a
+  // new tab in the hall's most valuable nav real estate a reviewed decision.
+  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'work', 'ideas', 'copy-desk', 'studio'],
     'the unlabeled group is the project itself (task 1002425 order)');
   assert.deepEqual(nav[1].items.map((i) => i.id), ['standing', 'profile'], 'You = your own numbers');
   // People (task 1002577): the /scouting directory graduated into the hall.

package/tests/hall_page_gate_map.mjs

@@ -52,6 +52,11 @@ const ORACLE = {
   // every rank by design, and collab's reads (task 1003172) are scoped to the
   // caller by the server — so for all three, sign-in IS the whole gate.
   '/builders/copy-desk': 'requireBuilderPage',
+  // task 1003117 (R06 of goal 1000074): the Studio (artist mode) — open to every
+  // rank like copy-desk (an artist is a craft, not a rank), so sign-in is the
+  // whole gate, and its two reads (GET /tasks, GET /copy-desk/queue) already gate
+  // themselves server-side.
+  '/builders/studio': 'requireBuilderPage',
   '/builders/ideas': 'requireBuilderPage',
   '/builders/collab': 'requireBuilderPage',
   // task 1002710: the orientation reading rooms moved DOWN to this tier from

package/tests/hall_studio_world.mjs

@@ -0,0 +1,143 @@
+// tests/hall_studio_world.mjs — the Studio (artist mode), R06 of goal 1000074
+// (task 1003117). The surface's load-bearing invariants, pinned so a later edit
+// cannot quietly turn the calm room back into a form or a write path.
+//
+// hall_audit.mjs already holds this page to the universal rules (style.css +
+// shell.js present, no colour literal, no page-declared pack var, no bespoke
+// pager/chart, no sideways-scroll style). hall_nav.mjs pins the nav entry and
+// hall_page_gate_map.mjs the sign-in gate. What is left, and lives here, is what
+// only the Studio must be true: it writes nothing, it gates nothing, it is a
+// room and not a table, and it IS the artist mode it claims to be.
+//
+// Pure file-read (no DB/network) — runs in the DB-free unit gate.
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+
+const HTML = read('studio.html');
+// Comments legitimately mention markup (e.g. "the page's one <h1>"), so strip
+// them before counting tags — the invariant is about the rendered DOM, not prose.
+const HTML_NC = HTML.replace(/<!--[\s\S]*?-->/g, '');
+const JS = read('studio.js');
+const CSS = read('studio.css');
+
+test('the Studio writes NOTHING — the goal\'s no-live-CMS rule, at the surface', () => {
+  // Every craft act (coach the grader, remake copy, propose wording) happens on
+  // the surface that owns it (the task record, the copy desk) as a claimed,
+  // graded, shipped task. This room only READS and ROUTES. A POST/PATCH/DELETE
+  // here would be the live-CMS write path the goal forbids (criterion
+  // artist-edits-land-as-tasks) — so it must not exist.
+  const writes = JS.match(/\.request\(\s*['"](POST|PATCH|PUT|DELETE)['"]/g) || [];
+  assert.deepEqual(writes, [], `studio.js must issue no writes; found ${writes.join(', ')}`);
+});
+
+test('the reviews read is bounded and correct', () => {
+  // Review requests (cascade.js) are filed at backlog, discipline artist. They sit
+  // there until dismissed and cascade files one per qualifying ship, so the read
+  // MUST carry a limit cap — the unbounded-read shape modules/hall-ui/CLAUDE.md
+  // flags as a repeat bug. Assert the actual bound, not just the filter, so the
+  // test name does not overclaim.
+  assert.match(JS, /\/tasks\?discipline=artist&status=backlog&limit=\$\{REVIEW_LIMIT\}/, 'the backlog artist read carries a limit cap');
+  assert.match(JS, /const REVIEW_LIMIT = \d+;/, 'the cap is a named, finite constant');
+  assert.match(JS, /source === 'cascade'/, 'and rows are filtered to the cascade (review) source');
+});
+
+test('the copy-desk read is best-effort — the room degrades, never errors', () => {
+  // An instance without the copy-desk module 404s /copy-desk/queue; the Studio
+  // must fall back to reviews alone, so the flags loader returns [] on !ok rather
+  // than throwing or blanking the room.
+  assert.match(JS, /copy-desk\/queue\?status=open/, 'flags come from the open copy-desk queue');
+  assert.match(JS, /if \(!res\.ok\) return \[\];/, 'a failed queue read yields no flags, not an error');
+});
+
+test('it is artist mode — the room declares the mode marker', () => {
+  // The social-mode pattern (shell.js applySocial): the mode rides an attribute
+  // on the document root, set here statically so entering the room IS entering
+  // the mode with no paint flash. Losing it makes this just another page.
+  assert.match(HTML, /<html[^>]*\bdata-artist="on"/, 'the page declares data-artist="on" on <html>');
+});
+
+test('one <main>, one <h1> — the greeting is it', () => {
+  // one-header-main-h1, checked here in the static markup so every state (incl.
+  // the no-JS fallback) keeps the single heading.
+  const h1s = HTML_NC.match(/<h1\b/g) || [];
+  assert.equal(h1s.length, 1, 'exactly one <h1>');
+  assert.match(HTML_NC, /<h1[^>]*id="studio-greet"/, 'the greeting is the page h1');
+});
+
+test('a room, not a table — no tabular markup', () => {
+  // The criterion is explicit: "rather than another table of rows". The copy
+  // desk is the table; the Studio must not become a second one.
+  assert.ok(!/<table\b/.test(HTML_NC) && !/<table\b/.test(JS), 'the Studio renders no <table>');
+});
+
+test('the accent is spent only where the rule allows', () => {
+  // DESIGN.md's One Warm Thing Rule: the accent lights the pressable (the primary
+  // action, .btn-accent, which the shell owns) or the LIVE. The one warm thing
+  // this sheet paints is the ambient lamp (an accent wash), documented as the
+  // room's live light; nothing else in studio.css may fill from the accent.
+  const accentFills = CSS.match(/background:\s*[^;]*var\(--accent\)[^;]*;/g) || [];
+  assert.ok(accentFills.length <= 1, `studio.css spends the accent on at most the lamp; found ${accentFills.length}`);
+});
+
+// Boot the real shell.js under a DOM stub (the hall_nav.mjs pattern) whose
+// #nav-studio records classList toggles, so applyCraftEmphasis is tested for
+// what it DOES, not just that it exists.
+function bootShell() {
+  const src = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
+  const makeEl = () => {
+    const classes = new Set();
+    return {
+      dataset: {}, style: {}, title: '', textContent: '', hidden: false, _classes: classes,
+      set innerHTML(_v) {}, get innerHTML() { return ''; },
+      classList: {
+        add: (c) => classes.add(c), remove: (c) => classes.delete(c),
+        toggle: (c, on) => { const want = on === undefined ? !classes.has(c) : !!on; if (want) classes.add(c); else classes.delete(c); return want; },
+        contains: (c) => classes.has(c),
+      },
+      setAttribute() {}, getAttribute() { return null; }, removeAttribute() {},
+      addEventListener() {}, querySelectorAll() { return []; }, appendChild() {}, focus() {},
+    };
+  };
+  const els = new Map();
+  const getEl = (id) => { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); };
+  const document = {
+    body: { dataset: { page: 'studio' } },
+    documentElement: getEl('__html__'),
+    getElementById: getEl,
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {}, dispatchEvent() {}, get cookie() { return ''; }, set cookie(_v) {},
+  };
+  const location = { hostname: 'builders.cloudbongos.com', origin: 'https://builders.cloudbongos.com', pathname: '/studio', hash: '', assign() {}, replace() {} };
+  const window = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => ({ request: () => new Promise(() => {}) }) },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage: { getItem() { return null; }, setItem() {} },
+    requestAnimationFrame() {}, scrollTo() {}, location, addEventListener() {},
+  };
+  const sandbox = { window, document, location, console, setTimeout, clearTimeout, CustomEvent: class {} };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(src, sandbox, { filename: 'shell.js' });
+  return { applyAccess: window.OTBShell.applyAccess, navStudio: () => getEl('nav-studio') };
+}
+
+test('the Studio nav entry is warmed only for an artist-craft builder', () => {
+  const { applyAccess, navStudio } = bootShell();
+
+  applyAccess({ authed: true, rank: 'archon', builder: { display_name: 'Artist A', preferred_disciplines: ['artist', 'ideator'] } });
+  assert.ok(navStudio()._classes.has('nav-item--craft'), 'an artist-craft builder gets the warmed entry');
+
+  applyAccess({ authed: true, rank: 'archon', builder: { display_name: 'Eng E', preferred_disciplines: ['engineer'] } });
+  assert.ok(!navStudio()._classes.has('nav-item--craft'), 'and a non-artist builder does not (the class is toggled off)');
+});

package/tests/skill_lint.mjs

@@ -3,6 +3,8 @@
 import { strict as assert } from 'node:assert';
 import { test } from 'node:test';
 import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -58,11 +60,58 @@ test('no frontmatter at all is an error', () => {
   assert.equal(run('# Title\n\nBody.\n').errors.length, 1);
 });
 
-test('the hook path filter matches only .claude/skills/<name>/SKILL.md', () => {
+test('the hook path filter matches a SKILL.md in either home — .claude/skills/ or a module (task 1003587)', () => {
   assert.ok(lint.isSkillMd('C:\\repo\\.claude\\skills\\dev\\SKILL.md'));
   assert.ok(lint.isSkillMd('/repo/.claude/skills/dev/SKILL.md'));
+  // The module copy is the file a builder EDITS; .claude/skills/ holds the generated
+  // copy, so a hook that only watched the tracked root never saw the real edit.
+  assert.ok(lint.isSkillMd('/repo/modules/ui-design/skills/dev/SKILL.md'));
+  assert.ok(lint.isSkillMd('C:\\repo\\modules\\ui-design\\skills\\vendor\\dev\\SKILL.md'));
   assert.ok(!lint.isSkillMd('/repo/.claude/skills/dev/notes.md'));
-  assert.ok(!lint.isSkillMd('/repo/modules/ui-design/skills/dev/SKILL.md'));
+  assert.ok(!lint.isSkillMd('/repo/modules/ui-design/skills/dev/notes.md'));
+  assert.ok(!lint.isSkillMd('/repo/docs/skills/dev/SKILL.md'));
+});
+
+// A fixture root, because a real dev checkout may or may not have materialized its
+// module skills into .claude/skills/ (claude-materialize.js, task 1003330) and the
+// lister's contract must hold either way.
+function fixtureRoot(files) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-lint-'));
+  for (const [rel, body] of Object.entries(files)) {
+    const abs = path.join(root, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, body);
+  }
+  return root;
+}
+
+test('the lister reaches module-owned skills, and a core copy of the same name wins (task 1003587)', () => {
+  const skill = fm('>-\n  A description long enough for the harness to route on, written as a block scalar.');
+  const root = fixtureRoot({
+    '.claude/skills/only-core/SKILL.md': skill,
+    '.claude/skills/both/SKILL.md': skill,
+    'modules/ui-design/skills/both/SKILL.md': skill,
+    'modules/ui-design/skills/only-module/SKILL.md': skill,
+    'modules/ui-design/skills/vendor/vendored/SKILL.md': skill,
+    'modules/ui-design/skills/README.md': '# not a skill\n',
+  });
+  const files = lint.listSkillFiles(root).map((f) => path.relative(root, f).replace(/\\/g, '/'));
+  assert.deepEqual(files.sort(), [
+    '.claude/skills/both/SKILL.md',
+    '.claude/skills/only-core/SKILL.md',
+    'modules/ui-design/skills/only-module/SKILL.md',
+    'modules/ui-design/skills/vendor/vendored/SKILL.md',
+  ], 'a module skill is linted at its source; a name already in .claude/skills/ is not counted twice');
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+test('every module-owned skill this repo ships parses too — the 14 that did not on 2026-09-04 (task 1003587)', () => {
+  const dir = path.join(ROOT, 'modules', 'ui-design', 'skills');
+  const files = lint.listSkillFiles(ROOT).filter((f) => f.startsWith(dir) || fs.existsSync(path.join(dir, path.basename(path.dirname(f)), 'SKILL.md')));
+  assert.ok(files.length >= 14, `the ui-design module ships 14+ skills; found ${files.length}`);
+  const report = lint.lintSkills(files);
+  const broken = report.results.filter((r) => r.errors.length).map((r) => path.relative(ROOT, r.file) + ': ' + r.errors.join('; '));
+  assert.deepEqual(broken, [], broken.join('\n'));
 });
 
 test('every committed skill parses (the ten that did not on 2026-09-03 must stay fixed)', () => {

package/tests/ui_design_skills.mjs

@@ -34,14 +34,24 @@ const policy = readJson(path.join(SKILLS, 'policy.json'));
 const manifest = readJson(path.join(MODULE, 'module.json'));
 const materialize = require(path.join(ROOT, 'scripts', 'gds', 'claude-materialize.js'));
 
-// Minimal YAML-frontmatter reader: `key: value` lines between the first two `---` fences.
+// Minimal YAML-frontmatter reader: `key: value` lines between the first two `---`
+// fences, plus folded block scalars (`key: >-` then the text indented), which is the
+// only safe way to write a description carrying a colon-space (task 1003587) — a plain
+// scalar with ": " in it makes Claude Code's YAML reader drop EVERY field silently.
 function frontmatter(text) {
   const m = text.match(/^---\n([\s\S]*?)\n---\n/);
   const out = {};
   if (!m) return out;
+  let block = null; // the key whose folded value the indented lines below belong to
   for (const line of m[1].split('\n')) {
     const kv = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
-    if (kv) out[kv[1]] = kv[2].replace(/^["']|["']$/g, '').trim();
+    if (kv) {
+      const v = kv[2].trim();
+      block = /^[>|][+-]?\d*$/.test(v) ? kv[1] : null;
+      out[kv[1]] = block ? '' : v.replace(/^["']|["']$/g, '').trim();
+      continue;
+    }
+    if (block && /^\s+\S/.test(line)) out[block] = (out[block] ? out[block] + ' ' : '') + line.trim();
   }
   return out;
 }