@bongos/core 1.19.459 → 1.19.461

package/tests/ui_design_skills.mjs

@@ -4,7 +4,11 @@
 // opens with the PLATFORM PREAMBLE byte-identical to PREAMBLE.md; every name the manifest
 // contributes resolves to a real skill dir; a module-owned skill reaches a builder's
 // materialised .claude/skills with its sidecar (and not when the module is off); /design
-// lists every vendored skill by name; the policy ADR is indexed. DB-free.
+// lists every vendored skill by name; the policy ADR is indexed. Since task 1003325 (ADR
+// 0220) the same file pins the IN-HOUSE rebuilds under skills/<name>/: the same preamble
+// first and once, a `## Rebuilt from` section instead of a sidecar (the spec task, ADR
+// 0198, "no upstream bytes"), the style library named as the palette source, no image
+// mandate, and the preamble copies proven not to be doc-entropy debt. DB-free.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { createRequire } from 'node:module';
@@ -93,6 +97,85 @@ test('every vendored SKILL.md opens with the PLATFORM PREAMBLE, byte-identical t
   }
 });
 
+// ── every in-house rebuild: the preamble, the Rebuilt-from section, no sidecar (ADR 0220) ──
+const TASTE_CORE = ['design-taste-frontend', 'design-taste-frontend-v1', 'high-end-visual-design', 'redesign-existing-projects'];
+
+test('the taste core of task 1003325 exists as four in-house skills and every one is declared', () => {
+  for (const name of TASTE_CORE) {
+    assert.ok(ownDirs.includes(name), `${name}: skills/${name}/SKILL.md exists`);
+    assert.ok(manifest.contributes.skills.includes(name), `${name}: declared in contributes.skills`);
+  }
+});
+
+test('every in-house SKILL.md opens with the PLATFORM PREAMBLE, byte-identical to PREAMBLE.md, exactly once, right after its frontmatter', () => {
+  const pre = read(path.join(SKILLS, 'PREAMBLE.md')).trimEnd();
+  for (const name of ownDirs) {
+    const text = read(path.join(SKILLS, name, 'SKILL.md'));
+    const fm = text.match(/^---\n[\s\S]*?\n---\n/);
+    assert.ok(fm, `${name}: SKILL.md keeps its frontmatter first`);
+    const body = text.slice(fm[0].length).replace(/^\n+/, '');
+    assert.ok(body.startsWith(pre), `${name}: the preamble block is the first thing after the frontmatter and matches PREAMBLE.md byte for byte`);
+    assert.equal(text.split(policy.preamble.begin).length, 2, `${name}: the preamble appears exactly once`);
+  }
+});
+
+test('every in-house skill names its dir, carries a description, and says what it was rebuilt from instead of carrying a sidecar', () => {
+  const pre = read(path.join(SKILLS, 'PREAMBLE.md')).trimEnd();
+  for (const name of ownDirs) {
+    const dir = path.join(SKILLS, name);
+    const text = read(path.join(dir, 'SKILL.md'));
+    const fm = frontmatter(text);
+    assert.equal(fm.name, name, `${name}: frontmatter names its own dir`);
+    assert.ok(fm.description && fm.description.length > 80, `${name}: a description the harness can route on`);
+    assert.ok(!fs.existsSync(path.join(dir, policy.sidecar)), `${name}: an in-house skill claims no upstream, so no ${policy.sidecar}`);
+    assert.ok(!fs.existsSync(path.join(dir, 'LICENSE')), `${name}: no upstream licence text travels with a rebuild`);
+    const afterPreamble = text.slice(text.indexOf(pre) + pre.length);
+    const section = afterPreamble.match(/^## Rebuilt from\n([\s\S]*?)(?=\n## )/m);
+    assert.ok(section, `${name}: a "## Rebuilt from" section is the first thing after the preamble`);
+    assert.match(afterPreamble.trimStart(), /^## Rebuilt from\n/, `${name}: nothing sits between the preamble and the Rebuilt-from section`);
+    assert.match(section[1], /builders#\/task\/\d+/, `${name}: the section links the spec task`);
+    assert.match(section[1], /ADR 0198/, `${name}: the section names the vendoring policy that made it a rebuild`);
+    assert.match(section[1], /REBUILD-SPEC/, `${name}: the section names the spec`);
+    assert.match(section[1], /no upstream bytes/i, `${name}: the section states no upstream bytes were consulted or copied`);
+    assert.match(section[1], /what changed in translation/i, `${name}: the section says where the rebuild departs from the documented behaviour`);
+  }
+});
+
+test('every in-house skill works inside the world: the style library is the palette source, images are hero plates only, and no step mandates generating one', () => {
+  const pre = read(path.join(SKILLS, 'PREAMBLE.md')).trimEnd();
+  for (const name of ownDirs) {
+    const text = read(path.join(SKILLS, name, 'SKILL.md'));
+    const own = text.slice(text.indexOf(pre) + pre.length); // the skill's own rules, not the shared block
+    assert.ok(own.includes('modules/ui-design/styles/'), `${name}: names the style library as where a variant comes from`);
+    assert.match(own, /hero plates/i, `${name}: restates the owner's imagery rule in its own rules`);
+    assert.doesNotMatch(own, /\b(must|always|first|then)\s+generate\s+(an?\s+|the\s+)?(image|asset|photo|render)/i, `${name}: no step mandates image generation (ADR 0198's panel finding; the owner's rule)`);
+    assert.doesNotMatch(own, /\b(use|add|insert|prefer|fall back to|source)\s+(seeded\s+)?placeholder (photo|imag)/i, `${name}: no step reaches for seeded placeholder photography (naming the ban is fine; directing it is not)`);
+    assert.match(own, /Kill Switch|prefers-reduced-motion/, `${name}: its motion rules name the switch they live inside`);
+    assert.match(own, /kit\/render\.js/, `${name}: the kit's render is its pre-flight`);
+  }
+});
+
+test('the preamble copies are policy, not doc-entropy debt: the scanner skips the block and still flags a plain duplicate', () => {
+  const de = require(path.join(ROOT, 'scripts', 'gds', 'docs-entropy.js'));
+  const carriers = ['modules/ui-design/skills/PREAMBLE.md', ...ownDirs.map((n) => `modules/ui-design/skills/${n}/SKILL.md`)];
+  assert.ok(carriers.length >= 2, 'at least one own skill carries the block beside PREAMBLE.md');
+  for (const rel of carriers) assert.ok(read(path.join(ROOT, rel)).includes(policy.preamble.begin), `${rel} carries the block`);
+  const dupes = de.scanDuplicateProse(carriers);
+  assert.ok(!dupes.some((d) => d.snippet.startsWith(policy.preamble.begin)), 'the byte-identical preamble is not reported as duplicate prose');
+  // calibration: the same scanner over the same files still sees a plain paragraph twice
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-skills-dupe-'));
+  const para = 'A plain paragraph long enough to clear the scanner\'s 120-character floor, written twice so the duplicate-prose scan has something real to report.';
+  const a = path.join(tmp, 'a.md');
+  const b = path.join(tmp, 'b.md');
+  fs.writeFileSync(a, `# a\n\n${para}\n\n${read(path.join(SKILLS, 'PREAMBLE.md'))}`);
+  fs.writeFileSync(b, `# b\n\n${para}\n\n${read(path.join(SKILLS, 'PREAMBLE.md'))}`);
+  const rel = (p) => path.relative(ROOT, p).split(path.sep).join('/');
+  const control = de.scanDuplicateProse([rel(a), rel(b)]);
+  assert.equal(control.length, 1, 'the plain paragraph is flagged once');
+  assert.ok(control[0].snippet.startsWith('A plain paragraph'), 'and it is the plain paragraph, not the preamble');
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
 // ── the manifest declares what is on disk, and nothing else ─────────────────
 test('every skill the manifest contributes resolves to a skill dir (core .claude/skills or the module), and every module skill dir is declared', () => {
   const declared = manifest.contributes.skills;
@@ -145,24 +228,31 @@ test('a module-owned skill lands in a materialised .claude/skills with its sidec
 });
 
 // ── the doors: /design lists them, the README rosters them, the ADR is indexed ──
-test('/design lists every vendored skill by name, one line each, and names the playwright plugin as a prerequisite', () => {
+test('/design lists every module skill (vendored or in-house) by name, one line each, and names the playwright plugin as a prerequisite', () => {
   const design = read(path.join(ROOT, '.claude', 'skills', 'design', 'SKILL.md'));
-  for (const name of vendoredDirs) {
+  for (const name of [...vendoredDirs, ...ownDirs]) {
     const line = design.split('\n').find((l) => l.includes(`\`/${name}\``) || l.includes(`**${name}**`));
     assert.ok(line, `/design names ${name} on a line of its own`);
   }
   assert.match(design, /playwright/i, '/design names the playwright plugin');
 });
 
-test('the skills README rosters every vendored skill and every rebuild spec by name', () => {
+test('the skills README and the module CLAUDE.md roster every module skill by name', () => {
   const readme = read(path.join(SKILLS, 'README.md'));
-  for (const name of vendoredDirs) assert.ok(readme.includes(`\`${name}\``), `README rosters ${name}`);
+  const claude = read(path.join(MODULE, 'CLAUDE.md'));
+  for (const name of [...vendoredDirs, ...ownDirs]) {
+    assert.ok(readme.includes(`\`${name}\``), `README rosters ${name}`);
+    assert.ok(claude.includes(`\`${name}\``), `modules/ui-design/CLAUDE.md names ${name}`);
+  }
   assert.ok(readme.includes('policy.json') && readme.includes('PREAMBLE.md') && readme.includes('PROVENANCE.md'));
+  assert.ok(readme.includes('Rebuilt from'), 'the README says what a rebuild carries instead of a sidecar');
 });
 
-test('the vendoring policy ADR exists and is indexed', () => {
-  const adr = fs.readdirSync(path.join(ROOT, 'docs', 'adr')).find((f) => /^0198-/.test(f));
-  assert.ok(adr, 'docs/adr/0198-*.md exists');
+test('the vendoring-policy ADR and the in-house-rebuild ADR exist and are indexed', () => {
   const index = read(path.join(ROOT, 'docs', 'adr', 'README.md'));
-  assert.ok(index.includes(`](${adr})`), 'docs/adr/README.md links the ADR');
+  for (const n of ['0198', '0220']) {
+    const adr = fs.readdirSync(path.join(ROOT, 'docs', 'adr')).find((f) => f.startsWith(`${n}-`));
+    assert.ok(adr, `docs/adr/${n}-*.md exists`);
+    assert.ok(index.includes(`](${adr})`), `docs/adr/README.md links ADR ${n}`);
+  }
 });