@unified-product-graph/core 0.8.7 → 0.8.8

package/dist/index.js

@@ -11633,293 +11633,6 @@ function getPropertySchema(entityType) {
   return UPG_PROPERTY_SCHEMA[entityType];
 }
 
-// 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"
-]);
-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" });
-      } else if (n.title.trim().length === 0) {
-        errors.push({ path: `${path}.title`, message: "Node title must not be blank (whitespace-only)" });
-      }
-      if (typeof n.type === "string") {
-        validateNodeProperties(n, `${path}`, warnings);
-      }
-    });
-    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 (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)}".`
-            });
-          }
-        });
-      });
-    }
-  }
-  return { valid: errors.length === 0, errors, warnings };
-}
-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/frameworks/canonical.ts
 var UPG_FRAMEWORKS = [
   {
@@ -12138,31 +11851,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"
       }
@@ -12791,26 +12510,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?"
       }
@@ -12978,31 +12702,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"
       }
@@ -13073,26 +12803,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"
       }
@@ -13572,21 +13307,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"
       }
@@ -13594,12 +13333,97 @@ var UPG_FRAMEWORKS = [
     "data": {
       "entity_types": [
         {
-          "type": "feature",
-          "role": "item"
+          "type": "feature",
+          "role": "scored_item"
+        }
+      ],
+      "required_properties": {
+        "feature": [
+          {
+            "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_properties": [
+        {
+          "property": "satisfaction_coefficient",
+          "expression": "(delighter_count + performance_count) / (delighter_count + performance_count + must_be_count + indifferent_count)",
+          "entity_type": "feature",
+          "label": "Satisfaction Coefficient",
+          "format": "number"
+        },
+        {
+          "property": "dissatisfaction_coefficient",
+          "expression": "(must_be_count + performance_count) / (delighter_count + performance_count + must_be_count + indifferent_count) * -1",
+          "entity_type": "feature",
+          "label": "Dissatisfaction Coefficient",
+          "format": "number"
         }
       ],
-      "required_properties": {
-        "feature": [
+      "scoring_lens": {
+        "applies_to": [
+          "feature"
+        ],
+        "inputs": [
           {
             "property": "functional_response",
             "type": "enum",
@@ -13662,24 +13486,22 @@ var UPG_FRAMEWORKS = [
             "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"
+          }
         ]
-      },
-      "computed_properties": [
-        {
-          "property": "satisfaction_coefficient",
-          "expression": "(delighter_count + performance_count) / (delighter_count + performance_count + must_be_count + indifferent_count)",
-          "entity_type": "feature",
-          "label": "Satisfaction Coefficient",
-          "format": "number"
-        },
-        {
-          "property": "dissatisfaction_coefficient",
-          "expression": "(must_be_count + performance_count) / (delighter_count + performance_count + must_be_count + indifferent_count) * -1",
-          "entity_type": "feature",
-          "label": "Dissatisfaction Coefficient",
-          "format": "number"
-        }
-      ]
+      }
     },
     "structure": {
       "pattern": "matrix"
@@ -13734,16 +13556,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"
       }
@@ -14259,26 +14084,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"
       }
@@ -14943,26 +14773,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"
       }
@@ -15032,26 +14867,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"
       }
@@ -15126,21 +14966,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"
       }
@@ -15214,26 +15058,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"
       }
@@ -15307,21 +15156,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"
       }
@@ -15409,48 +15262,341 @@ var UPG_FRAMEWORKS = [
         "description": "The business or product outcome the north-star metric is designed to represent"
       },
       {
-        "label": "Dashboard",
-        "entityTypeId": "dashboard",
-        "description": "Dashboard visualising the metrics tree and showing real-time progress across levels"
+        "label": "Dashboard",
+        "entityTypeId": "dashboard",
+        "description": "Dashboard visualising the metrics tree and showing real-time progress across levels"
+      },
+      {
+        "label": "Report",
+        "entityTypeId": "report",
+        "description": "Periodic report analysing movement across the tree and attributing changes to specific inputs"
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "metric",
+          "role": "item"
+        },
+        {
+          "type": "outcome",
+          "role": "root"
+        },
+        {
+          "type": "dashboard",
+          "role": "item"
+        },
+        {
+          "type": "report",
+          "role": "item"
+        }
+      ],
+      "required_properties": {}
+    },
+    "structure": {
+      "pattern": "tree"
+    },
+    "presentation": {
+      "layout": {
+        "type": "tree",
+        "direction": "TB",
+        "engine": "dagre"
+      },
+      "colour_by": "type",
+      "collapsible": true,
+      "card_fields": [
+        "title",
+        "description",
+        "status"
+      ]
+    },
+    "education": {
+      "purpose": "Decompose a top-level business metric into its component parts and drivers, creating a tree that shows exactly which levers move the number.",
+      "core_question": "What are the component metrics that drive our north star, and which lever has the most headroom for improvement?",
+      "when_to_use": [
+        "You need to structure your data architecture or analytics practice",
+        "Data quality, governance, or accessibility is a problem",
+        "You want to move from ad-hoc analysis to systematic data practices"
+      ],
+      "when_not_to_use": [
+        "The product generates minimal data that does not warrant formal practices",
+        "You are in very early stage where data infrastructure is premature"
+      ]
+    }
+  },
+  {
+    "id": "team-health-check",
+    "approach_ids": [
+      "inspect"
+    ],
+    "name": "Team Health Check",
+    "version": "1.0.0",
+    "description": "A facilitated team self-assessment across dimensions like mission, fun, learning, speed, and support, using traffic-light voting to surface strengths and improvement areas in a safe format.",
+    "category": "team_process",
+    "origin": {
+      "type": "practitioner",
+      "attribution": "Spotify / Kniberg",
+      "description": "Popularised by Spotify and Henrik Kniberg's Squad Health Check model (2014). Teams self-assess health across dimensions like mission clarity, psychological safety, speed, and learning.",
+      "url": "https://engineering.atspotify.com/2014/09/squad-health-check-model/",
+      "year": 2014,
+      "license": "open_attribution"
+    },
+    "tags": [
+      "team_process",
+      "table"
+    ],
+    "slots": [
+      {
+        "label": "Team",
+        "entityTypeId": "team",
+        "description": "Team conducting the health check; all members vote anonymously on each dimension"
+      },
+      {
+        "label": "Retrospective",
+        "entityTypeId": "retrospective",
+        "description": "Health check session results feeding into the retrospective discussion and action items"
+      },
+      {
+        "label": "Metric",
+        "entityTypeId": "metric",
+        "description": "Health dimension scored, e.g. delivering value, teamwork, fun, learning, mission clarity, speed"
+      },
+      {
+        "label": "Team OKR",
+        "entityTypeId": "team_okr",
+        "description": "Team OKR or improvement goal derived from consistently red health check dimensions"
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "team",
+          "role": "item"
+        },
+        {
+          "type": "retrospective",
+          "role": "item"
+        },
+        {
+          "type": "metric",
+          "role": "item"
+        },
+        {
+          "type": "team_okr",
+          "role": "item"
+        }
+      ],
+      "required_properties": {}
+    },
+    "structure": {
+      "pattern": "table"
+    },
+    "presentation": {
+      "layout": {
+        "type": "table",
+        "columns": [
+          {
+            "property": "title",
+            "label": "Team",
+            "sortable": true
+          },
+          {
+            "property": "title",
+            "label": "Retrospective",
+            "sortable": true
+          },
+          {
+            "property": "description",
+            "label": "Metric"
+          },
+          {
+            "property": "title",
+            "label": "Team OKR",
+            "sortable": true
+          }
+        ]
+      },
+      "sort_by": {
+        "property": "title",
+        "direction": "asc"
+      },
+      "colour_by": "type",
+      "card_fields": [
+        "title",
+        "description",
+        "status"
+      ]
+    },
+    "education": {
+      "purpose": "Regularly assess team health across dimensions (psychological safety, autonomy, mission clarity, fun, speed, learning) to catch problems early and celebrate strengths.",
+      "core_question": "How is the team really doing: where do they feel strong, where do they feel stuck, and what has changed since last check?",
+      "when_to_use": [
+        "You need to improve team collaboration, clarity, or effectiveness",
+        "Roles and responsibilities are unclear or causing friction",
+        "You want to establish or improve team processes and ceremonies"
+      ],
+      "when_not_to_use": [
+        "The team is small and informal coordination works well",
+        "Process overhead would slow down a team that needs speed"
+      ]
+    }
+  },
+  {
+    "id": "raid-log",
+    "approach_ids": [
+      "inspect"
+    ],
+    "name": "RAID Log",
+    "version": "1.0.0",
+    "description": "A project management register tracking Risks, Assumptions, Issues, and Dependencies, the four categories most likely to derail a project if left unmanaged.",
+    "category": "program_mgmt",
+    "origin": {
+      "type": "practitioner",
+      "description": "Standard project management tool used across methodologies. The RAID log (Risks, Assumptions, Issues, Dependencies) provides a single living document for tracking all factors that could derail a programme.",
+      "license": "cc_by"
+    },
+    "tags": [
+      "program_mgmt",
+      "table"
+    ],
+    "slots": [
+      {
+        "label": "Risk Register",
+        "entityTypeId": "risk_register",
+        "description": "Risk or assumption logged with likelihood, impact, owner, and mitigation strategy"
+      },
+      {
+        "label": "Risk",
+        "entityTypeId": "risk",
+        "description": "Individual risk scored by probability and impact; severity = probability * impact"
+      },
+      {
+        "label": "Dependency",
+        "entityTypeId": "dependency",
+        "description": "Dependency on another team, system, or deliverable that could block progress if not resolved"
       },
       {
-        "label": "Report",
-        "entityTypeId": "report",
-        "description": "Periodic report analysing movement across the tree and attributing changes to specific inputs"
+        "label": "Status Report",
+        "entityTypeId": "status_report",
+        "description": "Status update summarising RAID log changes: new risks, resolved issues, and dependency updates"
+      },
+      {
+        "label": "Deliverable",
+        "entityTypeId": "deliverable",
+        "description": "Deliverable affected by logged risks, issues, or dependencies, linking RAID items to project scope"
       }
     ],
     "data": {
       "entity_types": [
         {
-          "type": "metric",
+          "type": "risk_register",
           "role": "item"
         },
         {
-          "type": "outcome",
-          "role": "root"
+          "type": "risk",
+          "role": "scored_item"
         },
         {
-          "type": "dashboard",
+          "type": "dependency",
           "role": "item"
         },
         {
-          "type": "report",
+          "type": "status_report",
+          "role": "item"
+        },
+        {
+          "type": "deliverable",
           "role": "item"
         }
       ],
-      "required_properties": {}
+      "required_properties": {
+        "risk": [
+          {
+            "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_properties": [
+        {
+          "property": "severity",
+          "expression": "probability * impact",
+          "entity_type": "risk",
+          "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": "tree"
+      "pattern": "table"
     },
     "presentation": {
       "layout": {
-        "type": "tree",
-        "direction": "TB",
-        "engine": "dagre"
+        "type": "table",
+        "columns": [
+          {
+            "property": "title",
+            "label": "Item",
+            "sortable": true
+          },
+          {
+            "property": "description",
+            "label": "Category"
+          },
+          {
+            "property": "status",
+            "label": "Status"
+          },
+          {
+            "property": "description",
+            "label": "Owner / Action"
+          }
+        ]
+      },
+      "sort_by": {
+        "property": "title",
+        "direction": "asc"
       },
       "colour_by": "type",
-      "collapsible": true,
       "card_fields": [
         "title",
         "description",
@@ -15458,82 +15604,244 @@ var UPG_FRAMEWORKS = [
       ]
     },
     "education": {
-      "purpose": "Decompose a top-level business metric into its component parts and drivers, creating a tree that shows exactly which levers move the number.",
-      "core_question": "What are the component metrics that drive our north star, and which lever has the most headroom for improvement?",
+      "purpose": "Track Risks, Assumptions, Issues, and Dependencies in a single living document so the project manager sees all potential blockers in one place.",
+      "core_question": "What are the current risks, untested assumptions, open issues, and external dependencies that could derail this programme?",
       "when_to_use": [
-        "You need to structure your data architecture or analytics practice",
-        "Data quality, governance, or accessibility is a problem",
-        "You want to move from ad-hoc analysis to systematic data practices"
+        "You are managing complex, multi-team initiatives with dependencies",
+        "You need to track risks, decisions, and milestones across workstreams",
+        "Stakeholders need visibility into programme-level progress"
       ],
       "when_not_to_use": [
-        "The product generates minimal data that does not warrant formal practices",
-        "You are in very early stage where data infrastructure is premature"
+        "The project is small enough for a single team to manage",
+        "Formal programme management would create overhead without value"
       ]
     }
   },
   {
-    "id": "team-health-check",
+    "id": "ice-scoring",
     "approach_ids": [
-      "inspect"
+      "prioritise"
     ],
-    "name": "Team Health Check",
+    "name": "ICE Scoring",
     "version": "1.0.0",
-    "description": "A facilitated team self-assessment across dimensions like mission, fun, learning, speed, and support, using traffic-light voting to surface strengths and improvement areas in a safe format.",
-    "category": "team_process",
+    "description": "Rate ideas by Impact, Confidence, and Ease on a 1-10 scale. Multiply for a composite score. Fast and lightweight.",
+    "category": "prioritization",
     "origin": {
       "type": "practitioner",
-      "attribution": "Spotify / Kniberg",
-      "description": "Popularised by Spotify and Henrik Kniberg's Squad Health Check model (2014). Teams self-assess health across dimensions like mission clarity, psychological safety, speed, and learning.",
-      "url": "https://engineering.atspotify.com/2014/09/squad-health-check-model/",
-      "year": 2014,
+      "attribution": "Sean Ellis",
+      "description": "Created by Sean Ellis as a lightweight growth experiment scoring method. Widely adopted in growth teams.",
+      "year": 2010,
       "license": "open_attribution"
     },
     "tags": [
-      "team_process",
+      "prioritization",
       "table"
     ],
     "slots": [
       {
-        "label": "Team",
-        "entityTypeId": "team",
-        "description": "Team conducting the health check; all members vote anonymously on each dimension"
+        "label": "Items to score",
+        "role": "candidate",
+        "entityTypeId": "feature",
+        "description": "Features or experiments being evaluated"
       },
       {
-        "label": "Retrospective",
-        "entityTypeId": "retrospective",
-        "description": "Health check session results feeding into the retrospective discussion and action items"
+        "label": "Impact",
+        "role": "impact",
+        "entityTypeId": "outcome",
+        "description": "How much will this move the needle?"
       },
       {
-        "label": "Metric",
-        "entityTypeId": "metric",
-        "description": "Health dimension scored, e.g. delivering value, teamwork, fun, learning, mission clarity, speed"
+        "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."
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "feature",
+          "role": "scored_item"
+        },
+        {
+          "type": "outcome",
+          "role": "item"
+        },
+        {
+          "type": "assumption",
+          "role": "item"
+        },
+        {
+          "type": "opportunity",
+          "role": "scored_item"
+        },
+        {
+          "type": "need",
+          "role": "scored_item"
+        }
+      ],
+      "required_properties": {
+        "feature": [
+          {
+            "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)"
+          }
+        ],
+        "opportunity": [
+          {
+            "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)"
+          }
+        ],
+        "need": [
+          {
+            "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)"
+          }
+        ]
       },
-      {
-        "label": "Team OKR",
-        "entityTypeId": "team_okr",
-        "description": "Team OKR or improvement goal derived from consistently red health check dimensions"
-      }
-    ],
-    "data": {
-      "entity_types": [
-        {
-          "type": "team",
-          "role": "item"
-        },
+      "computed_properties": [
         {
-          "type": "retrospective",
-          "role": "item"
+          "property": "ice_score",
+          "expression": "impact * confidence * ease",
+          "entity_type": "feature",
+          "label": "ICE Score",
+          "format": "number"
         },
         {
-          "type": "metric",
-          "role": "item"
+          "property": "ice_score",
+          "expression": "impact * confidence * ease",
+          "entity_type": "opportunity",
+          "label": "ICE Score",
+          "format": "number"
         },
         {
-          "type": "team_okr",
-          "role": "item"
+          "property": "ice_score",
+          "expression": "impact * confidence * ease",
+          "entity_type": "need",
+          "label": "ICE Score",
+          "format": "number"
         }
       ],
-      "required_properties": {}
+      "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"
@@ -15544,21 +15852,22 @@ var UPG_FRAMEWORKS = [
         "columns": [
           {
             "property": "title",
-            "label": "Team",
+            "label": "Items to score",
             "sortable": true
           },
           {
-            "property": "title",
-            "label": "Retrospective",
+            "property": "impact",
+            "label": "Impact",
             "sortable": true
           },
           {
-            "property": "description",
-            "label": "Metric"
+            "property": "confidence",
+            "label": "Confidence",
+            "sortable": true
           },
           {
-            "property": "title",
-            "label": "Team OKR",
+            "property": "ease",
+            "label": "Ease",
             "sortable": true
           }
         ]
@@ -15575,114 +15884,227 @@ var UPG_FRAMEWORKS = [
       ]
     },
     "education": {
-      "purpose": "Regularly assess team health across dimensions (psychological safety, autonomy, mission clarity, fun, speed, learning) to catch problems early and celebrate strengths.",
-      "core_question": "How is the team really doing: where do they feel strong, where do they feel stuck, and what has changed since last check?",
+      "purpose": "Provide a lightweight scoring model for early-stage ideas when detailed effort estimates are unavailable. Faster than RICE and useful for brainstorm triage.",
+      "core_question": "Which ideas should we investigate further based on their potential impact, confidence in our assumptions, and implementation ease?",
       "when_to_use": [
-        "You need to improve team collaboration, clarity, or effectiveness",
-        "Roles and responsibilities are unclear or causing friction",
-        "You want to establish or improve team processes and ceremonies"
+        "You have more ideas or features than capacity to build them",
+        "Stakeholders disagree on what to build next",
+        "You need a transparent, defensible prioritisation process"
       ],
       "when_not_to_use": [
-        "The team is small and informal coordination works well",
-        "Process overhead would slow down a team that needs speed"
+        "You have a single obvious next step with no contention",
+        "The backlog is small enough to sequence intuitively"
       ]
     }
   },
   {
-    "id": "raid-log",
+    "id": "wsjf",
     "approach_ids": [
-      "inspect"
+      "prioritise"
     ],
-    "name": "RAID Log",
+    "name": "WSJF (Weighted Shortest Job First)",
     "version": "1.0.0",
-    "description": "A project management register tracking Risks, Assumptions, Issues, and Dependencies, the four categories most likely to derail a project if left unmanaged.",
-    "category": "program_mgmt",
+    "description": "Prioritise work by dividing Cost of Delay (user value + time criticality + risk reduction) by job duration to maximise economic throughput.",
+    "category": "planning",
     "origin": {
       "type": "practitioner",
-      "description": "Standard project management tool used across methodologies. The RAID log (Risks, Assumptions, Issues, Dependencies) provides a single living document for tracking all factors that could derail a programme.",
-      "license": "cc_by"
+      "attribution": "Reinertsen / SAFe",
+      "description": "Developed by Don Reinertsen and adopted as a core practice in the Scaled Agile Framework (SAFe). Combines urgency (Cost of Delay) with job size to produce an economic prioritisation sequence.",
+      "url": "https://www.scaledagileframework.com/wsjf/",
+      "year": 2011,
+      "license": "open_attribution"
     },
     "tags": [
-      "program_mgmt",
+      "planning",
       "table"
     ],
     "slots": [
       {
-        "label": "Risk Register",
-        "entityTypeId": "risk_register",
-        "description": "Risk or assumption logged with likelihood, impact, owner, and mitigation strategy"
+        "label": "Backlog Items",
+        "role": "candidate",
+        "entityTypeId": "feature",
+        "description": "Backlog Items: feature entries to evaluate"
       },
       {
-        "label": "Risk",
-        "entityTypeId": "risk",
-        "description": "Individual risk scored by probability and impact; severity = probability * impact"
+        "label": "User/Business Value",
+        "role": "user_business_value",
+        "entityTypeId": "metric",
+        "description": "User/Business Value: metric entries to evaluate"
       },
       {
-        "label": "Dependency",
-        "entityTypeId": "dependency",
-        "description": "Dependency on another team, system, or deliverable that could block progress if not resolved"
+        "label": "Time Criticality",
+        "role": "time_criticality",
+        "entityTypeId": "metric",
+        "description": "How much value decays if delivery is delayed (deadlines, competition, seasonal windows)"
       },
       {
-        "label": "Status Report",
-        "entityTypeId": "status_report",
-        "description": "Status update summarising RAID log changes: new risks, resolved issues, and dependency updates"
+        "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."
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "feature",
+          "role": "scored_item"
+        },
+        {
+          "type": "metric",
+          "role": "item"
+        },
+        {
+          "type": "opportunity",
+          "role": "scored_item"
+        }
+      ],
+      "required_properties": {
+        "feature": [
+          {
+            "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)"
+          }
+        ],
+        "opportunity": [
+          {
+            "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)"
+          }
+        ]
       },
-      {
-        "label": "Deliverable",
-        "entityTypeId": "deliverable",
-        "description": "Deliverable affected by logged risks, issues, or dependencies, linking RAID items to project scope"
-      }
-    ],
-    "data": {
-      "entity_types": [
-        {
-          "type": "risk_register",
-          "role": "item"
-        },
-        {
-          "type": "risk",
-          "role": "scored_item"
-        },
-        {
-          "type": "dependency",
-          "role": "item"
-        },
+      "computed_properties": [
         {
-          "type": "status_report",
-          "role": "item"
+          "property": "wsjf_score",
+          "expression": "(user_value + time_criticality + risk_reduction) / job_size",
+          "entity_type": "feature",
+          "label": "WSJF Score",
+          "format": "number"
         },
         {
-          "type": "deliverable",
-          "role": "item"
+          "property": "wsjf_score",
+          "expression": "(user_value + time_criticality + risk_reduction) / job_size",
+          "entity_type": "opportunity",
+          "label": "WSJF Score",
+          "format": "number"
         }
       ],
-      "required_properties": {
-        "risk": [
+      "scoring_lens": {
+        "applies_to": [
+          "feature",
+          "opportunity"
+        ],
+        "inputs": [
           {
-            "property": "probability",
+            "property": "user_value",
             "type": "number",
             "required": true,
-            "label": "Probability",
-            "description": "Likelihood the risk materialises (risk.probability assessment)"
+            "scope": "framework",
+            "label": "User/Business Value",
+            "description": "Relative value to users and the business if delivered"
           },
           {
-            "property": "impact",
+            "property": "time_criticality",
             "type": "number",
             "required": true,
-            "label": "Impact",
-            "description": "Consequence severity if the risk materialises (risk.impact assessment)"
+            "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"
           }
         ]
-      },
-      "computed_properties": [
-        {
-          "property": "severity",
-          "expression": "probability * impact",
-          "entity_type": "risk",
-          "label": "Severity",
-          "format": "number"
-        }
-      ]
+      }
     },
     "structure": {
       "pattern": "table"
@@ -15693,20 +16115,33 @@ var UPG_FRAMEWORKS = [
         "columns": [
           {
             "property": "title",
-            "label": "Item",
+            "label": "Backlog Items",
             "sortable": true
           },
           {
-            "property": "description",
-            "label": "Category"
+            "property": "user_value",
+            "label": "User/Business Value",
+            "sortable": true
           },
           {
-            "property": "status",
-            "label": "Status"
+            "property": "time_criticality",
+            "label": "Time Criticality",
+            "sortable": true
           },
           {
-            "property": "description",
-            "label": "Owner / Action"
+            "property": "risk_reduction",
+            "label": "Risk Reduction / Opportunity Enablement",
+            "sortable": true
+          },
+          {
+            "property": "job_size",
+            "label": "Job Size",
+            "sortable": true
+          },
+          {
+            "property": "wsjf_score",
+            "label": "WSJF Score",
+            "sortable": true
           }
         ]
       },
@@ -15722,34 +16157,34 @@ var UPG_FRAMEWORKS = [
       ]
     },
     "education": {
-      "purpose": "Track Risks, Assumptions, Issues, and Dependencies in a single living document so the project manager sees all potential blockers in one place.",
-      "core_question": "What are the current risks, untested assumptions, open issues, and external dependencies that could derail this programme?",
+      "purpose": "Prioritise work by dividing the Cost of Delay by job duration, ensuring the most time-sensitive, valuable items are done first.",
+      "core_question": "Considering the cost of waiting, which items should we start now to maximise economic benefit?",
       "when_to_use": [
-        "You are managing complex, multi-team initiatives with dependencies",
-        "You need to track risks, decisions, and milestones across workstreams",
-        "Stakeholders need visibility into programme-level progress"
+        "You need to coordinate work across multiple teams or time horizons",
+        "Stakeholders need visibility into what is coming and when",
+        "You want to balance commitments with flexibility"
       ],
       "when_not_to_use": [
-        "The project is small enough for a single team to manage",
-        "Formal programme management would create overhead without value"
+        "The team is small enough that informal coordination works",
+        "Plans would create false precision about uncertain outcomes"
       ]
     }
   },
   {
-    "id": "ice-scoring",
+    "id": "cost-of-delay",
     "approach_ids": [
       "prioritise"
     ],
-    "name": "ICE Scoring",
+    "name": "Cost of Delay",
     "version": "1.0.0",
-    "description": "Rate ideas by Impact, Confidence, and Ease on a 1-10 scale. Multiply for a composite score. Fast and lightweight.",
+    "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",
-      "attribution": "Sean Ellis",
-      "description": "Created by Sean Ellis as a lightweight growth experiment scoring method. Widely adopted in growth teams.",
-      "year": 2010,
-      "license": "open_attribution"
+      "attribution": "Don Reinertsen",
+      "description": "Formalised in The Principles of Product Development Flow (Celeritas Publishing). Foundational to lean product economics.",
+      "year": 2009,
+      "license": "public_domain"
     },
     "tags": [
       "prioritization",
@@ -15757,34 +16192,29 @@ var UPG_FRAMEWORKS = [
     ],
     "slots": [
       {
-        "label": "Items to score",
+        "label": "Items to evaluate",
         "entityTypeId": "feature",
-        "description": "Features or experiments being evaluated"
+        "description": "Features or initiatives being assessed"
       },
       {
-        "label": "Impact",
+        "label": "User-Business Value",
         "entityTypeId": "outcome",
-        "description": "How much will this move the needle?"
+        "description": "Revenue, retention, or strategic value"
       },
       {
-        "label": "Confidence",
-        "entityTypeId": "assumption",
-        "description": "How sure are we about the impact?"
+        "label": "Time Criticality",
+        "entityTypeId": "metric",
+        "description": "How much value decays with delay"
       },
       {
-        "label": "Ease",
-        "entityTypeId": "feature",
-        "description": "How easy is this to implement?"
+        "label": "Risk Reduction",
+        "entityTypeId": "risk",
+        "description": "What risk does this mitigate?"
       },
       {
         "label": "Opportunities to score",
         "entityTypeId": "opportunity",
-        "description": "Opportunities scored on the same ICE Scoring inputs as features."
-      },
-      {
-        "label": "Needs to score",
-        "entityTypeId": "need",
-        "description": "Needs scored on the same ICE Scoring inputs as features."
+        "description": "Opportunities scored on the same Cost of Delay inputs as features."
       }
     ],
     "data": {
@@ -15794,743 +16224,567 @@ var UPG_FRAMEWORKS = [
           "role": "scored_item"
         },
         {
-          "type": "outcome",
+          "type": "metric",
           "role": "item"
         },
         {
-          "type": "assumption",
+          "type": "outcome",
           "role": "item"
         },
         {
-          "type": "opportunity",
-          "role": "scored_item"
+          "type": "risk",
+          "role": "item"
         },
         {
-          "type": "need",
+          "type": "opportunity",
           "role": "scored_item"
         }
       ],
       "required_properties": {
         "feature": [
           {
-            "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)"
-          }
-        ],
-        "opportunity": [
-          {
-            "property": "impact",
-            "type": "number",
-            "required": true,
-            "scope": "framework",
-            "label": "Impact",
-            "description": "Expected impact on the target metric (1-10)"
-          },
-          {
-            "property": "confidence",
+            "property": "cost_of_delay",
             "type": "number",
             "required": true,
             "scope": "framework",
-            "label": "Confidence",
-            "description": "Confidence in the impact estimate (1-10)"
+            "label": "Cost of Delay",
+            "description": "Weekly revenue impact of not shipping"
           },
           {
-            "property": "ease",
-            "type": "number",
-            "required": true,
-            "scope": "framework",
-            "label": "Ease",
-            "description": "Ease of implementation (1-10)"
-          }
-        ],
-        "need": [
-          {
-            "property": "impact",
+            "property": "job_size",
             "type": "number",
             "required": true,
             "scope": "framework",
-            "label": "Impact",
-            "description": "Expected impact on the target metric (1-10)"
-          },
+            "label": "Job Size",
+            "description": "Weeks of development effort"
+          }
+        ],
+        "opportunity": [
           {
-            "property": "confidence",
+            "property": "cost_of_delay",
             "type": "number",
             "required": true,
             "scope": "framework",
-            "label": "Confidence",
-            "description": "Confidence in the impact estimate (1-10)"
+            "label": "Cost of Delay",
+            "description": "Weekly revenue impact of not shipping"
           },
           {
-            "property": "ease",
+            "property": "job_size",
             "type": "number",
             "required": true,
             "scope": "framework",
-            "label": "Ease",
-            "description": "Ease of implementation (1-10)"
+            "label": "Job Size",
+            "description": "Weeks of development effort"
           }
         ]
       },
       "computed_properties": [
         {
-          "property": "ice_score",
-          "expression": "impact * confidence * ease",
+          "property": "wsjf_score",
+          "expression": "cost_of_delay / job_size",
           "entity_type": "feature",
-          "label": "ICE Score",
+          "label": "WSJF Score",
           "format": "number"
         },
         {
-          "property": "ice_score",
-          "expression": "impact * confidence * ease",
+          "property": "wsjf_score",
+          "expression": "cost_of_delay / job_size",
           "entity_type": "opportunity",
-          "label": "ICE Score",
-          "format": "number"
-        },
-        {
-          "property": "ice_score",
-          "expression": "impact * confidence * ease",
-          "entity_type": "need",
-          "label": "ICE Score",
+          "label": "WSJF Score",
           "format": "number"
         }
       ],
       "scoring_lens": {
         "applies_to": [
           "feature",
-          "opportunity",
-          "need"
+          "opportunity"
         ],
         "inputs": [
           {
-            "property": "impact",
-            "type": "number",
-            "required": true,
-            "scope": "framework",
-            "label": "Impact",
-            "description": "Expected impact on the target metric (1-10)"
-          },
-          {
-            "property": "confidence",
+            "property": "cost_of_delay",
             "type": "number",
             "required": true,
             "scope": "framework",
-            "label": "Confidence",
-            "description": "Confidence in the impact estimate (1-10)"
+            "label": "Cost of Delay",
+            "description": "Weekly revenue impact of not shipping"
           },
           {
-            "property": "ease",
+            "property": "job_size",
             "type": "number",
             "required": true,
             "scope": "framework",
-            "label": "Ease",
-            "description": "Ease of implementation (1-10)"
+            "label": "Job Size",
+            "description": "Weeks of development effort"
           }
         ],
         "computed": [
           {
-            "property": "ice_score",
-            "expression": "impact * confidence * ease",
-            "label": "ICE Score",
+            "property": "wsjf_score",
+            "expression": "cost_of_delay / job_size",
+            "label": "WSJF Score",
             "format": "number"
           }
         ]
       }
     },
     "structure": {
-      "pattern": "table"
+      "pattern": "table"
+    },
+    "presentation": {
+      "layout": {
+        "type": "table",
+        "columns": [
+          {
+            "property": "title",
+            "label": "Items to evaluate",
+            "sortable": true
+          },
+          {
+            "property": "cost_of_delay",
+            "label": "User-Business Value",
+            "sortable": true
+          },
+          {
+            "property": "job_size",
+            "label": "Job Size",
+            "sortable": true
+          },
+          {
+            "property": "wsjf_score",
+            "label": "CoD Score",
+            "sortable": true
+          }
+        ]
+      },
+      "sort_by": {
+        "property": "title",
+        "direction": "asc"
+      },
+      "colour_by": "type",
+      "card_fields": [
+        "title",
+        "description",
+        "status"
+      ]
+    },
+    "education": {
+      "purpose": "Quantify the economic impact of not delivering a feature by a given date, making urgency visible and enabling time-sensitive prioritisation.",
+      "core_question": "How much value are we losing every week this feature is not in production, and does that urgency justify fast-tracking it?",
+      "when_to_use": [
+        "You have more ideas or features than capacity to build them",
+        "Stakeholders disagree on what to build next",
+        "You need a transparent, defensible prioritisation process"
+      ],
+      "when_not_to_use": [
+        "You have a single obvious next step with no contention",
+        "The backlog is small enough to sequence intuitively"
+      ]
+    }
+  },
+  {
+    "id": "five-whys",
+    "approach_ids": [
+      "reflect",
+      "inspect"
+    ],
+    "name": "Five Whys",
+    "version": "1.0.0",
+    "description": 'Iteratively ask "why?", typically five times, starting from a symptom; each answer becomes the subject of the next question. The chain of answers reveals the underlying root cause behind the surface problem.',
+    "category": "team_process",
+    "origin": {
+      "type": "practitioner",
+      "attribution": "Sakichi Toyoda / Toyota Production System",
+      "description": "Developed within the Toyota Production System as a root-cause analysis technique. Popularised through Lean and Six Sigma practice; now a widely used incident-review and design-debug staple.",
+      "year": 1930,
+      "license": "public_domain"
+    },
+    "tags": [
+      "team_process",
+      "reflection",
+      "root_cause",
+      "tree"
+    ],
+    "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."
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "need",
+          "role": "root"
+        },
+        {
+          "type": "insight",
+          "role": "branch"
+        }
+      ],
+      "required_properties": {}
+    },
+    "structure": {
+      "pattern": "tree"
+    },
+    "presentation": {
+      "layout": {
+        "type": "tree",
+        "direction": "TB"
+      },
+      "sort_by": {
+        "property": "title",
+        "direction": "asc"
+      },
+      "card_fields": [
+        "title",
+        "description"
+      ]
+    },
+    "education": {
+      "purpose": 'Move past surface symptoms by chaining "why?" questions until the underlying root cause surfaces, so fixes target the real driver rather than a downstream effect.',
+      "core_question": "Why is this happening, and why is THAT happening, until we reach a cause we can act on?",
+      "when_to_use": [
+        "A problem keeps recurring after surface fixes",
+        "Post-incident review where the obvious cause feels too obvious",
+        "Designing a fix and you want to confirm you understand the actual driver"
+      ],
+      "when_not_to_use": [
+        "The problem has multiple independent root causes (use a fishbone or richer RCA tool)",
+        "You need quantitative attribution rather than a single-thread narrative",
+        'Five linear "whys" oversimplify a systems problem with feedback loops'
+      ]
+    }
+  },
+  {
+    "id": "pre-mortem",
+    "approach_ids": [
+      "reflect"
+    ],
+    "name": "Pre-mortem",
+    "version": "1.0.0",
+    "description": "Imagine the project has already failed; work backward listing the plausible causes of the failure. Produce a risk register and matching mitigations before the work starts.",
+    "category": "team_process",
+    "origin": {
+      "type": "practitioner",
+      "attribution": "Gary Klein",
+      "description": "Popularised by Gary Klein in Harvard Business Review (2007) as a prospective-hindsight technique. Inverts the post-mortem: imagine failure first, then list causes, while there is still time to act.",
+      "url": "https://hbr.org/2007/09/performing-a-project-premortem",
+      "year": 2007,
+      "license": "published_methodology"
+    },
+    "tags": [
+      "team_process",
+      "reflection",
+      "risk",
+      "collection"
+    ],
+    "slots": [
+      {
+        "label": "Imagined failures",
+        "entityTypeId": "risk",
+        "description": "Plausible failure modes named as if they had already occurred."
+      },
+      {
+        "label": "Causes",
+        "entityTypeId": "insight",
+        "description": "For each imagined failure, the contributing causes the team can foresee."
+      },
+      {
+        "label": "Mitigations",
+        "entityTypeId": "initiative",
+        "description": "Mitigation actions the team will take before failure can occur."
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "risk",
+          "role": "bucket"
+        },
+        {
+          "type": "insight",
+          "role": "bucket"
+        },
+        {
+          "type": "initiative",
+          "role": "bucket"
+        }
+      ],
+      "required_properties": {}
+    },
+    "structure": {
+      "pattern": "collection"
     },
     "presentation": {
       "layout": {
-        "type": "table",
-        "columns": [
-          {
-            "property": "title",
-            "label": "Items to score",
-            "sortable": true
-          },
-          {
-            "property": "impact",
-            "label": "Impact",
-            "sortable": true
-          },
-          {
-            "property": "confidence",
-            "label": "Confidence",
-            "sortable": true
-          },
-          {
-            "property": "ease",
-            "label": "Ease",
-            "sortable": true
-          }
-        ]
+        "type": "grid",
+        "groupBy": "type"
       },
       "sort_by": {
         "property": "title",
         "direction": "asc"
       },
-      "colour_by": "type",
+      "colour_by": "group",
       "card_fields": [
         "title",
-        "description",
-        "status"
+        "description"
       ]
     },
     "education": {
-      "purpose": "Provide a lightweight scoring model for early-stage ideas when detailed effort estimates are unavailable. Faster than RICE and useful for brainstorm triage.",
-      "core_question": "Which ideas should we investigate further based on their potential impact, confidence in our assumptions, and implementation ease?",
+      "purpose": "Surface project risks early by inverting hindsight: imagine the project has already failed and ask why, while there is still time to mitigate.",
+      "core_question": "It is six months from now and the project has failed catastrophically. What happened, and why?",
       "when_to_use": [
-        "You have more ideas or features than capacity to build them",
-        "Stakeholders disagree on what to build next",
-        "You need a transparent, defensible prioritisation process"
+        "Kicking off a project with significant downside or irreversible commitment",
+        "A plan looks too clean and the team senses unspoken concerns",
+        "Stakeholders disagree on risk; the exercise externalises and ranks them"
       ],
       "when_not_to_use": [
-        "You have a single obvious next step with no contention",
-        "The backlog is small enough to sequence intuitively"
+        "The work is small, reversible, and cheap to course-correct",
+        "The team is in execution mode and reflective ceremonies will derail momentum",
+        "Risk surfacing has become performative: the team names risks but never mitigates them"
       ]
     }
   },
   {
-    "id": "wsjf",
+    "id": "red-team",
     "approach_ids": [
-      "prioritise"
+      "reflect",
+      "inspect"
     ],
-    "name": "WSJF (Weighted Shortest Job First)",
+    "name": "Red Team",
     "version": "1.0.0",
-    "description": "Prioritise work by dividing Cost of Delay (user value + time criticality + risk reduction) by job duration to maximise economic throughput.",
-    "category": "planning",
+    "description": "Structured adversarial review. A designated group is assigned to attack a plan, design, or proposal from an outside-in stance, surfacing weaknesses the inside-out builders cannot see.",
+    "category": "team_process",
     "origin": {
       "type": "practitioner",
-      "attribution": "Reinertsen / SAFe",
-      "description": "Developed by Don Reinertsen and adopted as a core practice in the Scaled Agile Framework (SAFe). Combines urgency (Cost of Delay) with job size to produce an economic prioritisation sequence.",
-      "url": "https://www.scaledagileframework.com/wsjf/",
-      "year": 2011,
-      "license": "open_attribution"
+      "attribution": "US Department of Defense (Cold War era); broadened by security and intelligence practice",
+      "description": `Originated in Cold War-era military strategic exercises ("red" team takes the adversary role against the "blue" team's defence). Adopted by cybersecurity, intelligence analysis, and product teams as a structured contrarian-review practice.`,
+      "year": 1960,
+      "license": "public_domain"
     },
     "tags": [
-      "planning",
-      "table"
+      "team_process",
+      "reflection",
+      "adversarial",
+      "collection"
     ],
     "slots": [
       {
-        "label": "Backlog Items",
-        "entityTypeId": "feature",
-        "description": "Backlog Items: feature entries to evaluate"
-      },
-      {
-        "label": "User/Business Value",
-        "entityTypeId": "metric",
-        "description": "User/Business Value: metric entries to evaluate"
-      },
-      {
-        "label": "Time Criticality",
-        "entityTypeId": "metric",
-        "description": "How much value decays if delivery is delayed (deadlines, competition, seasonal windows)"
-      },
-      {
-        "label": "Risk Reduction / Opportunity Enablement",
-        "entityTypeId": "metric",
-        "description": "Risk Reduction / Opportunity Enablement: metric entries to evaluate"
+        "label": "Target",
+        "entityTypeId": "initiative",
+        "description": "The plan, design, or proposal under adversarial review."
       },
       {
-        "label": "Job Size",
-        "entityTypeId": "metric",
-        "description": "Estimated effort (story points, t-shirt size, or person-weeks)"
+        "label": "Attack vectors",
+        "entityTypeId": "risk",
+        "description": "The angles the red team uses to probe weaknesses."
       },
       {
-        "label": "Opportunities to score",
-        "entityTypeId": "opportunity",
-        "description": "Opportunities scored on the same WSJF (Weighted Shortest Job First) inputs as features."
+        "label": "Findings",
+        "entityTypeId": "insight",
+        "description": "Weaknesses, blind spots, or unstated assumptions surfaced by the review."
       }
     ],
     "data": {
       "entity_types": [
         {
-          "type": "feature",
-          "role": "scored_item"
-        },
-        {
-          "type": "metric",
-          "role": "item"
-        },
-        {
-          "type": "opportunity",
-          "role": "scored_item"
-        }
-      ],
-      "required_properties": {
-        "feature": [
-          {
-            "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)"
-          }
-        ],
-        "opportunity": [
-          {
-            "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_properties": [
-        {
-          "property": "wsjf_score",
-          "expression": "(user_value + time_criticality + risk_reduction) / job_size",
-          "entity_type": "feature",
-          "label": "WSJF Score",
-          "format": "number"
-        },
-        {
-          "property": "wsjf_score",
-          "expression": "(user_value + time_criticality + risk_reduction) / job_size",
-          "entity_type": "opportunity",
-          "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"
-          }
-        ]
-      }
+          "type": "initiative",
+          "role": "root"
+        },
+        {
+          "type": "risk",
+          "role": "bucket"
+        },
+        {
+          "type": "insight",
+          "role": "bucket"
+        }
+      ],
+      "required_properties": {}
     },
     "structure": {
-      "pattern": "table"
+      "pattern": "collection"
     },
     "presentation": {
       "layout": {
-        "type": "table",
-        "columns": [
-          {
-            "property": "title",
-            "label": "Backlog Items",
-            "sortable": true
-          },
-          {
-            "property": "user_value",
-            "label": "User/Business Value",
-            "sortable": true
-          },
-          {
-            "property": "time_criticality",
-            "label": "Time Criticality",
-            "sortable": true
-          },
-          {
-            "property": "risk_reduction",
-            "label": "Risk Reduction / Opportunity Enablement",
-            "sortable": true
-          },
-          {
-            "property": "job_size",
-            "label": "Job Size",
-            "sortable": true
-          },
-          {
-            "property": "wsjf_score",
-            "label": "WSJF Score",
-            "sortable": true
-          }
-        ]
+        "type": "grid",
+        "groupBy": "type"
       },
       "sort_by": {
         "property": "title",
         "direction": "asc"
       },
-      "colour_by": "type",
+      "colour_by": "group",
       "card_fields": [
         "title",
-        "description",
-        "status"
+        "description"
       ]
     },
     "education": {
-      "purpose": "Prioritise work by dividing the Cost of Delay by job duration, ensuring the most time-sensitive, valuable items are done first.",
-      "core_question": "Considering the cost of waiting, which items should we start now to maximise economic benefit?",
+      "purpose": "Stress-test a plan against an explicit adversary by assigning reviewers to attack rather than agree, so weaknesses surface before reality finds them.",
+      "core_question": "If a competent adversary wanted this to fail, where would they push first, and would we hold?",
       "when_to_use": [
-        "You need to coordinate work across multiple teams or time horizons",
-        "Stakeholders need visibility into what is coming and when",
-        "You want to balance commitments with flexibility"
+        "A high-stakes decision, launch, or security posture needs hardening",
+        "Inside-out thinking is dominant and dissent has gone quiet",
+        "Risk register is suspiciously short for the size of the bet"
       ],
       "when_not_to_use": [
-        "The team is small enough that informal coordination works",
-        "Plans would create false precision about uncertain outcomes"
+        "Early-stage exploration where adversarial framing would crush a fragile idea prematurely",
+        "Team trust is too low: red-teaming will read as personal attack rather than role-play",
+        "The work is small enough that a lightweight devil's-advocate pass is sufficient"
       ]
     }
   },
   {
-    "id": "cost-of-delay",
+    "id": "devils-advocate",
     "approach_ids": [
-      "prioritise"
+      "reflect"
     ],
-    "name": "Cost of Delay",
+    "name": "Devil's Advocate",
     "version": "1.0.0",
-    "description": "Quantify the economic cost of not shipping a feature or opportunity to drive priority decisions. Combines urgency with value.",
-    "category": "prioritization",
+    "description": "Designate one reviewer to formally take the opposing position regardless of personal view. The assigned-role contrarian defangs groupthink by making dissent legitimate and structured.",
+    "category": "team_process",
     "origin": {
       "type": "practitioner",
-      "attribution": "Don Reinertsen",
-      "description": "Formalised in The Principles of Product Development Flow (Celeritas Publishing). Foundational to lean product economics.",
-      "year": 2009,
+      "attribution": "Roman Catholic Church (advocatus diaboli); broadened by decision-quality practice",
+      "description": "Originated in 16th-century canonisation proceedings as the advocatus diaboli, an official assigned to argue against canonising a candidate. Adopted by decision-science and product-team practice as a structured antidote to groupthink.",
+      "year": 1587,
       "license": "public_domain"
     },
     "tags": [
-      "prioritization",
-      "table"
+      "team_process",
+      "reflection",
+      "decision_quality",
+      "collection"
     ],
     "slots": [
       {
-        "label": "Items to evaluate",
-        "entityTypeId": "feature",
-        "description": "Features or initiatives being assessed"
-      },
-      {
-        "label": "User-Business Value",
-        "entityTypeId": "outcome",
-        "description": "Revenue, retention, or strategic value"
-      },
-      {
-        "label": "Time Criticality",
-        "entityTypeId": "metric",
-        "description": "How much value decays with delay"
+        "label": "Proposal",
+        "entityTypeId": "initiative",
+        "description": "The plan or recommendation under consideration."
       },
       {
-        "label": "Risk Reduction",
-        "entityTypeId": "risk",
-        "description": "What risk does this mitigate?"
+        "label": "Opposing arguments",
+        "entityTypeId": "insight",
+        "description": "The case against the proposal, voiced by the assigned contrarian regardless of personal view."
       },
       {
-        "label": "Opportunities to score",
-        "entityTypeId": "opportunity",
-        "description": "Opportunities scored on the same Cost of Delay inputs as features."
+        "label": "Counter-evidence",
+        "entityTypeId": "evidence",
+        "description": "Data points the contrarian raises that the proposal does not yet account for."
       }
     ],
     "data": {
       "entity_types": [
         {
-          "type": "feature",
-          "role": "scored_item"
-        },
-        {
-          "type": "metric",
-          "role": "item"
-        },
-        {
-          "type": "outcome",
-          "role": "item"
-        },
-        {
-          "type": "risk",
-          "role": "item"
-        },
-        {
-          "type": "opportunity",
-          "role": "scored_item"
-        }
-      ],
-      "required_properties": {
-        "feature": [
-          {
-            "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"
-          }
-        ],
-        "opportunity": [
-          {
-            "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_properties": [
-        {
-          "property": "wsjf_score",
-          "expression": "cost_of_delay / job_size",
-          "entity_type": "feature",
-          "label": "WSJF Score",
-          "format": "number"
+          "type": "initiative",
+          "role": "root"
         },
         {
-          "property": "wsjf_score",
-          "expression": "cost_of_delay / job_size",
-          "entity_type": "opportunity",
-          "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"
-    },
-    "presentation": {
-      "layout": {
-        "type": "table",
-        "columns": [
-          {
-            "property": "title",
-            "label": "Items to evaluate",
-            "sortable": true
-          },
-          {
-            "property": "cost_of_delay",
-            "label": "User-Business Value",
-            "sortable": true
-          },
-          {
-            "property": "job_size",
-            "label": "Job Size",
-            "sortable": true
-          },
-          {
-            "property": "wsjf_score",
-            "label": "CoD Score",
-            "sortable": true
-          }
-        ]
+          "type": "insight",
+          "role": "bucket"
+        },
+        {
+          "type": "evidence",
+          "role": "bucket"
+        }
+      ],
+      "required_properties": {}
+    },
+    "structure": {
+      "pattern": "collection"
+    },
+    "presentation": {
+      "layout": {
+        "type": "grid",
+        "groupBy": "type"
       },
       "sort_by": {
         "property": "title",
         "direction": "asc"
       },
-      "colour_by": "type",
+      "colour_by": "group",
       "card_fields": [
         "title",
-        "description",
-        "status"
+        "description"
       ]
     },
     "education": {
-      "purpose": "Quantify the economic impact of not delivering a feature by a given date, making urgency visible and enabling time-sensitive prioritisation.",
-      "core_question": "How much value are we losing every week this feature is not in production, and does that urgency justify fast-tracking it?",
+      "purpose": "Make dissent a legitimate role rather than a personal stance. Assigning one reviewer to argue against the proposal forces the team to confront the strongest counter-case.",
+      "core_question": "If we had to argue against this proposal (not because we believe it, but because the role demands it) what is the strongest case?",
       "when_to_use": [
-        "You have more ideas or features than capacity to build them",
-        "Stakeholders disagree on what to build next",
-        "You need a transparent, defensible prioritisation process"
+        "A decision is heading toward consensus and you suspect groupthink",
+        "Stakes are high and the team has not heard a serious counter-argument",
+        "Cultural norms make raw dissent costly; assigning the role lowers the social cost"
       ],
       "when_not_to_use": [
-        "You have a single obvious next step with no contention",
-        "The backlog is small enough to sequence intuitively"
+        "Genuine disagreement already exists in the room (let it surface; do not theatricalise it)",
+        "The decision is small enough that the ceremony costs more than the insight returned",
+        "The assigned contrarian will be punished socially for the role; set the norms first or skip"
       ]
     }
   },
   {
-    "id": "five-whys",
+    "id": "second-order-thinking",
     "approach_ids": [
-      "reflect",
-      "inspect"
+      "reflect"
     ],
-    "name": "Five Whys",
+    "name": "Second-order Thinking",
     "version": "1.0.0",
-    "description": 'Iteratively ask "why?", typically five times, starting from a symptom; each answer becomes the subject of the next question. The chain of answers reveals the underlying root cause behind the surface problem.',
+    "description": 'After deciding a move, ask "and then what?" repeatedly. Trace second-, third-, and higher-order consequences to surface downstream effects that first-order reasoning misses.',
     "category": "team_process",
     "origin": {
       "type": "practitioner",
-      "attribution": "Sakichi Toyoda / Toyota Production System",
-      "description": "Developed within the Toyota Production System as a root-cause analysis technique. Popularised through Lean and Six Sigma practice; now a widely used incident-review and design-debug staple.",
-      "year": 1930,
-      "license": "public_domain"
+      "attribution": "Howard Marks / Charlie Munger",
+      "description": `Howard Marks distinguished first-order vs second-order thinking in The Most Important Thing (2011) as the essential discipline of consequential decision-making. Charlie Munger's "and then what?" framing is the practical heuristic.`,
+      "url": "https://www.oaktreecapital.com/insights/memo/dare-to-be-great-ii",
+      "year": 2011,
+      "license": "published_methodology"
     },
     "tags": [
       "team_process",
       "reflection",
-      "root_cause",
+      "consequences",
       "tree"
     ],
     "slots": [
       {
-        "label": "Symptom",
-        "entityTypeId": "need",
-        "description": "The observed problem the analysis starts from."
+        "label": "First-order move",
+        "role": "first_order",
+        "entityTypeId": "decision",
+        "description": "The decision or move under consideration."
       },
       {
-        "label": "Why chain",
+        "label": "Second-order consequences",
+        "role": "second_order",
         "entityTypeId": "insight",
-        "description": 'Each "why?" answer along the chain, typically five iterations deep.'
+        "description": "Downstream effects that follow from the first-order move."
       },
       {
-        "label": "Root cause",
+        "label": "Higher-order consequences",
+        "role": "higher_order",
         "entityTypeId": "insight",
-        "description": "The terminal answer at the bottom of the chain: the underlying cause to address."
+        "description": "Third-, fourth-, fifth-order ripples: second-order consequences of the second-order consequences."
       }
     ],
     "data": {
       "entity_types": [
         {
-          "type": "need",
+          "type": "decision",
           "role": "root"
         },
         {
@@ -16558,382 +16812,461 @@ var UPG_FRAMEWORKS = [
       ]
     },
     "education": {
-      "purpose": 'Move past surface symptoms by chaining "why?" questions until the underlying root cause surfaces, so fixes target the real driver rather than a downstream effect.',
-      "core_question": "Why is this happening, and why is THAT happening, until we reach a cause we can act on?",
+      "purpose": 'Resist first-order reasoning by chaining "and then what?" until non-obvious downstream consequences come into view.',
+      "core_question": "If we make this move and it works, what does the world look like next, and is that the world we want?",
       "when_to_use": [
-        "A problem keeps recurring after surface fixes",
-        "Post-incident review where the obvious cause feels too obvious",
-        "Designing a fix and you want to confirm you understand the actual driver"
+        "A decision has feedback loops, market reactions, or behavioural ripples",
+        "The first-order case is compelling, which is exactly when downstream effects bite",
+        "Considering an irreversible or large-scale commitment"
       ],
       "when_not_to_use": [
-        "The problem has multiple independent root causes (use a fishbone or richer RCA tool)",
-        "You need quantitative attribution rather than a single-thread narrative",
-        'Five linear "whys" oversimplify a systems problem with feedback loops'
+        "Routine, reversible, low-blast-radius decisions where deliberation costs more than mistakes",
+        "Higher-order branches diverge into pure speculation with no anchor in evidence",
+        "Time pressure makes a deeper trace expensive and the first-order call is good enough"
       ]
     }
-  },
-  {
-    "id": "pre-mortem",
-    "approach_ids": [
-      "reflect"
-    ],
-    "name": "Pre-mortem",
-    "version": "1.0.0",
-    "description": "Imagine the project has already failed; work backward listing the plausible causes of the failure. Produce a risk register and matching mitigations before the work starts.",
-    "category": "team_process",
-    "origin": {
-      "type": "practitioner",
-      "attribution": "Gary Klein",
-      "description": "Popularised by Gary Klein in Harvard Business Review (2007) as a prospective-hindsight technique. Inverts the post-mortem: imagine failure first, then list causes, while there is still time to act.",
-      "url": "https://hbr.org/2007/09/performing-a-project-premortem",
-      "year": 2007,
-      "license": "published_methodology"
-    },
-    "tags": [
-      "team_process",
-      "reflection",
-      "risk",
-      "collection"
-    ],
-    "slots": [
-      {
-        "label": "Imagined failures",
-        "entityTypeId": "risk",
-        "description": "Plausible failure modes named as if they had already occurred."
-      },
-      {
-        "label": "Causes",
-        "entityTypeId": "insight",
-        "description": "For each imagined failure, the contributing causes the team can foresee."
-      },
-      {
-        "label": "Mitigations",
-        "entityTypeId": "initiative",
-        "description": "Mitigation actions the team will take before failure can occur."
+  }
+];
+var UPG_FRAMEWORKS_BY_ID = Object.fromEntries(
+  UPG_FRAMEWORKS.map((fw) => [fw.id, fw])
+);
+var UPG_FRAMEWORKS_BY_CATEGORY = {};
+for (const fw of UPG_FRAMEWORKS) {
+  if (!UPG_FRAMEWORKS_BY_CATEGORY[fw.category]) UPG_FRAMEWORKS_BY_CATEGORY[fw.category] = [];
+  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);
+        }
       }
-    ],
-    "data": {
-      "entity_types": [
-        {
-          "type": "risk",
-          "role": "bucket"
-        },
-        {
-          "type": "insight",
-          "role": "bucket"
-        },
-        {
-          "type": "initiative",
-          "role": "bucket"
+      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);
+          }
         }
-      ],
-      "required_properties": {}
-    },
-    "structure": {
-      "pattern": "collection"
-    },
-    "presentation": {
-      "layout": {
-        "type": "grid",
-        "groupBy": "type"
-      },
-      "sort_by": {
-        "property": "title",
-        "direction": "asc"
-      },
-      "colour_by": "group",
-      "card_fields": [
-        "title",
-        "description"
-      ]
-    },
-    "education": {
-      "purpose": "Surface project risks early by inverting hindsight: imagine the project has already failed and ask why, while there is still time to mitigate.",
-      "core_question": "It is six months from now and the project has failed catastrophically. What happened, and why?",
-      "when_to_use": [
-        "Kicking off a project with significant downside or irreversible commitment",
-        "A plan looks too clean and the team senses unspoken concerns",
-        "Stakeholders disagree on risk; the exercise externalises and ranks them"
-      ],
-      "when_not_to_use": [
-        "The work is small, reversible, and cheap to course-correct",
-        "The team is in execution mode and reflective ceremonies will derail momentum",
-        "Risk surfacing has become performative: the team names risks but never mitigates them"
-      ]
-    }
-  },
-  {
-    "id": "red-team",
-    "approach_ids": [
-      "reflect",
-      "inspect"
-    ],
-    "name": "Red Team",
-    "version": "1.0.0",
-    "description": "Structured adversarial review. A designated group is assigned to attack a plan, design, or proposal from an outside-in stance, surfacing weaknesses the inside-out builders cannot see.",
-    "category": "team_process",
-    "origin": {
-      "type": "practitioner",
-      "attribution": "US Department of Defense (Cold War era); broadened by security and intelligence practice",
-      "description": `Originated in Cold War-era military strategic exercises ("red" team takes the adversary role against the "blue" team's defence). Adopted by cybersecurity, intelligence analysis, and product teams as a structured contrarian-review practice.`,
-      "year": 1960,
-      "license": "public_domain"
-    },
-    "tags": [
-      "team_process",
-      "reflection",
-      "adversarial",
-      "collection"
-    ],
-    "slots": [
-      {
-        "label": "Target",
-        "entityTypeId": "initiative",
-        "description": "The plan, design, or proposal under adversarial review."
-      },
-      {
-        "label": "Attack vectors",
-        "entityTypeId": "risk",
-        "description": "The angles the red team uses to probe weaknesses."
-      },
-      {
-        "label": "Findings",
-        "entityTypeId": "insight",
-        "description": "Weaknesses, blind spots, or unstated assumptions surfaced by the review."
       }
-    ],
-    "data": {
-      "entity_types": [
-        {
-          "type": "initiative",
-          "role": "root"
-        },
-        {
-          "type": "risk",
-          "role": "bucket"
-        },
-        {
-          "type": "insight",
-          "role": "bucket"
+      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);
         }
-      ],
-      "required_properties": {}
-    },
-    "structure": {
-      "pattern": "collection"
-    },
-    "presentation": {
-      "layout": {
-        "type": "grid",
-        "groupBy": "type"
-      },
-      "sort_by": {
-        "property": "title",
-        "direction": "asc"
-      },
-      "colour_by": "group",
-      "card_fields": [
-        "title",
-        "description"
-      ]
-    },
-    "education": {
-      "purpose": "Stress-test a plan against an explicit adversary by assigning reviewers to attack rather than agree, so weaknesses surface before reality finds them.",
-      "core_question": "If a competent adversary wanted this to fail, where would they push first, and would we hold?",
-      "when_to_use": [
-        "A high-stakes decision, launch, or security posture needs hardening",
-        "Inside-out thinking is dominant and dissent has gone quiet",
-        "Risk register is suspiciously short for the size of the bet"
-      ],
-      "when_not_to_use": [
-        "Early-stage exploration where adversarial framing would crush a fragile idea prematurely",
-        "Team trust is too low: red-teaming will read as personal attack rather than role-play",
-        "The work is small enough that a lightweight devil's-advocate pass is sufficient"
-      ]
-    }
-  },
-  {
-    "id": "devils-advocate",
-    "approach_ids": [
-      "reflect"
-    ],
-    "name": "Devil's Advocate",
-    "version": "1.0.0",
-    "description": "Designate one reviewer to formally take the opposing position regardless of personal view. The assigned-role contrarian defangs groupthink by making dissent legitimate and structured.",
-    "category": "team_process",
-    "origin": {
-      "type": "practitioner",
-      "attribution": "Roman Catholic Church (advocatus diaboli); broadened by decision-quality practice",
-      "description": "Originated in 16th-century canonisation proceedings as the advocatus diaboli, an official assigned to argue against canonising a candidate. Adopted by decision-science and product-team practice as a structured antidote to groupthink.",
-      "year": 1587,
-      "license": "public_domain"
-    },
-    "tags": [
-      "team_process",
-      "reflection",
-      "decision_quality",
-      "collection"
-    ],
-    "slots": [
-      {
-        "label": "Proposal",
-        "entityTypeId": "initiative",
-        "description": "The plan or recommendation under consideration."
-      },
-      {
-        "label": "Opposing arguments",
-        "entityTypeId": "insight",
-        "description": "The case against the proposal, voiced by the assigned contrarian regardless of personal view."
-      },
-      {
-        "label": "Counter-evidence",
-        "entityTypeId": "evidence",
-        "description": "Data points the contrarian raises that the proposal does not yet account for."
       }
-    ],
-    "data": {
-      "entity_types": [
-        {
-          "type": "initiative",
-          "role": "root"
-        },
-        {
-          "type": "insight",
-          "role": "bucket"
-        },
-        {
-          "type": "evidence",
-          "role": "bucket"
-        }
-      ],
-      "required_properties": {}
-    },
-    "structure": {
-      "pattern": "collection"
-    },
-    "presentation": {
-      "layout": {
-        "type": "grid",
-        "groupBy": "type"
-      },
-      "sort_by": {
-        "property": "title",
-        "direction": "asc"
-      },
-      "colour_by": "group",
-      "card_fields": [
-        "title",
-        "description"
-      ]
-    },
-    "education": {
-      "purpose": "Make dissent a legitimate role rather than a personal stance. Assigning one reviewer to argue against the proposal forces the team to confront the strongest counter-case.",
-      "core_question": "If we had to argue against this proposal (not because we believe it, but because the role demands it) what is the strongest case?",
-      "when_to_use": [
-        "A decision is heading toward consensus and you suspect groupthink",
-        "Stakes are high and the team has not heard a serious counter-argument",
-        "Cultural norms make raw dissent costly; assigning the role lowers the social cost"
-      ],
-      "when_not_to_use": [
-        "Genuine disagreement already exists in the room (let it surface; do not theatricalise it)",
-        "The decision is small enough that the ceremony costs more than the insight returned",
-        "The assigned contrarian will be punished socially for the role; set the norms first or skip"
-      ]
+      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"
+        });
+      }
     }
-  },
-  {
-    "id": "second-order-thinking",
-    "approach_ids": [
-      "reflect"
-    ],
-    "name": "Second-order Thinking",
-    "version": "1.0.0",
-    "description": 'After deciding a move, ask "and then what?" repeatedly. Trace second-, third-, and higher-order consequences to surface downstream effects that first-order reasoning misses.',
-    "category": "team_process",
-    "origin": {
-      "type": "practitioner",
-      "attribution": "Howard Marks / Charlie Munger",
-      "description": `Howard Marks distinguished first-order vs second-order thinking in The Most Important Thing (2011) as the essential discipline of consequential decision-making. Charlie Munger's "and then what?" framing is the practical heuristic.`,
-      "url": "https://www.oaktreecapital.com/insights/memo/dare-to-be-great-ii",
-      "year": 2011,
-      "license": "published_methodology"
-    },
-    "tags": [
-      "team_process",
-      "reflection",
-      "consequences",
-      "tree"
-    ],
-    "slots": [
-      {
-        "label": "First-order move",
-        "entityTypeId": "decision",
-        "description": "The decision or move under consideration."
-      },
-      {
-        "label": "Second-order consequences",
-        "entityTypeId": "insight",
-        "description": "Downstream effects that follow from the first-order move."
-      },
-      {
-        "label": "Higher-order consequences",
-        "entityTypeId": "insight",
-        "description": "Third-, fourth-, fifth-order ripples: second-order consequences of the second-order consequences."
+  });
+}
+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)}.`;
       }
-    ],
-    "data": {
-      "entity_types": [
-        {
-          "type": "decision",
-          "role": "root"
-        },
-        {
-          "type": "insight",
-          "role": "branch"
+      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}].`;
         }
-      ],
-      "required_properties": {}
-    },
-    "structure": {
-      "pattern": "tree"
-    },
-    "presentation": {
-      "layout": {
-        "type": "tree",
-        "direction": "TB"
-      },
-      "sort_by": {
-        "property": "title",
-        "direction": "asc"
-      },
-      "card_fields": [
-        "title",
-        "description"
-      ]
-    },
-    "education": {
-      "purpose": 'Resist first-order reasoning by chaining "and then what?" until non-obvious downstream consequences come into view.',
-      "core_question": "If we make this move and it works, what does the world look like next, and is that the world we want?",
-      "when_to_use": [
-        "A decision has feedback loops, market reactions, or behavioural ripples",
-        "The first-order case is compelling, which is exactly when downstream effects bite",
-        "Considering an irreversible or large-scale commitment"
-      ],
-      "when_not_to_use": [
-        "Routine, reversible, low-blast-radius decisions where deliberation costs more than mistakes",
-        "Higher-order branches diverge into pure speculation with no anchor in evidence",
-        "Time pressure makes a deeper trace expensive and the first-order call is good enough"
-      ]
+      } 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;
   }
-];
-var UPG_FRAMEWORKS_BY_ID = Object.fromEntries(
-  UPG_FRAMEWORKS.map((fw) => [fw.id, fw])
-);
-var UPG_FRAMEWORKS_BY_CATEGORY = {};
-for (const fw of UPG_FRAMEWORKS) {
-  if (!UPG_FRAMEWORKS_BY_CATEGORY[fw.category]) UPG_FRAMEWORKS_BY_CATEGORY[fw.category] = [];
-  UPG_FRAMEWORKS_BY_CATEGORY[fw.category].push(fw);
+}
+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