@forwardimpact/libsyntheticrender 0.1.2 → 0.1.3

package/index.js

@@ -5,3 +5,4 @@ export { generateDrugs, generatePlatforms } from "./render/industry-data.js";
 export { assignLinks } from "./render/link-assigner.js";
 export { validateLinks, validateHTML } from "./render/validate-links.js";
 export { renderDataset } from "./render/dataset-renderers.js";
+export { validateEvalReferences } from "./validate-eval.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libsyntheticrender",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Multi-format rendering, validation, and formatting for synthetic data",
   "license": "Apache-2.0",
   "repository": {

package/render/enricher.js

@@ -44,10 +44,16 @@ function buildEnrichContext(enrichKey, linked) {
           .slice(0, 3)
           .map((m) => ({ type: "Person", name: m.name, iri: m.iri })),
       ];
+      const narrative = {};
+      if (proj.milestones?.length) narrative.milestones = proj.milestones;
+      if (proj.risks?.length) narrative.risks = proj.risks;
+      if (proj.technical_choices?.length)
+        narrative.technical_choices = proj.technical_choices;
       return {
         entityType: "Project",
         entityName: proj.name,
         mentionTargets: mentions,
+        ...(Object.keys(narrative).length > 0 && { narrative }),
       };
     }
     case "platform": {

package/render/html.js

@@ -9,6 +9,44 @@
 import { generateDrugs, generatePlatforms } from "./industry-data.js";
 import { assignLinks } from "./link-assigner.js";
 
+const FAQ_QUESTIONS = [
+  "What is pharmaceutical engineering and what does it involve?",
+  "How does computational chemistry accelerate drug discovery?",
+  "What are the key phases of clinical trial development?",
+  "How does GMP compliance affect manufacturing processes?",
+  "What role does data science play in pharmaceutical R&D?",
+  "How are biomarkers used in drug development?",
+  "What is the drug approval process and how long does it take?",
+  "How does continuous manufacturing differ from batch processing?",
+  "What are the main challenges in scaling up drug production?",
+  "How do platform engineering teams support drug discovery?",
+  "What regulatory frameworks govern pharmaceutical development?",
+  "How is AI being used in drug candidate screening?",
+  "What quality control measures ensure drug safety?",
+  "How does real-world evidence complement clinical trials?",
+  "What are the key considerations for biologics manufacturing?",
+  "How do cross-functional teams collaborate in drug development?",
+  "What is the role of process analytical technology in manufacturing?",
+  "How are digital twins used in pharmaceutical engineering?",
+  "What sustainability practices are used in drug manufacturing?",
+  "How does pharmacovigilance work after drug approval?",
+  "What are the differences between small molecule and biologic drugs?",
+  "How do adaptive trial designs improve clinical development?",
+  "What is the role of observability in manufacturing systems?",
+  "How are cloud platforms used in pharmaceutical data management?",
+  "What are the key challenges in supply chain management for pharma?",
+  "How does formulation science affect drug delivery?",
+  "What are the best practices for laboratory data management?",
+  "How do engineering teams handle regulatory submission preparation?",
+  "What is the role of DevOps in pharmaceutical software systems?",
+  "How are patient-reported outcomes used in clinical development?",
+  "What are the principles of quality by design in drug manufacturing?",
+  "How does risk management apply to pharmaceutical engineering?",
+  "What emerging technologies are transforming drug development?",
+  "How do companies manage intellectual property in pharma R&D?",
+  "What role does environmental monitoring play in GMP facilities?",
+];
+
 /** Wrap inner HTML in the page shell. */
 function page(templates, title, body, domain) {
   return templates.render("page.html", {
@@ -45,6 +83,18 @@ export function renderHTML(entities, prose, templates) {
   const blogCount = gc?.blogs || 0;
   const articleTopics = gc?.article_topics || [];
 
+  // Extract org name and date range from entities
+  const orgName = entities.orgs?.[0]?.name || domain;
+  const allDates = (entities.scenarios || [])
+    .flatMap((s) => (s.snapshots || []).map((snap) => snap.date))
+    .sort();
+  const startYear = allDates.length
+    ? new Date(allDates[0]).getFullYear()
+    : null;
+  const endYear = allDates.length
+    ? new Date(allDates.at(-1)).getFullYear()
+    : null;
+
   // Assign cross-links deterministically
   const linked = assignLinks({
     drugs,
@@ -59,6 +109,10 @@ export function renderHTML(entities, prose, templates) {
     blogCount,
     articleTopics,
     seed: entities.activity?.seed || 42,
+    orgName,
+    startYear,
+    endYear,
+    blogTopics: gc?.blog_topics || null,
   });
 
   // Enrich platform and drug entities with reverse links
@@ -227,7 +281,7 @@ export function renderHTML(entities, prose, templates) {
             ].filter(Boolean);
             return {
               iri: `https://${domain}/id/faq/faq-${i + 1}`,
-              question: `FAQ Question ${i + 1}`,
+              question: FAQ_QUESTIONS[i % FAQ_QUESTIONS.length],
               answer: prose.get(`faq_${i}`) || `Answer to FAQ ${i + 1}.`,
               aboutLinks,
             };

package/render/link-assigner.js

@@ -50,9 +50,16 @@ export function assignLinks({
   blogCount,
   articleTopics = [],
   seed = 42,
+  orgName = null,
+  startYear = null,
+  endYear = null,
+  blogTopics = null,
 }) {
   const rng = createSeededRNG(seed + 1000);
   const base = `https://${domain}`;
+  const effectiveOrgName = orgName || domain;
+  const effectiveStartYear = startYear || new Date().getFullYear();
+  const yearSpan = endYear && startYear ? endYear - startYear + 1 : 1;
 
   // --- Project linking ---
   const linkedProjects = projects.map((proj) => {
@@ -189,9 +196,9 @@ export function assignLinks({
         platformLink,
         drugLink,
         attendees,
-        date: `2025-${String((i % 12) + 1).padStart(2, "0")}-01`,
-        orgName: "BioNova",
-        orgIri: `${base}/org/headquarters`,
+        date: `${effectiveStartYear + (i % yearSpan)}-${String((i % 12) + 1).padStart(2, "0")}-01`,
+        orgName: effectiveOrgName,
+        orgIri: `${base}/id/org/headquarters`,
       };
     },
   );
@@ -228,7 +235,7 @@ export function assignLinks({
       aboutProjects,
       aboutDrugs,
       aboutPlatforms,
-      date: `2025-${String((i % 12) + 1).padStart(2, "0")}-15`,
+      date: `${effectiveStartYear + (i % yearSpan)}-${String((i % 12) + 1).padStart(2, "0")}-15`,
       location: "Cambridge, MA",
       eventStatus: "EventScheduled",
     };
@@ -253,6 +260,71 @@ export function assignLinks({
     "Open Source in Pharmaceutical R&D",
   ];
 
+  // Weighted topic selection from DSL blog_topics or fallback to BLOG_TOPICS
+  const weightedTopicEntries = blogTopics
+    ? Object.entries(blogTopics).map(([name, weight]) => ({ name, weight }))
+    : null;
+
+  // Title templates per topic — cycle through for variety
+  const TOPIC_TITLES = {
+    drug_discovery: [
+      "Advances in AI-Driven Drug Discovery",
+      "Accelerating Lead Optimization with Computational Methods",
+      "From Target Identification to Clinical Candidate",
+      "Novel Approaches to Drug Screening and Design",
+      "Machine Learning in Molecular Discovery",
+    ],
+    platform_engineering: [
+      "Building Scalable Platform Infrastructure",
+      "Platform Engineering at Scale",
+      "Cloud-Native Architecture for Life Sciences",
+      "Developer Experience and Platform Tooling",
+      "Infrastructure as Code in Practice",
+    ],
+    clinical_development: [
+      "Navigating Complex Clinical Trial Design",
+      "Real-World Evidence in Clinical Development",
+      "Adaptive Trial Strategies for Modern Therapeutics",
+      "Biomarker-Driven Clinical Programs",
+    ],
+    data_science: [
+      "Data Science in Pharmaceutical R&D",
+      "Building Robust Data Pipelines for Drug Development",
+      "Machine Learning Models for Bioprocess Optimization",
+      "Data Mesh Architecture for Pharma",
+    ],
+    engineering_culture: [
+      "Building a Culture of Engineering Excellence",
+      "Cross-Functional Collaboration in Drug Development",
+      "Developer Experience: Lessons Learned",
+      "Mentoring and Growth in Engineering Teams",
+    ],
+  };
+  const topicCounters = {};
+
+  function selectBlogTopic(index) {
+    if (!weightedTopicEntries) return BLOG_TOPICS[index % BLOG_TOPICS.length];
+    const total = weightedTopicEntries.reduce((s, t) => s + t.weight, 0);
+    let r = rng.random() * total;
+    let selectedKey = weightedTopicEntries.at(-1).name;
+    for (const t of weightedTopicEntries) {
+      r -= t.weight;
+      if (r <= 0) {
+        selectedKey = t.name;
+        break;
+      }
+    }
+    // Map topic key to a human-readable title
+    const titles = TOPIC_TITLES[selectedKey];
+    if (!titles)
+      return selectedKey
+        .replace(/_/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+    const count = topicCounters[selectedKey] || 0;
+    topicCounters[selectedKey] = count + 1;
+    return titles[count % titles.length];
+  }
+
   const linkedBlogPosts = Array.from({ length: blogCount }, (_, i) => {
     const author = rng.pick(people);
     const aboutDrugs = rng.shuffle(drugs).slice(0, rng.randomInt(1, 3));
@@ -271,16 +343,16 @@ export function assignLinks({
 
     return {
       index: i + 1,
-      headline: BLOG_TOPICS[i % BLOG_TOPICS.length],
+      headline: selectBlogTopic(i),
       iri: `${base}/id/blog/blog-${i + 1}`,
-      identifier: `BLOG-2025-${String(i + 1).padStart(3, "0")}`,
+      identifier: `BLOG-${effectiveStartYear}-${String(i + 1).padStart(3, "0")}`,
       author,
       aboutDrugs,
       aboutPlatforms,
       aboutProjects,
       mentionsPeople,
       keywords: keywords.join(", "),
-      date: `2025-${String(Math.floor(i / 2) + 1).padStart(2, "0")}-${String(10 + (i % 20)).padStart(2, "0")}`,
+      date: `${effectiveStartYear + (Math.floor(i / 24) % yearSpan)}-${String((Math.floor(i / 2) % 12) + 1).padStart(2, "0")}-${String(10 + (i % 20)).padStart(2, "0")}`,
     };
   });
 
@@ -334,7 +406,7 @@ export function assignLinks({
         ...drugLinks.map((d) => d.name),
         ...platformLinks.map((p) => p.name),
       ].join(", "),
-      date: `2025-${String((i % 12) + 1).padStart(2, "0")}-01`,
+      date: `${effectiveStartYear + (i % yearSpan)}-${String((i % 12) + 1).padStart(2, "0")}-01`,
     };
   });
 

package/render/raw.js

@@ -429,6 +429,7 @@ function renderRoster(entities) {
     level: person.level,
     hire_date: person.hire_date,
     is_manager: person.is_manager || false,
+    archetype: person.archetype || "steady_contributor",
   }));
 
   return YAML.stringify({ roster }, { lineWidth: 120 });
@@ -452,7 +453,7 @@ function renderTeams(entities) {
       department_name: dept?.name || "",
       manager: manager?.name || "",
       manager_email: manager?.email || "",
-      size: team.size,
+      size: members.length,
       members: members.map((m) => ({
         name: m.name,
         email: m.email,

package/test/enricher.test.js

@@ -0,0 +1,64 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { buildEntities } from "@forwardimpact/libsyntheticgen/engine/entities";
+import { createSeededRNG } from "@forwardimpact/libsyntheticgen/rng";
+
+/**
+ * Tests that entity IRIs from entities.js now consistently use /id/{type}/{id}
+ * format, which the enricher's stripOffDomainIris preserves.
+ */
+
+describe("enricher IRI compatibility", () => {
+  const minimalAst = {
+    domain: "test.example",
+    orgs: [{ id: "testorg", name: "TestOrg" }],
+    departments: [{ id: "eng", name: "Engineering", org: "testorg" }],
+    teams: [{ id: "team1", department: "eng", repos: [] }],
+    people: { count: 2, distribution: { L3: 1 }, disciplines: { se: 1 } },
+    projects: [
+      {
+        id: "proj1",
+        type: "drug",
+        teams: ["team1"],
+        prose_topic: "test",
+        prose_tone: "formal",
+      },
+    ],
+  };
+
+  test("all entity IRIs contain /id/ prefix", () => {
+    const rng = createSeededRNG(42);
+    const entities = buildEntities(minimalAst, rng);
+
+    for (const org of entities.orgs) {
+      assert.ok(
+        org.iri.includes("/id/org/"),
+        `Org IRI missing /id/: ${org.iri}`,
+      );
+    }
+    for (const dept of entities.departments) {
+      assert.ok(
+        dept.iri.includes("/id/department/"),
+        `Dept IRI missing /id/: ${dept.iri}`,
+      );
+    }
+    for (const team of entities.teams) {
+      assert.ok(
+        team.iri.includes("/id/team/"),
+        `Team IRI missing /id/: ${team.iri}`,
+      );
+    }
+    for (const person of entities.people) {
+      assert.ok(
+        person.iri.includes("/id/person/"),
+        `Person IRI missing /id/: ${person.iri}`,
+      );
+    }
+    for (const proj of entities.projects) {
+      assert.ok(
+        proj.iri.includes("/id/project/"),
+        `Project IRI missing /id/: ${proj.iri}`,
+      );
+    }
+  });
+});

package/test/industry-data.test.js

@@ -0,0 +1,85 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { generateDrugs, generatePlatforms } from "../render/industry-data.js";
+
+const DOMAIN = "test.example";
+
+describe("generateDrugs", () => {
+  test("returns an array of drug objects", () => {
+    const drugs = generateDrugs(DOMAIN);
+    assert.ok(Array.isArray(drugs));
+    assert.ok(drugs.length > 0);
+  });
+
+  test("each drug has required fields", () => {
+    const drugs = generateDrugs(DOMAIN);
+    for (const drug of drugs) {
+      assert.ok(drug.id, "drug missing id");
+      assert.ok(drug.name, "drug missing name");
+      assert.ok(drug.iri, "drug missing iri");
+      assert.ok(drug.drugClass, "drug missing drugClass");
+      assert.ok(drug.phase, "drug missing phase");
+    }
+  });
+
+  test("drug IRIs use /id/drug/ prefix", () => {
+    const drugs = generateDrugs(DOMAIN);
+    for (const drug of drugs) {
+      assert.ok(
+        drug.iri.includes("/id/drug/"),
+        `Drug IRI missing /id/drug/: ${drug.iri}`,
+      );
+    }
+  });
+
+  test("drug IDs are unique", () => {
+    const drugs = generateDrugs(DOMAIN);
+    const ids = drugs.map((d) => d.id);
+    assert.strictEqual(ids.length, new Set(ids).size);
+  });
+});
+
+describe("generatePlatforms", () => {
+  test("returns an array of platform objects", () => {
+    const platforms = generatePlatforms(DOMAIN);
+    assert.ok(Array.isArray(platforms));
+    assert.ok(platforms.length > 0);
+  });
+
+  test("each platform has required fields", () => {
+    const platforms = generatePlatforms(DOMAIN);
+    for (const p of platforms) {
+      assert.ok(p.id, "platform missing id");
+      assert.ok(p.name, "platform missing name");
+      assert.ok(p.iri, "platform missing iri");
+      assert.ok(p.category, "platform missing category");
+      assert.ok(Array.isArray(p.dependencies), "platform missing dependencies");
+    }
+  });
+
+  test("platform IRIs use /id/platform/ prefix", () => {
+    const platforms = generatePlatforms(DOMAIN);
+    for (const p of platforms) {
+      assert.ok(
+        p.iri.includes("/id/platform/"),
+        `Platform IRI missing /id/platform/: ${p.iri}`,
+      );
+    }
+  });
+
+  test("platform IDs are unique", () => {
+    const platforms = generatePlatforms(DOMAIN);
+    const ids = platforms.map((p) => p.id);
+    assert.strictEqual(ids.length, new Set(ids).size);
+  });
+
+  test("platform dependencies reference valid IDs", () => {
+    const platforms = generatePlatforms(DOMAIN);
+    const ids = new Set(platforms.map((p) => p.id));
+    for (const p of platforms) {
+      for (const dep of p.dependencies) {
+        assert.ok(ids.has(dep), `Platform ${p.id} depends on unknown ${dep}`);
+      }
+    }
+  });
+});

package/test/link-assigner.test.js

@@ -0,0 +1,163 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { assignLinks } from "../render/link-assigner.js";
+import { generateDrugs, generatePlatforms } from "../render/industry-data.js";
+
+const DOMAIN = "test.example";
+
+function makeTestEntities() {
+  const drugs = generateDrugs(DOMAIN);
+  const platforms = generatePlatforms(DOMAIN);
+  const teams = [
+    { id: "alpha", department: "eng", manager: "mgr-a" },
+    { id: "beta", department: "eng", manager: "mgr-b" },
+  ];
+  const departments = [{ id: "eng", name: "Engineering" }];
+  const people = [
+    {
+      id: "alice",
+      name: "Alice",
+      team_id: "alpha",
+      is_manager: true,
+      email: "alice@test.example",
+      github_username: "alice",
+    },
+    {
+      id: "bob",
+      name: "Bob",
+      team_id: "beta",
+      is_manager: true,
+      email: "bob@test.example",
+      github_username: "bob",
+    },
+    {
+      id: "carol",
+      name: "Carol",
+      team_id: "alpha",
+      is_manager: false,
+      email: "carol@test.example",
+      github_username: "carol",
+    },
+    {
+      id: "dave",
+      name: "Dave",
+      team_id: "beta",
+      is_manager: false,
+      email: "dave@test.example",
+      github_username: "dave",
+    },
+  ];
+  const projects = [
+    {
+      id: "proj1",
+      type: "drug",
+      teams: ["alpha"],
+      prose_topic: "testing",
+      prose_tone: "formal",
+    },
+  ];
+
+  return { drugs, platforms, teams, departments, people, projects };
+}
+
+describe("assignLinks", () => {
+  test("returns all expected entity types", () => {
+    const ent = makeTestEntities();
+    const result = assignLinks({
+      ...ent,
+      domain: DOMAIN,
+      courseCount: 3,
+      eventCount: 2,
+      blogCount: 5,
+      articleTopics: ["clinical"],
+      seed: 42,
+    });
+    assert.ok(Array.isArray(result.drugs));
+    assert.ok(Array.isArray(result.platforms));
+    assert.ok(Array.isArray(result.projects));
+    assert.ok(Array.isArray(result.courses));
+    assert.ok(Array.isArray(result.events));
+    assert.ok(Array.isArray(result.blogPosts));
+    assert.ok(Array.isArray(result.articles));
+  });
+
+  test("blog dates are valid for counts exceeding 24", () => {
+    const ent = makeTestEntities();
+    const result = assignLinks({
+      ...ent,
+      domain: DOMAIN,
+      courseCount: 0,
+      eventCount: 0,
+      blogCount: 45,
+      seed: 42,
+    });
+    for (const blog of result.blogPosts) {
+      const parsed = new Date(blog.date);
+      assert.ok(!isNaN(parsed.getTime()), `Invalid date: ${blog.date}`);
+      const month = parseInt(blog.date.split("-")[1], 10);
+      assert.ok(month >= 1 && month <= 12, `Month out of range: ${month}`);
+    }
+  });
+
+  test("project IRIs use /id/ prefix", () => {
+    const ent = makeTestEntities();
+    const result = assignLinks({
+      ...ent,
+      domain: DOMAIN,
+      courseCount: 2,
+      eventCount: 1,
+      blogCount: 1,
+      seed: 42,
+    });
+    for (const proj of result.projects) {
+      assert.ok(
+        proj.iri.includes("/id/project/"),
+        `Project IRI missing /id/: ${proj.iri}`,
+      );
+    }
+  });
+
+  test("course orgName uses provided value instead of hardcoded", () => {
+    const ent = makeTestEntities();
+    const result = assignLinks({
+      ...ent,
+      domain: DOMAIN,
+      courseCount: 3,
+      eventCount: 0,
+      blogCount: 0,
+      seed: 42,
+      orgName: "TestCorp",
+    });
+    for (const course of result.courses) {
+      assert.strictEqual(course.orgName, "TestCorp");
+    }
+  });
+
+  test("dates use provided startYear/endYear", () => {
+    const ent = makeTestEntities();
+    const result = assignLinks({
+      ...ent,
+      domain: DOMAIN,
+      courseCount: 2,
+      eventCount: 2,
+      blogCount: 3,
+      seed: 42,
+      startYear: 2027,
+      endYear: 2028,
+    });
+    for (const course of result.courses) {
+      const year = parseInt(course.date.split("-")[0], 10);
+      assert.ok(
+        year >= 2027 && year <= 2028,
+        `Course year out of range: ${year}`,
+      );
+    }
+    for (const event of result.events) {
+      const year = parseInt(event.date.split("-")[0], 10);
+      assert.ok(
+        year >= 2027 && year <= 2028,
+        `Event year out of range: ${year}`,
+      );
+    }
+  });
+});

package/test/validate-eval.test.js

@@ -0,0 +1,95 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { validateEvalReferences } from "../validate-eval.js";
+
+describe("validateEvalReferences", () => {
+  const generatedData = {
+    orgs: [
+      {
+        iri: "https://test.example/id/org/testorg",
+        name: "TestOrg",
+        id: "testorg",
+      },
+    ],
+    departments: [
+      {
+        iri: "https://test.example/id/department/eng",
+        name: "Engineering",
+        id: "eng",
+      },
+    ],
+    teams: [
+      {
+        iri: "https://test.example/id/team/alpha",
+        name: "Alpha Team",
+        id: "alpha",
+      },
+    ],
+    people: [
+      {
+        iri: "https://test.example/id/person/alice",
+        name: "Alice",
+        id: "alice",
+      },
+    ],
+    projects: [
+      {
+        iri: "https://test.example/id/project/proj1",
+        name: "Project One",
+        id: "proj1",
+      },
+    ],
+  };
+
+  test("passes when all IRI references exist", () => {
+    const scenarios = [
+      {
+        name: "valid_scenario",
+        evaluations: [
+          { data: "https://test.example/id/org/testorg" },
+          { data: "https://test.example/id/project/proj1" },
+        ],
+      },
+    ];
+    const result = validateEvalReferences(scenarios, generatedData);
+    assert.ok(result.passed);
+    assert.strictEqual(result.errors.length, 0);
+  });
+
+  test("reports missing IRI references", () => {
+    const scenarios = [
+      {
+        name: "broken_scenario",
+        evaluations: [{ data: "https://test.example/id/project/nonexistent" }],
+      },
+    ];
+    const result = validateEvalReferences(scenarios, generatedData);
+    assert.ok(!result.passed);
+    assert.strictEqual(result.errors.length, 1);
+    assert.ok(result.errors[0].includes("nonexistent"));
+  });
+
+  test("handles scenarios without evaluations", () => {
+    const scenarios = [{ name: "no_evals" }];
+    const result = validateEvalReferences(scenarios, generatedData);
+    assert.ok(result.passed);
+    assert.strictEqual(result.errors.length, 0);
+  });
+
+  test("handles evaluations without data", () => {
+    const scenarios = [
+      {
+        name: "no_data",
+        evaluations: [{ label: "something" }],
+      },
+    ];
+    const result = validateEvalReferences(scenarios, generatedData);
+    assert.ok(result.passed);
+  });
+
+  test("handles empty scenarios array", () => {
+    const result = validateEvalReferences([], generatedData);
+    assert.ok(result.passed);
+    assert.strictEqual(result.errors.length, 0);
+  });
+});

package/test/validate.test.js

@@ -32,7 +32,7 @@ function buildEntities(overrides = {}) {
       capabilities: [],
       behaviours: [],
       disciplines: [],
-      drivers: [],
+      drivers: [{ id: "code_review" }],
     },
     activity: {
       roster: [{ email: "zeus@acme.com" }, { email: "athena@acme.com" }],

package/validate-eval.js

@@ -0,0 +1,65 @@
+/**
+ * Eval Scenario Reference Validator.
+ *
+ * Validates that entity names and IRIs referenced in eval scenarios
+ * exist in the generated data. Reports missing references.
+ *
+ * @module libuniverse/validate-eval
+ */
+
+/**
+ * Validate eval scenario references against generated data.
+ * @param {object[]} evalScenarios - Parsed eval scenario definitions
+ * @param {object} generatedData - Full entity graph
+ * @returns {{ passed: boolean, errors: string[] }}
+ */
+export function validateEvalReferences(evalScenarios, generatedData) {
+  const errors = [];
+
+  // Build lookup sets from generated data
+  const allIris = new Set();
+  const allNames = new Set();
+
+  const entitySources = [
+    generatedData.orgs,
+    generatedData.departments,
+    generatedData.teams,
+    generatedData.people,
+    generatedData.projects,
+  ];
+
+  for (const source of entitySources) {
+    if (!Array.isArray(source)) continue;
+    for (const entity of source) {
+      if (entity.iri) allIris.add(entity.iri);
+      if (entity.name) allNames.add(entity.name);
+      if (entity.id) allNames.add(entity.id);
+    }
+  }
+
+  // Check each eval scenario
+  for (const scenario of evalScenarios) {
+    if (!scenario.evaluations) continue;
+    for (const evaluation of scenario.evaluations) {
+      const data = evaluation.data;
+      if (!data) continue;
+
+      // Check for IRI references
+      const iriMatches = data.match(/https?:\/\/[^\s"']+\/id\/[^\s"',)]+/g);
+      if (iriMatches) {
+        for (const iri of iriMatches) {
+          if (!allIris.has(iri)) {
+            errors.push(
+              `Scenario "${scenario.name}": IRI "${iri}" not found in generated data`,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    passed: errors.length === 0,
+    errors,
+  };
+}

package/validate.js

@@ -4,6 +4,8 @@
  * @module libuniverse/validate
  */
 
+import { PROFICIENCY_LEVELS } from "@forwardimpact/libsyntheticgen/vocabulary.js";
+
 /**
  * Validate cross-content integrity of generated entities.
  * @param {object} entities
@@ -36,6 +38,9 @@ export function validateCrossContent(entities) {
     checkScorecardCheckIds(entities),
     checkRosterSnapshotQuarters(entities),
     checkProjectTeamEmails(entities),
+    checkProseLength(entities),
+    checkProficiencyMonotonicity(entities),
+    checkSelfAssessmentPlausibility(entities),
   ];
 
   const failures = checks.filter((c) => !c.passed);
@@ -287,25 +292,10 @@ function checkGetDXSnapshotsInfoResponses(entities) {
 
 function checkSnapshotScoreDriverIds(entities) {
   const scores = entities.activity?.scores || [];
-  const VALID_DRIVERS = new Set([
-    "clear_direction",
-    "say_on_priorities",
-    "requirements_quality",
-    "ease_of_release",
-    "test_efficiency",
-    "managing_tech_debt",
-    "code_review",
-    "documentation",
-    "codebase_experience",
-    "incident_response",
-    "learning_culture",
-    "experimentation",
-    "connectedness",
-    "efficient_processes",
-    "deep_work",
-    "leveraging_user_feedback",
-  ]);
-  const invalid = scores.filter((s) => !VALID_DRIVERS.has(s.item_id));
+  const validDrivers = new Set(
+    (entities.framework?.drivers || []).map((d) => d.id),
+  );
+  const invalid = scores.filter((s) => !validDrivers.has(s.item_id));
   return {
     name: "snapshot_score_driver_ids",
     passed: invalid.length === 0,
@@ -331,13 +321,7 @@ function checkScoreTrajectories(entities) {
 
 function checkEvidenceProficiency(entities) {
   const evidence = entities.activity?.evidence || [];
-  const VALID_PROFICIENCIES = new Set([
-    "awareness",
-    "foundational",
-    "working",
-    "practitioner",
-    "expert",
-  ]);
+  const VALID_PROFICIENCIES = new Set(PROFICIENCY_LEVELS);
   const invalid = evidence.filter(
     (e) => e.proficiency && !VALID_PROFICIENCIES.has(e.proficiency),
   );
@@ -512,6 +496,179 @@ function checkProjectTeamEmails(entities) {
   };
 }
 
+// ─── E1: Prose length validation ────────────────
+
+const PROSE_RANGES = {
+  description: { min: 50, max: 2000 },
+  proficiencyDescription: { min: 20, max: 500 },
+  maturityDescription: { min: 20, max: 500 },
+};
+
+function checkProseLength(entities) {
+  const fw = entities.framework;
+  if (!fw)
+    return { name: "prose_length", passed: true, message: "No framework data" };
+
+  const errors = [];
+
+  // Check capabilities for description and proficiency descriptions
+  for (const cap of fw.capabilities || []) {
+    if (typeof cap !== "object") continue;
+    if (cap.description) {
+      const len = cap.description.length;
+      if (
+        len < PROSE_RANGES.description.min ||
+        len > PROSE_RANGES.description.max
+      ) {
+        errors.push(
+          `Capability '${cap.id || cap.name}' description: ${len} chars`,
+        );
+      }
+    }
+  }
+
+  // Check behaviours for description
+  for (const beh of fw.behaviours || []) {
+    if (typeof beh !== "object") continue;
+    if (beh.description) {
+      const len = beh.description.length;
+      if (
+        len < PROSE_RANGES.description.min ||
+        len > PROSE_RANGES.description.max
+      ) {
+        errors.push(
+          `Behaviour '${beh.id || beh.name}' description: ${len} chars`,
+        );
+      }
+    }
+  }
+
+  return {
+    name: "prose_length",
+    passed: errors.length === 0,
+    message:
+      errors.length === 0
+        ? "All prose fields within expected length range"
+        : `${errors.length} prose fields outside range: ${errors.slice(0, 3).join("; ")}`,
+  };
+}
+
+// ─── E2: Proficiency monotonicity ──────────────
+
+const PROF_INDEX = Object.fromEntries(PROFICIENCY_LEVELS.map((p, i) => [p, i]));
+
+function checkProficiencyMonotonicity(entities) {
+  const pathway = entities.pathway;
+  if (!pathway?.levels) {
+    return {
+      name: "proficiency_monotonicity",
+      passed: true,
+      message: "No pathway level data",
+    };
+  }
+
+  const levels = pathway.levels;
+  const levelIds = Object.keys(levels);
+  if (levelIds.length < 2) {
+    return {
+      name: "proficiency_monotonicity",
+      passed: true,
+      message: "Fewer than 2 levels",
+    };
+  }
+
+  const violations = [];
+  // For each skill, check that proficiency is non-decreasing across levels
+  const skillIds = new Set();
+  for (const levelId of levelIds) {
+    const baselines =
+      levels[levelId]?.baselines || levels[levelId]?.skillBaselines || {};
+    for (const skillId of Object.keys(baselines)) {
+      skillIds.add(skillId);
+    }
+  }
+
+  for (const skillId of skillIds) {
+    let prevIdx = -1;
+    for (const levelId of levelIds) {
+      const baselines =
+        levels[levelId]?.baselines || levels[levelId]?.skillBaselines || {};
+      const prof = baselines[skillId];
+      if (!prof || PROF_INDEX[prof] === undefined) continue;
+      const idx = PROF_INDEX[prof];
+      if (idx < prevIdx) {
+        violations.push(`Skill '${skillId}' decreases at level '${levelId}'`);
+      }
+      prevIdx = idx;
+    }
+  }
+
+  return {
+    name: "proficiency_monotonicity",
+    passed: violations.length === 0,
+    message:
+      violations.length === 0
+        ? "All skill proficiencies are non-decreasing across levels"
+        : `${violations.length} monotonicity violations: ${violations.slice(0, 3).join("; ")}`,
+  };
+}
+
+// ─── E3: Self-assessment plausibility ──────────
+
+function checkSelfAssessmentPlausibility(entities) {
+  const pathway = entities.pathway;
+  if (!pathway?.selfAssessments) {
+    return {
+      name: "self_assessment_plausibility",
+      passed: true,
+      message: "No self-assessment data",
+    };
+  }
+
+  const assessments = pathway.selfAssessments;
+  if (!Array.isArray(assessments) || assessments.length === 0) {
+    return {
+      name: "self_assessment_plausibility",
+      passed: true,
+      message: "No self-assessments",
+    };
+  }
+
+  const violations = [];
+  const threshold = 2; // Allow ±2 deviation from expected
+
+  for (let i = 0; i < assessments.length; i++) {
+    const assessment = assessments[i];
+    const profs = Object.values(assessment.skillProficiencies || {});
+    if (profs.length === 0) continue;
+
+    const indices = profs
+      .map((p) => PROF_INDEX[p])
+      .filter((idx) => idx !== undefined);
+    if (indices.length === 0) continue;
+
+    const median = indices.sort((a, b) => a - b)[
+      Math.floor(indices.length / 2)
+    ];
+    const expectedBase = Math.min(i, PROFICIENCY_LEVELS.length - 1);
+
+    if (Math.abs(median - expectedBase) > threshold) {
+      violations.push(
+        `Assessment '${assessment.id}': median proficiency ${median} vs expected ~${expectedBase}`,
+      );
+    }
+  }
+
+  return {
+    name: "self_assessment_plausibility",
+    passed: violations.length === 0,
+    message:
+      violations.length === 0
+        ? "Self-assessment distributions are plausible"
+        : `${violations.length} implausible assessments: ${violations.slice(0, 3).join("; ")}`,
+  };
+}
+
 /**
  * Content validator class with DI.
  */