@unified-product-graph/core 0.8.6 → 0.8.8

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   BUSINESS_GROWTH_METRIC_DRIVEN_PLAYBOOK: () => BUSINESS_GROWTH_METRIC_DRIVEN_PLAYBOOK,
   BUSINESS_GTM_GROWTH_PLAYBOOK: () => BUSINESS_GTM_GROWTH_PLAYBOOK,
   BUSINESS_MARKETING_AUDIENCE_FIRST_PLAYBOOK: () => BUSINESS_MARKETING_AUDIENCE_FIRST_PLAYBOOK,
+  CONTENT_DEPTH_WARNING_RULES: () => CONTENT_DEPTH_WARNING_RULES,
   DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK: () => DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK,
   ENGINEERING_PLATFORM_PLAYBOOK: () => ENGINEERING_PLATFORM_PLAYBOOK,
   EXPERIENCE_DESIGN_BRAND_PLAYBOOK: () => EXPERIENCE_DESIGN_BRAND_PLAYBOOK,
@@ -8666,209 +8667,6 @@ function rotateSlug(node, next) {
   return node;
 }
 
-// src/grammar/validate.ts
-var crossProductEdgeTypeSet = new Set(UPG_CROSS_EDGE_TYPES);
-function validateUPGDocument(doc) {
-  const errors = [];
-  const warnings = [];
-  if (!doc || typeof doc !== "object") {
-    return { valid: false, errors: [{ path: "$", message: "Document must be an object" }], warnings };
-  }
-  const d = doc;
-  if (!d.upg_version || typeof d.upg_version !== "string") {
-    errors.push({ path: "$.upg_version", message: "upg_version is required and must be a string" });
-  }
-  if (!d.exported_at || typeof d.exported_at !== "string") {
-    errors.push({ path: "$.exported_at", message: "exported_at is required and must be an ISO 8601 string" });
-  }
-  if (!d.source || typeof d.source !== "object") {
-    errors.push({ path: "$.source", message: "source is required and must be an object" });
-  } else {
-    const source = d.source;
-    if (!source.tool || typeof source.tool !== "string") {
-      errors.push({ path: "$.source.tool", message: "source.tool is required and must be a string" });
-    }
-  }
-  if (!d.product || typeof d.product !== "object") {
-    errors.push({ path: "$.product", message: "product is required and must be an object" });
-  } else {
-    const product = d.product;
-    if (!product.id || typeof product.id !== "string") {
-      errors.push({ path: "$.product.id", message: "product.id is required and must be a string" });
-    }
-    if (!product.title || typeof product.title !== "string") {
-      errors.push({ path: "$.product.title", message: "product.title is required and must be a string" });
-    }
-  }
-  const allKnownTypes = new Set(getTypes());
-  const allKnownEdgeTypes = new Set(Object.keys(UPG_EDGE_CATALOG));
-  if (!Array.isArray(d.nodes)) {
-    errors.push({ path: "$.nodes", message: "nodes is required and must be an array" });
-  } else {
-    const nodeIds = /* @__PURE__ */ new Set();
-    const nodesById = /* @__PURE__ */ new Map();
-    d.nodes.forEach((node, i) => {
-      const path = `$.nodes[${i}]`;
-      if (!node || typeof node !== "object") {
-        errors.push({ path, message: "Each node must be an object" });
-        return;
-      }
-      const n = node;
-      if (!n.id || typeof n.id !== "string") {
-        errors.push({ path: `${path}.id`, message: "Node id is required and must be a string" });
-      } else {
-        if (nodeIds.has(n.id)) {
-          errors.push({ path: `${path}.id`, message: `Duplicate node id: ${n.id}` });
-        }
-        nodeIds.add(n.id);
-        nodesById.set(n.id, n);
-      }
-      if (!n.type || typeof n.type !== "string") {
-        errors.push({ path: `${path}.type`, message: "Node type is required and must be a string" });
-      } else if (!allKnownTypes.has(n.type)) {
-        warnings.push({ path: `${path}.type`, message: `Unknown UPG type: "${n.type}". Node will be preserved with its original type.` });
-      }
-      if (!n.title || typeof n.title !== "string") {
-        errors.push({ path: `${path}.title`, message: "Node title is required and must be a string" });
-      }
-    });
-    if (!Array.isArray(d.edges)) {
-      errors.push({ path: "$.edges", message: "edges is required and must be an array" });
-    } else {
-      d.edges.forEach((edge, i) => {
-        const path = `$.edges[${i}]`;
-        if (!edge || typeof edge !== "object") {
-          errors.push({ path, message: "Each edge must be an object" });
-          return;
-        }
-        const e = edge;
-        if (!e.id || typeof e.id !== "string") {
-          errors.push({ path: `${path}.id`, message: "Edge id is required and must be a string" });
-        }
-        if (typeof e.type === "string" && crossProductEdgeTypeSet.has(e.type)) {
-          errors.push({
-            path: `${path}.type`,
-            message: `Cross-product edge type "${e.type}" must live in portfolio.cross_edges[], not product edges[].`
-          });
-          return;
-        }
-        if (!e.source || typeof e.source !== "string") {
-          errors.push({ path: `${path}.source`, message: "Edge source is required and must be a string" });
-        } else if (!nodeIds.has(e.source)) {
-          errors.push({ path: `${path}.source`, message: `Edge source references unknown node id: ${e.source}` });
-        }
-        if (!e.target || typeof e.target !== "string") {
-          errors.push({ path: `${path}.target`, message: "Edge target is required and must be a string" });
-        } else if (!nodeIds.has(e.target)) {
-          errors.push({ path: `${path}.target`, message: `Edge target references unknown node id: ${e.target}` });
-        }
-        if (!e.type || typeof e.type !== "string") {
-          errors.push({ path: `${path}.type`, message: "Edge type is required and must be a string" });
-        } else if (!allKnownEdgeTypes.has(e.type)) {
-          warnings.push({
-            path: `${path}.type`,
-            message: `Unknown edge type: "${e.type}". Edge preserved but not in the edge registry.`
-          });
-        }
-      });
-      const valueToAxis = /* @__PURE__ */ new Map();
-      const edgesArr = d.edges;
-      for (const edge of edgesArr) {
-        if (!edge || typeof edge !== "object") continue;
-        const e = edge;
-        if (e.type === "classification_axis_includes_classification_value" && typeof e.source === "string" && typeof e.target === "string") {
-          valueToAxis.set(e.target, e.source);
-        }
-      }
-      for (const [id, n] of nodesById.entries()) {
-        if (n.type !== "classification_value") continue;
-        if (valueToAxis.has(id)) continue;
-        const pid = n.parent_id;
-        if (typeof pid === "string") {
-          const parent = nodesById.get(pid);
-          if (parent && parent.type === "classification_axis") {
-            valueToAxis.set(id, pid);
-          }
-        }
-      }
-      const axesPerAnalysis = /* @__PURE__ */ new Map();
-      for (const edge of edgesArr) {
-        if (!edge || typeof edge !== "object") continue;
-        const e = edge;
-        if (e.type === "competitive_analysis_dimensioned_by_classification_axis" && typeof e.source === "string") {
-          axesPerAnalysis.set(e.source, (axesPerAnalysis.get(e.source) ?? 0) + 1);
-        }
-      }
-      d.nodes.forEach((node, i) => {
-        if (!node || typeof node !== "object") return;
-        const n = node;
-        if (n.type !== "competitive_analysis") return;
-        const props = n.properties;
-        if (!props || typeof props !== "object") return;
-        const empty = props.empty_cells;
-        if (!Array.isArray(empty)) return;
-        const axisCount = axesPerAnalysis.get(n.id ?? "") ?? 0;
-        if (axisCount !== 2) {
-          warnings.push({
-            path: `$.nodes[${i}].properties.empty_cells`,
-            message: `empty_cells is meaningful only on a 2-axis competitive_analysis; this node is dimensioned by ${axisCount} classification_axis ${axisCount === 1 ? "child" : "children"}.`
-          });
-        }
-        empty.forEach((cell, j) => {
-          const cpath = `$.nodes[${i}].properties.empty_cells[${j}]`;
-          if (!cell || typeof cell !== "object") {
-            errors.push({ path: cpath, message: "empty_cells entry must be an object" });
-            return;
-          }
-          const c = cell;
-          const aRef = c.axis_a_value_ref;
-          const bRef = c.axis_b_value_ref;
-          if (typeof aRef !== "string") {
-            errors.push({ path: `${cpath}.axis_a_value_ref`, message: "axis_a_value_ref is required and must be a string" });
-          }
-          if (typeof bRef !== "string") {
-            errors.push({ path: `${cpath}.axis_b_value_ref`, message: "axis_b_value_ref is required and must be a string" });
-          }
-          if (typeof aRef !== "string" || typeof bRef !== "string") return;
-          const aNode = nodesById.get(aRef);
-          const bNode = nodesById.get(bRef);
-          if (!aNode) {
-            errors.push({ path: `${cpath}.axis_a_value_ref`, message: `Unknown node id: ${aRef}` });
-          } else if (aNode.type !== "classification_value") {
-            errors.push({ path: `${cpath}.axis_a_value_ref`, message: `Expected classification_value, found "${String(aNode.type)}" at ${aRef}` });
-          }
-          if (!bNode) {
-            errors.push({ path: `${cpath}.axis_b_value_ref`, message: `Unknown node id: ${bRef}` });
-          } else if (bNode.type !== "classification_value") {
-            errors.push({ path: `${cpath}.axis_b_value_ref`, message: `Expected classification_value, found "${String(bNode.type)}" at ${bRef}` });
-          }
-          if (aNode && bNode && aNode.type === "classification_value" && bNode.type === "classification_value") {
-            const aAxis = valueToAxis.get(aRef);
-            const bAxis = valueToAxis.get(bRef);
-            if (aAxis && bAxis && aAxis === bAxis) {
-              errors.push({
-                path: cpath,
-                message: `empty_cells references two classification_values from the same axis (${aAxis}); axis_a and axis_b must come from distinct classification_axis parents.`
-              });
-            }
-          }
-          const kind = c.rationale_kind;
-          if (kind !== void 0 && kind !== "structural" && kind !== "ideological" && kind !== "opportunity") {
-            errors.push({
-              path: `${cpath}.rationale_kind`,
-              message: `rationale_kind must be one of 'structural' | 'ideological' | 'opportunity'; got "${String(kind)}".`
-            });
-          }
-        });
-      });
-    }
-  }
-  return { valid: errors.length === 0, errors, warnings };
-}
-function isUPGDocument(doc) {
-  return validateUPGDocument(doc).valid;
-}
-
 // src/properties/property-schema.ts
 var UPG_PROPERTY_SCHEMA = {
   // A11yAnnotationProperties: Accessibility annotation.
@@ -12245,31 +12043,37 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Customer Jobs",
+        "role": "customer_job",
         "entityTypeId": "job",
         "description": "Place job entities in the Customer Jobs position of the matrix"
       },
       {
         "label": "Pains",
+        "role": "pain",
         "entityTypeId": "need",
         "description": "Place need entities in the Pains position of the matrix"
       },
       {
         "label": "Gains",
+        "role": "gain",
         "entityTypeId": "desired_outcome",
         "description": "Place desired outcome entities in the Gains position of the matrix"
       },
       {
         "label": "Products & Services",
+        "role": "product_or_service",
         "entityTypeId": "feature",
         "description": "Place feature entities in the Products & Services position of the matrix"
       },
       {
         "label": "Pain Relievers",
+        "role": "pain_reliever",
         "entityTypeId": "feature",
         "description": "Place feature entities in the Pain Relievers position of the matrix"
       },
       {
         "label": "Gain Creators",
+        "role": "gain_creator",
         "entityTypeId": "feature",
         "description": "Place feature entities in the Gain Creators position of the matrix"
       }
@@ -12898,26 +12702,31 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Competitive Rivalry",
+        "role": "competitive_rivalry",
         "entityTypeId": "competitor",
         "description": "Intensity of competition among existing players"
       },
       {
         "label": "Threat of New Entrants",
+        "role": "new_entrants",
         "entityTypeId": "competitor",
         "description": "How easy is it for new competitors to enter?"
       },
       {
         "label": "Threat of Substitutes",
+        "role": "substitutes",
         "entityTypeId": "competitor",
         "description": "Can customers switch to alternatives?"
       },
       {
         "label": "Buyer Power",
+        "role": "buyer_power",
         "entityTypeId": "persona",
         "description": "How much leverage do buyers have?"
       },
       {
         "label": "Supplier Power",
+        "role": "supplier_power",
         "entityTypeId": "persona",
         "description": "How much leverage do suppliers have?"
       }
@@ -13085,31 +12894,37 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Inbound Logistics",
+        "role": "inbound_logistics",
         "entityTypeId": "key_activity",
         "description": "Inbound Logistics phase: key activity entities move through this stage"
       },
       {
         "label": "Operations",
+        "role": "operations",
         "entityTypeId": "key_activity",
         "description": "Operations phase: key activity entities move through this stage"
       },
       {
         "label": "Outbound Logistics",
+        "role": "outbound_logistics",
         "entityTypeId": "key_activity",
         "description": "Outbound Logistics phase: key activity entities move through this stage"
       },
       {
         "label": "Marketing & Sales",
+        "role": "marketing_and_sales",
         "entityTypeId": "key_activity",
         "description": "Marketing & Sales phase: key activity entities move through this stage"
       },
       {
         "label": "Service",
+        "role": "service",
         "entityTypeId": "key_activity",
         "description": "Service phase: key activity entities move through this stage"
       },
       {
         "label": "Support Activities",
+        "role": "support_activity",
         "entityTypeId": "capability",
         "description": "Support Activities phase: capability entities move through this stage"
       }
@@ -13180,26 +12995,31 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Portfolio",
+        "role": "portfolio",
         "entityTypeId": "portfolio",
         "description": "Innovation portfolio balanced across three horizons: core performance, emerging growth, and future creation"
       },
       {
         "label": "Product",
+        "role": "product",
         "entityTypeId": "product",
         "description": "Product or business unit assigned to a horizon: H1 (defend and extend), H2 (build), or H3 (seed and explore)"
       },
       {
         "label": "Initiative",
+        "role": "initiative",
         "entityTypeId": "portfolio",
         "description": "Growth initiative positioned in a horizon, with appropriate funding model, governance, and success metrics"
       },
       {
         "label": "Product Area",
+        "role": "product_area",
         "entityTypeId": "product_area",
         "description": "Product area representing a horizon: core products (H1), adjacent expansions (H2), or experimental ventures (H3)"
       },
       {
         "label": "Capability",
+        "role": "capability",
         "entityTypeId": "capability",
         "description": "Capability needed to execute across horizons: H1 needs efficiency, H2 needs scaling, H3 needs discovery"
       }
@@ -13263,7 +13083,7 @@ var UPG_FRAMEWORKS = [
     ],
     "name": "RICE Scoring",
     "version": "1.0.0",
-    "description": "Score features and opportunities by Reach, Impact, Confidence, and Effort to produce a ranked priority list.",
+    "description": "Score features, opportunities, and needs by Reach, Impact, Confidence, and Effort to produce a ranked priority list.",
     "category": "prioritization",
     "origin": {
       "type": "practitioner",
@@ -13281,7 +13101,7 @@ var UPG_FRAMEWORKS = [
       {
         "label": "Items to score",
         "entityTypeId": "feature",
-        "description": "Features, opportunities, or solutions being evaluated"
+        "description": "Features, opportunities, or needs being evaluated"
       },
       {
         "label": "Opportunities to score",
@@ -13447,7 +13267,60 @@ var UPG_FRAMEWORKS = [
           "label": "RICE Score",
           "format": "number"
         }
-      ]
+      ],
+      "scoring_lens": {
+        "applies_to": [
+          "feature",
+          "opportunity",
+          "need"
+        ],
+        "inputs": [
+          {
+            "property": "reach",
+            "type": "assessment",
+            "scale_id": "reach_5",
+            "required": true,
+            "scope": "framework",
+            "label": "Reach",
+            "description": "How many users will this impact per quarter?"
+          },
+          {
+            "property": "impact",
+            "type": "assessment",
+            "scale_id": "impact_5",
+            "required": true,
+            "scope": "framework",
+            "label": "Impact",
+            "description": "How much will this impact each user, on the impact scale?"
+          },
+          {
+            "property": "confidence",
+            "type": "assessment",
+            "scale_id": "confidence_5",
+            "required": true,
+            "scope": "framework",
+            "label": "Confidence",
+            "description": "How confident are you in the reach, impact, and effort estimates?"
+          },
+          {
+            "property": "effort",
+            "type": "assessment",
+            "scale_id": "effort_5",
+            "required": true,
+            "scope": "framework",
+            "label": "Effort",
+            "description": "How much work is required to build and ship this, on the effort scale?"
+          }
+        ],
+        "computed": [
+          {
+            "property": "rice_score",
+            "expression": "(reach * impact * confidence) / effort",
+            "label": "RICE Score",
+            "format": "number"
+          }
+        ]
+      }
     },
     "structure": {
       "pattern": "table"
@@ -13626,21 +13499,25 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Must-haves",
+        "role": "must_have",
         "entityTypeId": "feature",
         "description": "Expected features: absence causes dissatisfaction"
       },
       {
         "label": "Performance",
+        "role": "performance",
         "entityTypeId": "feature",
         "description": "More is better: linear satisfaction increase"
       },
       {
         "label": "Delighters",
+        "role": "delighter",
         "entityTypeId": "feature",
         "description": "Unexpected features: presence creates delight"
       },
       {
         "label": "Indifferent",
+        "role": "indifferent",
         "entityTypeId": "feature",
         "description": "Features users don't care about either way"
       }
@@ -13649,7 +13526,7 @@ var UPG_FRAMEWORKS = [
       "entity_types": [
         {
           "type": "feature",
-          "role": "item"
+          "role": "scored_item"
         }
       ],
       "required_properties": {
@@ -13733,12 +13610,95 @@ var UPG_FRAMEWORKS = [
           "label": "Dissatisfaction Coefficient",
           "format": "number"
         }
-      ]
-    },
-    "structure": {
-      "pattern": "matrix"
-    },
-    "presentation": {
+      ],
+      "scoring_lens": {
+        "applies_to": [
+          "feature"
+        ],
+        "inputs": [
+          {
+            "property": "functional_response",
+            "type": "enum",
+            "required": true,
+            "scope": "framework",
+            "label": "Functional Response",
+            "description": "How users feel when the feature IS present",
+            "enum_values": [
+              "i_like_it",
+              "i_expect_it",
+              "i_am_neutral",
+              "i_can_tolerate_it",
+              "i_dislike_it"
+            ]
+          },
+          {
+            "property": "dysfunctional_response",
+            "type": "enum",
+            "required": true,
+            "scope": "framework",
+            "label": "Dysfunctional Response",
+            "description": "How users feel when the feature IS NOT present",
+            "enum_values": [
+              "i_like_it",
+              "i_expect_it",
+              "i_am_neutral",
+              "i_can_tolerate_it",
+              "i_dislike_it"
+            ]
+          },
+          {
+            "property": "delighter_count",
+            "type": "number",
+            "required": false,
+            "scope": "framework",
+            "label": "Delighter classifications",
+            "description": "Count of survey responses classifying this feature as a delighter (attractive)"
+          },
+          {
+            "property": "performance_count",
+            "type": "number",
+            "required": false,
+            "scope": "framework",
+            "label": "Performance classifications",
+            "description": "Count of survey responses classifying this feature as performance (one-dimensional)"
+          },
+          {
+            "property": "must_be_count",
+            "type": "number",
+            "required": false,
+            "scope": "framework",
+            "label": "Must-be classifications",
+            "description": "Count of survey responses classifying this feature as must-be (basic)"
+          },
+          {
+            "property": "indifferent_count",
+            "type": "number",
+            "required": false,
+            "scope": "framework",
+            "label": "Indifferent classifications",
+            "description": "Count of survey responses classifying this feature as indifferent"
+          }
+        ],
+        "computed": [
+          {
+            "property": "satisfaction_coefficient",
+            "expression": "(delighter_count + performance_count) / (delighter_count + performance_count + must_be_count + indifferent_count)",
+            "label": "Satisfaction Coefficient",
+            "format": "number"
+          },
+          {
+            "property": "dissatisfaction_coefficient",
+            "expression": "(must_be_count + performance_count) / (delighter_count + performance_count + must_be_count + indifferent_count) * -1",
+            "label": "Dissatisfaction Coefficient",
+            "format": "number"
+          }
+        ]
+      }
+    },
+    "structure": {
+      "pattern": "matrix"
+    },
+    "presentation": {
       "layout": {
         "type": "matrix",
         "rows": 5,
@@ -13788,16 +13748,19 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Now",
+        "role": "now",
         "entityTypeId": "feature",
         "description": "Committed work in progress"
       },
       {
         "label": "Next",
+        "role": "next",
         "entityTypeId": "feature",
         "description": "High-confidence upcoming work"
       },
       {
         "label": "Later",
+        "role": "later",
         "entityTypeId": "initiative",
         "description": "Exploratory, needs more discovery"
       }
@@ -14313,26 +14276,31 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Atoms",
+        "role": "atom",
         "entityTypeId": "design_component",
         "description": "Atoms: design component entities for this dimension of the framework"
       },
       {
         "label": "Molecules",
+        "role": "molecule",
         "entityTypeId": "design_component",
         "description": "Molecules: design token entities for this dimension of the framework"
       },
       {
         "label": "Organisms",
+        "role": "organism",
         "entityTypeId": "design_pattern",
         "description": "Organisms: design pattern entities for this dimension of the framework"
       },
       {
         "label": "Templates",
+        "role": "template",
         "entityTypeId": "wireframe",
         "description": "Templates: design system entities for this dimension of the framework"
       },
       {
         "label": "Pages",
+        "role": "page",
         "entityTypeId": "screen",
         "description": "Pages: screen entities for this dimension of the framework"
       }
@@ -14997,26 +14965,31 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Outer Ring",
+        "role": "outer_ring",
         "entityTypeId": "acquisition_channel",
         "description": "All 19 traction channels brainstormed"
       },
       {
         "label": "Middle Ring",
+        "role": "middle_ring",
         "entityTypeId": "acquisition_channel",
         "description": "Top 6 channels worth testing"
       },
       {
         "label": "Inner Ring",
+        "role": "inner_ring",
         "entityTypeId": "acquisition_channel",
         "description": "Top 3 channels to focus on"
       },
       {
         "label": "Traction Test",
+        "role": "traction_test",
         "entityTypeId": "growth_campaign",
         "description": "Cheap test for each channel"
       },
       {
         "label": "Bullseye Channel",
+        "role": "bullseye_channel",
         "entityTypeId": "acquisition_channel",
         "description": "The single best-performing channel"
       }
@@ -15086,26 +15059,31 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Free Entry",
+        "role": "free_entry",
         "entityTypeId": "gtm_strategy",
         "description": "How users access the product for free"
       },
       {
         "label": "Aha Moment",
+        "role": "aha_moment",
         "entityTypeId": "gtm_strategy",
         "description": "First experience of core value"
       },
       {
         "label": "Expansion Motion",
+        "role": "expansion_motion",
         "entityTypeId": "sales_motion",
         "description": "How usage spreads within accounts"
       },
       {
         "label": "Monetisation Trigger",
+        "role": "monetisation_trigger",
         "entityTypeId": "gtm_strategy",
         "description": "When and how to convert to paid"
       },
       {
         "label": "Metric",
+        "role": "metric",
         "entityTypeId": "metric",
         "description": "Key metric driving the PLG motion"
       }
@@ -15180,21 +15158,25 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Objective",
+        "role": "objective",
         "entityTypeId": "objective",
         "description": "Qualitative, inspiring goal"
       },
       {
         "label": "Key Result 1",
+        "role": "key_result",
         "entityTypeId": "key_result",
         "description": "Measurable outcome proving progress"
       },
       {
         "label": "Key Result 2",
+        "role": "key_result",
         "entityTypeId": "key_result",
         "description": "Measurable outcome proving progress"
       },
       {
         "label": "Initiatives",
+        "role": "initiative",
         "entityTypeId": "initiative",
         "description": "Work streams that drive key results"
       }
@@ -15268,26 +15250,31 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Activity",
+        "role": "activity",
         "entityTypeId": "key_activity",
         "description": "Place persona entities in the Activity position of the matrix"
       },
       {
         "label": "Responsible",
+        "role": "responsible",
         "entityTypeId": "role",
         "description": "Does the work"
       },
       {
         "label": "Accountable",
+        "role": "accountable",
         "entityTypeId": "role",
         "description": "Makes the final call"
       },
       {
         "label": "Consulted",
+        "role": "consulted",
         "entityTypeId": "role",
         "description": "Gives input"
       },
       {
         "label": "Informed",
+        "role": "informed",
         "entityTypeId": "role",
         "description": "Kept in the loop"
       }
@@ -15361,21 +15348,25 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "What Went Well",
+        "role": "went_well",
         "entityTypeId": "outcome",
         "description": "Practices to continue"
       },
       {
         "label": "What Didn't Go Well",
+        "role": "went_poorly",
         "entityTypeId": "need",
         "description": "Issues to address"
       },
       {
         "label": "Action Items",
+        "role": "action_item",
         "entityTypeId": "learning",
         "description": "Changes for next iteration"
       },
       {
         "label": "Learnings",
+        "role": "learning",
         "entityTypeId": "learning",
         "description": "Insights to carry forward"
       }
@@ -15572,7 +15563,7 @@ var UPG_FRAMEWORKS = [
       "entity_types": [
         {
           "type": "team",
-          "role": "scored_item"
+          "role": "item"
         },
         {
           "type": "retrospective",
@@ -15736,7 +15727,36 @@ var UPG_FRAMEWORKS = [
           "label": "Severity",
           "format": "number"
         }
-      ]
+      ],
+      "scoring_lens": {
+        "applies_to": [
+          "risk"
+        ],
+        "inputs": [
+          {
+            "property": "probability",
+            "type": "number",
+            "required": true,
+            "label": "Probability",
+            "description": "Likelihood the risk materialises (risk.probability assessment)"
+          },
+          {
+            "property": "impact",
+            "type": "number",
+            "required": true,
+            "label": "Impact",
+            "description": "Consequence severity if the risk materialises (risk.impact assessment)"
+          }
+        ],
+        "computed": [
+          {
+            "property": "severity",
+            "expression": "probability * impact",
+            "label": "Severity",
+            "format": "number"
+          }
+        ]
+      }
     },
     "structure": {
       "pattern": "table"
@@ -15812,31 +15832,37 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Items to score",
+        "role": "candidate",
         "entityTypeId": "feature",
         "description": "Features or experiments being evaluated"
       },
       {
         "label": "Impact",
+        "role": "impact",
         "entityTypeId": "outcome",
         "description": "How much will this move the needle?"
       },
       {
         "label": "Confidence",
+        "role": "confidence",
         "entityTypeId": "assumption",
         "description": "How sure are we about the impact?"
       },
       {
         "label": "Ease",
+        "role": "ease",
         "entityTypeId": "feature",
         "description": "How easy is this to implement?"
       },
       {
         "label": "Opportunities to score",
+        "role": "candidate",
         "entityTypeId": "opportunity",
         "description": "Opportunities scored on the same ICE Scoring inputs as features."
       },
       {
         "label": "Needs to score",
+        "role": "candidate",
         "entityTypeId": "need",
         "description": "Needs scored on the same ICE Scoring inputs as features."
       }
@@ -15966,7 +15992,48 @@ var UPG_FRAMEWORKS = [
           "label": "ICE Score",
           "format": "number"
         }
-      ]
+      ],
+      "scoring_lens": {
+        "applies_to": [
+          "feature",
+          "opportunity",
+          "need"
+        ],
+        "inputs": [
+          {
+            "property": "impact",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Impact",
+            "description": "Expected impact on the target metric (1-10)"
+          },
+          {
+            "property": "confidence",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Confidence",
+            "description": "Confidence in the impact estimate (1-10)"
+          },
+          {
+            "property": "ease",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Ease",
+            "description": "Ease of implementation (1-10)"
+          }
+        ],
+        "computed": [
+          {
+            "property": "ice_score",
+            "expression": "impact * confidence * ease",
+            "label": "ICE Score",
+            "format": "number"
+          }
+        ]
+      }
     },
     "structure": {
       "pattern": "table"
@@ -16046,31 +16113,37 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Backlog Items",
+        "role": "candidate",
         "entityTypeId": "feature",
         "description": "Backlog Items: feature entries to evaluate"
       },
       {
         "label": "User/Business Value",
+        "role": "user_business_value",
         "entityTypeId": "metric",
         "description": "User/Business Value: metric entries to evaluate"
       },
       {
         "label": "Time Criticality",
+        "role": "time_criticality",
         "entityTypeId": "metric",
         "description": "How much value decays if delivery is delayed (deadlines, competition, seasonal windows)"
       },
       {
         "label": "Risk Reduction / Opportunity Enablement",
+        "role": "risk_reduction",
         "entityTypeId": "metric",
         "description": "Risk Reduction / Opportunity Enablement: metric entries to evaluate"
       },
       {
         "label": "Job Size",
+        "role": "job_size",
         "entityTypeId": "metric",
         "description": "Estimated effort (story points, t-shirt size, or person-weeks)"
       },
       {
         "label": "Opportunities to score",
+        "role": "candidate",
         "entityTypeId": "opportunity",
         "description": "Opportunities scored on the same WSJF (Weighted Shortest Job First) inputs as features."
       }
@@ -16175,7 +16248,55 @@ var UPG_FRAMEWORKS = [
           "label": "WSJF Score",
           "format": "number"
         }
-      ]
+      ],
+      "scoring_lens": {
+        "applies_to": [
+          "feature",
+          "opportunity"
+        ],
+        "inputs": [
+          {
+            "property": "user_value",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "User/Business Value",
+            "description": "Relative value to users and the business if delivered"
+          },
+          {
+            "property": "time_criticality",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Time Criticality",
+            "description": "How much value decays if delivery is delayed (deadlines, competition, seasonal windows)"
+          },
+          {
+            "property": "risk_reduction",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Risk Reduction / Opportunity Enablement",
+            "description": "Value from reducing risk or enabling future opportunities"
+          },
+          {
+            "property": "job_size",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Job Size",
+            "description": "Estimated effort (story points, t-shirt size, or person-weeks)"
+          }
+        ],
+        "computed": [
+          {
+            "property": "wsjf_score",
+            "expression": "(user_value + time_criticality + risk_reduction) / job_size",
+            "label": "WSJF Score",
+            "format": "number"
+          }
+        ]
+      }
     },
     "structure": {
       "pattern": "table"
@@ -16248,7 +16369,7 @@ var UPG_FRAMEWORKS = [
     ],
     "name": "Cost of Delay",
     "version": "1.0.0",
-    "description": "Quantify the economic cost of not shipping a feature to drive priority decisions. Combines urgency with value.",
+    "description": "Quantify the economic cost of not shipping a feature or opportunity to drive priority decisions. Combines urgency with value.",
     "category": "prioritization",
     "origin": {
       "type": "practitioner",
@@ -16364,7 +16485,39 @@ var UPG_FRAMEWORKS = [
           "label": "WSJF Score",
           "format": "number"
         }
-      ]
+      ],
+      "scoring_lens": {
+        "applies_to": [
+          "feature",
+          "opportunity"
+        ],
+        "inputs": [
+          {
+            "property": "cost_of_delay",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Cost of Delay",
+            "description": "Weekly revenue impact of not shipping"
+          },
+          {
+            "property": "job_size",
+            "type": "number",
+            "required": true,
+            "scope": "framework",
+            "label": "Job Size",
+            "description": "Weeks of development effort"
+          }
+        ],
+        "computed": [
+          {
+            "property": "wsjf_score",
+            "expression": "cost_of_delay / job_size",
+            "label": "WSJF Score",
+            "format": "number"
+          }
+        ]
+      }
     },
     "structure": {
       "pattern": "table"
@@ -16446,16 +16599,19 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "Symptom",
+        "role": "symptom",
         "entityTypeId": "need",
         "description": "The observed problem the analysis starts from."
       },
       {
         "label": "Why chain",
+        "role": "why",
         "entityTypeId": "insight",
         "description": 'Each "why?" answer along the chain, typically five iterations deep.'
       },
       {
         "label": "Root cause",
+        "role": "root_cause",
         "entityTypeId": "insight",
         "description": "The terminal answer at the bottom of the chain: the underlying cause to address."
       }
@@ -16800,16 +16956,19 @@ var UPG_FRAMEWORKS = [
     "slots": [
       {
         "label": "First-order move",
+        "role": "first_order",
         "entityTypeId": "decision",
         "description": "The decision or move under consideration."
       },
       {
         "label": "Second-order consequences",
+        "role": "second_order",
         "entityTypeId": "insight",
         "description": "Downstream effects that follow from the first-order move."
       },
       {
         "label": "Higher-order consequences",
+        "role": "higher_order",
         "entityTypeId": "insight",
         "description": "Third-, fourth-, fifth-order ripples: second-order consequences of the second-order consequences."
       }
@@ -16869,6 +17028,439 @@ for (const fw of UPG_FRAMEWORKS) {
   UPG_FRAMEWORKS_BY_CATEGORY[fw.category].push(fw);
 }
 
+// src/grammar/validate.ts
+var crossProductEdgeTypeSet = new Set(UPG_CROSS_EDGE_TYPES);
+var CONTENT_DEPTH_WARNING_RULES = /* @__PURE__ */ new Set([
+  "property-type",
+  "property-enum",
+  "self-loop",
+  "framework-score"
+]);
+function validateUPGDocument(doc) {
+  const errors = [];
+  const warnings = [];
+  if (!doc || typeof doc !== "object") {
+    return { valid: false, errors: [{ path: "$", message: "Document must be an object" }], warnings };
+  }
+  const d = doc;
+  if (!d.upg_version || typeof d.upg_version !== "string") {
+    errors.push({ path: "$.upg_version", message: "upg_version is required and must be a string" });
+  }
+  if (!d.exported_at || typeof d.exported_at !== "string") {
+    errors.push({ path: "$.exported_at", message: "exported_at is required and must be an ISO 8601 string" });
+  }
+  if (!d.source || typeof d.source !== "object") {
+    errors.push({ path: "$.source", message: "source is required and must be an object" });
+  } else {
+    const source = d.source;
+    if (!source.tool || typeof source.tool !== "string") {
+      errors.push({ path: "$.source.tool", message: "source.tool is required and must be a string" });
+    }
+  }
+  if (!d.product || typeof d.product !== "object") {
+    errors.push({ path: "$.product", message: "product is required and must be an object" });
+  } else {
+    const product = d.product;
+    if (!product.id || typeof product.id !== "string") {
+      errors.push({ path: "$.product.id", message: "product.id is required and must be a string" });
+    }
+    if (!product.title || typeof product.title !== "string") {
+      errors.push({ path: "$.product.title", message: "product.title is required and must be a string" });
+    }
+  }
+  const allKnownTypes = new Set(getTypes());
+  const allKnownEdgeTypes = new Set(Object.keys(UPG_EDGE_CATALOG));
+  if (!Array.isArray(d.nodes)) {
+    errors.push({
+      path: "$.nodes",
+      message: d.nodes === void 0 ? "nodes is required and must be an array" : `nodes must be an array, got ${describeKind(d.nodes)}`
+    });
+  } else {
+    const nodeIds = /* @__PURE__ */ new Set();
+    const nodesById = /* @__PURE__ */ new Map();
+    d.nodes.forEach((node, i) => {
+      const path = `$.nodes[${i}]`;
+      if (!node || typeof node !== "object") {
+        errors.push({ path, message: "Each node must be an object" });
+        return;
+      }
+      const n = node;
+      if (!n.id || typeof n.id !== "string") {
+        errors.push({ path: `${path}.id`, message: "Node id is required and must be a string" });
+      } else {
+        if (nodeIds.has(n.id)) {
+          errors.push({ path: `${path}.id`, message: `Duplicate node id: ${n.id}` });
+        }
+        nodeIds.add(n.id);
+        nodesById.set(n.id, n);
+      }
+      if (!n.type || typeof n.type !== "string") {
+        errors.push({ path: `${path}.type`, message: "Node type is required and must be a string" });
+      } else if (!allKnownTypes.has(n.type)) {
+        warnings.push({ path: `${path}.type`, message: `Unknown UPG type: "${n.type}". Node will be preserved with its original type.` });
+      }
+      if (!n.title || typeof n.title !== "string") {
+        errors.push({ path: `${path}.title`, message: "Node title is required and must be a string" });
+      } else if (n.title.trim().length === 0) {
+        errors.push({ path: `${path}.title`, message: "Node title must not be blank (whitespace-only)" });
+      }
+      if (n.properties !== void 0 && n.properties !== null) {
+        if (typeof n.properties !== "object" || Array.isArray(n.properties)) {
+          errors.push({
+            path: `${path}.properties`,
+            message: `Node properties must be a plain object when present, got ${describeKind(n.properties)}.`
+          });
+        }
+      }
+      if (typeof n.type === "string") {
+        validateNodeProperties(n, `${path}`, warnings);
+      }
+    });
+    if (!Array.isArray(d.edges)) {
+      errors.push({
+        path: "$.edges",
+        message: d.edges === void 0 ? "edges is required and must be an array" : `edges must be an array, got ${describeKind(d.edges)}`
+      });
+    } else {
+      d.edges.forEach((edge, i) => {
+        const path = `$.edges[${i}]`;
+        if (!edge || typeof edge !== "object") {
+          errors.push({ path, message: "Each edge must be an object" });
+          return;
+        }
+        const e = edge;
+        if (!e.id || typeof e.id !== "string") {
+          errors.push({ path: `${path}.id`, message: "Edge id is required and must be a string" });
+        }
+        if (typeof e.type === "string" && crossProductEdgeTypeSet.has(e.type)) {
+          errors.push({
+            path: `${path}.type`,
+            message: `Cross-product edge type "${e.type}" must live in portfolio.cross_edges[], not product edges[].`
+          });
+          return;
+        }
+        if (!e.source || typeof e.source !== "string") {
+          errors.push({ path: `${path}.source`, message: "Edge source is required and must be a string" });
+        } else if (!nodeIds.has(e.source)) {
+          errors.push({ path: `${path}.source`, message: `Edge source references unknown node id: ${e.source}` });
+        }
+        if (!e.target || typeof e.target !== "string") {
+          errors.push({ path: `${path}.target`, message: "Edge target is required and must be a string" });
+        } else if (!nodeIds.has(e.target)) {
+          errors.push({ path: `${path}.target`, message: `Edge target references unknown node id: ${e.target}` });
+        }
+        if (typeof e.source === "string" && typeof e.target === "string" && e.source === e.target) {
+          warnings.push({
+            path: `${path}`,
+            message: `Self-loop edge: source and target are the same node ("${e.source}"). A node related to itself is almost always an error.`,
+            rule: "self-loop"
+          });
+        }
+        if (!e.type || typeof e.type !== "string") {
+          errors.push({ path: `${path}.type`, message: "Edge type is required and must be a string" });
+        } else if (!allKnownEdgeTypes.has(e.type)) {
+          warnings.push({
+            path: `${path}.type`,
+            message: `Unknown edge type: "${e.type}". Edge preserved but not in the edge registry.`
+          });
+        }
+      });
+      const valueToAxis = /* @__PURE__ */ new Map();
+      const edgesArr = d.edges;
+      for (const edge of edgesArr) {
+        if (!edge || typeof edge !== "object") continue;
+        const e = edge;
+        if (e.type === "classification_axis_includes_classification_value" && typeof e.source === "string" && typeof e.target === "string") {
+          valueToAxis.set(e.target, e.source);
+        }
+      }
+      for (const [id, n] of nodesById.entries()) {
+        if (n.type !== "classification_value") continue;
+        if (valueToAxis.has(id)) continue;
+        const pid = n.parent_id;
+        if (typeof pid === "string") {
+          const parent = nodesById.get(pid);
+          if (parent && parent.type === "classification_axis") {
+            valueToAxis.set(id, pid);
+          }
+        }
+      }
+      const axesPerAnalysis = /* @__PURE__ */ new Map();
+      for (const edge of edgesArr) {
+        if (!edge || typeof edge !== "object") continue;
+        const e = edge;
+        if (e.type === "competitive_analysis_dimensioned_by_classification_axis" && typeof e.source === "string") {
+          axesPerAnalysis.set(e.source, (axesPerAnalysis.get(e.source) ?? 0) + 1);
+        }
+      }
+      d.nodes.forEach((node, i) => {
+        if (!node || typeof node !== "object") return;
+        const n = node;
+        if (n.type !== "competitive_analysis") return;
+        const props = n.properties;
+        if (!props || typeof props !== "object") return;
+        const empty = props.empty_cells;
+        if (!Array.isArray(empty)) return;
+        const axisCount = axesPerAnalysis.get(n.id ?? "") ?? 0;
+        if (axisCount !== 2) {
+          warnings.push({
+            path: `$.nodes[${i}].properties.empty_cells`,
+            message: `empty_cells is meaningful only on a 2-axis competitive_analysis; this node is dimensioned by ${axisCount} classification_axis ${axisCount === 1 ? "child" : "children"}.`
+          });
+        }
+        empty.forEach((cell, j) => {
+          const cpath = `$.nodes[${i}].properties.empty_cells[${j}]`;
+          if (!cell || typeof cell !== "object") {
+            errors.push({ path: cpath, message: "empty_cells entry must be an object" });
+            return;
+          }
+          const c = cell;
+          const aRef = c.axis_a_value_ref;
+          const bRef = c.axis_b_value_ref;
+          if (typeof aRef !== "string") {
+            errors.push({ path: `${cpath}.axis_a_value_ref`, message: "axis_a_value_ref is required and must be a string" });
+          }
+          if (typeof bRef !== "string") {
+            errors.push({ path: `${cpath}.axis_b_value_ref`, message: "axis_b_value_ref is required and must be a string" });
+          }
+          if (typeof aRef !== "string" || typeof bRef !== "string") return;
+          const aNode = nodesById.get(aRef);
+          const bNode = nodesById.get(bRef);
+          if (!aNode) {
+            errors.push({ path: `${cpath}.axis_a_value_ref`, message: `Unknown node id: ${aRef}` });
+          } else if (aNode.type !== "classification_value") {
+            errors.push({ path: `${cpath}.axis_a_value_ref`, message: `Expected classification_value, found "${String(aNode.type)}" at ${aRef}` });
+          }
+          if (!bNode) {
+            errors.push({ path: `${cpath}.axis_b_value_ref`, message: `Unknown node id: ${bRef}` });
+          } else if (bNode.type !== "classification_value") {
+            errors.push({ path: `${cpath}.axis_b_value_ref`, message: `Expected classification_value, found "${String(bNode.type)}" at ${bRef}` });
+          }
+          if (aNode && bNode && aNode.type === "classification_value" && bNode.type === "classification_value") {
+            const aAxis = valueToAxis.get(aRef);
+            const bAxis = valueToAxis.get(bRef);
+            if (aAxis && bAxis && aAxis === bAxis) {
+              errors.push({
+                path: cpath,
+                message: `empty_cells references two classification_values from the same axis (${aAxis}); axis_a and axis_b must come from distinct classification_axis parents.`
+              });
+            }
+          }
+          const kind = c.rationale_kind;
+          if (kind !== void 0 && kind !== "structural" && kind !== "ideological" && kind !== "opportunity") {
+            errors.push({
+              path: `${cpath}.rationale_kind`,
+              message: `rationale_kind must be one of 'structural' | 'ideological' | 'opportunity'; got "${String(kind)}".`
+            });
+          }
+        });
+      });
+      validateFrameworkScores(d.nodes, d.edges, warnings);
+    }
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function validateFrameworkScores(nodes, edges, warnings) {
+  const nodeById = /* @__PURE__ */ new Map();
+  const exercises = [];
+  for (const node of nodes) {
+    if (!node || typeof node !== "object") continue;
+    const n = node;
+    if (typeof n.id === "string") nodeById.set(n.id, n);
+    if (n.type !== "framework_exercise") continue;
+    const props = n.properties;
+    if (!props || typeof props !== "object" || Array.isArray(props)) continue;
+    const frameworkId = props.framework_id;
+    if (typeof frameworkId !== "string") continue;
+    const framework = UPG_FRAMEWORKS_BY_ID[frameworkId];
+    if (!framework) continue;
+    if (typeof n.id === "string") exercises.push({ id: n.id, framework });
+  }
+  if (exercises.length === 0) return;
+  const exerciseById = new Map(exercises.map((e) => [e.id, e.framework]));
+  edges.forEach((edge, i) => {
+    if (!edge || typeof edge !== "object") return;
+    const e = edge;
+    if (e.type !== "framework_exercise_includes_node") return;
+    if (typeof e.source !== "string" || typeof e.target !== "string") return;
+    const framework = exerciseById.get(e.source);
+    if (!framework) return;
+    const score = e.properties;
+    if (!score || typeof score !== "object" || Array.isArray(score)) return;
+    const targetNode = nodeById.get(e.target);
+    const targetType = typeof targetNode?.type === "string" ? targetNode.type : void 0;
+    if (!targetType) return;
+    const requirements = framework.data?.required_properties?.[targetType];
+    if (!requirements || requirements.length === 0) return;
+    const divisors = divisorInputs(framework);
+    const path = `$.edges[${i}].properties`;
+    const scoreObj = score;
+    for (const req of requirements) {
+      const value = scoreObj[req.property];
+      if (value === void 0 || value === null) continue;
+      const finding = checkScoreValue(req, value, divisors.has(req.property), framework.id);
+      if (finding) {
+        warnings.push({
+          path: `${path}.${req.property}`,
+          message: finding,
+          rule: "framework-score"
+        });
+      }
+    }
+  });
+}
+function divisorInputs(framework) {
+  const expr = framework.data?.computed_properties?.[0]?.expression;
+  if (typeof expr !== "string" || expr.length === 0) return EMPTY_STRING_SET;
+  const out = /* @__PURE__ */ new Set();
+  const re = /\/\s*\(?\s*([A-Za-z_][A-Za-z0-9_]*)/g;
+  let m;
+  while ((m = re.exec(expr)) !== null) out.add(m[1]);
+  return out;
+}
+var EMPTY_STRING_SET = /* @__PURE__ */ new Set();
+function checkScoreValue(req, value, isDivisor, frameworkId) {
+  switch (req.type) {
+    case "enum": {
+      const allowed = req.enum_values ?? [];
+      if (typeof value !== "string") {
+        return `${frameworkId} score "${req.property}" must be one of ${allowed.join(", ")}; got ${describeKind(value)}.`;
+      }
+      if (allowed.length > 0 && !allowed.includes(value)) {
+        return `${frameworkId} score "${req.property}" has value "${value}" outside its allowed set: ${allowed.join(", ")}.`;
+      }
+      return null;
+    }
+    case "assessment": {
+      const num = numericScore(value);
+      if (num === null) {
+        return `${frameworkId} score "${req.property}" must be a number; got ${describeKind(value)}.`;
+      }
+      const scale = req.scale_id ? getScale(req.scale_id) : void 0;
+      if (scale) {
+        if (num < scale.min || num > scale.max) {
+          return `${frameworkId} score "${req.property}" is ${num}, outside the ${req.scale_id} scale range [${scale.min}, ${scale.max}].`;
+        }
+      } else if (num <= 0) {
+        return `${frameworkId} score "${req.property}" must be greater than 0; got ${num}.`;
+      }
+      if (isDivisor && num === 0) {
+        return `${frameworkId} score "${req.property}" must not be 0 (it is a divisor in the framework's formula).`;
+      }
+      return null;
+    }
+    case "number": {
+      const num = numericScore(value);
+      if (num === null) {
+        return `${frameworkId} score "${req.property}" must be a number; got ${describeKind(value)}.`;
+      }
+      if (isDivisor && num === 0) {
+        return `${frameworkId} score "${req.property}" must not be 0 (it is a divisor in the framework's formula).`;
+      }
+      if (num < 0) {
+        return `${frameworkId} score "${req.property}" must not be negative; got ${num}.`;
+      }
+      return null;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") {
+        return `${frameworkId} score "${req.property}" must be a boolean; got ${describeKind(value)}.`;
+      }
+      return null;
+    }
+    case "string": {
+      if (typeof value !== "string") {
+        return `${frameworkId} score "${req.property}" must be a string; got ${describeKind(value)}.`;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function numericScore(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const n = Number.parseFloat(value);
+    return Number.isFinite(n) ? n : null;
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const v = value.value;
+    if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  }
+  return null;
+}
+function runtimeKind(val) {
+  if (val === null || val === void 0) return null;
+  if (Array.isArray(val)) return "string[]";
+  switch (typeof val) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return "object";
+    default:
+      return null;
+  }
+}
+function valueMatchesType(defType, val) {
+  const kind = runtimeKind(val);
+  if (kind === null) return true;
+  switch (defType) {
+    case "string":
+      return kind === "string";
+    case "number":
+      return kind === "number";
+    case "boolean":
+      return kind === "boolean";
+    case "string[]":
+      return kind === "string[]";
+    case "object":
+    case "assessment":
+      return kind === "object";
+    default:
+      return true;
+  }
+}
+function describeKind(val) {
+  if (Array.isArray(val)) return "array";
+  return typeof val;
+}
+function validateNodeProperties(node, basePath, warnings) {
+  const type = node.type;
+  if (typeof type !== "string") return;
+  const schema = getPropertySchema(type);
+  if (!schema) return;
+  const props = node.properties;
+  if (!props || typeof props !== "object" || Array.isArray(props)) return;
+  for (const [key, value] of Object.entries(props)) {
+    const def = schema[key];
+    if (!def) continue;
+    if (value === null || value === void 0) continue;
+    if (!valueMatchesType(def.type, value)) {
+      warnings.push({
+        path: `${basePath}.properties.${key}`,
+        message: `Property "${key}" on ${type} should be ${def.type}, got ${describeKind(value)}.`,
+        rule: "property-type"
+      });
+      continue;
+    }
+    if (def.enum && typeof value === "string" && !def.enum.includes(value)) {
+      warnings.push({
+        path: `${basePath}.properties.${key}`,
+        message: `Property "${key}" on ${type} has value "${value}" outside its allowed set: ${def.enum.join(", ")}.`,
+        rule: "property-enum"
+      });
+    }
+  }
+}
+function isUPGDocument(doc) {
+  return validateUPGDocument(doc).valid;
+}
+
 // src/presentation/labels.ts
 var PRIORITY_LABELS = [
   // ── need (CONSOLIDATED: replaces pain_point + user_need) ─────────────────────
@@ -25265,7 +25857,7 @@ function isCanonical(text) {
 }
 
 // src/index.ts
-var UPG_VERSION = "0.8.6";
+var UPG_VERSION = "0.8.7";
 var UPG_FORMAT_VERSION = "0.4.0";
 var MARKDOWN_FORMAT_VERSION = "0.1";
 var UPG_TYPES = getTypes();
@@ -25334,6 +25926,7 @@ var UPG_META_COUNT = UPG_ENTITY_META.length;
   BUSINESS_GROWTH_METRIC_DRIVEN_PLAYBOOK,
   BUSINESS_GTM_GROWTH_PLAYBOOK,
   BUSINESS_MARKETING_AUDIENCE_FIRST_PLAYBOOK,
+  CONTENT_DEPTH_WARNING_RULES,
   DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK,
   ENGINEERING_PLATFORM_PLAYBOOK,
   EXPERIENCE_DESIGN_BRAND_PLAYBOOK,