@struq/skill 0.5.2 → 0.5.3

package/skills/struq/scripts/film-check.mjs

@@ -18,6 +18,18 @@ export const FILM_RULES = [
     title: 'The plan carries a treatment',
     fix: 'Write the treatment head in STRUQ.md: Idea, Language, Motif, Lexicon, Centerpiece, Tone arc and a numbered Storyboard with one line per scene.',
   },
+  {
+    id: 'uncast-slot',
+    severity: 'fail',
+    title: 'Every scene is cast',
+    fix: 'Replace every <cast: ...> and <loud|quiet> the arc printed (blocks.mjs arc, or the treatment struq_richting returns) with one pick and its reason after "because", chosen from the Idea and the Motif, and delete the options list.',
+  },
+  {
+    id: 'no-unlike',
+    severity: 'warn',
+    title: 'The plan says what it is unlike',
+    fix: 'Add an Unlike: line under the Idea: the likeliest site for this brief, and Struq\'s own reflex (a framed photo with the name beside it, growing to full screen), then what this site does instead. Cast the Opening and the Centerpiece against it.',
+  },
   {
     id: 'one-centerpiece',
     severity: 'fail',
@@ -639,7 +651,10 @@ function holdBudgets(add, { used, scenes, extraOwn, treatment, planned, routes,
   // FAIL
 
   const centerpieces = used.filter((block) => block.role === 'centerpiece');
-  if (centerpieces.length === 0) add('one-centerpiece', 1, `No centerpiece on the ${where}.`);
+  // The plan's Centerpiece line may name an own scene ("Centerpiece: own scene ..."). The storyboard shows it in its
+  // slot; the built page cannot tell an own scene's role, so there a plan that names own needs no centerpiece block.
+  const ownCenter = planned && treatment.centerpiece === 'own';
+  if (centerpieces.length === 0 && !(ownCenter && where === 'page')) add('one-centerpiece', 1, `No centerpiece on the ${where}.`);
   else if (centerpieces.length > 1) {
     add('one-centerpiece', centerpieces.length, `${plural(centerpieces.length, 'centerpiece')}: ${list(centerpieces)}.`);
   }
@@ -691,7 +706,7 @@ function holdBudgets(add, { used, scenes, extraOwn, treatment, planned, routes,
   if (planned) {
     const named = treatment.centerpiece;
     if (!named) add('centerpiece-is-planned', 1, 'The plan has no Centerpiece line.');
-    else if (!centerpieces.some((block) => block.slug === named)) {
+    else if (ownCenter ? centerpieces.some((block) => !block.own) : !centerpieces.some((block) => block.slug === named)) {
       const onPage = centerpieces.length ? `the ${where} has ${list(centerpieces)}` : `it is not on the ${where}`;
       add('centerpiece-is-planned', 1, `The plan names ${named}; ${onPage}.`);
     }
@@ -903,6 +918,12 @@ export function planCheck({ plan, catalog, routes = 1 } = {}) {
   }
   const planned = treatment.hasLanguage;
   if (!planned) add('no-treatment', 1, missingTreatment(treatment));
+  // The arc is printed with no picks on purpose (2026-11-14); a slot left as printed was never cast.
+  const uncast = treatment.storyboard
+    .map((text, at) => (/<cast\b|<loud\|quiet>/i.test(text) ? at + 1 : 0))
+    .filter(Boolean);
+  if (uncast.length) add('uncast-slot', uncast.length, `Scene ${uncast.join(', ')} still ${uncast.length === 1 ? 'reads' : 'read'} as the arc printed ${uncast.length === 1 ? 'it' : 'them'}.`);
+  if (!/^Unlike:\s*\S/m.test(String(plan ?? ''))) add('no-unlike', 1, 'The plan has no Unlike: line.');
 
   const count = treatment.storyboard.length;
   if (count < SCENE_MIN || count > SCENE_MAX) {
@@ -958,6 +979,9 @@ export function planCheck({ plan, catalog, routes = 1 } = {}) {
       });
     }
     if (line.own) {
+      // An own scene in the Centerpiece slot is the centerpiece: the hand deals one centerpiece since 2026-11-15, and
+      // when it does not fit the brief the agent builds its own (release proof saas: film-strip for an invoicing app).
+      const center = /^centerpiece$/i.test((line.name || '').trim());
       used.push({
         scene,
         tone: line.tone,
@@ -966,11 +990,11 @@ export function planCheck({ plan, catalog, routes = 1 } = {}) {
         slug: null,
         variant: null,
         kind: 'own-scene',
-        role: 'scene',
+        role: center ? 'centerpiece' : 'scene',
         home: null,
         motif: null,
         metaphor: null,
-        energy: 1,
+        energy: center ? 3 : 1,
         pins: false,
         scroll: 0,
         fullBleed: false,

package/skills/struq/scripts/gate.mjs

@@ -16,10 +16,20 @@ const BY_SLUG = new Map(CATALOG.map((b) => [b.slug, b]));
 const CHECK_CMD = `node "${join(here, "check.mjs")}" --plan`;
 const LOG_CMD = `node "${join(here, "log.mjs")}"`;
 
-/** The approval entry check.mjs asks for too: a Step 2 Approval heading with the user's words on a Reply: line. */
+/** The approval entry check.mjs asks for too: a Step 2 Approval heading with the user's words on a Reply: line.
+ *  Every such entry counts, not only the first: the log is append-only, and agents log a "Reply: pending" line before
+ *  the stop, which used to hide the real reply logged after it and block the build (release-proof restaurant, fashion
+ *  and bakery, 2026-11-15). A quoted placeholder ("pending", "waiting", "TBD") is no reply. */
+const PLACEHOLDER_REPLY = /^\s*(?:pending|waiting|awaiting\b.*|to come|tbd|tbc|n\/a|none|nog niet|wacht\w*|in afwachting\b.*)\s*\.?\s*$/i;
 export function hasApproval(log) {
-  const entry = String(log ?? "").match(/^## Step 2 Approval[^\n]*\n([\s\S]*?)(?=^## |(?![\s\S]))/m);
-  return Boolean(entry && /^Reply:\s*["“‘'].+["”’']\s*$/m.test(entry[1]));
+  const entries = String(log ?? "").matchAll(/^## Step 2 Approval[^\n]*\n([\s\S]*?)(?=^## |(?![\s\S]))/gm);
+  for (const [, body] of entries) {
+    for (const line of body.split(/\r?\n/)) {
+      const reply = line.match(/^Reply:\s*["“‘'](.+)["”’']\s*$/);
+      if (reply && !PLACEHOLDER_REPLY.test(reply[1])) return true;
+    }
+  }
+  return false;
 }
 
 /** The page files under app/ (or src/app/): one per route. */

package/skills/struq/scripts/hand.mjs

@@ -0,0 +1,222 @@
+// blocks/film/hand.mjs
+//
+// The hand: what one site chooses its direction from. Proof runs of 2026-11-14 (struq-showcases, proof/phase-1) showed
+// why it exists. With a pre-filled storyboard 11 of 12 sites opened the same way; naming the reflex only moved it to
+// the next one. Dealing each site a random hand and holding its plan to it gave real variety while the agent still
+// chooses. A hand is two of the three motion languages, two type pairings, two palettes (one light, one dark), three
+// openings, one centerpiece and three lenses. A lens is where the idea starts looking: the round of 2026-11-15
+// showed that asking for three ideas still gave each brief the same idea on every run, so the starting points are
+// dealt too, and the plan's Idea line names the lens it came from.
+//
+// The hand is small on purpose. Round 6 of 2026-11-15 showed the model picks the same palette
+// (frontier-marrow-bone-blood-orange, dealt four times, picked four times), the same pairing (geometric-modern, three
+// of three) and the same opener and centerpiece whenever they are dealt, so dealing fewer makes the deal itself the
+// variety.
+//
+// The centerpiece is dealt alone. The release proof of 2026-11-15 gave three of eight sites (saas, conference,
+// plumber) the same scrub-connector, picked from three dealt each time it was among them, so one card is the deal
+// and the variety comes from the deal. An own scene stays allowed.
+//
+// A hand has a short id, and the id is the whole state: the same id deals the same hand from the same pools, so the
+// MCP (which keeps nothing between calls) and a check running on the client's machine both rebuild it from the
+// `Hand: <id>` line in STRUQ.md. Each item is ranked by a hash of the id and the item's own name (rendezvous hashing)
+// and the lowest ranks are dealt, so a block admitted or a palette added later changes a dealt hand only where the
+// newcomer outranks a card in it, never the whole hand.
+//
+// `checkHand` holds a plan's Idea, Language, Palette, Type, Opening and Centerpiece lines to a hand: anything else is
+// `off-draw`, except the client's own brand colours or faces, marked (brand), and a block or language the client
+// named, marked (named).
+//
+// A plain ES module with no imports at all, like film-check.mjs: the skill copies it verbatim on release and the MCP
+// serves it as a file, so it has to run on bare Node 18 wherever it lands.
+
+/** The motion languages a hand deals from. */
+export const HAND_LANGUAGES = ['weight', 'cut', 'curtain'];
+
+/**
+ * Where an idea can start looking. Each is a way into any client's world, never a style: the agent turns it on this
+ * client and writes the point of view it finds there.
+ */
+export const HAND_LENSES = [
+  { id: 'material', prompt: 'the stuff the work is made of, seen close enough to touch' },
+  { id: 'hour', prompt: "one hour of the client's day, and what is true only then" },
+  { id: 'first-minute', prompt: "the visitor's first minute with the thing itself" },
+  { id: 'number', prompt: 'one number this trade lives by, and what it means to the visitor' },
+  { id: 'tool', prompt: "the tool in the maker's hand and the mark it leaves" },
+  { id: 'place', prompt: 'the street, room or city where the work happens' },
+  { id: 'mistake', prompt: 'the mistake this client saves the visitor from' },
+  { id: 'ritual', prompt: 'a gesture the trade repeats every day' },
+  { id: 'before-after', prompt: 'the state of things before the work and after it' },
+  { id: 'leftover', prompt: 'what is left when the work is done: offcuts, crumbs, receipts, rings on a table' },
+  { id: 'scale', prompt: 'the work at a scale nobody sees it: one stitch, one bolt, the whole city' },
+  { id: 'sound', prompt: 'what the work sounds like, carried by type and motion' },
+  { id: 'season', prompt: 'how the work changes across a year' },
+  { id: 'name', prompt: "the client's name taken apart and used as material" },
+];
+
+/** How many of each a hand holds. */
+export const HAND_SIZE = { languages: 2, lightPalettes: 1, darkPalettes: 1, pairings: 2, openings: 3, centerpieces: 1, lenses: 3 };
+
+const ID_LENGTH = 6;
+const ID_ALPHABET = 'abcdefghijkmnpqrstuvwxyz23456789';
+
+/** True for a hand id: six lower-case letters and digits, without the look-alikes l, o, 0 and 1. */
+export function isHandId(value) {
+  return typeof value === 'string' && new RegExp(`^[${ID_ALPHABET}]{${ID_LENGTH}}$`).test(value);
+}
+
+/** A fresh hand id from a random source in [0, 1), Math.random by default. */
+export function newHandId(random = Math.random) {
+  let id = '';
+  for (let i = 0; i < ID_LENGTH; i++) id += ID_ALPHABET[Math.floor(random() * ID_ALPHABET.length) % ID_ALPHABET.length];
+  return id;
+}
+
+/** The `Hand: <id>` line of a plan, or null. */
+export function readHandId(plan) {
+  const id = String(plan ?? '').match(/^Hand:\s*([a-z0-9]+)\s*$/m)?.[1] ?? null;
+  return isHandId(id) ? id : null;
+}
+
+/**
+ * The pools a hand deals from, out of the canon and the catalogue. Palettes and pairings marked `autoPick: false` are
+ * kept for a brand that asks and never dealt; a palette says whether its ground is light. Openings and centerpieces
+ * are the catalogue's blocks of that role with no home language (a block with a home is a frame of its language).
+ *
+ * @param {{ palettes: Array<{ id: string, light: boolean, autoPick?: boolean }>, pairings: Array<{ id: string, autoPick?: boolean }>, catalog: Array<{ slug: string, role?: string, home?: string | null }> }} input
+ */
+export function handPools({ palettes = [], pairings = [], catalog = [] } = {}) {
+  const open = (list) => list.filter((entry) => entry.autoPick !== false);
+  const role = (name) => catalog.filter((block) => block.role === name && !block.home).map((block) => block.slug);
+  return {
+    languages: [...HAND_LANGUAGES],
+    lightPalettes: open(palettes).filter((p) => p.light).map((p) => p.id),
+    darkPalettes: open(palettes).filter((p) => !p.light).map((p) => p.id),
+    pairings: open(pairings).map((t) => t.id),
+    openings: role('opening'),
+    centerpieces: role('centerpiece'),
+    lenses: HAND_LENSES.map((lens) => lens.id),
+  };
+}
+
+/** A 53-bit hash of a string (cyrb53): spreads well enough to rank a few dozen names fairly. */
+function hash(text) {
+  let h1 = 0xdeadbeef;
+  let h2 = 0x41c6ce57;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 2654435761);
+    h2 = Math.imul(h2 ^ c, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+
+/** The n names of a pool that rank lowest for this id, in rank order (which is random, so it suggests no favourite). */
+function deal(id, pool, name, n) {
+  return [...new Set(pool)]
+    .map((item) => [hash(`${id}:${name}:${item}`), item])
+    .sort((a, b) => a[0] - b[0] || (a[1] < b[1] ? -1 : 1))
+    .slice(0, n)
+    .map(([, item]) => item);
+}
+
+/**
+ * An opening that needs no photo: a WebGL background or hero-opener. Every hand holds one, so a site whose photo pack
+ * shows nothing of the client can still open well (Roy, 2026-11-15: a type-led or WebGL first screen when no photo
+ * fits, never an off-topic one).
+ */
+export const isPhotolessOpening = (slug) => slug.startsWith('background-') || slug === 'hero-opener';
+
+/** The opening hand: the three that rank lowest for this id, the last swapped for the best photoless one if none is in. */
+function openingsFor(id, pool) {
+  const ranked = deal(id, pool, 'opening', pool.length);
+  const hand = ranked.slice(0, HAND_SIZE.openings);
+  if (hand.some(isPhotolessOpening)) return hand;
+  const photoless = ranked.find(isPhotolessOpening);
+  return photoless ? [...hand.slice(0, -1), photoless] : hand;
+}
+
+/**
+ * Deal a hand from the pools (handPools). `source` is a hand id, to rebuild a hand already dealt, or a random source in
+ * [0, 1) for a new one (Math.random when left out). Returns the id with the dealt names, in the shape of the skill's
+ * .struq/draw.json: { id, languages, palettes, pairings, openings, centerpieces, lenses }, the palettes the light one
+ * then the dark one.
+ */
+export function dealHand(pools, source = Math.random) {
+  const id = typeof source === 'string' ? source : newHandId(source);
+  if (!isHandId(id)) throw new Error(`"${id}" is not a hand id.`);
+  return {
+    id,
+    languages: deal(id, pools.languages ?? HAND_LANGUAGES, 'language', HAND_SIZE.languages),
+    palettes: [
+      ...deal(id, pools.lightPalettes ?? [], 'palette', HAND_SIZE.lightPalettes),
+      ...deal(id, pools.darkPalettes ?? [], 'palette', HAND_SIZE.darkPalettes),
+    ],
+    pairings: deal(id, pools.pairings ?? [], 'pairing', HAND_SIZE.pairings),
+    openings: openingsFor(id, pools.openings ?? []),
+    centerpieces: deal(id, pools.centerpieces ?? [], 'centerpiece', HAND_SIZE.centerpieces),
+    lenses: deal(id, pools.lenses ?? HAND_LENSES.map((lens) => lens.id), 'lens', HAND_SIZE.lenses),
+  };
+}
+
+/** One line of the treatment head, `Field: value`, or an empty string. */
+function headLine(plan, field) {
+  return plan.match(new RegExp(`^${field}:\\s*(.*)$`, 'm'))?.[1] ?? '';
+}
+
+/** The numbered storyboard line of a scene, `3. Opening (loud) hero-poster ...`, or an empty string. */
+function sceneLine(plan, scene) {
+  return plan.match(new RegExp(`^\\s*\\d+\\.\\s*${scene}\\b[^\\n]*$`, 'm'))?.[0] ?? '';
+}
+
+const BRAND = /\(brand\b|\bbrand\)/i;
+const NAMED = /\(named\b|\bnamed\)/i;
+
+/**
+ * Hold a plan to a hand: the Idea line opens with a dealt lens (`Idea: hour: <point of view>`), unless the client gave
+ * the idea, marked (named); the Language, Palette and Type lines and the Opening and Centerpiece scenes of the storyboard
+ * each come from it. A Palette or Type line marked (brand) is the client's own and passes; a Language line or an
+ * Opening or Centerpiece scene marked (named) is what the client asked for by name and passes. An own scene passes.
+ * A line not written yet is no finding here: the film check reports a missing treatment. A hand without a list (an
+ * older .struq/draw.json) skips that list.
+ *
+ * @returns {Array<{ severity: 'fail', id: 'off-draw', detail: string, fix: string }>}
+ */
+export function checkHand(plan, hand) {
+  const text = String(plan ?? '');
+  const findings = [];
+  const off = (field, name, ids, fix) =>
+    findings.push({ severity: 'fail', id: 'off-draw', detail: `${field} ${name} is not in this site's hand (${ids.join(', ')})`, fix });
+  if (hand?.lenses) {
+    const idea = headLine(text, 'Idea');
+    const lens = idea.match(/^([a-z][\w-]*)\s*:/)?.[1];
+    if (idea && !(lens && hand.lenses.includes(lens)) && !NAMED.test(idea)) {
+      off('Idea', lens ? `lens ${lens}` : 'without a lens', hand.lenses, 'open the Idea line with the dealt lens it started from (Idea: <lens>: <point of view>), or mark an idea the client gave with (named)');
+    }
+  }
+  for (const [field, ids] of [['Language', hand?.languages], ['Palette', hand?.palettes], ['Type', hand?.pairings]]) {
+    if (!ids) continue;
+    const line = headLine(text, field);
+    const name = line.match(/^[\w-]+/)?.[0];
+    if (!name || ids.includes(name)) continue;
+    if (field === 'Language' ? NAMED.test(line) : BRAND.test(line)) continue;
+    off(
+      field,
+      name,
+      ids,
+      field === 'Language'
+        ? 'pick the language from the two the hand dealt, or mark one the client asked for by name with (named)'
+        : `choose the ${field} from the hand, or mark the client's own brand ${field === 'Type' ? 'faces' : 'colours'} with (brand)`,
+    );
+  }
+  for (const [scene, ids] of [['Opening', hand?.openings], ['Centerpiece', hand?.centerpieces]]) {
+    if (!ids) continue;
+    const line = sceneLine(text, scene);
+    const slug = line.match(/\)\s*([a-z][\w-]*)/)?.[1];
+    if (!slug || slug === 'own' || ids.includes(slug) || NAMED.test(line)) continue;
+    off(scene, slug, ids, `cast the ${scene} from the hand, or mark a block the client named with (named)`);
+  }
+  return findings;
+}

package/skills/struq/scripts/images.mjs

@@ -6,6 +6,7 @@
 //   node <skill-dir>/scripts/images.mjs --list                every pack, with what it shows
 //   node <skill-dir>/scripts/images.mjs --brief "<the brief>"  picks the pack and the fitting photos
 //   node <skill-dir>/scripts/images.mjs <pack-slug> --brief "<the brief>"
+//   add --no-hero when no hero photo shows the client's own subject: the first screen is then type-led or WebGL
 //
 // With --brief (always pass it): the pack follows Struq's rule (scripts/packs.mjs) when no slug is
 // given, and photos whose alt names a subject the client does not do are left out, best fit first.
@@ -60,6 +61,9 @@ const flag = (name) => {
 };
 const root = resolve(flag("--dir") ?? process.cwd());
 const brief = flag("--brief");
+// --no-hero: you looked at the hero photos and none shows this client's own subject, so the pack only serves the
+// supporting slots and the first screen is type-led or WebGL (Roy, 2026-11-15: never an off-topic first screen).
+const noHero = args.includes("--no-hero");
 const slug = args.find((a, i) => !a.startsWith("--") && args[i - 1] !== "--dir" && args[i - 1] !== "--brief") ?? (brief ? packForBrief(brief) : undefined);
 const why = brief && !args.find((a, i) => !a.startsWith("--") && args[i - 1] !== "--dir" && args[i - 1] !== "--brief") ? packReason(brief) : "named on the command line";
 
@@ -186,7 +190,7 @@ function writeModule(entries, packSlug, fallback, imageFit = "full") {
     return `  ${s}: [\n${rows}\n  ],`;
   }).join("\n");
   const source = `// Written by the Struq skill (scripts/images.mjs). Do not hand-edit the list: run the script again
-// to change pack. Pack: ${packSlug}${fallback ? " (FALLBACK PLATES: Struq was unreachable, run the script again when online)" : ""}.
+// to change pack. Pack: ${packSlug}${fallback ? " (FALLBACK PLATES: Struq was unreachable, run the script again when online)" : ""}.${brief ? "\n// Fitted to the brief: images.mjs --brief kept only the photos that fit." : ""}
 // Beeldbank images are CC0. Translate the alt texts when the site is not in Dutch.
 
 export type StruqImage = {
@@ -216,8 +220,8 @@ export const imagePack = ${JSON.stringify(packSlug)};
  */
 export const imageFit: "full" | "partial" | "none" = ${JSON.stringify(imageFit)};
 
-/** The credit line for the footer: one quiet text-small link, never a badge. */
-export const imageCredit = { label: "Beeld: Struq", href: "https://struq.app/photos" };
+/** The credit line for the footer: one quiet text-small link, never a badge. In the site's language ("Beeld: Struq" in Dutch). */
+export const imageCredit = { label: "Photos: Struq", href: "https://struq.app/photos" };
 
 export const images: Record<ImageSlot, StruqImage[]> = {
 ${body}
@@ -307,6 +311,11 @@ async function main() {
     } else {
       console.warn('WARN no --brief: every photo of the pack is used. Pass --brief so photos of subjects this client does not do are left out.');
     }
+    if (noHero) {
+      pack.images = pack.images.filter((img) => img.slot !== "hero");
+      if (imageFit === "full") imageFit = "partial";
+      console.log("--no-hero: no hero photo; open with a type-led or WebGL opening (background-*, hero-opener, or type alone).");
+    }
     const jobs = pack.images
       .filter((img) => SLOTS.includes(img.slot))
       .map((img) => {