@bongos/core 1.19.478 → 1.19.480

package/tests/ui_design_skills.mjs

@@ -8,7 +8,13 @@
 // 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.
+// mandate, and the preamble copies proven not to be doc-entropy debt. Since task 1003327
+// (ADR 0230) it also pins the four LOOKS: each names the style-library entry it was tuned
+// against, declares no colour of its own outside the legal black/white carve-out, adds no
+// face, and keeps the translations that ADR fixed (the archetype that still ships both modes,
+// the deterministic selection, the transcribed colour contract). Since task 1003475 (ADR
+// 0231) a module skill declares one of TWO origins - a rebuild from a spec, or first party -
+// and the origin pins branch on which; the /style session is the first original. DB-free.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { createRequire } from 'node:module';
@@ -200,6 +206,57 @@ test('the worked example of the image family is the grove specimen: the pair wit
   assert.match(design, /grove-pod\.jpg/, 'the look\'s DESIGN.md names its specimen\'s plate instead of claiming it brings none');
 });
 
+// ── the four looks (task 1003327, ADR 0230): a composition grammar, never a palette ──
+const LOOKS = ['minimalist-ui', 'industrial-brutalist-ui', 'gpt-taste', 'stitch-design-taste'];
+const LIBRARY = ['chrome-world', 'expedition', 'grove'];
+const ownRules = (name) => {
+  const pre = read(path.join(SKILLS, 'PREAMBLE.md')).trimEnd();
+  const text = read(path.join(SKILLS, name, 'SKILL.md'));
+  return text.slice(text.indexOf(pre) + pre.length);
+};
+
+test('the four looks of task 1003327 exist as in-house skills, are declared, and each names the library entry it was tuned against', () => {
+  for (const name of LOOKS) {
+    assert.ok(ownDirs.includes(name), `${name}: skills/${name}/SKILL.md exists`);
+    assert.ok(manifest.contributes.skills.includes(name), `${name}: declared in contributes.skills`);
+    const own = ownRules(name);
+    assert.ok(LIBRARY.some((look) => own.includes(`\`${look}\``)), `${name}: names a style-library entry by directory, so a builder can render the grammar under a real look`);
+    assert.match(own, /1003327/, `${name}: names the port task`);
+    assert.match(own, /ADR 0230/, `${name}: names the look-skill ADR`);
+  }
+});
+
+test('a look skill ships a grammar and no world of its own: no palette of its own, no face, the pack is the source', () => {
+  for (const name of LOOKS) {
+    const own = ownRules(name);
+    // the preamble's only legal literal is pure black or white; every other colour is a var() or a color-mix()
+    const illegal = (own.match(/#[0-9a-fA-F]{3,8}\b/g) || []).filter((h) => !/^#(0{3,8}|f{3,8})$/i.test(h));
+    assert.deepEqual(illegal, [], `${name}: a look skill declares no colour of its own (found ${illegal.join(', ')})`);
+    assert.doesNotMatch(own, /\b(add|load|install|import|declare|register)\s+(an?\s+|the\s+|a new\s+)?(@?font-face|webfont|typeface|font family|google font)/i, `${name}: a look skill adds no face; the pack's two stacks are the type system`);
+    assert.doesNotMatch(own, /https?:\/\/fonts\./i, `${name}: no font host of its own`);
+    assert.match(own, /the pack|instance's pack/i, `${name}: says the palette is the instance's pack`);
+  }
+});
+
+test('each look keeps the translation ADR 0230 fixed: the substrate is an archetype, the selection is deterministic, the document transcribes, the placeholder photography is gone', () => {
+  const brutalist = ownRules('industrial-brutalist-ui');
+  assert.match(brutalist, /the other mode/i, 'brutalist: the substrate became an archetype and the other mode still ships');
+  assert.match(brutalist, /never mixed/i, 'brutalist: the two archetypes are never mixed in one interface');
+  const gpt = ownRules('gpt-taste');
+  assert.match(gpt, /deterministic, not random/i, 'gpt-taste: the selection is deterministic, not a roll');
+  assert.match(gpt, /sibling/i, 'gpt-taste: the selection is checked against sibling surfaces');
+  const stitch = ownRules('stitch-design-taste');
+  assert.match(stitch, /transcrib/i, 'stitch: the colour contract is transcribed from the pack');
+  assert.match(stitch, /diff/i, 'stitch: the thirteen are diffed against the pack, not retyped');
+  for (const name of ['minimalist-ui', 'gpt-taste']) {
+    assert.match(ownRules(name), /seeded placeholder photograph/i, `${name}: names the upstream's seeded placeholder photography, which this port drops`);
+  }
+  const index = read(path.join(ROOT, 'docs', 'adr', 'README.md'));
+  const adr = fs.readdirSync(path.join(ROOT, 'docs', 'adr')).find((f) => f.startsWith('0230-'));
+  assert.ok(adr, 'docs/adr/0230-*.md exists');
+  assert.ok(index.includes(`](${adr})`), 'docs/adr/README.md links ADR 0230');
+});
+
 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) {
@@ -212,7 +269,7 @@ test('every in-house SKILL.md opens with the PLATFORM PREAMBLE, byte-identical t
   }
 });
 
-test('every in-house skill names its dir, carries a description, and says what it was rebuilt from instead of carrying a sidecar', () => {
+test('every in-house skill names its dir, carries a description, and declares exactly one origin: a rebuild from a spec, or first party (ADR 0231)', () => {
   const pre = read(path.join(SKILLS, 'PREAMBLE.md')).trimEnd();
   for (const name of ownDirs) {
     const dir = path.join(SKILLS, name);
@@ -221,17 +278,51 @@ test('every in-house skill names its dir, carries a description, and says what i
     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`);
+    assert.ok(!fs.existsSync(path.join(dir, 'LICENSE')), `${name}: no upstream licence text travels with an in-house skill`);
     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`);
+    const rebuilt = afterPreamble.match(/^## Rebuilt from\n([\s\S]*?)(?=\n## )/m);
+    const original = afterPreamble.match(/^## First party\n([\s\S]*?)(?=\n## )/m);
+    assert.ok(!!rebuilt !== !!original, `${name}: exactly one origin section - a rebuild carries "## Rebuilt from", an original carries "## First party"`);
+    assert.match(afterPreamble.trimStart(), /^## (Rebuilt from|First party)\n/, `${name}: the origin section is the first thing after the preamble, with nothing between`);
+    if (rebuilt) {
+      assert.match(rebuilt[1], /builders#\/task\/\d+/, `${name}: the section links the spec task`);
+      assert.match(rebuilt[1], /ADR 0198/, `${name}: the section names the vendoring policy that made it a rebuild`);
+      assert.match(rebuilt[1], /REBUILD-SPEC/, `${name}: the section names the spec`);
+      assert.match(rebuilt[1], /no upstream bytes/i, `${name}: the section states no upstream bytes were consulted or copied`);
+      assert.match(rebuilt[1], /what changed in translation/i, `${name}: the section says where the rebuild departs from the documented behaviour`);
+    } else {
+      assert.match(original[1], /builders#\/task\/\d+/, `${name}: the section links the task that authored it`);
+      assert.match(original[1], /no upstream/i, `${name}: an original states plainly that it has no upstream`);
+      assert.match(original[1], /ADR 0231/, `${name}: the section names the two-origin rule`);
+      assert.match(original[1], /why it exists/i, `${name}: an original says why it exists, since it has no spec to point at`);
+    }
+  }
+});
+
+// ── the /style session (task 1003475, ADR 0231): the module's first original skill ──
+test('the /style session is a first-party skill that runs four bounded steps and never writes the instance\'s world', () => {
+  const pre = read(path.join(SKILLS, 'PREAMBLE.md')).trimEnd();
+  assert.ok(ownDirs.includes('style'), 'skills/style/SKILL.md exists');
+  assert.ok(manifest.contributes.skills.includes('style'), 'declared in contributes.skills');
+  const text = read(path.join(SKILLS, 'style', 'SKILL.md'));
+  const own = text.slice(text.indexOf(pre) + pre.length);
+  assert.match(own, /^## First party\n/m, 'it declares itself first party, not a rebuild');
+  for (const step of ['Search', 'Create', 'Prove', 'Adopt']) {
+    assert.ok(new RegExp(`## Step \\d+ . ${step}`, 'i').test(own), `the session carries the ${step} step`);
   }
+  for (const cli of ['kit/contrast.js', 'kit/render.js', 'kit/check-mock.js', 'tests/ui_design_styles.mjs']) {
+    assert.ok(own.includes(cli), `the PROVE step names ${cli}`);
+  }
+  assert.match(own, /sixteenth token/i, 'a look that needs a sixteenth token is refused at the door');
+  assert.match(own, /never a fork of a sheet|not a fork of a sheet/i, 'a look is a pack, never a fork of a sheet');
+  assert.match(own, /does not edit `config\/branding\.json`|read, never written/i, 'adopting a look stays the owner\'s decision; the session never writes the host boundary');
+  assert.doesNotMatch(own, /bypassPermissions|--dangerously-skip-permissions/, 'no permission bypass');
+  assert.doesNotMatch(own, /\b(write|add|install|register)\b[^.\n]{0,60}\b(PostToolUse|PreToolUse|Stop)\b[^.\n]{0,40}\bhooks?\b/i, 'no step writes a hook into a harness config');
+  assert.doesNotMatch(own, /\b(curl|wget|fetch|download)\b[^.\n]{0,60}\bhttps?:\/\//i, 'no remote bundle download');
+  const index = read(path.join(ROOT, 'docs', 'adr', 'README.md'));
+  const adr = fs.readdirSync(path.join(ROOT, 'docs', 'adr')).find((f) => f.startsWith('0231-'));
+  assert.ok(adr, 'docs/adr/0231-*.md exists');
+  assert.ok(index.includes(`](${adr})`), 'docs/adr/README.md links ADR 0231');
 });
 
 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', () => {