@bastani/atomic 0.9.10 → 0.9.11-alpha.10

package/dist/builtin/workflows/skills/impeccable/scripts/hook.mjs

@@ -1,19 +1,25 @@
 #!/usr/bin/env node
 /**
- * Impeccable design hook — PostToolUse entry point.
+ * Impeccable design hook — PostToolUse + Stop entry point.
  *
- * Reads the Claude Code / Codex / Cursor hook event from stdin, runs the design
- * detector against the touched file, and emits a system reminder via
- * `hookSpecificOutput.additionalContext` when findings exist.
+ * Reads the Claude Code, Codex, or GitHub Copilot hook event from stdin and routes by
+ * `hook_event_name`:
+ *
+ *   - PostToolUse: runs the immediate-tier detector rules against the touched
+ *     file and emits a system reminder via
+ *     `hookSpecificOutput.additionalContext` when findings exist.
+ *   - Stop: runs the FULL detector rule set over every UI file touched this
+ *     session (the deep pass), deduped against what the per-edit pass already
+ *     surfaced, and emits once via the Stop additionalContext channel.
  *
  * Contract: never break a turn. Always exit 0. Clean files emit a small ack
- * unless quiet mode is enabled.
+ * unless quiet mode is enabled; a clean Stop pass is silent.
  *
  * Most logic lives in `hook-lib.mjs` so it is unit-testable without a
  * subprocess. This file is the thin stdin/stdout adapter.
  */
 
-import { runHook, writeAuditLog } from './hook-lib.mjs';
+import { runHook, runStopHook, writeAuditLog } from './hook-lib.mjs';
 
 async function readStdin() {
   if (process.stdin.isTTY) return '';
@@ -22,6 +28,16 @@ async function readStdin() {
   return Buffer.concat(chunks).toString('utf-8');
 }
 
+function isStopEvent(stdinJson) {
+  try {
+    const event = JSON.parse(stdinJson);
+    return event && typeof event === 'object' && event.hook_event_name === 'Stop';
+  } catch {
+    // Malformed stdin falls through to runHook, which audits the skip.
+    return false;
+  }
+}
+
 async function main() {
   // Snapshot the inherited env FIRST so the re-entrancy guard checks the
   // parent's value, not the value we are about to export for any child
@@ -32,7 +48,8 @@ async function main() {
   let stdinJson = '';
   try { stdinJson = await readStdin(); } catch { /* fall through */ }
 
-  const result = await runHook({
+  const run = isStopEvent(stdinJson) ? runStopHook : runHook;
+  const result = await run({
     stdinJson,
     env: inheritedEnv,
     cwd: process.cwd(),
@@ -50,7 +67,7 @@ main().catch((err) => {
   try {
     writeAuditLog(process.env, {
       ts: new Date().toISOString(),
-      event: 'PostToolUse',
+      event: 'hook-error',
       error: String(err && err.message ? err.message : err),
     });
   } catch { /* swallow */ }

package/dist/builtin/workflows/skills/impeccable/scripts/lib/artifact-schema.mjs

@@ -0,0 +1,93 @@
+/**
+ * Schema versions for the artifacts Impeccable writes, plus the readers and
+ * writers for the PRODUCT.md provenance stamp.
+ *
+ * Why schema versions rather than the skill version: a PRODUCT.md written by
+ * v4.0.0 is not stale under v4.0.1, so stamping the release version would make
+ * every artifact "old" on every patch. A schema version changes only when the
+ * shape changes, which is exactly when a migration is owed. It also gives the
+ * writing flows a literal constant to copy instead of a value they would have
+ * to look up.
+ *
+ * DESIGN.md deliberately carries no stamp. It follows the external
+ * design.md spec that Stitch's linter validates, and an extra frontmatter key
+ * risks failing that lint for no gain: every DESIGN.md staleness signal
+ * (sidecar schema version, sidecar mtime, section coverage, git drift) is
+ * measurable without one.
+ */
+
+/** PRODUCT.md as init.md writes it today: the ten-section v4 record. */
+export const PRODUCT_SCHEMA_VERSION = 1;
+
+/** `.impeccable/design.json`, as documented in reference/document.md Step 4b. */
+export const DESIGN_SIDECAR_SCHEMA_VERSION = 2;
+
+/**
+ * Sections init.md added in v4. A PRODUCT.md carrying none of them, and no
+ * stamp, predates the current record. Used only as a fallback: an explicit
+ * stamp always wins.
+ */
+export const PRODUCT_V4_SECTIONS = Object.freeze([
+  'Positioning',
+  'Operating Context',
+  'Evidence on Hand',
+  'Product Principles',
+]);
+
+/**
+ * Headings Impeccable used to read and no longer does, with the reason. The
+ * agent needs the reason: told only that a field is deprecated it tends to
+ * preserve it "just in case", which is how a v3 register value keeps steering
+ * v4 output.
+ */
+export const PRODUCT_DEPRECATED_SECTIONS = Object.freeze({
+  Register: 'v4 replaced the brand/product register axis with the four visitor modes '
+    + '(Persuade, Operate, Read, Experience), which are chosen per surface and persisted in that '
+    + "surface's brief. Nothing reads `## Register` any more.",
+});
+
+const PRODUCT_STAMP_RE = /^[ \t]*<!--[ \t]*impeccable:product-schema[ \t]+(\d+)[ \t]*-->[ \t]*$/im;
+
+/** The literal stamp line, for the init template and for migrations. */
+export function productStampLine(version = PRODUCT_SCHEMA_VERSION) {
+  return `<!-- impeccable:product-schema ${version} -->`;
+}
+
+/**
+ * Schema version stamped in a PRODUCT.md body, or null when unstamped. Null
+ * means "written before stamping existed", not "invalid".
+ */
+export function readProductSchemaVersion(markdown) {
+  const match = String(markdown || '').match(PRODUCT_STAMP_RE);
+  if (!match) return null;
+  const version = Number.parseInt(match[1], 10);
+  return Number.isInteger(version) ? version : null;
+}
+
+/**
+ * Add or update the stamp, returning the new body. Idempotent. A stamped file
+ * keeps the stamp where it already sits so a migration never reorders the
+ * user's prose; an unstamped file gets it directly under the leading `#`
+ * heading, or at the top when there is none.
+ */
+export function stampProductSchema(markdown, version = PRODUCT_SCHEMA_VERSION) {
+  const body = String(markdown || '');
+  const line = productStampLine(version);
+  if (PRODUCT_STAMP_RE.test(body)) return body.replace(PRODUCT_STAMP_RE, line);
+
+  const lines = body.split('\n');
+  const headingIndex = lines.findIndex((entry) => /^#\s+\S/.test(entry));
+  if (headingIndex === -1) return `${line}\n\n${body.replace(/^\n+/, '')}`;
+  lines.splice(headingIndex + 1, 0, '', line);
+  return lines.join('\n');
+}
+
+/**
+ * Schema version of a parsed design.json. Returns null for a missing or
+ * non-numeric field, which is how schemaVersion-1-era sidecars present
+ * (the field predates the v2 rewrite in some files).
+ */
+export function readSidecarSchemaVersion(sidecar) {
+  const version = sidecar && typeof sidecar === 'object' ? sidecar.schemaVersion : null;
+  return Number.isInteger(version) ? version : null;
+}

package/dist/builtin/workflows/skills/impeccable/scripts/lib/composition-catalog.mjs

@@ -0,0 +1,165 @@
+import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { CONCEPT_STATUSES, normalizeConceptForm } from './concept-catalog.mjs';
+
+// Catalog B: stagings rather than styles. A composition organizes attention,
+// sequence, or manipulation on a surface and must survive being dressed in
+// any committed visual identity; it deliberately carries no palette or type
+// half. Surface-scope seeds draw from here (plus catalog A duals); direction
+// seeds pair one composition with a chosen world for the first surface.
+
+export const COMPOSITION_GRAMMAR_PREFIXES = [
+  'Staging/hierarchy:',
+  'Sequence/attention:',
+  'Controls/state:',
+  'Adaptation:',
+];
+
+// Surfaces align with the skill's modes: a persuade staging and an operate
+// staging are different species, and read/experience surfaces get their own.
+export const COMPOSITION_SURFACES = new Set(['persuade', 'operate', 'read', 'experience']);
+
+export function compositionContentHash(composition) {
+  const payload = [
+    composition?.form ?? '',
+    composition?.lineage ?? '',
+    JSON.stringify(composition?.tags ?? []),
+    JSON.stringify(composition?.grammar ?? []),
+    composition?.spark ?? '',
+    composition?.webLeverage ?? '',
+  ].join('\n');
+  return crypto.createHash('sha256').update(payload).digest('hex').slice(0, 12);
+}
+
+export function validateCompositionEntry(composition, { existingForms = new Map() } = {}) {
+  const errors = [];
+  const id = composition?.id || '(unknown)';
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(composition?.id || '')) {
+    errors.push(`invalid composition id: ${String(composition?.id)}`);
+  }
+  const normalized = normalizeConceptForm(composition?.form);
+  if (!normalized) {
+    errors.push(`composition ${id} needs a form`);
+  } else if (existingForms.has(normalized)) {
+    errors.push(`duplicate composition form: ${id} and ${existingForms.get(normalized)}`);
+  }
+  if (typeof composition?.form !== 'string'
+    || composition.form.trim().length < 40
+    || composition.form.trim().length > 360
+    || !composition.form.includes(',')) {
+    errors.push(`composition ${id} must name a staging and its structural mechanism after a comma`);
+  }
+  if (typeof composition?.lineage !== 'string'
+    || composition.lineage.trim().length < 12
+    || composition.lineage.trim().length > 200) {
+    errors.push(`composition ${id} needs lineage metadata of 12–200 characters`);
+  }
+  if (!COMPOSITION_SURFACES.has(composition?.surface)) {
+    errors.push(`composition ${id} needs a surface of ${[...COMPOSITION_SURFACES].join(', ')}`);
+  }
+  if (!Array.isArray(composition?.tags)
+    || composition.tags.length !== 3
+    || composition.tags.some(tag => typeof tag !== 'string' || !tag.trim())) {
+    errors.push(`composition ${id} must have exactly three structural tags`);
+  }
+  if (!Array.isArray(composition?.grammar)
+    || composition.grammar.length !== COMPOSITION_GRAMMAR_PREFIXES.length
+    || composition.grammar.some(rule => typeof rule !== 'string' || rule.trim().length < 12 || rule.trim().length > 180)) {
+    errors.push(`composition ${id} needs grammar with exactly four rules of 12–180 characters`);
+  } else {
+    const unique = new Set(composition.grammar.map(normalizeConceptForm));
+    if (unique.size !== COMPOSITION_GRAMMAR_PREFIXES.length) {
+      errors.push(`composition ${id} has duplicate grammar rules`);
+    }
+    if (composition.grammar.some((rule, index) => !rule.startsWith(COMPOSITION_GRAMMAR_PREFIXES[index]))) {
+      errors.push(`composition ${id} grammar must use staging, sequence, controls, and adaptation prefixes in order`);
+    }
+  }
+  if (typeof composition?.spark !== 'string'
+    || composition.spark.trim().length < 80
+    || composition.spark.trim().length > 320) {
+    errors.push(`composition ${id} needs a vivid spark of 80–320 characters`);
+  }
+  if (typeof composition?.webLeverage !== 'string'
+    || composition.webLeverage.trim().length < 20
+    || composition.webLeverage.trim().length > 240) {
+    errors.push(`composition ${id} needs web leverage of 20–240 characters`);
+  }
+  return errors;
+}
+
+export function readCompositionCatalog(catalogPath, reviewsPath) {
+  const catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+  const reviewData = JSON.parse(readFileSync(reviewsPath, 'utf8'));
+  const reviews = reviewData.reviews || {};
+  const familiesById = new Map((catalog.families || []).map(family => [family.id, family]));
+  const compositions = (catalog.compositions || []).map(composition => ({
+    ...composition,
+    familyLabel: familiesById.get(composition.familyId)?.label || null,
+    status: reviews[composition.id]?.status || 'pending',
+    review: reviews[composition.id] || null,
+  }));
+  return { catalog, reviewData, reviews, compositions };
+}
+
+export function validateCompositionCatalog(catalog, reviewData, { minimumTotal } = {}) {
+  const errors = [];
+  const familyIds = new Set();
+  const ids = new Set();
+  const forms = new Map();
+
+  if (!Number.isInteger(catalog?.schemaVersion) || catalog.schemaVersion < 1) {
+    errors.push('composition catalog schemaVersion must be a positive integer');
+  }
+  if (typeof catalog?.qualityBar?.principle !== 'string' || catalog.qualityBar.principle.trim().length < 80) {
+    errors.push('composition qualityBar.principle must define the staging bar');
+  }
+  if (!Array.isArray(catalog?.families) || catalog.families.length < 4) {
+    errors.push('composition catalog needs at least four families');
+  }
+  for (const family of catalog?.families || []) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(family.id || '')) errors.push(`invalid composition family id: ${String(family.id)}`);
+    if (familyIds.has(family.id)) errors.push(`duplicate composition family id: ${family.id}`);
+    familyIds.add(family.id);
+    if (typeof family.description !== 'string' || family.description.trim().length < 40) {
+      errors.push(`composition family ${family.id || '(unknown)'} needs a description`);
+    }
+  }
+  for (const composition of catalog?.compositions || []) {
+    if (ids.has(composition.id)) errors.push(`duplicate composition id: ${composition.id}`);
+    ids.add(composition.id);
+    if (!familyIds.has(composition.familyId)) {
+      errors.push(`composition ${composition.id} must belong to a declared family, got: ${String(composition.familyId)}`);
+    }
+    errors.push(...validateCompositionEntry(composition, { existingForms: forms }));
+    const normalized = normalizeConceptForm(composition.form);
+    if (normalized) forms.set(normalized, composition.id);
+  }
+  if (minimumTotal !== undefined && (catalog?.compositions || []).length < minimumTotal) {
+    errors.push(`expected at least ${minimumTotal} compositions, found ${(catalog?.compositions || []).length}`);
+  }
+  for (const [id, review] of Object.entries(reviewData?.reviews || {})) {
+    if (!ids.has(id)) errors.push(`composition review references missing entry: ${id}`);
+    if (!CONCEPT_STATUSES.has(review?.status)) errors.push(`invalid composition review status for ${id}`);
+    if (typeof review?.formHash !== 'string' || !review.formHash.trim()) {
+      errors.push(`composition review ${id} needs a formHash`);
+    } else {
+      const entry = (catalog?.compositions || []).find(composition => composition.id === id);
+      if (entry && review.formHash !== compositionContentHash(entry)) {
+        errors.push(`composition review ${id} is stale: content changed since review`);
+      }
+    }
+    if (review?.note !== undefined && (typeof review.note !== 'string' || !review.note.trim() || review.note.length > 500)) {
+      errors.push(`composition review ${id} note must be a non-empty string of 500 characters or fewer`);
+    }
+  }
+  return {
+    errors,
+    stats: {
+      families: familyIds.size,
+      compositions: (catalog?.compositions || []).length,
+      approved: Object.values(reviewData?.reviews || {}).filter(review => review?.status === 'approved').length,
+      rejected: Object.values(reviewData?.reviews || {}).filter(review => review?.status === 'rejected').length,
+    },
+  };
+}

package/dist/builtin/workflows/skills/impeccable/scripts/lib/concept-catalog.mjs

@@ -0,0 +1,329 @@
+import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+export const CONCEPT_STATUSES = new Set(['approved', 'rejected']);
+
+// What a concept is actually strong at. Worlds carry a durable visual
+// identity (their palette/type half is the magnet); compositions carry a
+// staging or interaction idea (their topology half is the magnet) that can be
+// dressed in any committed identity; duals fuse both inseparably. Direction
+// seeds draw world|dual, surface seeds draw composition|dual.
+export const CONCEPT_STRENGTHS = new Set(['world', 'composition', 'dual']);
+
+// Challenger tiers, ordered by translation cost: graphic grammars map to
+// interface almost directly, instrument languages carry interaction physics,
+// atmosphere worlds need the largest translation step. Every seed roll draws
+// one challenger from each tier so at least one directly-usable graphic
+// system is always on the table.
+export const WELL_TIERS = ['graphic', 'interaction', 'atmosphere'];
+
+const WEB_LEVERAGE_RE = /(?:\b3d\b|\badaptive\b|\banimat(?:e|ed|ion)\b|\bapi\b|\baria\b|\baudio\b|\bautomated?\b|\bbarcode\b|\bbroadcastchannel\b|\bbrowser\b|\bcamera\b|canvas\b|\bcaption\b|\bcollaborat(?:e|ive|ion)\b|\bcompar(?:e|ison)\b|\bcomput(?:e|ed|ation)\b|\bcomputer[- ]vision\b|\bconstraint[- ]solving\b|\bcryptographic?\b|\bcss\b|\bdeep[- ]link(?:ing)?\b|\bdirect manipulation\b|\bdom\b|\bdrag\b|\bfilter\b|\bfocus\b|\bgenerative\b|\bgeolocat(?:e|ed|ion)\b|\bgesture\b|\bgpu\b|\bgraph\b|\bhistory\b|\bindexeddb\b|\binteractive\b|\bintersectionobserver\b|\bkeyboard\b|\blive\b|\blocal\b|\bmicrophone\b|\bmotion\b|\bmultiplayer\b|\bnative\b|\bnotification\b|\boffline\b|\bpersonaliz(?:e|ed|ation)\b|\bplayable\b|\bpointer\b|\bprocedural\b|\bprovenance\b|\breal[- ]?time\b|\bresizeobserver\b|\bresponsive\b|\breveal\b|\bscrub\b|\bsearch\b|\bsearchparams\b|\bsensor\b|\bserver[- ]sent\b|\bservice worker\b|\bshader\b|\bsimulat(?:e|ed|ion|or)\b|\bspatial\b|\bstate\b|\bstream(?:ing)?\b|\bsvg\b|\bsynchroniz(?:e|ed|ation)\b|\btimeline\b|\btouch\b|\burl|\bvideo\b|\bweb(?:gl|socket|vtt)?\b|\bworker\b|\bzoom\b)/i;
+export const SYSTEM_PREFIXES = [
+  'Palette/material:',
+  'Type/composition:',
+  'Topology/navigation:',
+  'Controls/state:',
+  'Responsive/motion:',
+];
+const BLAND_FORM_RE = /\b(?:control room|command center|operations center|dispatch desk|review queue|speaker queue|management console|admin console|operator loop|coordination system|tracking system|planning system|software platform|digital platform|operations cockpit|app portal|web portal|data hub|dashboard|workflow|planner|tracker|orchestrator)\b/i;
+
+export function normalizeConceptForm(value) {
+  return String(value || '')
+    .normalize('NFKD')
+    .toLowerCase()
+    .replace(/[’‘]/g, "'")
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+}
+
+export function validateConceptEntry(concept, { existingForms = new Map() } = {}) {
+  const errors = [];
+  const id = concept?.id || '(unknown)';
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(concept?.id || '')) {
+    errors.push(`invalid concept id: ${String(concept?.id)}`);
+  }
+
+  const normalized = normalizeConceptForm(concept?.form);
+  if (!normalized) {
+    errors.push(`concept ${id} needs a form`);
+  } else if (existingForms.has(normalized)) {
+    errors.push(`duplicate concept form: ${id} and ${existingForms.get(normalized)}`);
+  }
+  if (typeof concept?.form !== 'string'
+    || concept.form.trim().length < 40
+    || concept.form.trim().length > 360
+    || !concept.form.includes(',')) {
+    errors.push(`concept ${id} must name a form and inherited structure after a comma`);
+  }
+  if (typeof concept?.lineage !== 'string'
+    || concept.lineage.trim().length < 12
+    || concept.lineage.trim().length > 200) {
+    errors.push(`concept ${id} needs specific lineage metadata of 12–200 characters`);
+  }
+  if (!CONCEPT_STRENGTHS.has(concept?.strength)) {
+    errors.push(`concept ${id} needs a strength of ${[...CONCEPT_STRENGTHS].join(', ')}`);
+  }
+  if (!Array.isArray(concept?.tags)
+    || concept.tags.length !== 3
+    || concept.tags.some(tag => typeof tag !== 'string' || !tag.trim())) {
+    errors.push(`concept ${id} must have exactly three structural tags`);
+  }
+  if (!Array.isArray(concept?.system)
+    || concept.system.length !== SYSTEM_PREFIXES.length
+    || concept.system.some(rule => typeof rule !== 'string' || rule.trim().length < 12 || rule.trim().length > 180)) {
+    errors.push(`concept ${id} needs system grammar with exactly five rules of 12–180 characters`);
+  } else {
+    const uniqueRules = new Set(concept.system.map(normalizeConceptForm));
+    if (uniqueRules.size !== SYSTEM_PREFIXES.length) {
+      errors.push(`concept ${id} has duplicate system grammar rules`);
+    }
+    if (concept.system.some((rule, index) => !rule.startsWith(SYSTEM_PREFIXES[index]))) {
+      errors.push(`concept ${id} system grammar must use palette, type, topology, controls, and responsive prefixes in order`);
+    }
+  }
+  if (typeof concept?.spark !== 'string'
+    || concept.spark.trim().length < 80
+    || concept.spark.trim().length > 320) {
+    errors.push(`concept ${id} needs a vivid creative spark of 80–320 characters`);
+  }
+  if (typeof concept?.webLeverage !== 'string'
+    || concept.webLeverage.trim().length < 20
+    || concept.webLeverage.trim().length > 240) {
+    errors.push(`concept ${id} needs web leverage of 20–240 characters`);
+  }
+  if (/\b(?:live digital system|shared participatory system) modeled on\b/i.test(concept?.form || '')) {
+    errors.push(`concept ${id} is a generic wrapper around another artifact`);
+  }
+  if (/\b(?:in the style of|styled like|copy of)\b/i.test(concept?.form || '')) {
+    errors.push(`concept ${id} contains imitation language`);
+  }
+  if (BLAND_FORM_RE.test(concept?.form || '')) {
+    errors.push(`concept ${id} is framed as a literal software or operations archetype instead of an inspiring visual world`);
+  }
+  return errors;
+}
+
+// Fingerprint of everything a reviewer judged. Reviews carry this hash so an
+// approval cannot silently survive a content edit: the validator rejects any
+// review whose hash no longer matches the concept it points at.
+export function conceptContentHash(concept) {
+  const payload = [
+    concept?.form ?? '',
+    concept?.lineage ?? '',
+    JSON.stringify(concept?.tags ?? []),
+    JSON.stringify(concept?.system ?? []),
+    concept?.spark ?? '',
+    concept?.webLeverage ?? '',
+  ].join('\n');
+  return crypto.createHash('sha256').update(payload).digest('hex').slice(0, 12);
+}
+
+export function readConceptCatalog(catalogPath, reviewsPath) {
+  const catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+  const reviewData = JSON.parse(readFileSync(reviewsPath, 'utf8'));
+  const reviews = reviewData.reviews || {};
+  const wellsById = new Map((catalog.wells || []).map(well => [well.id, well]));
+  const concepts = [];
+
+  for (const family of catalog.families || []) {
+    for (const concept of family.concepts || []) {
+      concepts.push({
+        ...concept,
+        familyId: family.id,
+        familyLabel: family.label,
+        wellId: family.well || null,
+        wellLabel: wellsById.get(family.well)?.label || null,
+        wellTier: wellsById.get(family.well)?.tier || null,
+        status: reviews[concept.id]?.status || 'pending',
+        review: reviews[concept.id] || null,
+      });
+    }
+  }
+
+  return { catalog, reviewData, reviews, concepts };
+}
+
+export function validateConceptCatalog(catalog, reviewData, {
+  expectedTotal,
+  minimumTotal,
+  requireApprovedMinimum = true,
+} = {}) {
+  const errors = [];
+  const warnings = [];
+  const familyIds = new Set();
+  const conceptIds = new Set();
+  const normalizedForms = new Map();
+  const concepts = [];
+
+  if (!Number.isInteger(catalog?.schemaVersion) || catalog.schemaVersion < 7) {
+    errors.push('catalog.schemaVersion must be 7 or newer');
+  }
+  if (typeof catalog?.catalogVersion !== 'string' || !catalog.catalogVersion.trim()) {
+    errors.push('catalog.catalogVersion must be a non-empty string');
+  }
+  if (typeof catalog?.qualityBar?.principle !== 'string' || catalog.qualityBar.principle.trim().length < 80) {
+    errors.push('catalog.qualityBar.principle must define the universal creative bar');
+  }
+  if (!Array.isArray(catalog?.qualityBar?.rejectIf) || catalog.qualityBar.rejectIf.length < 5) {
+    errors.push('catalog.qualityBar.rejectIf must define at least five rejection gates');
+  }
+  if (!Array.isArray(catalog?.qualityBar?.reviewAxes) || catalog.qualityBar.reviewAxes.length < 8) {
+    errors.push('catalog.qualityBar.reviewAxes must define at least eight review axes');
+  }
+  if (!Array.isArray(catalog?.families) || catalog.families.length < 3) {
+    errors.push('catalog.families must contain at least three families');
+  }
+
+  const wellIds = new Set();
+  if (!Array.isArray(catalog?.wells) || catalog.wells.length < 5) {
+    errors.push('catalog.wells must define at least five inspiration wells');
+  }
+  for (const well of catalog?.wells || []) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(well.id || '')) {
+      errors.push(`invalid well id: ${String(well.id)}`);
+    } else if (wellIds.has(well.id)) {
+      errors.push(`duplicate well id: ${well.id}`);
+    }
+    wellIds.add(well.id);
+    if (typeof well.label !== 'string' || !well.label.trim()) {
+      errors.push(`well ${well.id || '(unknown)'} needs a label`);
+    }
+    if (typeof well.description !== 'string' || well.description.trim().length < 40) {
+      errors.push(`well ${well.id || '(unknown)'} needs a description of at least 40 characters`);
+    }
+    if (!WELL_TIERS.includes(well.tier)) {
+      errors.push(`well ${well.id || '(unknown)'} needs a tier of ${WELL_TIERS.join(', ')}, got: ${String(well.tier)}`);
+    }
+  }
+  const tiersPresent = new Set((catalog?.wells || []).map(well => well.tier).filter(tier => WELL_TIERS.includes(tier)));
+  for (const tier of WELL_TIERS) {
+    if ((catalog?.wells || []).length > 0 && !tiersPresent.has(tier)) {
+      errors.push(`no well declares the ${tier} tier`);
+    }
+  }
+  const populatedWells = new Set();
+
+  for (const family of catalog?.families || []) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(family.id || '')) {
+      errors.push(`invalid family id: ${String(family.id)}`);
+    } else if (familyIds.has(family.id)) {
+      errors.push(`duplicate family id: ${family.id}`);
+    }
+    familyIds.add(family.id);
+    if (typeof family.label !== 'string' || !family.label.trim()) {
+      errors.push(`family ${family.id || '(unknown)'} needs a label`);
+    }
+    if (!wellIds.has(family.well)) {
+      errors.push(`family ${family.id || '(unknown)'} must belong to a declared well, got: ${String(family.well)}`);
+    } else {
+      populatedWells.add(family.well);
+    }
+    if (!Array.isArray(family.concepts) || family.concepts.length === 0) {
+      errors.push(`family ${family.id || '(unknown)'} has no concepts`);
+      continue;
+    }
+
+    for (const concept of family.concepts) {
+      concepts.push(concept);
+      if (conceptIds.has(concept.id)) {
+        errors.push(`duplicate concept id: ${concept.id}`);
+      }
+      errors.push(...validateConceptEntry(concept, { existingForms: normalizedForms }));
+      conceptIds.add(concept.id);
+      const normalized = normalizeConceptForm(concept.form);
+      if (normalized) normalizedForms.set(normalized, concept.id);
+      if (typeof concept.webLeverage === 'string' && !WEB_LEVERAGE_RE.test(concept.webLeverage)) {
+        warnings.push(`concept ${concept.id} web leverage should be checked for a specific browser-native capability`);
+      }
+    }
+  }
+
+  for (const well of catalog?.wells || []) {
+    if (well.id && !populatedWells.has(well.id)) {
+      errors.push(`well ${well.id} has no families`);
+    }
+  }
+
+  if (expectedTotal !== undefined && concepts.length !== expectedTotal) {
+    errors.push(`expected ${expectedTotal} concepts, found ${concepts.length}`);
+  }
+  if (minimumTotal !== undefined && concepts.length < minimumTotal) {
+    errors.push(`expected at least ${minimumTotal} concepts, found ${concepts.length}`);
+  }
+
+  if (!Number.isInteger(reviewData?.schemaVersion) || reviewData.schemaVersion < 2) {
+    errors.push('reviews.schemaVersion must be 2 or newer');
+  }
+  const conceptsById = new Map(concepts.map(concept => [concept.id, concept]));
+  for (const [id, review] of Object.entries(reviewData?.reviews || {})) {
+    if (!conceptIds.has(id)) errors.push(`review references missing concept: ${id}`);
+    if (!CONCEPT_STATUSES.has(review?.status)) errors.push(`invalid review status for ${id}: ${String(review?.status)}`);
+    if (typeof review?.reviewedBy !== 'string' || !review.reviewedBy.trim()) {
+      errors.push(`review ${id} needs reviewedBy`);
+    }
+    if (typeof review?.reviewedAt !== 'string' || Number.isNaN(Date.parse(review.reviewedAt))) {
+      errors.push(`review ${id} needs an ISO reviewedAt timestamp`);
+    }
+    if (typeof review?.formHash !== 'string' || !review.formHash.trim()) {
+      errors.push(`review ${id} needs a formHash of the reviewed content`);
+    } else if (conceptsById.has(id) && review.formHash !== conceptContentHash(conceptsById.get(id))) {
+      errors.push(`review ${id} is stale: concept content changed since it was reviewed; reset or re-review it`);
+    }
+    if (review?.note !== undefined && (typeof review.note !== 'string' || !review.note.trim() || review.note.length > 500)) {
+      errors.push(`review ${id} note must be a non-empty string of 500 characters or fewer`);
+    }
+    // Rating grades how strong an approved concept is (3 exceptional, 2 solid,
+    // 1 marginal keep). Optional, approved-only, and read as a calibration
+    // signal for future authoring rounds.
+    if (review?.rating !== undefined) {
+      if (![1, 2, 3].includes(review.rating)) {
+        errors.push(`review ${id} rating must be 1, 2, or 3`);
+      } else if (review.status !== 'approved') {
+        errors.push(`review ${id} rating only applies to approved concepts`);
+      }
+    }
+  }
+
+  const wellTierById = new Map((catalog?.wells || []).map(well => [well.id, well.tier]));
+  const approved = concepts.filter(concept => reviewData?.reviews?.[concept.id]?.status === 'approved');
+  const approvedTiers = new Set(
+    (catalog?.families || [])
+      .filter(family => family.concepts?.some(concept => reviewData?.reviews?.[concept.id]?.status === 'approved'))
+      .map(family => wellTierById.get(family.well))
+      .filter(tier => WELL_TIERS.includes(tier))
+  );
+  if (requireApprovedMinimum && approved.length < 3) errors.push('at least three concepts must be approved');
+  if (requireApprovedMinimum && approvedTiers.size < WELL_TIERS.length) {
+    errors.push('approved concepts must cover every challenger tier');
+  }
+
+  return {
+    errors,
+    warnings,
+    stats: {
+      wells: wellIds.size,
+      families: familyIds.size,
+      concepts: concepts.length,
+      approved: approved.length,
+      pending: concepts.length - Object.keys(reviewData?.reviews || {}).length,
+      rejected: Object.values(reviewData?.reviews || {}).filter(review => review?.status === 'rejected').length,
+    },
+  };
+}
+
+export function approvedPoolRevision(concepts) {
+  const payload = concepts
+    .filter(concept => concept.status === 'approved')
+    .map(concept => `${concept.familyId}:${concept.id}:${concept.strength}:${concept.form}:${concept.spark}:${JSON.stringify(concept.system)}:${concept.webLeverage}`)
+    .sort()
+    .join('\n');
+  return crypto.createHash('sha256').update(payload).digest('hex').slice(0, 12);
+}
+
+export function deterministicRank(items, input, idFor = item => item.id) {
+  return [...items].sort((a, b) => {
+    const scoreA = crypto.createHash('sha256').update(`${input}:${idFor(a)}`).digest('hex');
+    const scoreB = crypto.createHash('sha256').update(`${input}:${idFor(b)}`).digest('hex');
+    return scoreB.localeCompare(scoreA) || idFor(a).localeCompare(idFor(b));
+  });
+}