@unified-product-graph/mcp-server 0.8.1 → 0.8.4

package/dist/index.js

@@ -20,50 +20,10 @@ import {
 // src/lib/server-context.ts
 import * as fsp from "fs/promises";
 import * as path from "path";
-import { createHash } from "crypto";
-function text(s) {
-  return { content: [{ type: "text", text: s }] };
-}
-function textError(s) {
-  return { content: [{ type: "text", text: s }], isError: true };
-}
-function createSessionContext() {
-  return {
-    lens: "product",
-    skills_invoked: [],
-    recommendations_given: [],
-    focus_area: null,
-    custom: {}
-  };
-}
-function createQueryCache() {
-  return { entries: /* @__PURE__ */ new Map(), counter: 0 };
-}
-function syncFilePath(upgPath) {
-  const dir = path.dirname(upgPath);
-  const base = path.basename(upgPath, ".upg");
-  return path.join(dir, `${base}.upg-sync`);
-}
-async function readSyncState(upgPath) {
-  const p = syncFilePath(upgPath);
-  try {
-    const raw = await fsp.readFile(p, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function writeSyncState(upgPath, state) {
-  const p = syncFilePath(upgPath);
-  await fsp.writeFile(p, JSON.stringify(state, null, 2) + "\n", "utf-8");
-}
-async function hashFile(filePath) {
-  const content = await fsp.readFile(filePath, "utf-8");
-  return createHash("sha256").update(content).digest("hex");
-}
+import { createHash as createHash2 } from "crypto";
 
 // ../upg-spec/dist/index.js
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 var UPG_DOMAINS = [
   {
     id: "strategy",
@@ -551,8 +511,8 @@ var UPG_DOMAINS = [
   {
     id: "workspace",
     label: "Workspace",
-    description: "Spatial thinking spaces for arranging entities, debating decisions, and committing to the graph. Workspaces are transient canvases that sit alongside all other domains, letting you compose and explore relationships before they become permanent graph structure.",
-    types: ["workspace"]
+    description: "Spatial thinking spaces for arranging entities, debating decisions, and committing to the graph. Workspaces are transient canvases that sit alongside all other domains, letting you compose and explore relationships before they become permanent graph structure. A framework exercise is a structured workspace: one run of a framework (MoSCoW, RICE, Kano, \u2026) applied to a chosen set of entities, with each entity's result recorded on the exercise-to-entity edge rather than the entity itself.",
+    types: ["workspace", "framework_exercise"]
   }
 ];
 var UPG_ENTITY_TO_DOMAIN = Object.freeze(
@@ -973,7 +933,8 @@ var UPG_ENTITY_META = [
   { name: "integration_partner", type_id: "ent_311", maturity: "stable", since: "0.1.0" },
   { name: "partner_revenue_share", type_id: "ent_312", maturity: "stable", since: "0.1.0" },
   // ── Workspace ──
-  { name: "workspace", type_id: "ent_328", maturity: "proposed", since: "0.2.0" }
+  { name: "workspace", type_id: "ent_328", maturity: "proposed", since: "0.2.0" },
+  { name: "framework_exercise", type_id: "ent_350", maturity: "proposed", since: "0.8.4" }
 ];
 var UPG_ENTITY_META_BY_NAME = new Map(
   UPG_ENTITY_META.map((m) => [m.name, m])
@@ -993,7 +954,7 @@ var UPG_EDGE_CATALOG = {
   // product → persona is the most fundamental relationship in the
   // user domain ("who is this product for?") and was the only way to
   // anchor a fresh persona to its product before this edge existed. Without
-  // it, the natural agent path through `/upg-persona` produced an orphan
+  // it, the natural agent path through `/upg-new-persona` produced an orphan
   // persona only attached laterally via `ideal_customer_profile_maps_to_persona`
   // or `positioning_resonates_with_persona`. Semantic, not hierarchy: a
   // product doesn't "contain" personas; it targets them.
@@ -2113,6 +2074,18 @@ var UPG_EDGE_CATALOG = {
   // universal across the DDD type family. Verbs follow DDD literature:
   // aggregate belongs_to context, context contains aggregates.
   node_belongs_to_bounded_context: { forward_verb: "belongs_to", reverse_verb: "contains", classification: "cross-domain", source_type: "node", target_type: "bounded_context" },
+  // ── Cross-domain: Framework exercises ────────────────────────────────────────
+  // A framework_exercise is one run of a framework (MoSCoW, RICE, Kano, …) over a
+  // set of entities. It `includes` each entity it touches; the framework's
+  // per-entity result — a MoSCoW bucket, a RICE score, a canvas slot, a funnel
+  // stage — rides on this edge's `properties`, NOT on the entity node. A value
+  // that exists only within a specific exercise is a fact about the relationship,
+  // not the entity, so it lives on the edge (same principle as owner-as-edge).
+  // Polymorphic (`target_type: 'node'`): an exercise can include any entity type,
+  // which closes the feature-only limitation structurally. `carries_properties`
+  // opts this edge into the gated edge-property model. See ADR
+  // 2026-06-02-framework-exercises.
+  framework_exercise_includes_node: { forward_verb: "includes", reverse_verb: "included_in", classification: "cross-domain", source_type: "framework_exercise", target_type: "node", carries_properties: true },
   // ── New edges replacing deleted string properties ────────────────────
   // Marketing
   marketing_strategy_pursues_outcome: { forward_verb: "pursues", reverse_verb: "pursued_by", classification: "cross-domain", source_type: "marketing_strategy", target_type: "outcome" },
@@ -2208,6 +2181,13 @@ var UPG_EDGE_CATALOG = {
   // release strategy to the concrete deployments it governs.
   incident_affects_feature: { forward_verb: "affects", reverse_verb: "affected_by", classification: "cross-domain", source_type: "incident", target_type: "feature" },
   release_strategy_used_by_deployment: { forward_verb: "used_by", reverse_verb: "uses", classification: "cross-domain", source_type: "release_strategy", target_type: "deployment" },
+  // v0.8.2 (UPG-615): ITIL/ITSM incident management explicitly links an incident
+  // to the customer-facing support tickets/cases it spawns — when a service
+  // breaks, customers raise tickets; the incident is the cause, the ticket the
+  // effect. Closes the otherwise-unmediated "Customer Support" island in
+  // `playbook:operations-quality`, binding `support_ticket` to the incident/ops
+  // spine. Source: ITIL v4 incident management; DORA/SRE customer-facing impact.
+  incident_generates_support_ticket: { forward_verb: "generates", reverse_verb: "generated_by", classification: "cross-domain", source_type: "incident", target_type: "support_ticket" },
   // Cluster C: User Research linkage matrix.
   // research_study → {participant, research_question, survey_response,
   // interview_guide} containment edges already exist (49/49 in Wave 4).
@@ -2735,7 +2715,9 @@ var UPG_POLYMORPHIC_EDGE_KEYS = [
   "node_owned_by_department",
   "node_owned_by_person",
   // Universal architecture references
-  "node_belongs_to_bounded_context"
+  "node_belongs_to_bounded_context",
+  // Framework exercises (an exercise can include any entity type)
+  "framework_exercise_includes_node"
 ];
 var _POLY_KEY_SET = new Set(UPG_POLYMORPHIC_EDGE_KEYS);
 var LEGACY_PRODUCT_STAGES = Object.freeze({
@@ -5658,6 +5640,31 @@ var TEMPLATE_LIFECYCLES = [
   // ── Phase B: SALES_DEAL (qualified → proposal → negotiation → won/lost) ─────
   fromTemplate("deal", SALES_DEAL_TEMPLATE)
 ];
+var FRAMEWORK_EXERCISE_LIFECYCLE = {
+  entity_type: "framework_exercise",
+  initial_phase: "draft",
+  terminal_phases: ["archived"],
+  phases: [
+    {
+      id: "draft",
+      label: "Draft",
+      description: "The exercise has been created and entities pulled into scope, but the framework's inputs have not all been filled in yet.",
+      transitions_to: ["active", "archived"]
+    },
+    {
+      id: "active",
+      label: "Active",
+      description: "The current, authoritative run of its framework. Its include edges carry the live results consumers read, rank, and render by.",
+      transitions_to: ["archived"]
+    },
+    {
+      id: "archived",
+      label: "Archived",
+      description: "A past run, retained for provenance. Still queryable but superseded by a newer exercise and hidden from default views. Can be revived to active.",
+      transitions_to: ["active"]
+    }
+  ]
+};
 var UPG_LIFECYCLES = [
   // Product (root)
   PRODUCT_LIFECYCLE,
@@ -5759,6 +5766,8 @@ var UPG_LIFECYCLES = [
   // Product & Growth
   VARIANT_LIFECYCLE,
   GROWTH_CAMPAIGN_LIFECYCLE,
+  // Workspace
+  FRAMEWORK_EXERCISE_LIFECYCLE,
   // ── Template-generated lifecycles ─────────────────────────────────
   ...TEMPLATE_LIFECYCLES
 ];
@@ -9236,6 +9245,11 @@ var UPG_PROPERTY_SCHEMA = {
     },
     methodology: { type: "string", description: "Forecasting methodology used" }
   },
+  // FrameworkExerciseProperties: Framework exercise: one run of a framework over a set of entities.
+  framework_exercise: {
+    framework_id: { type: "string", description: "Which framework this exercise runs: a framework id (e.g. 'moscow', 'rice-scoring', 'kano-model'). Resolves against the framework catalog." },
+    inputs_snapshot: { type: "object", description: "Optional frozen copy of the framework's input spec at apply time, so a historical exercise still renders correctly if the framework definition later evolves (inputs added, removed, or rescaled)." }
+  },
   // FunnelProperties: Funnel entity.
   funnel: {
     funnel_type: { type: "string", enum: ["acquisition", "activation", "retention", "revenue", "referral", "custom"], description: "Which stage of the customer lifecycle this funnel measures" },
@@ -11261,6 +11275,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "value-proposition-canvas",
+    "approach_ids": [
+      "trace"
+    ],
     "name": "Value Proposition Canvas",
     "version": "1.0.0",
     "description": "Map customer jobs, pains, and gains on one side, then align product features, pain relievers, and gain creators on the other to achieve product-market fit.",
@@ -11365,6 +11382,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "persona-canvas",
+    "approach_ids": [
+      "trace"
+    ],
     "name": "Persona Canvas",
     "version": "1.0.0",
     "description": "Demographics, goals, frustrations, JTBD: a structured template for creating research-backed personas.",
@@ -11477,6 +11497,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "empathy-map",
+    "approach_ids": [
+      "trace"
+    ],
     "name": "Empathy Map",
     "version": "1.0.0",
     "description": "Visualise what a user says, thinks, does, and feels to build deeper empathy and uncover hidden needs.",
@@ -11637,6 +11660,7 @@ var UPG_FRAMEWORKS = [
             "property": "evolution_stage",
             "type": "enum",
             "required": true,
+            "scope": "framework",
             "label": "Evolution Stage",
             "description": "Where this component sits on the evolution axis",
             "enum_values": [
@@ -11650,6 +11674,7 @@ var UPG_FRAMEWORKS = [
             "property": "visibility",
             "type": "number",
             "required": true,
+            "scope": "framework",
             "label": "Visibility",
             "description": "Y-axis position (0=infrastructure, 1=anchor/user)"
           }
@@ -11659,6 +11684,7 @@ var UPG_FRAMEWORKS = [
             "property": "evolution_stage",
             "type": "enum",
             "required": true,
+            "scope": "framework",
             "label": "Evolution Stage",
             "description": "Where this component sits on the evolution axis",
             "enum_values": [
@@ -11672,6 +11698,7 @@ var UPG_FRAMEWORKS = [
             "property": "visibility",
             "type": "number",
             "required": true,
+            "scope": "framework",
             "label": "Visibility",
             "description": "Y-axis position (0=infrastructure, 1=anchor/user)"
           }
@@ -11681,6 +11708,7 @@ var UPG_FRAMEWORKS = [
             "property": "evolution_stage",
             "type": "enum",
             "required": true,
+            "scope": "framework",
             "label": "Evolution Stage",
             "description": "Where this component sits on the evolution axis",
             "enum_values": [
@@ -11694,6 +11722,7 @@ var UPG_FRAMEWORKS = [
             "property": "visibility",
             "type": "number",
             "required": true,
+            "scope": "framework",
             "label": "Visibility",
             "description": "Y-axis position (0=infrastructure, 1=anchor/user)"
           }
@@ -11703,6 +11732,7 @@ var UPG_FRAMEWORKS = [
             "property": "evolution_stage",
             "type": "enum",
             "required": true,
+            "scope": "framework",
             "label": "Evolution Stage",
             "description": 'Where this component sits on the evolution axis (need anchor is usually at "product" or "commodity")',
             "enum_values": [
@@ -11716,6 +11746,7 @@ var UPG_FRAMEWORKS = [
             "property": "visibility",
             "type": "number",
             "required": true,
+            "scope": "framework",
             "label": "Visibility",
             "description": "Y-axis position (0=infrastructure, 1=anchor/user); needs sit at 1.0"
           }
@@ -11756,6 +11787,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "business-model-canvas",
+    "approach_ids": [
+      "plan"
+    ],
     "name": "Business Model Canvas",
     "version": "1.0.0",
     "description": "Nine building blocks that describe how an organisation creates, delivers, and captures value.",
@@ -11895,6 +11929,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "porter-five-forces",
+    "approach_ids": [
+      "inspect"
+    ],
     "name": "Porter Five Forces",
     "version": "1.0.0",
     "description": "Analyse industry competitiveness through five forces: rivalry, new entrants, substitutes, buyer power, and supplier power.",
@@ -11984,6 +12021,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "swot-analysis",
+    "approach_ids": [
+      "inspect"
+    ],
     "name": "SWOT Analysis",
     "version": "1.0.0",
     "description": "Map Strengths, Weaknesses, Opportunities, and Threats in a 2x2 grid. Internal vs external, helpful vs harmful.",
@@ -12310,6 +12350,7 @@ var UPG_FRAMEWORKS = [
             "type": "assessment",
             "scale_id": "reach_5",
             "required": true,
+            "scope": "framework",
             "label": "Reach",
             "description": "How many users will this impact per quarter?"
           },
@@ -12318,6 +12359,7 @@ var UPG_FRAMEWORKS = [
             "type": "assessment",
             "scale_id": "impact_5",
             "required": true,
+            "scope": "framework",
             "label": "Impact",
             "description": "How much will this impact each user, on the impact scale?"
           },
@@ -12326,6 +12368,7 @@ var UPG_FRAMEWORKS = [
             "type": "assessment",
             "scale_id": "confidence_5",
             "required": true,
+            "scope": "framework",
             "label": "Confidence",
             "description": "How confident are you in the reach, impact, and effort estimates?"
           },
@@ -12334,6 +12377,7 @@ var UPG_FRAMEWORKS = [
             "type": "assessment",
             "scale_id": "effort_5",
             "required": true,
+            "scope": "framework",
             "label": "Effort",
             "description": "How much work is required to build and ship this, on the effort scale?"
           }
@@ -12420,6 +12464,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "build-measure-learn",
+    "approach_ids": [
+      "reflect"
+    ],
     "name": "Build-Measure-Learn",
     "version": "1.0.0",
     "description": "The core Lean Startup feedback loop: build a minimum viable product, measure its impact with actionable metrics, and learn whether to pivot or persevere.",
@@ -12555,6 +12602,7 @@ var UPG_FRAMEWORKS = [
             "property": "functional_response",
             "type": "enum",
             "required": true,
+            "scope": "framework",
             "label": "Functional Response",
             "description": "How users feel when the feature IS present",
             "enum_values": [
@@ -12569,6 +12617,7 @@ var UPG_FRAMEWORKS = [
             "property": "dysfunctional_response",
             "type": "enum",
             "required": true,
+            "scope": "framework",
             "label": "Dysfunctional Response",
             "description": "How users feel when the feature IS NOT present",
             "enum_values": [
@@ -12583,6 +12632,7 @@ var UPG_FRAMEWORKS = [
             "property": "delighter_count",
             "type": "number",
             "required": false,
+            "scope": "framework",
             "label": "Delighter classifications",
             "description": "Count of survey responses classifying this feature as a delighter (attractive)"
           },
@@ -12590,6 +12640,7 @@ var UPG_FRAMEWORKS = [
             "property": "performance_count",
             "type": "number",
             "required": false,
+            "scope": "framework",
             "label": "Performance classifications",
             "description": "Count of survey responses classifying this feature as performance (one-dimensional)"
           },
@@ -12597,6 +12648,7 @@ var UPG_FRAMEWORKS = [
             "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)"
           },
@@ -12604,6 +12656,7 @@ var UPG_FRAMEWORKS = [
             "property": "indifferent_count",
             "type": "number",
             "required": false,
+            "scope": "framework",
             "label": "Indifferent classifications",
             "description": "Count of survey responses classifying this feature as indifferent"
           }
@@ -12796,6 +12849,7 @@ var UPG_FRAMEWORKS = [
             "property": "moscow",
             "type": "enum",
             "required": true,
+            "scope": "framework",
             "label": "MoSCoW priority",
             "description": "Which scope bucket this requirement falls into for the current release",
             "enum_values": [
@@ -12806,16 +12860,7 @@ var UPG_FRAMEWORKS = [
             ]
           }
         ]
-      },
-      "computed_properties": [
-        {
-          "property": "must_have_ratio",
-          "expression": "must_count / total_count",
-          "entity_type": "feature",
-          "label": "Must-have Ratio",
-          "format": "percentage"
-        }
-      ]
+      }
     },
     "structure": {
       "pattern": "table"
@@ -12979,6 +13024,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "c4-model",
+    "approach_ids": [
+      "trace"
+    ],
     "name": "C4 Model",
     "version": "1.0.0",
     "description": "Visualise software architecture at four levels of abstraction: System Context, Container, Component, and Code. Each level zooms in to reveal more detail.",
@@ -13071,6 +13119,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "adr-log",
+    "approach_ids": [
+      "inspect"
+    ],
     "name": "ADR Log",
     "version": "1.0.0",
     "description": "Architecture Decision Records: log decisions with context, options, and rationale.",
@@ -13184,6 +13235,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "atomic-design",
+    "approach_ids": [
+      "trace"
+    ],
     "name": "Atomic Design",
     "version": "1.0.0",
     "description": "Atoms, Molecules, Organisms, Templates, Pages: a methodology for creating design systems from the smallest elements up.",
@@ -13281,6 +13335,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "double-diamond",
+    "approach_ids": [
+      "plan"
+    ],
     "name": "Double Diamond",
     "version": "1.0.0",
     "description": "Discover, Define, Develop, Deliver: a four-phase divergent/convergent design process.",
@@ -13371,6 +13428,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "dora-metrics",
+    "approach_ids": [
+      "inspect"
+    ],
     "name": "DORA Metrics",
     "version": "1.0.0",
     "description": "Four key metrics for software delivery performance: deployment frequency, lead time, change failure rate, and time to restore.",
@@ -13430,16 +13490,7 @@ var UPG_FRAMEWORKS = [
             ]
           }
         ]
-      },
-      "computed_properties": [
-        {
-          "property": "stability_index",
-          "expression": "change_failure_rate * mean_time_to_recovery",
-          "entity_type": "metric",
-          "label": "Stability Index",
-          "format": "number"
-        }
-      ]
+      }
     },
     "structure": {
       "pattern": "collection"
@@ -13568,6 +13619,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "pirate-metrics-aarrr",
+    "approach_ids": [
+      "trace"
+    ],
     "name": "Pirate Metrics AARRR",
     "version": "1.0.0",
     "description": "Track user lifecycle across five stages: Acquisition, Activation, Retention, Revenue, and Referral.",
@@ -13601,7 +13655,7 @@ var UPG_FRAMEWORKS = [
       "required_properties": {
         "metric": [
           {
-            "property": "lifecycle_stage",
+            "property": "metric_category",
             "type": "enum",
             "required": true,
             "label": "Lifecycle stage",
@@ -13615,16 +13669,7 @@ var UPG_FRAMEWORKS = [
             ]
           }
         ]
-      },
-      "computed_properties": [
-        {
-          "property": "conversion_rate",
-          "expression": "(stage_exits / stage_entries) * 100",
-          "entity_type": "metric",
-          "label": "Stage Conversion",
-          "format": "percentage"
-        }
-      ]
+      }
     },
     "structure": {
       "pattern": "funnel",
@@ -13688,6 +13733,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "north-star-metric",
+    "approach_ids": [
+      "plan"
+    ],
     "name": "North Star Metric",
     "version": "1.0.0",
     "description": "One metric that best captures the core value you deliver. Supported by 3-5 input metrics that drive it.",
@@ -13721,7 +13769,7 @@ var UPG_FRAMEWORKS = [
       "required_properties": {
         "metric": [
           {
-            "property": "metric_role",
+            "property": "designation",
             "type": "enum",
             "required": true,
             "label": "Metric role",
@@ -13739,16 +13787,7 @@ var UPG_FRAMEWORKS = [
             "description": "How strongly this input metric moves the North Star (input metrics only)"
           }
         ]
-      },
-      "computed_properties": [
-        {
-          "property": "nsm_impact",
-          "expression": "input_metric_value * leverage",
-          "entity_type": "metric",
-          "label": "NSM Impact",
-          "format": "number"
-        }
-      ]
+      }
     },
     "structure": {
       "pattern": "collection"
@@ -13784,6 +13823,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "marketing-mix-4ps",
+    "approach_ids": [
+      "plan"
+    ],
     "name": "Marketing Mix 4Ps",
     "version": "1.0.0",
     "description": "The foundational marketing framework. Every marketing strategy must address four decisions: what to sell (Product), what to charge (Price), where to sell (Place), and how to promote (Promotion).",
@@ -13877,6 +13919,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "bullseye-framework",
+    "approach_ids": [
+      "plan"
+    ],
     "name": "Bullseye Framework",
     "version": "1.0.0",
     "description": "Test 19 traction channels systematically. Start with the outer ring (what's possible), narrow to the middle ring (what's probable), then focus on the inner ring (what's working). Run cheap tests across all channels to find your bullseye.",
@@ -13963,6 +14008,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "product-led-growth-framework",
+    "approach_ids": [
+      "plan"
+    ],
     "name": "PLG Framework",
     "version": "1.0.0",
     "description": "Product-led go-to-market motion. Free entry gives users access, the aha moment hooks them, they expand usage within their team, and monetisation captures value from power users.",
@@ -14145,6 +14193,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "id": "raci-matrix",
+    "approach_ids": [
+      "inspect"
+    ],
     "name": "RACI Matrix",
     "version": "1.0.0",
     "description": "Assign roles: Responsible, Accountable, Consulted, Informed for each activity.",
@@ -14196,16 +14247,7 @@ var UPG_FRAMEWORKS = [
           "role": "item"
         }
       ],
-      "required_properties": {},
-      "computed_properties": [
-        {
-          "property": "coverage_score",
-          "expression": "assigned_count / total_activities",
-          "entity_type": "team",
-          "label": "RACI Coverage",
-          "format": "percentage"
-        }
-      ]
+      "required_properties": {}
     },
     "structure": {
       "pattern": "matrix"
@@ -14429,6 +14471,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "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.",
@@ -14486,16 +14531,7 @@ var UPG_FRAMEWORKS = [
           "role": "item"
         }
       ],
-      "required_properties": {},
-      "computed_properties": [
-        {
-          "property": "health_index",
-          "expression": "(green_count - red_count) / total_indicators",
-          "entity_type": "team",
-          "label": "Health Index",
-          "format": "number"
-        }
-      ]
+      "required_properties": {}
     },
     "structure": {
       "pattern": "table"
@@ -14552,6 +14588,9 @@ var UPG_FRAMEWORKS = [
   },
   {
     "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.",
@@ -14571,6 +14610,11 @@ var UPG_FRAMEWORKS = [
         "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",
@@ -14593,6 +14637,10 @@ var UPG_FRAMEWORKS = [
           "type": "risk_register",
           "role": "item"
         },
+        {
+          "type": "risk",
+          "role": "scored_item"
+        },
         {
           "type": "dependency",
           "role": "item"
@@ -14606,7 +14654,24 @@ var UPG_FRAMEWORKS = [
           "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",
@@ -14667,90 +14732,992 @@ var UPG_FRAMEWORKS = [
         "Formal programme management would create overhead without value"
       ]
     }
-  }
-];
-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);
-}
-var PRIORITY_LABELS = [
-  // ── need (CONSOLIDATED: replaces pain_point + user_need) ─────────────────────
-  {
-    id: "need",
-    canonical_label: "Need",
-    alt_labels: [
-      "pain point",
-      "pain",
-      "user need",
-      "customer need",
-      "problem",
-      "struggle",
-      "customer pain",
-      "frustration",
-      "gap",
-      "unmet need",
-      "user problem"
-    ],
-    framework_labels: {
-      lean_canvas: "Problem",
-      design_thinking: "Pain Point",
-      ost: "Opportunity (need)",
-      jtbd: "Struggle",
-      vpc: "Customer Pain"
-    },
-    designations: {
-      pain: "Pain Point",
-      gap: "Need",
-      desire: "Desire",
-      constraint: "Constraint"
-    }
-  },
-  // ── opportunity ──────────────────────────────────────────────────────────────
-  {
-    id: "opportunity",
-    canonical_label: "Opportunity",
-    alt_labels: ["product opportunity", "market opportunity", "user opportunity"],
-    framework_labels: {
-      ost: "Opportunity"
-    }
-  },
-  // ── solution ─────────────────────────────────────────────────────────────────
-  {
-    id: "solution",
-    canonical_label: "Solution",
-    alt_labels: ["proposed solution", "solution idea", "concept", "approach"],
-    framework_labels: {
-      ost: "Solution",
-      design_thinking: "Solution",
-      lean_canvas: "Solution",
-      rice: "Scored Solution"
-    }
   },
-  // ── experiment (CONSOLIDATED: absorbs ab_test, growth_experiment, pricing_experiment) ──
   {
-    id: "experiment",
-    canonical_label: "Experiment",
-    alt_labels: [
-      "test",
-      "validation",
-      "ab test",
-      "a/b test",
-      "split test",
-      "growth experiment",
-      "pricing experiment",
-      "usability test",
-      "discovery experiment"
+    "id": "ice-scoring",
+    "approach_ids": [
+      "prioritise"
     ],
-    framework_labels: {
-      ost: "Experiment",
-      design_thinking: "Test",
-      lean_startup: "Experiment"
-    },
-    designations: {
+    "name": "ICE Scoring",
+    "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.",
+    "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"
+    },
+    "tags": [
+      "prioritization",
+      "table"
+    ],
+    "slots": [
+      {
+        "label": "Items to score",
+        "entityTypeId": "feature",
+        "description": "Features or experiments being evaluated"
+      },
+      {
+        "label": "Impact",
+        "entityTypeId": "outcome",
+        "description": "How much will this move the needle?"
+      },
+      {
+        "label": "Confidence",
+        "entityTypeId": "assumption",
+        "description": "How sure are we about the impact?"
+      },
+      {
+        "label": "Ease",
+        "entityTypeId": "feature",
+        "description": "How easy is this to implement?"
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "feature",
+          "role": "scored_item"
+        },
+        {
+          "type": "outcome",
+          "role": "item"
+        },
+        {
+          "type": "assumption",
+          "role": "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)"
+          }
+        ]
+      },
+      "computed_properties": [
+        {
+          "property": "ice_score",
+          "expression": "impact * confidence * ease",
+          "entity_type": "feature",
+          "label": "ICE Score",
+          "format": "number"
+        }
+      ]
+    },
+    "structure": {
+      "pattern": "table"
+    },
+    "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
+          }
+        ]
+      },
+      "sort_by": {
+        "property": "title",
+        "direction": "asc"
+      },
+      "colour_by": "type",
+      "card_fields": [
+        "title",
+        "description",
+        "status"
+      ]
+    },
+    "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?",
+      "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": "wsjf",
+    "approach_ids": [
+      "prioritise"
+    ],
+    "name": "WSJF (Weighted Shortest Job First)",
+    "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",
+    "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"
+    },
+    "tags": [
+      "planning",
+      "table"
+    ],
+    "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": "Job Size",
+        "entityTypeId": "metric",
+        "description": "Estimated effort (story points, t-shirt size, or person-weeks)"
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "feature",
+          "role": "scored_item"
+        },
+        {
+          "type": "metric",
+          "role": "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)"
+          }
+        ]
+      },
+      "computed_properties": [
+        {
+          "property": "wsjf_score",
+          "expression": "(user_value + time_criticality + risk_reduction) / job_size",
+          "entity_type": "feature",
+          "label": "WSJF Score",
+          "format": "number"
+        }
+      ]
+    },
+    "structure": {
+      "pattern": "table"
+    },
+    "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
+          }
+        ]
+      },
+      "sort_by": {
+        "property": "title",
+        "direction": "asc"
+      },
+      "colour_by": "type",
+      "card_fields": [
+        "title",
+        "description",
+        "status"
+      ]
+    },
+    "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?",
+      "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"
+      ],
+      "when_not_to_use": [
+        "The team is small enough that informal coordination works",
+        "Plans would create false precision about uncertain outcomes"
+      ]
+    }
+  },
+  {
+    "id": "cost-of-delay",
+    "approach_ids": [
+      "prioritise"
+    ],
+    "name": "Cost of Delay",
+    "version": "1.0.0",
+    "description": "Quantify the economic cost of not shipping a feature to drive priority decisions. Combines urgency with value.",
+    "category": "prioritization",
+    "origin": {
+      "type": "practitioner",
+      "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",
+      "table"
+    ],
+    "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": "Risk Reduction",
+        "entityTypeId": "risk",
+        "description": "What risk does this mitigate?"
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "feature",
+          "role": "scored_item"
+        },
+        {
+          "type": "metric",
+          "role": "item"
+        },
+        {
+          "type": "outcome",
+          "role": "item"
+        },
+        {
+          "type": "risk",
+          "role": "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"
+          }
+        ]
+      },
+      "computed_properties": [
+        {
+          "property": "wsjf_score",
+          "expression": "cost_of_delay / job_size",
+          "entity_type": "feature",
+          "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
+          }
+        ]
+      },
+      "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",
+        "entityTypeId": "need",
+        "description": "The observed problem the analysis starts from."
+      },
+      {
+        "label": "Why chain",
+        "entityTypeId": "insight",
+        "description": 'Each "why?" answer along the chain, typically five iterations deep.'
+      },
+      {
+        "label": "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": "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"
+        }
+      ],
+      "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"
+      ]
+    }
+  },
+  {
+    "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."
+      }
+    ],
+    "data": {
+      "entity_types": [
+        {
+          "type": "decision",
+          "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": '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"
+      ]
+    }
+  }
+];
+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);
+}
+var PRIORITY_LABELS = [
+  // ── need (CONSOLIDATED: replaces pain_point + user_need) ─────────────────────
+  {
+    id: "need",
+    canonical_label: "Need",
+    alt_labels: [
+      "pain point",
+      "pain",
+      "user need",
+      "customer need",
+      "problem",
+      "struggle",
+      "customer pain",
+      "frustration",
+      "gap",
+      "unmet need",
+      "user problem"
+    ],
+    framework_labels: {
+      lean_canvas: "Problem",
+      design_thinking: "Pain Point",
+      ost: "Opportunity (need)",
+      jtbd: "Struggle",
+      vpc: "Customer Pain"
+    },
+    designations: {
+      pain: "Pain Point",
+      gap: "Need",
+      desire: "Desire",
+      constraint: "Constraint"
+    }
+  },
+  // ── opportunity ──────────────────────────────────────────────────────────────
+  {
+    id: "opportunity",
+    canonical_label: "Opportunity",
+    alt_labels: ["product opportunity", "market opportunity", "user opportunity"],
+    framework_labels: {
+      ost: "Opportunity"
+    }
+  },
+  // ── solution ─────────────────────────────────────────────────────────────────
+  {
+    id: "solution",
+    canonical_label: "Solution",
+    alt_labels: ["proposed solution", "solution idea", "concept", "approach"],
+    framework_labels: {
+      ost: "Solution",
+      design_thinking: "Solution",
+      lean_canvas: "Solution",
+      rice: "Scored Solution"
+    }
+  },
+  // ── experiment (CONSOLIDATED: absorbs ab_test, growth_experiment, pricing_experiment) ──
+  {
+    id: "experiment",
+    canonical_label: "Experiment",
+    alt_labels: [
+      "test",
+      "validation",
+      "ab test",
+      "a/b test",
+      "split test",
+      "growth experiment",
+      "pricing experiment",
+      "usability test",
+      "discovery experiment"
+    ],
+    framework_labels: {
+      ost: "Experiment",
+      design_thinking: "Test",
+      lean_startup: "Experiment"
+    },
+    designations: {
       discovery: "Discovery Experiment",
       ab_test: "A/B Test",
       growth: "Growth Experiment",
@@ -15614,7 +16581,10 @@ var STRATEGY_OUTCOMES_PLAYBOOK = {
   region: "strategy_outcomes",
   is_canonical: true,
   related_framework_ids: ["okr-framework", "three-horizons", "north-star-metric", "metrics-tree", "wardley-map"],
-  target_anchor_entity: "objective",
+  // DT-PB-3: anchor is `outcome`, not `objective`. The creation_sequence
+  // creates outcome (step 3) before objective (step 4), and outcome is the
+  // strategy region's gravitational centre (objectives translate outcomes).
+  target_anchor_entity: "outcome",
   creation_sequence: [
     seqStep(
       1,
@@ -15770,8 +16740,12 @@ var DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK = {
     seqStep(
       8,
       "Test",
-      ["experiment", "test_plan", "evidence"],
-      "Validate with targeted experiments. Close the loop between research and action."
+      // DT-PB-1: was `experiment` — which resolves to NO canonical edge with
+      // hypothesis or test_plan, forcing an orphan. `experiment_run` is the
+      // hypothesis-linked test unit (experiment_run_validates_hypothesis,
+      // test_plan_ran_as_experiment_run, experiment_run_yields_evidence).
+      ["experiment_run", "test_plan", "evidence"],
+      "Validate with targeted experiment runs. Close the loop between research and action."
     )
   ]
 };
@@ -15818,8 +16792,8 @@ var MARKET_COMPETITIVE_PLAYBOOK = {
     seqStep(
       6,
       "Moves",
-      ["partnership"],
-      "Look where competitors are weak and trends are strong. That intersection is where your moves live, including who to partner with."
+      ["competitive_battle_card"],
+      "Look where competitors are weak and trends are strong. That intersection is where your moves live: arm the team with battle cards that turn each competitor weakness into a position you can win. (Partnership moves belong in the business & GTM playbook, where `partnership` connects.)"
     )
   ]
 };
@@ -16232,8 +17206,8 @@ var OPERATIONS_QUALITY_PLAYBOOK = {
     seqStep(
       5,
       "Quality Gates",
-      ["test_suite", "test_case", "regression_test", "qa_session"],
-      "Establish what does not ship until tests pass. Define the test pyramid: unit, integration, end-to-end."
+      ["test_suite", "test_case", "regression_test", "qa_session", "feature", "bug"],
+      "Establish what does not ship until tests pass. Define the test pyramid: unit, integration, end-to-end. Quality is a delivery concern: gates guard the features they cover and the bugs they catch, which is also where incidents trace back (a shipped defect becomes a production incident)."
     ),
     seqStep(
       6,
@@ -16941,6 +17915,9 @@ function getVisibleTypes(lens) {
   }
   return [...typeSet];
 }
+function getLensIds() {
+  return UPG_LENSES.map((l) => l.id);
+}
 var UPG_DOMAIN_RINGS = [
   {
     id: "nucleus",
@@ -17834,7 +18811,7 @@ var PORTFOLIO_GUIDE = {
 var WORKSPACE_GUIDE = {
   domain_id: "workspace",
   anchor_entity: "workspace",
-  creation_sequence: ["workspace"],
+  creation_sequence: ["workspace", "framework_exercise"],
   patterns: [],
   required_bridges: [],
   anti_patterns: [
@@ -20221,7 +21198,7 @@ var UPG_ANTI_PATTERNS = [
       ]
     },
     why_it_matters: "Without any chain link, every downstream artefact (need, opportunity, feature) loses its anchor. Features end up addressing demographics instead of struggles.",
-    remediation: "For each persona, connect it into the user chain via at least one of: `persona_pursues_job`, `persona_experiences_need`, `persona_aspires_to_desired_outcome`, or `persona_incurs_switching_cost`. Use `/upg-persona` or the JTBD canvas workflow.",
+    remediation: "For each persona, connect it into the user chain via at least one of: `persona_pursues_job`, `persona_experiences_need`, `persona_aspires_to_desired_outcome`, or `persona_incurs_switching_cost`. Use `/upg-new-persona` or the JTBD canvas workflow.",
     stages: ["concept", "validation", "build", "beta", "launch", "growth", "mature"],
     severity: "high",
     source: { kind: "practitioner", attribution: "Clayton Christensen, Jobs to Be Done" }
@@ -20361,7 +21338,7 @@ var UPG_ANTI_PATTERNS = [
       ]
     },
     why_it_matters: "OKRs without measurable key results cannot be tracked, debated, or learned from. The graph carries intent but not accountability.",
-    remediation: "For each `objective`, define 2\u20134 `key_result` entities and link via `objective_achieved_through_key_result`. Use `/upg-okr` to author.",
+    remediation: "For each `objective`, define 2\u20134 `key_result` entities and link via `objective_achieved_through_key_result`. Use `/upg-new-okr` to author.",
     stages: ["validation", "build", "beta", "launch", "growth", "mature"],
     severity: "high",
     source: { kind: "book", citation: "Measure What Matters, John Doerr (2017)" }
@@ -20421,7 +21398,7 @@ var UPG_ANTI_PATTERNS = [
       }
     },
     why_it_matters: 'A graph with one persona past validation is usually carrying an unexamined "everyone is the same user" assumption.',
-    remediation: "Add personas representing the next 1\u20132 most distinct user segments. Use `/upg-persona`.",
+    remediation: "Add personas representing the next 1\u20132 most distinct user segments. Use `/upg-new-persona`.",
     stages: ["validation", "build", "beta", "launch", "growth", "mature"],
     severity: "medium",
     source: { kind: "practitioner", attribution: "Alan Cooper, The Inmates Are Running the Asylum" }
@@ -20439,7 +21416,7 @@ var UPG_ANTI_PATTERNS = [
       ]
     },
     why_it_matters: "Build-only graphs commit the team to delivery without a learning loop. Every shipped feature becomes a permanent assumption.",
-    remediation: "Spin up at least one `experiment_plan` or `hypothesis` per quarter's build batch. Use `/upg-discover` or `/upg-hypothesis`.",
+    remediation: "Spin up at least one `experiment_plan` or `hypothesis` per quarter's build batch. Use `/upg-new-discovery` or `/upg-new-hypothesis`.",
     stages: ["build", "beta", "launch", "growth"],
     severity: "high",
     source: { kind: "practitioner", attribution: "Marty Cagan, Inspired (continuous discovery)" }
@@ -20677,25 +21654,54 @@ var UPG_PRODUCT_STAGE_COERCION_MAP = Object.freeze({
   // check happens before the coercion lookup.
 });
 var UPG_PRODUCT_STAGES_SET = new Set(UPG_PRODUCT_STAGES);
+function coerceProductStage(value) {
+  if (value === void 0 || value === null) {
+    return { canonical: void 0, originalValue: value, wasCoerced: false, wasUnknown: false };
+  }
+  if (typeof value !== "string") {
+    return { canonical: void 0, originalValue: value, wasCoerced: false, wasUnknown: true };
+  }
+  if (UPG_PRODUCT_STAGES_SET.has(value)) {
+    return { canonical: value, originalValue: value, wasCoerced: false, wasUnknown: false };
+  }
+  const lower = value.toLowerCase();
+  const mapped = UPG_PRODUCT_STAGE_COERCION_MAP[lower];
+  if (mapped) {
+    return { canonical: mapped, originalValue: value, wasCoerced: true, wasUnknown: false };
+  }
+  return { canonical: void 0, originalValue: value, wasCoerced: false, wasUnknown: true };
+}
 var REFLECT_MODES = [
   "assumptions",
   "alternatives",
   "blind-spots",
   "load-bearing"
 ];
+function deriveFrameworkExamples() {
+  const byApproach = {
+    plan: [],
+    inspect: [],
+    prioritise: [],
+    trace: [],
+    reflect: []
+  };
+  for (const fw of UPG_FRAMEWORKS) {
+    for (const approachId of fw.approach_ids ?? []) {
+      if (approachId in byApproach) {
+        byApproach[approachId].push(fw.id);
+      }
+    }
+  }
+  return byApproach;
+}
+var FRAMEWORK_EXAMPLES = deriveFrameworkExamples();
 var PLAN = {
   id: "plan",
   label: "Plan",
   description: 'The path of arrival to "what should I build next?". Plan engages a region by surveying its entity coverage against canonical expectations and surfacing the missing scaffolding: the entities a healthy region carries that this graph does not. Cartographic sense: you are walking the coastline of a region and noting where the contour is incomplete, not deciding a strategy. Frameworks like Now/Next/Later, MoSCoW, and Wardley Mapping live within Plan as the named techniques for organising the gap-filling sequence.',
   question_answered: "what should I build next?",
   signature_hint: "({ region?: UPGRegionId }) \u2192 { missing_entities, coverage_score }",
-  framework_id_examples: [
-    "now-next-later",
-    "moscow",
-    "wardley-map",
-    "okr-framework",
-    "three-horizons"
-  ]
+  framework_id_examples: FRAMEWORK_EXAMPLES.plan
 };
 var INSPECT = {
   id: "inspect",
@@ -20703,28 +21709,15 @@ var INSPECT = {
   description: 'The path of arrival to "what\'s broken?". Inspect engages a region or a set of entities by running canonical health checks (anti-pattern audits, drift reports, lint passes) and emitting a structured violation list with severity, kind, target entity, description, and fix hint. Cartographic sense: you are surveying the coastline for hazards before approach; the violations are the rocks marked on the chart. The named techniques inside Inspect are the audit catalogues themselves (`UPG_ANTI_PATTERNS` and the lint passes built on the structural rules).',
   question_answered: "what's broken?",
   signature_hint: "({ region?: UPGRegionId, entities?: entity_ids[] }) \u2192 { violations: [{ severity, kind, entity_id, description, fix_hint }] }",
-  framework_id_examples: [
-    "heuristic-evaluation",
-    "tech-debt-tracker",
-    "accessibility-maturity-model",
-    "cognitive-walkthrough",
-    "blameless-postmortem"
-  ]
+  framework_id_examples: FRAMEWORK_EXAMPLES.inspect
 };
 var PRIORITISE = {
   id: "prioritise",
   label: "Prioritise",
-  description: `The path of arrival to "what's most important?". Prioritise engages an explicit candidate set (entity ids the caller passes in) and ranks it by an explicit framework: RICE, ICE, Kano, Cost of Delay. The framework_id is required because prioritisation without a declared scoring lens is incoherent. Cartographic sense: you have a set of charted destinations and you are computing the order of arrival from a chosen vantage. Different frameworks weight the same candidate set differently; the approach delegates the actual ranking math to the named technique (the framework definition).`,
+  description: `The path of arrival to "what's most important?". Prioritise engages an explicit candidate set (entity ids the caller passes in) and ranks it by an explicit framework: RICE, Kano, MoSCoW. The framework_id is required because prioritisation without a declared scoring lens is incoherent. Cartographic sense: you have a set of charted destinations and you are computing the order of arrival from a chosen vantage. Different frameworks weight the same candidate set differently; the approach delegates the actual ranking math to the named technique (the framework definition).`,
   question_answered: "what's most important?",
   signature_hint: "({ candidates: entity_ids[], framework_id }) \u2192 { ranked: [{ entity_id, score, rationale }], framework_used }",
-  framework_id_examples: [
-    "rice-scoring",
-    "ice-scoring",
-    "kano-model",
-    "cost-of-delay",
-    "moscow",
-    "wsjf"
-  ]
+  framework_id_examples: FRAMEWORK_EXAMPLES.prioritise
 };
 var TRACE = {
   id: "trace",
@@ -20732,34 +21725,15 @@ var TRACE = {
   description: 'The path of arrival to "walk a meaningful path through existing graph". Trace engages an anchor entity and follows a path expressed as a UPGEntityType[] shorthand. Example: `["persona", "job", "feature"]` walks persona\u2192job\u2192feature using the canonical edge for each pair (resolved via `resolve_edge_for_pair`). An optional `edges_override` array selects non-canonical edges per hop when a pair has multiple resolutions. Cartographic sense: you are tracing a route across charted terrain; anchor is the departure, path is the heading sequence, the canonical edges are the roads. No DSL invented; the shorthand IS the path expression.',
   question_answered: "walk a meaningful path through existing graph",
   signature_hint: "({ anchor: entity_id, path: UPGEntityType[], edges_override?: (string | null)[] }) \u2192 { trail: [{ depth, entity_id, edge_type_in }], reached: entity_id[] }",
-  framework_id_examples: [
-    "opportunity-solution-tree",
-    "strategic-cascade",
-    "metrics-tree",
-    "user-journey-map",
-    "impact-map",
-    "dependency-map"
-  ]
+  framework_id_examples: FRAMEWORK_EXAMPLES.trace
 };
 var REFLECT = {
   id: "reflect",
   label: "Reflect",
-  description: 'The path of arrival to "what should I be questioning?". Reflect engages an optional scope (region, entity, or `null` for the whole graph) and emits structured prompts a thinker should consider: assumptions to test, alternatives to weigh, blind-spots to surface, load-bearing claims to verify. Mode is optional; absence is open reflection. Cartographic sense: before approaching the coastline, you are asking which features of your chart you have not actually verified; the prompts mark the parts of the map that may be conjecture. Five Whys, Pre-mortem, Red Team, and Devil\'s Advocate are the named techniques inside this approach.',
+  description: 'The path of arrival to "what should I be questioning?". Reflect engages an optional scope (region, entity, or `null` for the whole graph) and emits structured prompts a thinker should consider: assumptions to test, alternatives to weigh, blind-spots to surface, load-bearing claims to verify. Mode is optional; absence is open reflection. Cartographic sense: before approaching the coastline, you are asking which features of your chart you have not actually verified; the prompts mark the parts of the map that may be conjecture. Retrospective and Build-Measure-Learn are the named reflective techniques in the canonical surface.',
   question_answered: "what should I be questioning?",
   signature_hint: "({ scope?: UPGRegionId | entity_id | null, mode?: 'assumptions' | 'alternatives' | 'blind-spots' | 'load-bearing' }) \u2192 { prompts: [{ kind, question, target_entities? }] }",
-  framework_id_examples: [
-    // Reflection classics: the five canonical reflect frameworks.
-    "five-whys",
-    "pre-mortem",
-    "red-team",
-    "devils-advocate",
-    "second-order-thinking",
-    // Reflective ceremonies + reflective JTBD lens already in the catalog.
-    "retrospective",
-    "four-forces-of-progress",
-    "assumption-canvas",
-    "win-loss-analysis"
-  ]
+  framework_id_examples: FRAMEWORK_EXAMPLES.reflect
 };
 var UPG_APPROACHES = [PLAN, INSPECT, PRIORITISE, TRACE, REFLECT];
 var UPG_APPROACHES_BY_ID = Object.fromEntries(
@@ -22637,7 +23611,7 @@ var NODE_KEY_ORDER = [
   "sort_order",
   "properties"
 ];
-var EDGE_KEY_ORDER = ["id", "source", "target", "type", "mapping_confidence"];
+var EDGE_KEY_ORDER = ["id", "source", "target", "type", "mapping_confidence", "properties"];
 var CROSS_EDGE_KEY_ORDER = ["id", "source", "target", "type", "source_product_id", "target_product_id", "mapping_confidence"];
 var PRODUCT_KEY_ORDER = ["id", "title", "description", "stage", "properties"];
 function canonicalNode(node) {
@@ -22649,7 +23623,8 @@ function canonicalNode(node) {
 }
 function canonicalEdge(edge) {
   return orderedObject(edge, EDGE_KEY_ORDER, {
-    forceKeys: ["id", "source", "target", "type"]
+    forceKeys: ["id", "source", "target", "type"],
+    openKeys: ["properties"]
   });
 }
 function canonicalCrossEdge(edge) {
@@ -22687,7 +23662,7 @@ function portfolioBody(doc) {
 function computeBodyChecksum(doc) {
   const body = isPortfolio(doc) ? portfolioBody(doc) : singleBody(doc);
   const content = JSON.stringify(body);
-  return createHash2(INTEGRITY_HASH_PRIMITIVE).update(content).digest("hex").slice(0, INTEGRITY_DIGEST_HEX);
+  return createHash(INTEGRITY_HASH_PRIMITIVE).update(content).digest("hex").slice(0, INTEGRITY_DIGEST_HEX);
 }
 function isPortfolio(doc) {
   return doc.type === "portfolio" || "cross_edges" in doc;
@@ -22753,7 +23728,7 @@ function serializePortfolioWithHeader(doc, opts) {
   header.integrity = { algorithm: INTEGRITY_ALGORITHM, body: computeBodyChecksum(doc) };
   return JSON.stringify({ $upg: header, ...body }, null, 2) + "\n";
 }
-var UPG_VERSION = "0.8.0";
+var UPG_VERSION = "0.8.4";
 var MARKDOWN_FORMAT_VERSION = "0.1";
 var UPG_TYPES = getTypes();
 var UPG_TYPES_SET = new Set(UPG_TYPES);
@@ -22813,6 +23788,52 @@ var UPG_DOMAIN_COUNT = UPG_DOMAINS.length;
 var UPG_EDGE_COUNT = UPG_EDGE_TYPES.length;
 var UPG_META_COUNT = UPG_ENTITY_META.length;
 
+// src/lib/server-context.ts
+function text(s) {
+  return { content: [{ type: "text", text: s }] };
+}
+function textError(s) {
+  return { content: [{ type: "text", text: s }], isError: true };
+}
+var CANONICAL_LENS_IDS = getLensIds();
+function isCanonicalLens(id) {
+  return typeof id === "string" && CANONICAL_LENS_IDS.includes(id);
+}
+function createSessionContext() {
+  return {
+    lens: "product",
+    skills_invoked: [],
+    recommendations_given: [],
+    focus_area: null,
+    custom: {}
+  };
+}
+function createQueryCache() {
+  return { entries: /* @__PURE__ */ new Map(), counter: 0 };
+}
+function syncFilePath(upgPath) {
+  const dir = path.dirname(upgPath);
+  const base = path.basename(upgPath, ".upg");
+  return path.join(dir, `${base}.upg-sync`);
+}
+async function readSyncState(upgPath) {
+  const p = syncFilePath(upgPath);
+  try {
+    const raw = await fsp.readFile(p, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeSyncState(upgPath, state) {
+  const p = syncFilePath(upgPath);
+  await fsp.writeFile(p, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+async function hashFile(filePath) {
+  const content = await fsp.readFile(filePath, "utf-8");
+  return createHash2("sha256").update(content).digest("hex");
+}
+
 // src/tools/context.ts
 import { computeGraphDigest } from "@unified-product-graph/sdk";
 function lensAwareLabel(entityType, lensId) {
@@ -22870,7 +23891,7 @@ Lens: ${sessionContext.lens}`
         lines.push(`  - [${sev}] ${b.title}`);
       }
     }
-  } else if (sessionContext.lens === "design") {
+  } else if (sessionContext.lens === "ux_design") {
     const screens = nodes.filter((n) => n.type === "screen");
     const components = nodes.filter((n) => n.type === "design_component");
     const flows = nodes.filter((n) => n.type === "user_flow");
@@ -22985,7 +24006,7 @@ var getGraphDigest = (args, ctx) => {
     const blockedFeatures = allNodes.filter((n) => blockedFeatureIds.has(n.id)).map((n) => n.title);
     const openInvestigations = allNodes.filter((n) => n.type === "investigation" && n.status !== "resolved").length;
     lensDigest = { open_bugs: openBugs, blockers: blockerEdges.length, in_flight_features: inFlightFeatures, active_debt: activeDebt, blocked_features: blockedFeatures, open_investigations: openInvestigations };
-  } else if (sessionContext.lens === "design") {
+  } else if (sessionContext.lens === "ux_design") {
     const screens = allNodes.filter((n) => n.type === "screen").length;
     const components = allNodes.filter((n) => n.type === "design_component").length;
     const flows = allNodes.filter((n) => n.type === "user_flow").length;
@@ -23103,7 +24124,12 @@ var updateSessionContext = (args, ctx) => {
   if (focusArea !== void 0) {
     sessionContext.focus_area = focusArea;
   }
-  if (lensArg && ["product", "engineering", "design", "growth"].includes(lensArg)) {
+  if (lensArg !== void 0) {
+    if (!isCanonicalLens(lensArg)) {
+      return textError(
+        `Invalid lens "${lensArg}". Canonical lenses: ${CANONICAL_LENS_IDS.join(", ")}`
+      );
+    }
     sessionContext.lens = lensArg;
     if (persistLens && store) {
       const doc = store.getDocument();
@@ -23913,7 +24939,7 @@ var updateNode = (args, ctx) => {
     const existingNode = store.getNode(nid);
     if (existingNode) {
       const sw = validateStatusAgainstLifecycle(existingNode.type, args.status);
-      if (sw) warnings.push(sw);
+      if (sw) return textError(sw);
     }
   }
   let unknownProperties = [];
@@ -23946,10 +24972,18 @@ var updateNode = (args, ctx) => {
   });
   if (lengthWarnings.length > 0) warnings.push(...lengthWarnings);
   try {
-    const updated = store.updateNode(nid, patch);
+    let updated = store.updateNode(nid, patch);
+    let removedKeys;
+    const unsetArg = args.unset_properties;
+    if (Array.isArray(unsetArg) && unsetArg.length > 0) {
+      const r = store.unsetNodeProperties(nid, unsetArg);
+      updated = r.node;
+      if (r.removed.length > 0) removedKeys = r.removed;
+    }
     const result = { node: updated };
     if (warnings.length > 0) result.warning = warnings.join(" | ");
     if (unknownProperties.length > 0) result.unknown_properties = unknownProperties;
+    if (removedKeys && removedKeys.length > 0) result.unset = removedKeys;
     return text(JSON.stringify(result, null, 2));
   } catch (err) {
     return textError(err.message);
@@ -24271,7 +25305,7 @@ var deduplicateNodes = (args, ctx) => {
 // src/tools/edges.ts
 import { edgeId as edgeId2 } from "@unified-product-graph/sdk";
 import { inferEdgeTypeWithTier } from "@unified-product-graph/sdk";
-import { validateEdgeTypePair } from "@unified-product-graph/sdk";
+import { validateExplicitEdgeType } from "@unified-product-graph/sdk";
 import { buildResolverHints } from "@unified-product-graph/sdk";
 import {
   createEdge as createEdgeLib,
@@ -24300,7 +25334,8 @@ var createEdge = (args, ctx) => {
     target_id: args.target_id,
     target_title: args.target_title,
     target_type: args.target_type,
-    type: args.type
+    type: args.type,
+    properties: args.properties
   });
   if ("error" in result) {
     if (result.no_canonical_edge_for) {
@@ -24378,13 +25413,13 @@ var batchCreateEdges = (args, ctx) => {
       );
     }
     if (e.type) {
-      const pairCheck = validateEdgeTypePair(
+      const typeCheck = validateExplicitEdgeType(
         e.type,
         sourceNode.type,
         targetNode.type
       );
-      if (!pairCheck.valid) {
-        return textError(`Edge at index ${i}: ${pairCheck.reason}`);
+      if (typeCheck.errors.length > 0) {
+        return textError(`Edge at index ${i}: ${typeCheck.errors.join(" ")}`);
       }
       resolvedEdgeTypes.push(e.type);
     } else {
@@ -24832,10 +25867,11 @@ var listLocalProducts = (_args, _ctx) => {
     try {
       const raw = fs.readFileSync(filePath, "utf-8");
       const doc = JSON.parse(raw);
+      const coerced = coerceProductStage(doc.product?.stage);
       products.push({
         file: path3.relative(cwd, filePath),
         title: doc.product?.title ?? "(untitled)",
-        stage: doc.product?.stage ?? "unknown",
+        stage: coerced.canonical ?? null,
         nodes: Array.isArray(doc.nodes) ? doc.nodes.length : 0,
         edges: Array.isArray(doc.edges) ? doc.edges.length : 0
       });
@@ -25198,6 +26234,62 @@ var getEntitySchema = (args, _ctx) => {
   }
 };
 
+// src/tools/frameworks.ts
+import {
+  applyFramework as applyFrameworkLib,
+  scoreEntity as scoreEntityLib
+} from "@unified-product-graph/sdk";
+var applyFramework = (args, ctx) => {
+  const { store } = ctx;
+  const frameworkId = args.framework_id;
+  if (!frameworkId) {
+    return textError('Missing required parameter: framework_id (e.g. "moscow", "rice-scoring")');
+  }
+  try {
+    const result = applyFrameworkLib(store, {
+      framework_id: frameworkId,
+      title: args.title,
+      entity_ids: args.entity_ids ?? [],
+      status: args.status
+    });
+    return text(
+      JSON.stringify(
+        {
+          exercise_id: result.exercise.id,
+          exercise: result.exercise,
+          included: result.edges.map((e) => ({ edge_id: e.id, entity_id: e.target })),
+          warnings: result.warnings
+        },
+        null,
+        2
+      )
+    );
+  } catch (err) {
+    return textError(err.message);
+  }
+};
+var scoreEntity = (args, ctx) => {
+  const { store } = ctx;
+  const exerciseId = args.exercise_id;
+  const entityId = args.entity_id;
+  const values = args.values;
+  if (!exerciseId) return textError("Missing required parameter: exercise_id");
+  if (!entityId) return textError("Missing required parameter: entity_id");
+  if (!values || typeof values !== "object" || Array.isArray(values)) {
+    return textError(
+      'Missing required parameter: values (object of input \u2192 value, e.g. { "moscow": "must" })'
+    );
+  }
+  const result = scoreEntityLib(store, {
+    exercise_id: exerciseId,
+    entity_id: entityId,
+    values,
+    replace: args.replace
+  });
+  if ("error" in result) return textError(result.error);
+  return text(JSON.stringify({ edge: result.edge, warnings: result.warnings }, null, 2));
+};
+
 // src/tools/spec.ts
 import { buildResolverHints as buildResolverHints2 } from "@unified-product-graph/sdk";
 import {
@@ -25211,7 +26303,7 @@ import {
 // src/tools/validation.ts
 import { computeSchemaDriftSummary } from "@unified-product-graph/sdk";
 import { collectAntiPatternInputs } from "@unified-product-graph/sdk";
-import { validateEdgeTypePair as validateEdgeTypePair2 } from "@unified-product-graph/sdk";
+import { validateEdgeTypePair } from "@unified-product-graph/sdk";
 import { checkPropertyTypes as checkPropertyTypes2 } from "@unified-product-graph/sdk";
 var CANONICAL_NODE_FIELDS = /* @__PURE__ */ new Set([
   "id",
@@ -25503,7 +26595,7 @@ var validateGraph = (args, ctx) => {
         const sourceNode = nodeById.get(edge.source);
         const targetNode = nodeById.get(edge.target);
         if (!sourceNode || !targetNode) continue;
-        const pairCheck = validateEdgeTypePair2(
+        const pairCheck = validateEdgeTypePair(
           edge.type,
           sourceNode.type,
           targetNode.type
@@ -25757,10 +26849,13 @@ function approachEnvelope(approachId, scope, payload) {
 }
 var plan = (args, ctx) => {
   const region = args.region;
-  const result = executePlan(ctx.store, region);
+  const exhaustive = args.exhaustive;
+  const result = executePlan(ctx.store, { region, exhaustive });
   return approachEnvelope("plan", region ?? null, {
-    params: { region: region ?? null },
+    params: { region: region ?? null, exhaustive: exhaustive ?? false },
     region: result.region,
+    plan_scope: result.scope,
+    scoped_regions: result.scoped_regions,
     missing_entities: result.missing_entities,
     coverage_score: result.coverage_score,
     expected_count: result.expected_count,
@@ -25789,34 +26884,38 @@ var inspect = async (args, ctx) => {
   });
 };
 var prioritise = (args, ctx) => {
-  const candidates = args.candidates;
+  const candidates = args.candidates ?? [];
   const frameworkId = args.framework_id;
-  if (!candidates || !Array.isArray(candidates) || candidates.length === 0) {
-    return textError("Missing required parameter: candidates (entity_id[])");
-  }
+  const exerciseId = args.exercise_id;
   if (!frameworkId) {
     return textError(
       'Missing required parameter: framework_id (e.g. "rice-scoring", "ice-scoring", "wsjf")'
     );
   }
+  if (!exerciseId && (!Array.isArray(candidates) || candidates.length === 0)) {
+    return textError(
+      "Provide candidates (entity_id[]), or an exercise_id whose includes edges supply the candidates and their scoring inputs."
+    );
+  }
   const framework = UPG_FRAMEWORKS_BY_ID[frameworkId];
   if (!framework) {
     return textError(
       `Unknown framework_id: "${frameworkId}". See list_frameworks for valid ids.`
     );
   }
-  const execResult = executePrioritise(framework, candidates, ctx.store);
+  const execResult = executePrioritise(framework, candidates, ctx.store, { exerciseId });
+  const params = { candidates, framework_id: frameworkId, ...exerciseId ? { exercise_id: exerciseId } : {} };
   if (execResult.kind === "execution") {
     return approachEnvelope("prioritise", candidates, {
-      params: { candidates, framework_id: frameworkId },
+      params,
       framework_resolved: execResult.framework_used,
       ranked: execResult.ranked,
       required_properties: execResult.required_properties,
-      execution_mode: "execution_v0_4_0"
+      execution_mode: exerciseId ? "exercise_v0_8_4" : "execution_v0_4_0"
     });
   }
   return approachEnvelope("prioritise", candidates, {
-    params: { candidates, framework_id: frameworkId },
+    params,
     framework_resolved: execResult.framework_used,
     hint: execResult.hint,
     execution_mode: "definition_lookup_v0_4_0"
@@ -26782,9 +27881,14 @@ function auditOne(name) {
   };
 }
 function allSkillNames() {
-  const dir = sourceSkillsDir();
-  if (!existsSync2(dir)) return [];
-  return readdirSync2(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  const names = /* @__PURE__ */ new Set();
+  for (const dir of [sourceSkillsDir(), deployedSkillsDir()]) {
+    if (!existsSync2(dir)) continue;
+    for (const d of readdirSync2(dir, { withFileTypes: true })) {
+      if (d.isDirectory() || d.isSymbolicLink()) names.add(d.name);
+    }
+  }
+  return [...names].sort();
 }
 var skillAudit = (args) => {
   const filter = typeof args?.name === "string" && args.name.length > 0 ? args.name : null;
@@ -26974,6 +28078,11 @@ var TOOL_DEFINITIONS = [
         properties: {
           type: "object",
           description: "Merged with existing properties"
+        },
+        unset_properties: {
+          type: "array",
+          items: { type: "string" },
+          description: "Property keys to DELETE. Applied after the `properties` merge, so one call can set some keys and drop others. Writing `{ key: null }` only stores a literal null; use this to actually remove a key. Unknown keys are ignored."
         }
       },
       required: ["node_id"]
@@ -27181,6 +28290,10 @@ var TOOL_DEFINITIONS = [
         type: {
           type: "string",
           description: "Edge type. Auto-inferred if omitted."
+        },
+        properties: {
+          type: "object",
+          description: "Edge-scoped properties. Only permitted on edge types that opt in (currently framework_exercise_includes_node); rejected on plain semantic edges."
         }
       },
       required: ["source_id"]
@@ -27456,17 +28569,18 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "plan",
-    description: 'Plan approach: path of arrival to "what should I build next?". Returns the Plan record + invocation params wrapped in `{ approach_id, scope, generated_at, approach, params }`. The LLM consumes `signature_hint` and synthesises `{ missing_entities, coverage_score }` against the live graph. Optional `region` narrows scope.',
+    description: 'Plan approach: path of arrival to "what should I build next?". Returns the Plan record + invocation params wrapped in `{ approach_id, scope, generated_at, approach, params }`. The LLM consumes `signature_hint` and synthesises `{ missing_entities, coverage_score }` against the live graph. Optional `region` narrows scope; omit `region` to scope to the product\'s ACTIVE regions; pass `exhaustive:true` to score the full type universe (UPG-601).',
     inputSchema: {
       type: "object",
       properties: {
-        region: { type: "string", description: 'Optional UPGRegionId. Narrows planning scope to a single region (e.g. "users_needs", "business_gtm_growth"). Omit for whole-graph planning.' }
+        region: { type: "string", description: `Optional UPGRegionId or atomic-domain id. Narrows planning scope to a single region (e.g. "users_needs", "business_gtm_growth"). Omit to scope to the product's active regions.` },
+        exhaustive: { type: "boolean", description: "If true, score against the entire 312-type universe (every domain creation sequence). Off by default; whole-universe gap scoring is noisy for a focused product. Only applies when `region` is omitted." }
       }
     }
   },
   {
     name: "inspect",
-    description: '[LLM-mediated] This tool returns a routing envelope, not computed results. For user-facing inspection, invoke the /upg-inspect skill instead of calling this tool directly. Inspect approach: path of arrival to "what\'s broken?". Returns the Inspect record + invocation params in the family-resemblance envelope. The LLM consumes `signature_hint` and emits `{ violations: [{ severity, kind, entity_id, description, fix_hint }] }` against `UPG_ANTI_PATTERNS` + the live graph. Optional `region` or `entities[]` scope the audit.',
+    description: '[LLM-mediated] This tool returns a routing envelope, not computed results. For user-facing inspection, invoke the /upg-show-entity skill instead of calling this tool directly. Inspect approach: path of arrival to "what\'s broken?". Returns the Inspect record + invocation params in the family-resemblance envelope. The LLM consumes `signature_hint` and emits `{ violations: [{ severity, kind, entity_id, description, fix_hint }] }` against `UPG_ANTI_PATTERNS` + the live graph. Optional `region` or `entities[]` scope the audit.',
     inputSchema: {
       type: "object",
       properties: {
@@ -27481,10 +28595,39 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        candidates: { type: "array", items: { type: "string" }, description: "Required. entity_id[] to rank." },
-        framework_id: { type: "string", description: 'Required. UPGFramework.id of the scoring lens (e.g. "rice-scoring", "ice-scoring", "kano-model", "cost-of-delay", "wsjf").' }
+        candidates: { type: "array", items: { type: "string" }, description: "entity_id[] to rank. Optional when exercise_id is given (the exercise supplies them)." },
+        framework_id: { type: "string", description: 'Required. UPGFramework.id of the scoring lens (e.g. "rice-scoring", "ice-scoring", "kano-model", "cost-of-delay", "wsjf").' },
+        exercise_id: { type: "string", description: "Optional (0.8.4). A framework_exercise id: reads each candidate's scoring inputs from its includes-edge properties instead of node.properties, and bypasses the target-type guard so any entity type can be scored." }
       },
-      required: ["candidates", "framework_id"]
+      required: ["framework_id"]
+    }
+  },
+  {
+    name: "apply_framework",
+    description: "Apply a framework (MoSCoW, RICE, Kano, ...) to a set of entities: creates a framework_exercise node and an `includes` edge to each entity. The per-entity result is recorded on the edge via score_entity, never on the entity node, so the same entity can sit in many exercises and any entity type can be scored. Returns { exercise_id, exercise, included, warnings }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        framework_id: { type: "string", description: 'Required. UPGFramework.id (e.g. "moscow", "rice-scoring").' },
+        title: { type: "string", description: 'Human label for the exercise (default "<Framework> exercise").' },
+        entity_ids: { type: "array", items: { type: "string" }, description: "Entities to pull into the exercise (any type)." },
+        status: { type: "string", description: "Lifecycle phase: draft | active | archived (default draft)." }
+      },
+      required: ["framework_id"]
+    }
+  },
+  {
+    name: "score_entity",
+    description: "Record a framework's result for one entity on the exercise's includes edge (a MoSCoW bucket, a RICE score, a canvas slot). Auto-includes the entity if not already in scope. Merges into existing edge properties unless replace is set. Returns { edge, warnings }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        exercise_id: { type: "string", description: "Required. The framework_exercise id." },
+        entity_id: { type: "string", description: "Required. The entity being scored." },
+        values: { type: "object", description: 'Required. The result as { input: value }, e.g. { "moscow": "must" } or { "reach": 800, "impact": 3 }.' },
+        replace: { type: "boolean", description: "Replace the edge properties instead of merging (default false)." }
+      },
+      required: ["exercise_id", "entity_id", "values"]
     }
   },
   {
@@ -27970,10 +29113,10 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        skill_invoked: { type: "string", description: 'Register that this skill was just invoked (e.g. "upg-status")' },
-        recommendation: { type: "string", description: 'Record a recommendation given to the user (e.g. "Run /upg-strategy to fill strategy gap")' },
+        skill_invoked: { type: "string", description: 'Register that this skill was just invoked (e.g. "upg-show-status")' },
+        recommendation: { type: "string", description: 'Record a recommendation given to the user (e.g. "Run /upg-new-strategy to fill strategy gap")' },
         focus_area: { type: "string", description: 'Set the current focus area (e.g. "strategy", "validation", "user_research")' },
-        lens: { type: "string", enum: ["product", "engineering", "design", "growth"], description: "Switch the active lens. Changes what context, skills, and gaps are surfaced first." },
+        lens: { type: "string", enum: [...CANONICAL_LENS_IDS], description: "Switch the active lens. Changes what context, skills, and gaps are surfaced first. Canonical lens ids (derived from core): product, ux_design, engineering, growth, business, research, marketing, full." },
         persist_lens: { type: "boolean", description: "If true, also save the lens to the .upg file so it persists across sessions" },
         custom: { type: "object", description: "Arbitrary key-value pairs for cross-skill state" }
       }
@@ -28140,6 +29283,8 @@ var HANDLERS = {
   batch_delete_nodes: batchDeleteNodes,
   batch_create_edges: batchCreateEdges,
   batch_delete_edges: batchDeleteEdges,
+  apply_framework: applyFramework,
+  score_entity: scoreEntity,
   repair_dangling_edges: repairDanglingEdges,
   export_edges: exportEdges,
   rename_edge_type: renameEdgeType,
@@ -28301,7 +29446,7 @@ function createServer(store) {
   {
     const doc = store.getDocument();
     const persistedLens = doc.product?.lens;
-    if (persistedLens && ["product", "engineering", "design", "growth"].includes(persistedLens)) {
+    if (persistedLens && isCanonicalLens(persistedLens)) {
       sessionContext.lens = persistedLens;
     }
   }
@@ -28408,7 +29553,12 @@ async function runMcpServer() {
     options: {
       file: { type: "string", short: "f" },
       title: { type: "string", short: "t" }
-    }
+    },
+    // Tolerate stray positionals. When launched via `upg mcp run`, argv carries
+    // the `mcp run` subcommand tokens; without this, parseArgs throws
+    // ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL and the server never starts. The
+    // standalone bin (`upg-mcp-server`) passes none, so this is harmless there.
+    allowPositionals: true
   });
   let resolvedPath = await discoverUPGFile(values.file);
   if (!resolvedPath) {
@@ -28480,7 +29630,7 @@ async function runMcpServer() {
 Deprecated types found in your graph:
 ${lines.join("\n")}
 `);
-    process.stderr.write(`Run /upg-migrate to update them.
+    process.stderr.write(`Run /upg-fix-types to update them.
 
 `);
   }