@struq/skill 0.4.3 → 0.5.1

package/skills/struq/scripts/gate.mjs

@@ -0,0 +1,146 @@
+// Struq's one stop, held by the scripts instead of by advice. Nothing goes into a project before its treatment passes
+// the plan check (film-check.mjs planCheck, the same rules as check.mjs --plan) and the user's reply to it is logged in
+// STRUQ-LOG.md. blocks.mjs add and canon.mjs palette and type call these before they touch a file; blocks.mjs add also
+// installs only what the storyboard names, in the site's language, and a page transition only once there are routes.
+//
+// A refusal is two lines: the reason, then exactly what to do next. The caller prints them and exits 1.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { planCheck, readTreatment, resolveBlock } from "./film-check.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const CATALOG = JSON.parse(readFileSync(join(here, "..", "blocks", "catalog.json"), "utf8")).blocks;
+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. */
+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]));
+}
+
+/** The page files under app/ (or src/app/): one per route. */
+export function routeCount(root) {
+  const app = ["app", join("src", "app")].map((d) => join(root, d)).find((d) => existsSync(d));
+  if (!app) return 0;
+  const walk = (dir) =>
+    readdirSync(dir).flatMap((name) => {
+      if (name === "node_modules" || name.startsWith(".")) return [];
+      const full = join(dir, name);
+      return statSync(full).isDirectory() ? walk(full) : /^page\.(tsx|jsx|js)$/.test(name) ? [full] : [];
+    });
+  return walk(app).length;
+}
+
+const read = (path) => (existsSync(path) ? readFileSync(path, "utf8") : "");
+
+/** null when STRUQ.md holds a plan that passes the plan check, else the refusal. */
+function planRefusal(root) {
+  const plan = read(join(root, "STRUQ.md"));
+  const next = `Write the treatment in STRUQ.md and run ${CHECK_CMD} until PLAN: PASS, then run this again.`;
+  if (!plan.trim()) return { reason: `No STRUQ.md in ${root}, so there is no treatment to build from.`, next };
+  const { findings } = planCheck({ plan, catalog: CATALOG, routes: Math.max(1, routeCount(root)) });
+  const failed = findings.filter((f) => f.severity === "fail");
+  if (!failed.length) return null;
+  return { reason: `The plan in STRUQ.md does not pass: ${failed.map((f) => `${f.id} (${f.detail.replace(/\.$/, "")})`).join("; ")}.`, next };
+}
+
+/** null when STRUQ-LOG.md carries the user's reply to the treatment, else the refusal. */
+function approvalRefusal(root) {
+  if (hasApproval(read(join(root, "STRUQ-LOG.md")))) return null;
+  return {
+    reason: "The treatment is not approved yet: STRUQ-LOG.md has no Step 2 Approval entry with the user's reply.",
+    next: `Send the treatment to the user and stop; when they reply, log it with ${LOG_CMD} "Step 2 Approval" "Asked: ..." "Reply: \\"<their words>\\"" and run this again.`,
+  };
+}
+
+/** The plan gate and the approval gate, in that order: null when both hold, else the first refusal. */
+export function stopRefusal(root) {
+  return planRefusal(root) ?? approvalRefusal(root);
+}
+
+const SLUG = /(?<![A-Za-z0-9-])([a-z0-9]+(?:-[a-z0-9]+)*)(?::([a-z0-9]+(?:-[a-z0-9]+)*))?(?![A-Za-z0-9-])/g;
+
+/** Every catalogue block the storyboard names, read as the plan check reads a line: after the (tone) tag, and after footer:. */
+export function namedBlocks(plan) {
+  const treatment = readTreatment(plan);
+  const named = [];
+  (treatment.storyboard ?? []).forEach((text, at) => {
+    const head = text.split("|")[0];
+    const tag = /\(([^)]*)\)/.exec(head);
+    const scene = `${at + 1} ${(tag ? head.slice(0, tag.index) : "").trim()}`.trim();
+    const zones = [tag ? head.slice(tag.index + tag[0].length) : head];
+    const footer = /\bfooter\s*:([^|]*)/i.exec(text);
+    if (footer) zones.push(footer[1]);
+    for (const zone of zones) {
+      for (const m of zone.matchAll(SLUG)) if (BY_SLUG.has(m[1])) named.push({ slug: m[1], variant: m[2] ?? null, scene });
+    }
+  });
+  if (treatment.centerpiece && BY_SLUG.has(treatment.centerpiece)) named.push({ slug: treatment.centerpiece, variant: null, scene: "Centerpiece" });
+  return { language: treatment.language, named };
+}
+
+/** The variant a block goes in: the one asked for, else the storyboard's, else the one of the site's language. */
+function chosenVariant(block, asked, named, language) {
+  if (asked) return asked;
+  const fromBoard = named.find((n) => n.slug === block.slug && n.variant)?.variant;
+  if (fromBoard) return fromBoard;
+  const own = block.variants.find((v) => resolveBlock(CATALOG, block.slug, v.id)?.home === language);
+  return own?.id ?? null;
+}
+
+/**
+ * The refusal for `blocks.mjs add`, or null when every requested block may go in. `requests` is [{ slug, variant }]
+ * with known slugs. Every refused slug is listed with its reason; nothing is installed when one is refused.
+ */
+export function addRefusal(root, requests) {
+  const stop = stopRefusal(root);
+  if (stop) return stop;
+  const { language, named } = namedBlocks(read(join(root, "STRUQ.md")));
+  const routes = routeCount(root);
+  const refused = [];
+  const unnamed = [];
+  const nexts = new Set();
+  for (const { slug, variant } of requests) {
+    const block = BY_SLUG.get(slug);
+    const chosen = chosenVariant(block, variant, named, language);
+    const film = resolveBlock(CATALOG, slug, chosen);
+    const shown = chosen ? `${slug}:${chosen}` : slug;
+    const reasons = [];
+    const exempt = slug === "header-bar" || (slug === "menu-curtain" && film.home === language);
+    if (!exempt && !named.some((n) => n.slug === slug)) {
+      reasons.push("the storyboard does not name it");
+      unnamed.push(slug);
+    }
+    if (film.home && film.home !== language) {
+      reasons.push(`it belongs to the ${film.home} language and the site's Language is ${language}`);
+      nexts.add(`Take the variant or block of the ${language} language (blocks.mjs list shows them).`);
+    }
+    if (block.kind === "page-transition" && routes < 2) {
+      reasons.push(`a page transition needs two routes and app/ holds ${routes} page.tsx`);
+      nexts.add("Leave the page transition out until app/ holds a second page.tsx.");
+    }
+    if (reasons.length) refused.push(`${shown} (${reasons.join("; ")})`);
+  }
+  if (!refused.length) return null;
+  if (unnamed.length) {
+    const asked = unnamed.join(" or ");
+    nexts.add(`Install only what the storyboard names; if the user asked for ${asked}, put it on a scene line in STRUQ.md first and run ${CHECK_CMD}.`);
+  }
+  const shown = named.filter((n, at) => n.scene !== "Centerpiece" || !named.slice(0, at).some((m) => m.slug === n.slug));
+  const board = shown.length ? shown.map((n) => `${n.scene}: ${n.variant ? `${n.slug}:${n.variant}` : n.slug}`).join(", ") : "nothing";
+  return {
+    reason: `Refused, nothing installed: ${refused.join("; ")}. The storyboard names ${board}.`,
+    next: `${[...nexts].reverse().join(" ")} Then run add again.`,
+  };
+}
+
+/** Print a refusal as its two lines and set exit code 1. */
+export function refuse(what, refusal) {
+  console.error(`FAIL ${what}: ${refusal.reason}`);
+  console.error(`Next: ${refusal.next}`);
+  process.exitCode = 1;
+}

package/skills/struq/scripts/images.mjs

@@ -11,11 +11,12 @@
 // given, and photos whose alt names a subject the client does not do are left out, best fit first.
 //
 // What it does, in order:
-// 1. Reads the pack from https://struq.nl/api/media/packs/<slug> (public, no key, CC0 images).
+// 1. Reads the pack from https://struq.app/api/media/packs/<slug> (public, no key, CC0 images),
+//    or from https://struq.nl when struq.app does not answer.
 // 2. Downloads all 24 images to public/images/<slot>-<n>.webp and checks each one is a real image.
 // 3. Writes lib/struq-images.ts (src/lib/ when the project uses src/): every image with its alt,
 //    size and description, grouped by slot, plus the credit line. Components import from it.
-// 4. If struq.nl cannot be reached, or a file fails its check, it writes a graded fallback plate
+// 4. If Struq cannot be reached, or a file fails its check, it writes a graded fallback plate
 //    in the site palette for that slot instead, so no frame is ever empty, and says so.
 //
 // Node 18 or later, no dependencies. Safe to run again: a file is kept only when the last run
@@ -26,12 +27,21 @@ import { join, resolve } from "node:path";
 import { appendLog } from "./log.mjs";
 import { fitImages, packForBrief, packReason } from "./packs.mjs";
 
-// STRUQ_API_BASE points a test run at another Struq environment (for example https://staging.struq.nl).
-// Real users never set it: the default is production.
-const BASE = (process.env.STRUQ_API_BASE || "https://struq.nl").replace(/\/+$/, "");
-const API = `${BASE}/api/media/packs`;
-/** The download URL, on the same base as the API (directPath), falling back to the absolute publicUrl. */
-const imageUrl = (img) => (img.directPath ? `${BASE}${img.directPath}` : img.publicUrl);
+// Struq lives at struq.app. The old domain struq.nl keeps answering the pack API and the media for
+// installed skills, so a run tries struq.app first and falls back to struq.nl when struq.app gives a
+// network error, a non-2xx answer or something that is not the pack.
+// STRUQ_API_BASE points a test run at another Struq environment (for example https://staging.struq.app),
+// with no fallback. Real users never set it: the default is production.
+const DEFAULT_BASES = ["https://struq.app", "https://struq.nl"];
+const BASES = process.env.STRUQ_API_BASE ? [process.env.STRUQ_API_BASE.replace(/\/+$/, "")] : DEFAULT_BASES;
+const PACKS = "/api/media/packs";
+const HOSTS = BASES.map((b) => b.replace(/^https?:\/\//, "")).join(" and ");
+/** The base that last answered the pack API; image downloads try it first. */
+let activeBase = BASES[0];
+/** The bases in the order to try: the one that answered first, then the rest. */
+const basesInOrder = () => [activeBase, ...BASES.filter((b) => b !== activeBase)];
+/** Download URLs on the same bases as the API (directPath), or the absolute publicUrl. */
+const imageUrls = (img) => (img.directPath ? basesInOrder().map((b) => `${b}${img.directPath}`) : [img.publicUrl]);
 const SLOTS = ["hero", "band", "card", "column", "detail", "backdrop"];
 const FALLBACK_COUNTS = { hero: 3, band: 2, card: 8, column: 4, detail: 4, backdrop: 3 };
 const FALLBACK_SIZE = {
@@ -53,10 +63,22 @@ const brief = flag("--brief");
 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";
 
-async function getJson(url) {
-  const res = await fetch(url, { signal: AbortSignal.timeout(20000), headers: { accept: "application/json" } });
-  if (!res.ok) throw new Error(`${url} answered ${res.status}`);
-  return res.json();
+/** GET a path of the pack API from each base in turn; the first JSON answer wins and sets activeBase. */
+async function getJson(path) {
+  const errors = [];
+  for (const base of basesInOrder()) {
+    const url = `${base}${path}`;
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(20000), headers: { accept: "application/json" } });
+      if (!res.ok) throw new Error(`${url} answered ${res.status}`);
+      const json = await res.json();
+      activeBase = base;
+      return json;
+    } catch (error) {
+      errors.push(error.message.startsWith(url) ? error.message : `${url}: ${error.message}`);
+    }
+  }
+  throw new Error(errors.join("; "));
 }
 
 function isImage(buf) {
@@ -77,20 +99,23 @@ function fileIsImage(path) {
   }
 }
 
-async function download(url, path) {
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const res = await fetch(url, { signal: AbortSignal.timeout(30000) });
-      if (!res.ok) continue;
-      const buf = Buffer.from(await res.arrayBuffer());
-      if (!isImage(buf)) continue;
-      writeFileSync(path, buf);
-      return true;
-    } catch {
-      // retry once, then fall back
+/** Tries each URL twice in turn; returns the URL that gave a real image, or null. */
+async function download(urls, path) {
+  for (const url of urls) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(30000) });
+        if (!res.ok) continue;
+        const buf = Buffer.from(await res.arrayBuffer());
+        if (!isImage(buf)) continue;
+        writeFileSync(path, buf);
+        return url;
+      } catch {
+        // retry once, then the next base, then fall back
+      }
     }
   }
-  return false;
+  return null;
 }
 
 function readPalette() {
@@ -161,7 +186,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.nl 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)" : ""}.
 // Beeldbank images are CC0. Translate the alt texts when the site is not in Dutch.
 
 export type StruqImage = {
@@ -192,7 +217,7 @@ 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.nl/beeldbank" };
+export const imageCredit = { label: "Beeld: Struq", href: "https://struq.app/photos" };
 
 export const images: Record<ImageSlot, StruqImage[]> = {
 ${body}
@@ -226,7 +251,7 @@ function removeStale(outDir, manifest) {
 }
 
 async function list() {
-  const index = await getJson(API);
+  const index = await getJson(PACKS);
   console.log(`${index.packCount} packs, ${index.totalImages} images, ${index.license}\n`);
   for (const p of index.packs) console.log(`${p.slug.padEnd(10)} ${p.description}`);
 }
@@ -250,11 +275,11 @@ async function main() {
   let droppedImages = [];
   let imageFit = "full";
   try {
-    pack = await getJson(`${API}/${encodeURIComponent(slug)}`);
+    pack = await getJson(`${PACKS}/${encodeURIComponent(slug)}`);
     if (!Array.isArray(pack?.images) || pack.images.length === 0) throw new Error("pack has no images");
   } catch (error) {
     try {
-      const index = await getJson(API);
+      const index = await getJson(PACKS);
       const known = index.packs.map((p) => p.slug);
       if (!known.includes(slug)) {
         console.error(`Unknown pack "${slug}". Packs: ${known.join(", ")}`);
@@ -263,7 +288,7 @@ async function main() {
     } catch {
       // the API itself is down: fall through to the plates
     }
-    console.warn(`WARN struq.nl unreachable (${error.message}). Writing graded fallback plates instead.`);
+    console.warn(`WARN ${HOSTS} unreachable (${error.message}). Writing graded fallback plates instead.`);
     pack = null;
   }
 
@@ -293,10 +318,12 @@ async function main() {
       while (cursor < jobs.length) {
         const job = jobs[cursor++];
         const target = join(outDir, `${job.name}.webp`);
-        const source = imageUrl(job.img);
-        const kept = previous.get(`public/images/${job.name}.webp`) === source && fileIsImage(target);
-        const ok = kept || (await download(source, target));
-        if (ok) {
+        const urls = imageUrls(job.img);
+        const last = previous.get(`public/images/${job.name}.webp`);
+        // The same photo from either base counts as the same source.
+        const kept = urls.includes(last) && fileIsImage(target);
+        const source = kept ? last : await download(urls, target);
+        if (source) {
           real++;
           entries.push({
             slot: job.img.slot,
@@ -345,7 +372,7 @@ async function main() {
           width: size[0],
           height: size[1],
           ratio: `${size[0]}:${size[1]}`,
-          description: "Fallback plate in the site palette (struq.nl was unreachable).",
+          description: "Fallback plate in the site palette (Struq was unreachable).",
           unoptimized: true,
         });
         manifest.push({ file: `public/images/${slot}-${n}.svg`, id: null, slot, source: "fallback" });
@@ -372,13 +399,13 @@ async function main() {
     console.log(`${`images.${e.slot}[${e.order - 1}]`.padEnd(18)} ${e.ratio.padEnd(5)} ${e.description.slice(0, 110)}`);
   }
   if (plates > 0) {
-    console.log(`\nWARN ${plates} slot(s) use fallback plates. Run this script again when struq.nl answers.`);
+    console.log(`\nWARN ${plates} slot(s) use fallback plates. Run this script again when Struq answers.`);
   }
   appendLog(root, "Step 4 Images", [
     `images.mjs: pack ${slug} (${why}), ${real} images downloaded and verified, ${plates} fallback plates.`,
     ...(droppedImages.length ? [`Left out ${droppedImages.length} photos that do not fit this client: ${[...new Set(droppedImages.map((d) => d.reason))].join("; ")}.`] : []),
     ...(imageFit !== "full" ? [`Image fit: ${imageFit}${imageFit === "none" ? ", the opener is typographic or WebGL, and the approval stop asks for photos" : ""}.`] : []),
-    `Files in public/images, list in ${module.replace(root, ".")}${BASE !== "https://struq.nl" ? `, from ${BASE}` : ""}.`,
+    `Files in public/images, list in ${module.replace(root, ".")}${activeBase !== DEFAULT_BASES[0] ? `, from ${activeBase}` : ""}.`,
   ]);
   console.log(imageFit === "none" ? "\nOK no fitting photos: build the opener without them" : real > 0 ? "\nOK images ready" : "\nOK fallback plates ready (no frame is empty)");
 }

package/skills/struq/scripts/packs.mjs

@@ -1,9 +1,10 @@
 // Struq beeldbank: which pack fits a brief, and which photos inside a pack fit this client.
 //
 // The pack rule mirrors Struq's MCP (public canon logic), in order:
-//   1. A sector word in the brief picks that sector's pack, matched as whole words (neighbouring
-//      words are also tried joined, so "e-bike" matches "ebike"). Most matches wins; table order
-//      breaks a tie.
+//   1. A sector word in the brief picks that sector's pack. A stem of four letters or more also
+//      matches its inflections and the compounds that hold it (architectenstudio, boetiekhotel);
+//      a shorter one only matches whole. Neighbouring words are also tried joined, so "e-bike"
+//      matches "ebike". Most matches wins; table order breaks a tie.
 //   2. No sector word, but the brief launches or sells a product: vitrine (product photography),
 //      and the hero scene carries the product.
 //   3. Anything else: halide, because a wrong photograph is worse than an abstract one.
@@ -24,9 +25,10 @@ export function normalize(text) {
 }
 
 export const PACK_SIGNALS = [
-  ["proof", ["restaurant", "restaurants", "visrestaurant", "bistro", "brasserie", "eetcafe", "horeca", "keuken", "chef", "kok", "koken", "kookt", "bakkerij", "bakker", "patisserie", "lunchroom", "koffiebar", "bakery", "cafe", "wine", "wijnbar", "pizzeria", "catering", "kitchen", "dining"]],
+  ["proof", ["restaurant", "restaurants", "visrestaurant", "bistro", "brasserie", "eetcafe", "horeca", "keuken", "chef", "kok", "koken", "kookt", "bakkerij", "bakker", "patisserie", "lunchroom", "koffiebar", "koffie", "bakery", "cafe", "wine", "wijnbar", "pizzeria", "catering", "kitchen", "dining"]],
   ["datum", ["architect", "architecten", "architectenbureau", "architectuur", "architectuurbureau", "woningbouw", "fabriekspand", "fabriekspanden", "stedenbouw", "vastgoed", "makelaar", "makelaardij", "projectontwikkelaar", "architects", "architecture", "realestate", "property"]],
-  ["mortar", ["bouw", "bouwbedrijf", "aannemer", "aannemersbedrijf", "renovatie", "verbouwing", "timmerman", "dakdekker", "loodgieter", "installateur", "installatiebedrijf", "elektricien", "construction", "contractor", "builder", "plumber", "renovation"]],
+  // No bare "bouw": nearly every brief opens with it as a verb ("Bouw een website voor ...").
+  ["mortar", ["bouwbedrijf", "aannemer", "aannemersbedrijf", "renovatie", "verbouwing", "timmerman", "dakdekker", "loodgieter", "installateur", "installatiebedrijf", "elektricien", "construction", "contractor", "builder", "plumber", "renovation"]],
   ["portico", ["hotel", "hotels", "resort", "vakantie", "vakantiehuis", "vakantiepark", "gastenverblijf", "reisbureau", "reizen", "travel", "holiday", "villa"]],
   ["transit", ["logistiek", "logistieke", "vracht", "vrachtvervoer", "distributie", "distributiecentrum", "transport", "transportbedrijf", "transporteur", "expeditie", "magazijn", "container", "containers", "depot", "pallets", "logistics", "freight", "warehouse", "haulage", "shipping"]],
   ["cadence", ["sport", "sportschool", "sportclub", "gym", "fitness", "crossfit", "boksen", "atletiek", "hardlopen", "wielrennen", "running", "boxing", "athletics"]],
@@ -48,14 +50,70 @@ export const PACK_SIGNALS = [
 
 export const PRODUCT_LAUNCH_WORDS = ["lancering", "lanceren", "lanceert", "gelanceerd", "productlancering", "launch", "launches", "launching", "introductie", "product", "producten", "products"];
 
+// Endings that only inflect a word (architect-en, verbouwing-en, renovatie-s, makelaar-s).
+const INFLECTIONS = new Set(["s", "e", "n", "en", "es", "er", "ers", "ing", "ingen", "ies"]);
+
+// Everyday words that hold a sector stem but do not name the sector: "zorgvuldig" (careful) reached the care pack
+// through "zorg", "natuurlijk" (natural) the nature pack through "natuur". A brief word that starts with one of these
+// never matches by stem, so each entry also covers its inflections (zorgvuldige, natuurlijke). Struq's MCP keeps the
+// same list, so both land a brief on the same pack.
+export const NOT_A_SECTOR = [
+  "zorgvuldig", "zorgeloos", "zorgeloze", "zorgelijk", "zorgen", "klantenzorg", "kwaliteitszorg",
+  "natuurlijk", "natuurkunde", "natuurkundig", "natuurgetrouw", "signatuur",
+  "kunstmatig", "kunststof", "kunstlicht",
+  "modern", "moderate", "moderator", "moderation",
+  "eventual", "operation",
+  "bedrijfscultuur", "organisatiecultuur", "werkcultuur", "teamcultuur", "agriculture",
+  "metaalachtig",
+  "verteler", "verhalenverteler",
+  "grondstof", "voedingsstof",
+  "praktijkgericht", "praktijkervaring", "praktijkvoorbeeld",
+  "whitelabel",
+];
+
+/**
+ * True when a brief word is a sector stem, an inflection of it or a compound that holds it.
+ * A stem under four letters only matches whole (so "art" never matches "smart"). A longer stem
+ * matches at the start of the word when the rest is an inflection or a word of its own (five
+ * letters or more: architect-enstudio, mode-label, keramiek-atelier, but not mode-rn), and at the
+ * end when a modifier of three letters or more comes before it (boetiek-hotel, tandarts-praktijk).
+ * A word that starts with an entry of NOT_A_SECTOR never matches by stem; a word equal to a sector
+ * word still matches whole.
+ */
+export function wordMatches(word, stem) {
+  if (word === stem) return true;
+  if (stem.length < 4) return false;
+  if (NOT_A_SECTOR.some((entry) => word.startsWith(entry))) return false;
+  if (word.startsWith(stem)) {
+    const rest = word.slice(stem.length);
+    return INFLECTIONS.has(rest) || rest.length >= 5;
+  }
+  return word.endsWith(stem) && word.length - stem.length >= 3;
+}
+
+/**
+ * A matcher for one brief: its words match by stem, neighbours joined only whole ("e bike" reads
+ * as "ebike", but "modern design" never reads as a compound of "mode").
+ */
+function briefMatcher(brief) {
+  const words = normalize(brief).split(" ").filter(Boolean);
+  const joined = new Set();
+  for (let i = 0; i < words.length - 1; i++) joined.add(`${words[i]}${words[i + 1]}`);
+  return (stem) => joined.has(stem) || words.some((w) => wordMatches(w, stem));
+}
+
+/** True when the brief says one of this pack's sector words (the pack shows the client's world). */
+export function packMatchesBrief(pack, brief) {
+  const says = briefMatcher(brief);
+  return (PACK_SIGNALS.find(([p]) => p === pack)?.[1] ?? []).some(says);
+}
+
 /** The pack a brief's own sector words point at, or null. */
 export function packSignalForBrief(brief) {
-  const words = normalize(brief).split(" ").filter(Boolean);
-  const tokens = new Set(words);
-  for (let i = 0; i < words.length - 1; i++) tokens.add(`${words[i]}${words[i + 1]}`);
+  const says = briefMatcher(brief);
   let best = null;
   for (const [pack, signals] of PACK_SIGNALS) {
-    const score = signals.filter((s) => tokens.has(s)).length;
+    const score = signals.filter(says).length;
     if (score > 0 && (!best || score > best.score)) best = { pack, score };
   }
   return best?.pack ?? null;
@@ -118,7 +176,7 @@ export function altFitsBrief(alt, brief) {
  * Keep the photos that fit this client, best fit first per slot.
  * images: [{ slot, alt, description, ... }]. Returns { keep, dropped, fit } in slot order.
  *
- * When the brief's own sector words point at this pack, its photos show the client's world and
+ * When the brief names one of this pack's sector words, its photos show the client's world and
  * only off-subject ones are left out (fit "full"). When they do not (a product launch handed
  * vitrine, a pack named by hand), a photo is kept only if its alt names something the brief is
  * about: the material, the city, the street. Otherwise none: an off-topic photo is worse than no
@@ -126,7 +184,10 @@ export function altFitsBrief(alt, brief) {
  */
 export function fitImages(pack, brief, images) {
   const b = words(brief);
-  const strict = packSignalForBrief(brief) !== pack;
+  const says = briefMatcher(brief);
+  // Strict only when the brief names none of this pack's sector words: a pack named by hand for
+  // an architect is the client's world even when another sector scores higher.
+  const strict = !packMatchesBrief(pack, brief);
   const rules = IMAGE_RULES[pack] ?? [];
   const keep = [];
   const dropped = [];
@@ -135,7 +196,7 @@ export function fitImages(pack, brief, images) {
     // Dutch compounds carry the subject inside them (meelsporen, broodkorst), so a term counts
     // when an alt word contains it; the brief's own words still have to match whole.
     const names = (t) => [...altWords].some((w) => w.includes(t));
-    const offSubject = rules.find((r) => r.terms.some(names) && !r.unless.some((u) => b.has(u)));
+    const offSubject = rules.find((r) => r.terms.some(names) && !r.unless.some(says));
     if (offSubject) dropped.push({ ...img, reason: `shows ${offSubject.subject}, which the brief does not name` });
     else if (strict && !altFitsBrief(img.alt, brief)) dropped.push({ ...img, reason: "shows nothing this brief is about" });
     else keep.push(img);