@nodaro/prompts 1.14.0 → 1.16.0

package/src/__tests__/minor-age-floor.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from "vitest"
+import { buildPersonHints } from "../person.js"
+import { buildStylingHints } from "../styling.js"
+import { getAdultOnlyEntries, applyMinorAgeFloorToPickerValues, getAdultOnlyHintStrings, ADULT_SWEPT_CATALOG_IDS, FLOORED_PICKER_KEYS } from "../age-floor.js"
+
+/** The seven P0 prompts' shape (2026-07-30): a 5-year-old + fitted clothing +
+ *  parted lips + baby-soft skin + direct gaze. Assembled from picker values —
+ *  the stored prompts are never replayed. */
+const CHILD = {
+  type: "boy-next-door",
+  age: "age-young-child",
+  frame: "frame-slim",
+  lipState: ["lip-state-parted"],
+  eyeState: ["eye-state-staring-camera"],
+  skinTexture: ["texture-baby-soft"],
+} as const
+
+describe("Layer 1 — the collectors drop adultOnly entries for a minor", () => {
+  it("a child with flagged lip/eye/skin picks emits none of their hints, keeps the rest", () => {
+    const hints = buildPersonHints({ ...CHILD, bust: "bust-very-full", distinctiveFeature: ["feature-midriff-visible"] } as never)
+    const joined = hints.join(", ")
+    expect(joined).toContain("a young child around 5 years old")
+    expect(joined).toContain("slim")
+    expect(joined).not.toMatch(/bust|midriff|cropped hemline|slightly open|mid-sentence/i)
+    // eye-state-staring-camera and texture-baby-soft are NOT flagged — they stay.
+    expect(joined).toContain("looking directly into the camera")
+  })
+
+  it("compact mode drops the same ids", () => {
+    const terms = buildPersonHints({ ...CHILD, bust: "bust-very-full", lipState: ["lip-state-glossy"] } as never, "compact")
+    expect(terms.join(", ")).not.toMatch(/bust|glossy/i)
+  })
+
+  it("styling on the flat subject bag drops flagged garments when the bag says minor", () => {
+    const hints = buildStylingHints({ age: "age-child", wardrobeState: ["state-fitted"], top: "top-crop-top", outfit: "outfit-bikini" } as never)
+    const joined = hints.join(", ")
+    expect(joined).not.toMatch(/close-fitting|bikini/i)
+    expect(joined).toMatch(/cropped top/i) // top-crop-top is deliberately NOT flagged
+  })
+
+  it("styling with no age signal on the bag is untouched (separate-node consumers; Layer 2 covers them)", () => {
+    const hints = buildStylingHints({ wardrobeState: ["state-fitted"] } as never)
+    expect(hints.join(", ")).toMatch(/close-fitting/i)
+  })
+
+  it("adults are byte-identical to before: every flagged entry still emits for age-30s", () => {
+    for (const e of getAdultOnlyEntries().filter((x) => x.id.startsWith("bust-") || x.id.startsWith("lip-state-"))) {
+      const field = e.id.startsWith("bust-") ? "bust" : "lipState"
+      const value = field === "bust" ? e.id : [e.id]
+      const hints = buildPersonHints({ age: "age-30s", [field]: value } as never)
+      expect(hints.join(" "), e.id).toContain(e.promptHint)
+    }
+  })
+
+  it("a minor-implying type with no age is floored too", () => {
+    const hints = buildPersonHints({ type: "alice-wonderland", bust: "bust-full" } as never)
+    expect(hints.join(", ")).not.toMatch(/bust/i)
+  })
+})
+
+describe("applyMinorAgeFloorToPickerValues", () => {
+  it("strips flagged ids from person/styling/pose/mood when the person is a minor", () => {
+    const out = applyMinorAgeFloorToPickerValues({
+      person: { age: "age-early-teen", bust: "bust-full", lipState: ["lip-state-glossy", "lip-state-bold-red"] },
+      styling: { top: "top-bra-top", wardrobeState: ["state-fitted", "state-layered"] },
+      pose: { pose: "arched-back" },
+      mood: { mood: ["sultry", "calm"] },
+    })
+    expect(out.person).toEqual({ age: "age-early-teen", lipState: ["lip-state-bold-red"] })
+    expect(out.styling).toEqual({ wardrobeState: ["state-layered"] })
+    expect(out.pose).toEqual({})
+    expect(out.mood).toEqual({ mood: ["calm"] })
+  })
+
+  it("is the identity for an adult", () => {
+    const values = { person: { age: "age-30s", bust: "bust-full" }, styling: { top: "top-bra-top" } }
+    expect(applyMinorAgeFloorToPickerValues(values)).toBe(values)
+  })
+
+  // The final-review gap: `photo-genre` is swept for the flag
+  // (ADULT_SWEPT_CATALOG_IDS) but the hand-written strip list omitted it, so a
+  // minor kept `glamour-portrait` / `brand-helmut-newton`. FLOORED_PICKER_KEYS
+  // is derived from the sweep list now, which is what makes this pass.
+  it("strips a flagged photo-genre id from a minor's values", () => {
+    // The real analyzer field for this picker is `photoGenre`
+    // (picker-analyzer-registry.ts) — `stripIds` drops by VALUE, so the key
+    // name is immaterial; both shapes are pinned so neither can regress.
+    const out = applyMinorAgeFloorToPickerValues({
+      person: { age: "age-child" },
+      "photo-genre": { photoGenre: "glamour-portrait" },
+    })
+    expect(out["photo-genre"]).toEqual({})
+
+    const coordinatorShape = applyMinorAgeFloorToPickerValues({
+      person: { age: "age-child" },
+      "photo-genre": { genre: "glamour-portrait" },
+    })
+    expect(coordinatorShape["photo-genre"]).toEqual({})
+  })
+
+  it("an adult keeps the same photo-genre id (identity)", () => {
+    const values = { person: { age: "age-30s" }, "photo-genre": { photoGenre: "glamour-portrait" } }
+    expect(applyMinorAgeFloorToPickerValues(values)).toBe(values)
+  })
+
+  // Totality: the strip list can never again be a subset of the sweep list.
+  it("every swept catalog is a floored picker key, and person leads the list", () => {
+    for (const id of ADULT_SWEPT_CATALOG_IDS) {
+      expect(FLOORED_PICKER_KEYS as ReadonlyArray<string>, id).toContain(id)
+    }
+    expect(FLOORED_PICKER_KEYS[0]).toBe("person")
+    expect(FLOORED_PICKER_KEYS).toHaveLength(ADULT_SWEPT_CATALOG_IDS.length + 1)
+  })
+})
+
+describe("getAdultOnlyHintStrings", () => {
+  it("contains the seven-prompt trigger clause and is longest-first", () => {
+    const strings = getAdultOnlyHintStrings()
+    expect(strings).toContain("the clothing fitted and form-conscious, hugging the contours of the body")
+    expect(strings.length).toBeGreaterThan(0)
+    for (let i = 1; i < strings.length; i++) expect(strings[i - 1].length).toBeGreaterThanOrEqual(strings[i].length)
+  })
+
+  it("excludes bare derived terms that are absent from every promptHint (fix round 1: promptHint-only)", () => {
+    const strings = getAdultOnlyHintStrings()
+    // "lounging" (pose id/label, no explicit term — deriveTerm(label) would
+    // back-fill it in the composed catalog) and "cropped top" (state-cropped's
+    // explicit `term`, distinct from its promptHint "the top cropped above the
+    // midriff with the stomach visible") are exactly the short, generic strings
+    // that over-strip unrelated benign text when swept as needles.
+    expect(strings).not.toContain("lounging")
+    expect(strings).not.toContain("cropped top")
+    expect(strings).not.toContain("school uniform")
+    expect(strings).not.toContain("lying down")
+  })
+})

package/src/__tests__/person-body-axes.test.ts

@@ -18,7 +18,7 @@ describe("buildPersonHints — body proportion axes", () => {
       silhouette: "silhouette-hourglass",
     })
     expect(hints.join(", ")).toBe(
-      "slim, lean build, full bust, defined waist, hourglass silhouette",
+      "slim, lean build, full bust, a defined waistline, an hourglass figure",
     )
   })
 
@@ -56,7 +56,7 @@ describe("buildPersonHints — body proportion axes", () => {
   })
 
   it("Bust:Very Full emits the distinct very-full token", () => {
-    expect(buildPersonHints({ bust: "bust-very-full" })).toEqual(["very full bust"])
+    expect(buildPersonHints({ bust: "bust-very-full" })).toEqual(["a fuller bust"])
   })
 
   it("ignores stored values for the retired Build / Body Proportions keys (no migration)", () => {

package/src/__tests__/person-exposure-hints.test.ts

@@ -14,15 +14,15 @@ describe("exposure hint collapsing", () => {
     const hints = buildPersonHints({
       distinctiveFeature: ["feature-midriff-visible", "feature-navel-visible"],
     } as never)
-    const exposure = hints.filter((h) => /midriff|navel|stomach/i.test(h))
-    expect(exposure).toEqual(["wearing a cropped style, midriff and navel visible"])
+    const exposure = hints.filter((h) => /cropped hemline|navel|stomach/i.test(h))
+    expect(exposure).toEqual(["with a cropped hemline and the navel showing"])
   })
 
   it("each alone keeps its own (softened, garment-language) hint", () => {
     const midriffOnly = buildPersonHints({
       distinctiveFeature: ["feature-midriff-visible"],
     } as never)
-    expect(midriffOnly).toContain("wearing a cropped style with the midriff visible")
+    expect(midriffOnly).toContain("with a cropped hemline")
     expect(midriffOnly.join(" ")).not.toMatch(/bare stomach/i)
 
     const navelOnly = buildPersonHints({
@@ -40,7 +40,7 @@ describe("exposure hint collapsing", () => {
         "feature-freckles",
       ],
     } as never)
-    expect(hints.filter((h) => /midriff/i.test(h))).toHaveLength(1)
+    expect(hints.filter((h) => /cropped hemline/i.test(h))).toHaveLength(1)
     expect(hints.length).toBeGreaterThan(1)
   })
 })
@@ -59,3 +59,58 @@ describe("bold-lips cross-catalog dedupe", () => {
     expect(hints.join(" ")).toMatch(/bold lips/i)
   })
 })
+
+describe("cropped-clause de-stack across the person↔styling boundary (W1-b)", () => {
+  it("the midriff person clause suppresses BOTH styling cropped twins on the shared bag", () => {
+    const hints = buildStylingHints({
+      distinctiveFeature: ["feature-midriff-visible"],
+      top: "top-crop-top",
+      wardrobeState: ["state-cropped"],
+    } as never)
+    const joined = hints.join(", ")
+    expect(joined).not.toMatch(/cropped top|cropped above the midriff/i)
+  })
+
+  it("without the person clause, the garment wins and the modifier yields", () => {
+    const hints = buildStylingHints({
+      top: "top-crop-top",
+      wardrobeState: ["state-cropped"],
+    } as never)
+    const joined = hints.join(", ")
+    expect(joined).toMatch(/wearing a cropped top that ends above the midriff/i)
+    expect(joined).not.toMatch(/the top cropped above the midriff with the stomach visible/i)
+  })
+
+  it("a MINOR who picks midriff + crop-top still gets exactly one cropped clause", () => {
+    // The person clause is dropped by the floor (feature-midriff-visible is
+    // adultOnly), so the styling twin must NOT be suppressed — otherwise the
+    // floor silently deletes a garment detail instead of a body detail.
+    const hints = buildStylingHints({
+      age: "age-child",
+      distinctiveFeature: ["feature-midriff-visible"],
+      top: "top-crop-top",
+    } as never)
+    expect(hints.join(", ")).toMatch(/wearing a cropped top that ends above the midriff/i)
+  })
+
+  it("either styling id alone is untouched (no person clause, no twin)", () => {
+    expect(buildStylingHints({ wardrobeState: ["state-cropped"] } as never).join(", "))
+      .toMatch(/the top cropped above the midriff/i)
+    expect(buildStylingHints({ top: "top-crop-top" } as never).join(", "))
+      .toMatch(/wearing a cropped top/i)
+  })
+
+  it("de-stacks a BARE-STRING wardrobeState too, not just the array form", () => {
+    // `wardrobeState` is a single-pick-or-multi field (string | string[]), and
+    // `normalizeSubjectFields` unwraps a lone array pick to a bare string
+    // before the styling collector ever sees it — the single-pick case is the
+    // common one, not an edge case, so the suppression must not be array-only.
+    const hints = buildStylingHints({
+      distinctiveFeature: "feature-midriff-visible",
+      top: "top-crop-top",
+      wardrobeState: "state-cropped",
+    } as never)
+    const joined = hints.join(", ")
+    expect(joined).not.toMatch(/cropped top|cropped above the midriff/i)
+  })
+})

package/src/__tests__/person-pack-adult-only.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { registerPersonPack, resetPersonPacks, getRegisteredPeople } from "../person-packs.js"
+import { registerCatalogPack, resetCatalogPacks } from "../catalog-packs.js"
+
+beforeEach(() => {
+  resetPersonPacks()
+  resetCatalogPacks()
+})
+
+describe("person packs carry adultOnly", () => {
+  it("an extend person pack entry keeps its flag in getRegisteredPeople()", () => {
+    registerPersonPack({
+      id: "test/person-extend",
+      dimensions: [{ dimension: "vibe", field: "vibe", label: "Vibe" }],
+      entries: [
+        { id: "vibe-boudoir", label: "Boudoir", dimension: "vibe", description: "Boudoir styling", promptHint: "in a boudoir setting", adultOnly: true },
+        { id: "vibe-picnic", label: "Picnic", dimension: "vibe", description: "Picnic styling", promptHint: "at a picnic" },
+      ],
+    })
+    const people = getRegisteredPeople()
+    expect(people.find((p) => p.id === "vibe-boudoir")?.adultOnly).toBe(true)
+    expect(people.find((p) => p.id === "vibe-picnic")?.adultOnly).toBeUndefined()
+  })
+
+  it("a replace catalog pack for person keeps the flag through personEntriesFromDims", () => {
+    registerCatalogPack({
+      id: "test/person-replace",
+      catalogId: "person",
+      mode: "replace",
+      catalog: {
+        catalogId: "person",
+        kind: "multi",
+        label: "Person",
+        dimensions: [
+          {
+            field: "bust",
+            label: "Bust",
+            options: [{ id: "bust-very-full", label: "Very Full", promptHint: "very full bust", adultOnly: true }],
+          },
+        ],
+      } as never,
+    })
+    expect(getRegisteredPeople().find((p) => p.id === "bust-very-full")?.adultOnly).toBe(true)
+  })
+})

package/src/__tests__/picker-analyzer-registry.test.ts

@@ -7,6 +7,7 @@ import {
 import {
   buildPickerAnalyzerSpec,
   buildPickerZodSchema,
+  PICKER_ANALYZER_REGISTRY,
 } from "../picker-analyzer-registry.js"
 // NOTE: the existing test file already imports `buildPickerAnalyzerSpec` from
 // "../picker-analyzer-registry.js" — do NOT re-import it here (duplicate-identifier
@@ -116,3 +117,16 @@ describe("registry invariants (all analyzable pickers)", () => {
     expect(buildPickerAnalyzerSpec("lens").dimensions[0].entryIds).toEqual(LENSES.map((l) => l.id))
   })
 })
+
+describe("personCleanup (W1-a: minor-age floor)", () => {
+  it("drops flagged ids from the patch when the patch itself is a minor", () => {
+    const patch: Record<string, unknown> = {
+      age: "age-child",
+      bust: "bust-full",
+      lipState: ["lip-state-glossy", "lip-state-bold-red"],
+    }
+    PICKER_ANALYZER_REGISTRY.person.cleanup?.(patch, "fill-empty")
+    expect(patch.bust).toBeUndefined()
+    expect(patch.lipState).toEqual(["lip-state-bold-red"])
+  })
+})

package/src/__tests__/retired-hint-strings.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest"
+import { getAdultOnlyHintStrings, RETIRED_ADULT_ONLY_HINT_STRINGS } from "../age-floor.js"
+
+/**
+ * W1-b (spec 2026-09-01 §3.3) rewords 17 catalog hints that W1-a (PR 2) had
+ * flagged `adultOnly`. The backend `minor-age-floor` policy strips sentences
+ * by STRING, so a rewording silently narrows the floor for every consumer
+ * still on the pre-rephrase `@nodaro/prompts` — including person.nodaro.ai,
+ * whose client-assembled `seedPrompt` is precisely how the 2026-07-30 P0
+ * prompts carried `state-fitted`'s clause to the provider.
+ *
+ * The retired strings therefore stay in the strip set forever. A retired
+ * string can only over-strip, and only for a subject already judged a minor.
+ */
+describe("retired adult-only wording stays inside the floor", () => {
+  it("every retired string is still returned by getAdultOnlyHintStrings()", () => {
+    const live = new Set(getAdultOnlyHintStrings())
+    const missing = RETIRED_ADULT_ONLY_HINT_STRINGS.filter((s) => !live.has(s.toLowerCase()))
+    expect(missing, "retired strings dropped out of the floor").toEqual([])
+  })
+
+  it("the 2026-07-30 incident clause is in the set by name", () => {
+    expect(getAdultOnlyHintStrings()).toContain(
+      "the clothing fitted and form-conscious, hugging the contours of the body",
+    )
+    expect(getAdultOnlyHintStrings()).toContain("wearing a cropped style, midriff and navel visible")
+    expect(getAdultOnlyHintStrings()).toContain("with lips slightly parted, taking a soft breath")
+  })
+
+  it("the NEW wording is a live needle too — the floor tracks the rephrase forward", () => {
+    // The derivation makes this true by construction, but nothing else states
+    // it: a future edit that drops a hint under the `length >= 8` filter, or
+    // an entry quietly losing `adultOnly`, would narrow the floor silently.
+    // (Green only after Task 5; see that task's Step 7 run set.)
+    const strings = getAdultOnlyHintStrings()
+    expect(strings).toContain("tailored, close-fitting clothing")
+    expect(strings).toContain("with a cropped hemline")
+  })
+
+  it("no bare derived TERM leaked into the needle set (the promptHint-only contract)", () => {
+    const strings = getAdultOnlyHintStrings()
+    for (const t of ["lounging", "cropped top", "school uniform", "lying down", "wet clothing", "bare shoulders"]) {
+      expect(strings, `term "${t}" must never be a needle`).not.toContain(t)
+    }
+  })
+
+  it("every retired string is lower-case and long enough to survive the length filter", () => {
+    for (const s of RETIRED_ADULT_ONLY_HINT_STRINGS) {
+      expect(s, s).toBe(s.toLowerCase())
+      expect(s.length, s).toBeGreaterThanOrEqual(8)
+    }
+  })
+
+  it("the set covers all 15 flagged rephrased entries plus the fold literal", () => {
+    // 15 flagged promptHints (the 14 flagged person/styling entries plus the
+    // pose twin) + the hard-coded fold literal = 16. `promptHint`s only —
+    // never terms. A change to the count must be a deliberate edit here, not
+    // a silent drift.
+    expect(RETIRED_ADULT_ONLY_HINT_STRINGS.length).toBe(16)
+  })
+
+  it("the list is longest-first, matching getAdultOnlyHintStrings' contract", () => {
+    const strings = getAdultOnlyHintStrings()
+    for (let i = 1; i < strings.length; i++) {
+      expect(strings[i - 1].length).toBeGreaterThanOrEqual(strings[i].length)
+    }
+  })
+})

package/src/__tests__/subject-registry.test.ts

@@ -218,7 +218,7 @@ describe("renderSubjectHints — the flat-bag behaviors", () => {
       { distinctiveFeature: ["feature-midriff-visible", "feature-navel-visible"] },
       IMAGE,
     )
-    expect(out).toEqual(["wearing a cropped style, midriff and navel visible"])
+    expect(out).toEqual(["with a cropped hemline and the navel showing"])
   })
 
   it("de-duplicates an exact repeated clause, first occurrence winning", () => {

package/src/__tests__/w1b-rephrase.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest"
+import { PEOPLE } from "../person.js"
+import { STYLINGS } from "../styling.js"
+import { POSES } from "../pose.js"
+import { PICKER_CATALOGS } from "../picker-catalogs.js"
+import { RETIRED_ADULT_ONLY_HINT_STRINGS } from "../age-floor.js"
+
+/**
+ * W1-b — spec 2026-09-01-app-reports-triage-design.md §3.3, wording approved
+ * by §10 decisions 1 and 6.
+ *
+ * 12 adult `generate-character` prompts were refused by the provider's safety
+ * filter because stacked picker fragments read as sexualized. The principle:
+ * describe the garment or the look, not exposed skin; drop
+ * "wet / sheen / exposed / bare / hugging / soft breath"; keep the attribute
+ * renderable.
+ *
+ * SCOPE RULING, LATER RESOLVED (replay-harness verdict, internal validation
+ * results, 2026-09-02): the go/no-go criterion initially failed for TWO
+ * entries — `eye-state-half-lidded` and `feature-collarbone-visible`
+ * rendered their attribute 0/10 and 0/22 times under either wording, so
+ * their approved rewording could not be validated at the time and both
+ * shipped byte-identical in the original W1-b PR. A follow-up replay on
+ * staging found wordings that DO render, approved 2026-09-03. Both are now
+ * included in PERSON_EXPECTED below with BOTH `promptHint` and `term`
+ * reworded, like every other entry — the compact-mode term is not left
+ * carrying the old wording.
+ *
+ * This file pins BOTH fields of every reworded entry — `promptHint` (verbose
+ * mode) and `term` (compact mode) — because a rephrase that touched only one
+ * of them would leave the old wording reachable through the other. The last
+ * test is the ratchet: no retired string may reappear anywhere in the
+ * catalog corpus.
+ */
+
+interface Expected {
+  readonly id: string
+  readonly promptHint: string
+  readonly term: string
+}
+
+const PERSON_EXPECTED: ReadonlyArray<Expected> = [
+  { id: "bust-very-full", promptHint: "a fuller bust", term: "fuller bust" },
+  { id: "silhouette-hourglass", promptHint: "an hourglass figure", term: "hourglass figure" },
+  { id: "waist-defined", promptHint: "a defined waistline", term: "defined waistline" },
+  { id: "lip-state-glossy", promptHint: "with a glossy lip finish", term: "glossy lips" },
+  { id: "lip-state-parted", promptHint: "with lips relaxed and slightly open, as if mid-sentence", term: "lips slightly open" },
+  { id: "lip-state-bitten", promptHint: "lightly biting the lower lip", term: "biting lower lip" },
+  { id: "eye-state-staring-camera", promptHint: "looking directly into the camera", term: "direct gaze to camera" },
+  { id: "eye-state-half-lidded", promptHint: "with drowsy, partly closed eyes, the lids sitting low over the iris", term: "drowsy, partly closed eyes" },
+  { id: "texture-dewy", promptHint: "with dewy, luminous skin", term: "dewy skin" },
+  { id: "texture-glistening", promptHint: "with a light glistening sheen on the skin", term: "glistening sheen" },
+  { id: "texture-baby-soft", promptHint: "with soft, fine-pored skin", term: "soft fine-pored skin" },
+  { id: "texture-shower-fresh-wet", promptHint: "with fresh, water-dappled skin as if just out of the shower", term: "water-dappled skin" },
+  { id: "feature-bare-shoulders", promptHint: "with the shoulders uncovered", term: "shoulders uncovered" },
+  { id: "feature-collarbone-visible", promptHint: "with an open neckline that leaves the collarbones uncovered", term: "open neckline, collarbones uncovered" },
+  { id: "feature-midriff-visible", promptHint: "with a cropped hemline", term: "cropped hemline" },
+]
+
+const STYLING_EXPECTED: ReadonlyArray<Expected> = [
+  { id: "state-fitted", promptHint: "tailored, close-fitting clothing", term: "close-fitting clothing" },
+  { id: "state-wet", promptHint: "the clothing soaked through and dripping", term: "soaked clothing" },
+]
+
+const POSE_EXPECTED: ReadonlyArray<Expected> = [
+  { id: "biting-lip", promptHint: "lightly biting the lower lip, a subtle playful expression", term: "biting lower lip" },
+]
+
+function check(catalog: ReadonlyArray<{ id: string; promptHint: string; term?: string }>, expected: ReadonlyArray<Expected>) {
+  for (const want of expected) {
+    const entry = catalog.find((e) => e.id === want.id)
+    expect(entry, `missing entry ${want.id}`).toBeDefined()
+    expect(entry!.promptHint, `${want.id}.promptHint`).toBe(want.promptHint)
+    expect(entry!.term, `${want.id}.term (authored, not label-derived)`).toBe(want.term)
+  }
+}
+
+describe("W1-b rephrase — the 17 reworded entries plus the pose twin", () => {
+  it("person entries carry the approved promptHint and term", () => {
+    check(PEOPLE, PERSON_EXPECTED)
+  })
+
+  it("eye-state-half-lidded and feature-collarbone-visible keep adultOnly through the rework", () => {
+    const halfLidded = PEOPLE.find((e) => e.id === "eye-state-half-lidded")
+    expect(halfLidded?.adultOnly).toBe(true)
+
+    const collarbone = PEOPLE.find((e) => e.id === "feature-collarbone-visible")
+    expect(collarbone?.adultOnly).toBe(true)
+  })
+
+  it("styling entries carry the approved promptHint and term", () => {
+    check(STYLINGS, STYLING_EXPECTED)
+  })
+
+  it("the pose twin of lip-state-bitten is reworded to match", () => {
+    check(POSES, POSE_EXPECTED)
+  })
+
+  it("all 18 ids are covered — the count is deliberate, not incidental", () => {
+    expect(PERSON_EXPECTED.length + STYLING_EXPECTED.length + POSE_EXPECTED.length).toBe(18)
+  })
+
+  it("RATCHET: no retired string survives anywhere in the catalog corpus", () => {
+    const offenders: string[] = []
+    for (const cat of PICKER_CATALOGS) {
+      const options = [...(cat.options ?? []), ...(cat.dimensions ?? []).flatMap((d) => d.options)]
+      for (const o of options) {
+        for (const retired of RETIRED_ADULT_ONLY_HINT_STRINGS) {
+          // The fold literal is not an entry field; it is pinned separately in
+          // person-exposure-hints.test.ts.
+          if (o.promptHint === retired || o.term === retired) {
+            offenders.push(`${cat.catalogId} • ${o.id} • "${retired}"`)
+          }
+        }
+      }
+    }
+    expect(offenders, `retired wording is still live:\n${offenders.join("\n")}`).toEqual([])
+  })
+})

package/src/action-fx.ts

@@ -18,6 +18,7 @@
  */
 
 import { resolveTerm, type PickerHintMode } from "./term.js"
+import { overlayEntry } from "./catalog-overlay.js"
 
 export type ActionFxCategory =
   | "disaster"
@@ -224,7 +225,7 @@ const actionFxById = new Map<string, ActionFx>(ACTION_FX.map((fx) => [fx.id, fx]
 
 export function getActionFx(id: string | undefined | null): ActionFx | undefined {
   if (!id) return undefined
-  return actionFxById.get(id)
+  return overlayEntry("action-fx", id, actionFxById.get(id))
 }
 
 export function getActionFxLabel(id: string | undefined | null, fallback?: string): string {

package/src/aesthetic.ts

@@ -20,6 +20,7 @@
  */
 
 import { resolveTerm, type PickerHintMode } from "./term.js"
+import { overlayEntry } from "./catalog-overlay.js"
 
 export type AestheticCategory = "mainstream" | "niche" | "era" | "mood"
 
@@ -400,7 +401,7 @@ const aestheticById = new Map<string, Aesthetic>(
 
 export function getAesthetic(id: string | undefined | null): Aesthetic | undefined {
   if (!id) return undefined
-  return aestheticById.get(id)
+  return overlayEntry("aesthetic", id, aestheticById.get(id))
 }
 
 export function getAestheticLabel(id: string | undefined | null, fallback?: string): string {