@unified-product-graph/core 0.29.0 → 0.31.0

package/dist/index.d.ts

@@ -11,7 +11,7 @@
  * @see registry/entity-meta.ts for type IDs and maturity
  * @see grammar/hierarchy.ts for parent-child rules
  */
-type UPGEntityType = 'specification' | 'primitive' | 'operating_lifecycle' | 'operating_stage' | 'product' | 'outcome' | 'objective' | 'key_result' | 'metric' | 'metric_quality_assessment' | 'vision' | 'mission' | 'strategic_theme' | 'initiative' | 'capability' | 'value_stream' | 'strategic_pillar' | 'assumption' | 'decision' | 'constraint' | 'strategic_question' | 'persona' | 'job' | 'need' | 'desired_outcome' | 'job_step' | 'switching_cost' | 'opportunity' | 'solution' | 'feasibility_study' | 'design_sprint' | 'hypothesis' | 'hypothesis_evidence' | 'experiment' | 'experiment_plan' | 'experiment_run' | 'learning' | 'test_plan' | 'evidence' | 'research_plan' | 'competitor' | 'competitor_feature' | 'competitor_signal' | 'market_trend' | 'market_segment' | 'competitive_analysis' | 'classification_axis' | 'classification_value' | 'research_study' | 'insight' | 'participant' | 'observation' | 'quote' | 'affinity_cluster' | 'research_question' | 'interview_guide' | 'survey_response' | 'user_journey' | 'journey_step' | 'journey_phase' | 'journey_action' | 'design_question' | 'design_concept' | 'prototype' | 'wireframe' | 'user_flow' | 'screen' | 'screen_state' | 'surface' | 'annotation' | 'interaction_spec' | 'design_component' | 'design_token' | 'design_system' | 'design_pattern' | 'design_guideline' | 'brand_identity' | 'brand_colour' | 'brand_typography' | 'brand_voice' | 'brand_logo' | 'brand_imagery' | 'feature_area' | 'feature' | 'epic' | 'user_story' | 'story_statement' | 'story_task' | 'acceptance_criterion' | 'release' | 'task' | 'bug' | 'roadmap' | 'roadmap_item' | 'theme' | 'roadmap_theme' | 'changelog' | 'planning_cycle' | 'bounded_context' | 'service' | 'domain_event' | 'api_contract' | 'technical_debt_item' | 'feature_flag' | 'deployment' | 'aggregate' | 'domain_entity' | 'value_object' | 'command' | 'read_model' | 'api_endpoint' | 'database_schema' | 'queue_topic' | 'build_artifact' | 'code_repository' | 'library_dependency' | 'integration_pattern' | 'external_api' | 'data_flow' | 'investigation' | 'root_cause' | 'symptom' | 'fix' | 'funnel' | 'funnel_step' | 'acquisition_channel' | 'growth_campaign' | 'cohort' | 'behavioral_segment' | 'growth_loop' | 'variant' | 'attribution_model' | 'business_model' | 'value_proposition' | 'revenue_stream' | 'pricing_tier' | 'cost_structure' | 'unit_economics' | 'partnership' | 'key_resource' | 'key_activity' | 'customer_relationship' | 'distribution_channel' | 'gtm_strategy' | 'ideal_customer_profile' | 'positioning' | 'messaging' | 'launch' | 'content_strategy' | 'sales_motion' | 'competitive_battle_card' | 'demand_gen_program' | 'territory' | 'objection' | 'rebuttal' | 'proof_point' | 'team' | 'role' | 'stakeholder' | 'person' | 'team_okr' | 'retrospective' | 'dependency' | 'department' | 'skill' | 'ceremony' | 'capacity_plan' | 'data_source' | 'event_schema' | 'dashboard' | 'data_model' | 'data_quality_rule' | 'data_product' | 'data_pipeline' | 'data_lineage' | 'glossary_term' | 'data_domain' | 'report' | 'content_piece' | 'knowledge_base_article' | 'brand_asset' | 'prompt_template' | 'content_calendar' | 'content_theme' | 'documentation_template' | 'document' | 'legal_entity' | 'ip_asset' | 'contract' | 'contract_clause' | 'privacy_policy' | 'compliance_requirement' | 'risk' | 'data_contract' | 'audit_log_policy' | 'compliance_framework' | 'security_audit' | 'service_level_indicator' | 'service_level_objective' | 'error_budget' | 'incident' | 'postmortem' | 'runbook' | 'monitor' | 'alert_rule' | 'ci_pipeline' | 'release_strategy' | 'on_call_rotation' | 'infrastructure_component' | 'threat_model' | 'threat' | 'vulnerability' | 'security_control' | 'security_policy' | 'penetration_test' | 'security_review' | 'data_classification' | 'access_policy' | 'a11y_standard' | 'a11y_guideline' | 'a11y_audit' | 'a11y_issue' | 'a11y_annotation' | 'test_suite' | 'test_case' | 'qa_session' | 'regression_test' | 'test_coverage_report' | 'test_environment' | 'test_result' | 'feedback_program' | 'feature_request' | 'feedback_vote' | 'nps_campaign' | 'user_advisory_board' | 'beta_program' | 'feedback_theme' | 'pricing_strategy' | 'discount_strategy' | 'trial_config' | 'paywall' | 'ai_model' | 'prompt_version' | 'eval_benchmark' | 'eval_run' | 'ai_cost_tracker' | 'hallucination_report' | 'ai_guardrail' | 'model_comparison' | 'ai_experiment' | 'ai_dataset' | 'ai_trace' | 'workflow_template' | 'workflow_run' | 'agent_definition' | 'agent_session' | 'review_gate' | 'approval_record' | 'agent_skill' | 'agent_hook' | 'workflow_artifact' | 'agent_task' | 'organization' | 'portfolio' | 'product_area' | 'workspace' | 'framework_exercise' | 'account' | 'contact' | 'lead' | 'deal' | 'pipeline_sales' | 'pipeline_stage' | 'quote_document' | 'subscription' | 'invoice' | 'forecast' | 'program' | 'project' | 'milestone' | 'risk_register' | 'change_request' | 'deliverable' | 'resource_allocation' | 'status_report' | 'marketing_strategy' | 'marketing_channel' | 'marketing_campaign_plan' | 'email_sequence' | 'social_post' | 'seo_keyword' | 'ad_creative' | 'press_release' | 'event' | 'community_initiative' | 'support_ticket' | 'customer_feedback' | 'churn_reason' | 'customer_health_score' | 'playbook' | 'service_level_agreement' | 'customer_journey_stage' | 'touchpoint' | 'success_milestone' | 'service_blueprint' | 'locale' | 'translation_key' | 'translation_bundle' | 'locale_config' | 'cultural_adaptation' | 'regional_pricing' | 'education_program' | 'tutorial' | 'walkthrough' | 'webinar' | 'certification' | 'help_video' | 'learning_path' | 'partner_program' | 'partner_tier' | 'api_ecosystem' | 'marketplace_listing' | 'developer_portal' | 'integration_partner' | 'partner_revenue_share';
+type UPGEntityType = 'specification' | 'primitive' | 'operating_lifecycle' | 'operating_stage' | 'product' | 'outcome' | 'objective' | 'key_result' | 'metric' | 'metric_quality_assessment' | 'vision' | 'mission' | 'strategic_theme' | 'initiative' | 'capability' | 'value_stream' | 'strategic_pillar' | 'assumption' | 'decision' | 'constraint' | 'strategic_question' | 'persona' | 'job' | 'need' | 'desired_outcome' | 'job_step' | 'switching_cost' | 'opportunity' | 'solution' | 'feasibility_study' | 'design_sprint' | 'hypothesis' | 'hypothesis_evidence' | 'experiment' | 'experiment_plan' | 'experiment_run' | 'learning' | 'test_plan' | 'evidence' | 'research_plan' | 'competitor' | 'competitor_feature' | 'competitor_signal' | 'market_trend' | 'market_segment' | 'competitive_analysis' | 'classification_axis' | 'classification_value' | 'research_study' | 'insight' | 'participant' | 'observation' | 'quote' | 'affinity_cluster' | 'research_question' | 'interview_guide' | 'survey_response' | 'user_journey' | 'journey_step' | 'journey_phase' | 'journey_action' | 'design_question' | 'design_concept' | 'prototype' | 'wireframe' | 'user_flow' | 'screen' | 'screen_state' | 'surface' | 'annotation' | 'interaction_spec' | 'design_component' | 'design_token' | 'design_system' | 'design_pattern' | 'design_guideline' | 'brand_identity' | 'brand_colour' | 'brand_typography' | 'brand_voice' | 'brand_logo' | 'brand_imagery' | 'feature_area' | 'feature' | 'epic' | 'user_story' | 'story_statement' | 'story_task' | 'acceptance_criterion' | 'release' | 'task' | 'bug' | 'roadmap' | 'roadmap_item' | 'theme' | 'roadmap_theme' | 'changelog' | 'planning_cycle' | 'configuration_axis' | 'bounded_context' | 'service' | 'domain_event' | 'api_contract' | 'technical_debt_item' | 'feature_flag' | 'deployment' | 'aggregate' | 'domain_entity' | 'value_object' | 'command' | 'read_model' | 'api_endpoint' | 'database_schema' | 'queue_topic' | 'build_artifact' | 'code_repository' | 'library_dependency' | 'integration_pattern' | 'external_api' | 'data_flow' | 'investigation' | 'root_cause' | 'symptom' | 'fix' | 'funnel' | 'funnel_step' | 'acquisition_channel' | 'growth_campaign' | 'cohort' | 'behavioral_segment' | 'growth_loop' | 'variant' | 'attribution_model' | 'business_model' | 'value_proposition' | 'revenue_stream' | 'pricing_tier' | 'cost_structure' | 'unit_economics' | 'partnership' | 'key_resource' | 'key_activity' | 'customer_relationship' | 'distribution_channel' | 'gtm_strategy' | 'ideal_customer_profile' | 'positioning' | 'messaging' | 'launch' | 'content_strategy' | 'sales_motion' | 'competitive_battle_card' | 'demand_gen_program' | 'territory' | 'objection' | 'rebuttal' | 'proof_point' | 'team' | 'role' | 'stakeholder' | 'person' | 'team_okr' | 'retrospective' | 'dependency' | 'department' | 'skill' | 'ceremony' | 'capacity_plan' | 'data_source' | 'event_schema' | 'dashboard' | 'data_model' | 'data_quality_rule' | 'data_product' | 'data_pipeline' | 'data_lineage' | 'glossary_term' | 'data_domain' | 'report' | 'content_piece' | 'knowledge_base_article' | 'brand_asset' | 'prompt_template' | 'content_calendar' | 'content_theme' | 'documentation_template' | 'document' | 'legal_entity' | 'ip_asset' | 'contract' | 'contract_clause' | 'privacy_policy' | 'compliance_requirement' | 'risk' | 'data_contract' | 'audit_log_policy' | 'compliance_framework' | 'security_audit' | 'service_level_indicator' | 'service_level_objective' | 'error_budget' | 'incident' | 'postmortem' | 'runbook' | 'monitor' | 'alert_rule' | 'ci_pipeline' | 'release_strategy' | 'on_call_rotation' | 'infrastructure_component' | 'threat_model' | 'threat' | 'vulnerability' | 'security_control' | 'security_policy' | 'penetration_test' | 'security_review' | 'data_classification' | 'access_policy' | 'a11y_standard' | 'a11y_guideline' | 'a11y_audit' | 'a11y_issue' | 'a11y_annotation' | 'test_suite' | 'test_case' | 'qa_session' | 'regression_test' | 'test_coverage_report' | 'test_environment' | 'test_result' | 'feedback_program' | 'feature_request' | 'feedback_vote' | 'nps_campaign' | 'user_advisory_board' | 'beta_program' | 'feedback_theme' | 'pricing_strategy' | 'discount_strategy' | 'trial_config' | 'paywall' | 'ai_model' | 'prompt_version' | 'eval_benchmark' | 'eval_run' | 'ai_cost_tracker' | 'hallucination_report' | 'ai_guardrail' | 'model_comparison' | 'ai_experiment' | 'ai_dataset' | 'ai_trace' | 'workflow_template' | 'workflow_run' | 'agent_definition' | 'agent_session' | 'review_gate' | 'approval_record' | 'agent_skill' | 'agent_hook' | 'workflow_artifact' | 'agent_task' | 'organization' | 'portfolio' | 'product_area' | 'workspace' | 'framework_exercise' | 'composition' | 'account' | 'contact' | 'lead' | 'deal' | 'pipeline_sales' | 'pipeline_stage' | 'quote_document' | 'subscription' | 'invoice' | 'forecast' | 'program' | 'project' | 'milestone' | 'risk_register' | 'change_request' | 'deliverable' | 'resource_allocation' | 'status_report' | 'marketing_strategy' | 'marketing_channel' | 'marketing_campaign_plan' | 'email_sequence' | 'social_post' | 'seo_keyword' | 'ad_creative' | 'press_release' | 'event' | 'community_initiative' | 'support_ticket' | 'customer_feedback' | 'churn_reason' | 'customer_health_score' | 'playbook' | 'service_level_agreement' | 'customer_journey_stage' | 'touchpoint' | 'success_milestone' | 'service_blueprint' | 'locale' | 'translation_key' | 'translation_bundle' | 'locale_config' | 'cultural_adaptation' | 'regional_pricing' | 'education_program' | 'tutorial' | 'walkthrough' | 'webinar' | 'certification' | 'help_video' | 'learning_path' | 'partner_program' | 'partner_tier' | 'api_ecosystem' | 'marketplace_listing' | 'developer_portal' | 'integration_partner' | 'partner_revenue_share';
 /**
  * No entity types are currently deprecated; this union is `never`. The
  * deprecated-name bridge, which previously widened this union to early
@@ -138,11 +138,27 @@ interface UPGBaseNode {
  * wall-clock timestamp: generation is deterministic). This file is a GATED
  * artifact — check:generated re-runs the generator and fails on any drift, so
  * edit the sources above, never this file.
- * Entity types with properties: 324
+ * Entity types with properties: 326
  */
 interface PropertyDefinition {
     type: 'string' | 'number' | 'boolean' | 'string[]' | 'object' | 'object[]' | 'assessment';
+    /**
+     * The CONTRACT: what the property means and the semantics a caller must
+     * not get wrong. Two or three sentences. This is what a hover card, a
+     * tooltip and a token-conscious agent read.
+     */
     description?: string;
+    /**
+     * The LONGFORM half (`@remarks` in the source JSDoc): rationale, edge
+     * cases, workflow recipes, design history. The reference page renders it
+     * behind a disclosure; hovers and schema summaries leave it out.
+     *
+     * Semantics MOVE here, they are never deleted. A field that stops being
+     * findable is worse than a field that is long, which is the lesson a
+     * reporter taught by concluding a capability did not exist when it was
+     * documented somewhere they did not read.
+     */
+    notes?: string;
     enum?: string[];
     /** For 'assessment'-typed fields: the canonical UPG scale this property is rated on (e.g. 'confidence_5'). */
     scale_id?: string;
@@ -283,6 +299,68 @@ declare const CLASSIFICATION_EDGE_PROPERTY_SCHEMA: PropertySchema;
  * a stated period); the writers reject any other key.
  */
 declare const DEFER_EDGE_PROPERTY_SCHEMA: PropertySchema;
+/**
+ * Property schema carried by `surface_varies_by_configuration_axis` (0.30.0).
+ *
+ * CONDITIONAL EXISTENCE, expressed as an edge. The surface exists in the stored
+ * graph regardless; this edge says which members of the configuration family it
+ * appears in. No edge at all means invariant, which is why every graph written
+ * before this existed keeps meaning exactly what it meant.
+ */
+declare const CONFIGURATION_VARIANCE_EDGE_PROPERTY_SCHEMA: PropertySchema;
+/**
+ * Property schema carried by the two surface-composition edges
+ * (`surface_contains_surface` and `feature_occupies_surface`), 0.30.0.
+ *
+ * A single `active_when` key qualifies the relationship by a configuration
+ * axis: the edge holds only under the named values, and is absent from every
+ * other projection.
+ *
+ * SCOPE IS THE POINT, NOT AN OVERSIGHT. These two edges are the whole legal
+ * surface for the qualifier, and `validate_graph` rejects `active_when` on any
+ * other edge type. UPG is not adding a general modality system on one field
+ * report; it is answering the composition question that report actually asked.
+ * Any further edge earns the qualifier on field evidence, one at a time.
+ *
+ * A QUALIFIER CANNOT EXPRESS NON-EXISTENCE. If the surface itself is absent
+ * under a value, say so on the node with `surface_varies_by_configuration_axis`;
+ * the projection then drops this edge as dangling and the qualifier is
+ * redundant. Reach for `active_when` only when BOTH endpoints exist and the
+ * RELATIONSHIP is what changes: the occupant that moves to a different row, the
+ * feature that occupies a different place under the flag.
+ *
+ * ONE AXIS PER QUALIFIER. An edge conditional on two axes at once is a stated
+ * non-goal; where it is genuinely needed, the honest model is one axis whose
+ * values are the combinations that actually occur, which is the same discipline
+ * as "one axis per semantic lever".
+ */
+declare const CONFIGURATION_QUALIFIER_EDGE_PROPERTY_SCHEMA: PropertySchema;
+/**
+ * Property schema carried by `workspace_arranges_node`: where a node sits on a
+ * canvas, and how its card is presented there.
+ *
+ * A PLACEMENT IS A FACT ABOUT THE RELATIONSHIP, not about either endpoint. The
+ * same persona can sit at different coordinates on five different canvases, and
+ * none of those coordinates is a property of the persona. This is the same
+ * principle `framework_exercise_includes_node` applies to per-entity results.
+ *
+ * `selected` IS DELIBERATELY ABSENT. Selection is ephemeral UI state, and
+ * persisting it means reloading a canvas restores someone's month-old
+ * selection and every click dirties the file. The spec does not bless it.
+ *
+ * AT MOST ONE ARRANGEMENT PER (WORKSPACE, NODE) PAIR: a card appears once on a
+ * canvas. The write amplification is real and named rather than hidden:
+ * dragging a card rewrites edge properties and so changes the body checksum,
+ * which is diff noise on a shared graph. It is bounded by the tool writing only
+ * the canvases a user explicitly keeps, and by viewport panning touching the
+ * opaque `canvas` bag rather than any edge.
+ *
+ * `x` and `y` are expected on every instance. Requiredness here is convention
+ * rather than enforcement: `PropertyDefinition.required` names required keys
+ * WITHIN a nested object, and the edge-property validator has no top-level
+ * required-key concept, so the contract is stated in each description.
+ */
+declare const WORKSPACE_ARRANGEMENT_EDGE_PROPERTY_SCHEMA: PropertySchema;
 declare const UPG_EDGE_CATALOG: {
     product_targets_persona: {
         forward_verb: string;
@@ -1769,6 +1847,8 @@ declare const UPG_EDGE_CATALOG: {
         classification: "hierarchy";
         source_type: string;
         target_type: string;
+        carries_properties: true;
+        property_schema: PropertySchema;
     };
     surface_serves_job: {
         forward_verb: string;
@@ -1815,12 +1895,44 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    product_defines_configuration_axis: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "hierarchy";
+        source_type: string;
+        target_type: string;
+    };
+    feature_flag_drives_configuration_axis: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+    };
+    surface_varies_by_configuration_axis: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+        carries_properties: true;
+        property_schema: PropertySchema;
+    };
+    surface_alternates_with_surface: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "semantic";
+        source_type: string;
+        target_type: string;
+    };
     feature_occupies_surface: {
         forward_verb: string;
         reverse_verb: string;
         classification: "cross-domain";
         source_type: string;
         target_type: string;
+        carries_properties: true;
+        property_schema: PropertySchema;
     };
     screen_renders_surface: {
         forward_verb: string;
@@ -3215,6 +3327,20 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    eval_benchmark_measures_node: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "semantic";
+        source_type: string;
+        target_type: string;
+    };
+    eval_benchmark_draws_cases_from_ai_dataset: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "semantic";
+        source_type: string;
+        target_type: string;
+    };
     ai_guardrail_enforces_security_policy: {
         forward_verb: string;
         reverse_verb: string;
@@ -3425,6 +3551,13 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    agent_task_executes_task: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+    };
     product_measures_funnel: {
         forward_verb: string;
         reverse_verb: string;
@@ -5231,6 +5364,13 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    product_targets_milestone: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "hierarchy";
+        source_type: string;
+        target_type: string;
+    };
     project_produces_deliverable: {
         forward_verb: string;
         reverse_verb: string;
@@ -5917,6 +6057,22 @@ declare const UPG_EDGE_CATALOG: {
         source_type: string;
         target_type: string;
     };
+    workspace_arranges_node: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+        carries_properties: true;
+        property_schema: PropertySchema;
+    };
+    composition_focuses_node: {
+        forward_verb: string;
+        reverse_verb: string;
+        classification: "cross-domain";
+        source_type: string;
+        target_type: string;
+    };
     feature_addresses_job: {
         forward_verb: string;
         reverse_verb: string;
@@ -7904,7 +8060,9 @@ declare function isDeliberateOnlyEdge(type: string): boolean;
 /**
  * Canonical allow-list of edges that use the `'node'` wildcard endpoint.
  *
- * Eight semantic families are sanctioned:
+ * Ten semantic families are sanctioned. The count and the partition are
+ * asserted in `spec-integrity.test.ts`, so this list cannot silently fall out
+ * of step with the array below the way it did between 0.28.0 and 0.31.0:
  *
  * 1. **Universal semantic verbs**: any node can inform / constrain / inspire
  *    any other node. The meaning is deliberately abstract; consumers render
@@ -7928,6 +8086,17 @@ declare function isDeliberateOnlyEdge(type: string): boolean;
  *    produce any entity type arranged in it (decision, feature, persona, ...).
  *    Widened from the single-target `workspace_produced_decision`; see
  *    `UPG_EDGE_MIGRATIONS` for the rename rule.
+ * 9. **Canvas arrangement and published-view focus**: any entity can be dragged
+ *    onto a canvas or shown in a published view, and neither placement carries
+ *    a structural role, so both collapse polymorphic rather than enumerating
+ *    the type universe twice. Both are `cross-domain`, so neither enters
+ *    `UPG_VALID_CHILDREN` and neither can be walked as containment.
+ * 10. **Benchmark subject** (0.31.0): an eval measures a tool, a document, a
+ *    check, an importer, a feature. Registered as OVER-WIDE by admission,
+ *    because a benchmark measures a measurable thing rather than literally any
+ *    node; the width is what it costs to avoid answering "what is a tool in the
+ *    graph" as a side effect of building an eval harness. Reach for the typed
+ *    `eval_benchmark_measures_feature` when the subject IS a feature.
  *
  * Adding a new polymorphic edge requires extending this array AND the
  * spec-integrity regression test, which forces a conscious decision and
@@ -8715,7 +8884,7 @@ declare const UPG_DOMAINS: readonly [{
     readonly id: "product_spec";
     readonly label: "Product Specification";
     readonly description: "What you are building and shipping. Feature areas group related capabilities. Features, epics, and user stories break work down. Acceptance criteria define done. Tasks and bugs track execution. Releases and changelogs mark what shipped. Roadmaps and roadmap items plan what comes next. Roadmap themes group roadmap work around the customer problem it solves, one level down from the strategic themes in Strategy. Planning cycles are the cadence axis: the named, dated, self-nesting intervals (sprint, iteration, quarter, program increment, cooldown) that work is scheduled through. Translates Strategy into Engineering and tracks delivery through Program Management.";
-    readonly types: readonly ["feature", "feature_area", "epic", "user_story", "acceptance_criterion", "release", "task", "bug", "roadmap", "roadmap_item", "roadmap_theme", "changelog", "planning_cycle"];
+    readonly types: readonly ["feature", "feature_area", "epic", "user_story", "acceptance_criterion", "release", "task", "bug", "roadmap", "roadmap_item", "roadmap_theme", "changelog", "planning_cycle", "configuration_axis"];
 }, {
     readonly id: "engineering";
     readonly label: "Engineering";
@@ -8809,7 +8978,7 @@ declare const UPG_DOMAINS: readonly [{
 }, {
     readonly id: "program_mgmt";
     readonly label: "Program Management";
-    readonly description: "Coordinating delivery across teams and timelines. Programs are the highest container. Projects break programs down. Milestones mark key dates. Risk registers track threats to delivery. Change requests manage scope changes. Deliverables define what ships. Resource allocations assign effort. Status reports communicate progress. Connects Product Specification (what to deliver) to Team & Organisation (who delivers).";
+    readonly description: "Coordinating delivery across teams and timelines. Programs are the highest container. Projects break programs down. Milestones mark key dates, and hang from either a project or, where a product owns the date outright with no program above it, from the product itself. Risk registers track threats to delivery. Change requests manage scope changes. Deliverables define what ships. Resource allocations assign effort. Status reports communicate progress. Connects Product Specification (what to deliver) to Team & Organisation (who delivers).";
     readonly types: readonly ["program", "project", "milestone", "risk_register", "change_request", "deliverable", "resource_allocation", "status_report"];
 }, {
     readonly id: "marketing";
@@ -8844,8 +9013,8 @@ declare const UPG_DOMAINS: readonly [{
 }, {
     readonly id: "workspace";
     readonly label: "Workspace";
-    readonly 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, …) applied to a chosen set of entities, with each entity's result recorded on the exercise-to-entity edge rather than the entity itself.";
-    readonly types: readonly ["workspace", "framework_exercise"];
+    readonly 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, …) applied to a chosen set of entities, with each entity's result recorded on the exercise-to-entity edge rather than the entity itself. A composition is the durable other half: a named, published view assembled from a canvas, with a stable slug people link to and a revision history, whose frozen arrangement holds pointers rather than copied content.";
+    readonly types: readonly ["workspace", "framework_exercise", "composition"];
 }, {
     readonly id: "foundations";
     readonly label: "Foundations";
@@ -9011,6 +9180,203 @@ declare const UPG_CONTAINMENT_FREE_TYPES: ReadonlySet<string>;
  */
 declare function isContainmentFreeType(entityType: string): boolean;
 
+/**
+ * UPG Configuration Projection (0.30.0).
+ *
+ * The stored graph is the UNION of a configuration family. A single
+ * configuration is a PROJECTION of it, and this is the operator that takes one.
+ *
+ * π(G, C) drops what a named configuration does not contain and leaves
+ * everything else exactly as it was. Facts that carry no configuration
+ * qualification are invariant: they belong to every member of the family, which
+ * is why a graph written before this existed projects to itself under every C
+ * and needs no migration.
+ *
+ * PURE, AND DELIBERATELY STORE-FREE. It takes node and edge arrays and returns
+ * node and edge arrays, so the local file store, the cloud SQL store and a
+ * synthetic store built for validation preview all reuse one definition of what
+ * a projection IS. A projection implemented twice is two projections.
+ *
+ * READ-ONLY. Nothing writes a projected graph back. The union is the file.
+ *
+ * https://unifiedproductgraph.org/spec | MIT
+ */
+/** The minimum a node must expose to be projected. */
+interface ProjectableNode {
+    id: string;
+    type?: string;
+    properties?: Record<string, unknown> | undefined;
+}
+/** The minimum an edge must expose to be projected. */
+interface ProjectableEdge {
+    id?: string;
+    source: string;
+    target: string;
+    type?: string;
+    properties?: Record<string, unknown> | undefined;
+}
+/**
+ * A configuration: axis node id to the single value that holds on it.
+ *
+ * PARTIAL BY DESIGN. An axis absent from the map is not applied, so every fact
+ * qualified on it is retained. Projecting on nothing returns the union, which
+ * makes a configuration a strictly narrowing filter an agent can apply
+ * incrementally rather than an all-or-nothing mode.
+ */
+type Configuration = Readonly<Record<string, string>>;
+/** The edge that declares conditional existence. */
+declare const VARIES_BY_EDGE = "surface_varies_by_configuration_axis";
+/** The property carried by that edge. */
+declare const PRESENT_UNDER_PROPERTY = "present_under";
+/** The qualifier property carried by the two composition edges. */
+declare const ACTIVE_WHEN_PROPERTY = "active_when";
+/**
+ * The only edge types on which `active_when` is legal (D3).
+ *
+ * Scope is enforced, not merely documented: `validate_graph`'s
+ * `configuration_drift` scope reports the qualifier on any other edge type as
+ * an error. The projection operator itself is deliberately permissive here (it
+ * honours a qualifier wherever it finds one) so that a graph carrying an
+ * illegal qualifier still projects predictably while the validator names the
+ * problem. Silently ignoring it would make the drift invisible in the one view
+ * where its effect shows.
+ */
+declare const QUALIFIABLE_EDGE_TYPES: readonly string[];
+/** Result of a projection: the surviving nodes and edges, plus what it dropped. */
+interface ProjectionResult<N extends ProjectableNode = ProjectableNode, E extends ProjectableEdge = ProjectableEdge> {
+    nodes: N[];
+    edges: E[];
+    /** Node ids dropped because the configuration excluded them. */
+    excluded_node_ids: string[];
+    /** Count of edges dropped because their own qualifier excluded them. */
+    deactivated_edge_count: number;
+    /** Count of edges dropped because an endpoint was excluded. */
+    dangling_edge_count: number;
+}
+/**
+ * Read a string array property defensively; anything else reads as absent.
+ *
+ * Exported so the drift checker and the read-tool view share one reading of
+ * what a list-valued configuration property is. Three copies of this drifting
+ * apart is how a value the validator accepts becomes a value the projection
+ * ignores.
+ */
+declare function readStringArray(properties: Record<string, unknown> | undefined, key: string): string[] | undefined;
+/**
+ * Read an `active_when` qualifier, or undefined when the edge carries none or
+ * carries something malformed.
+ *
+ * A malformed qualifier reads as ABSENT rather than as "excludes everything".
+ * Absence means the relationship is invariant, so a broken qualifier leaves the
+ * edge in every projection: the graph shows too much rather than too little,
+ * and `configuration_drift` reports the malformation by name. The alternative
+ * would let one bad property silently delete structure from every view.
+ */
+declare function readActiveWhen(edge: ProjectableEdge): {
+    axis: string;
+    values: string[];
+} | undefined;
+/**
+ * Project a graph onto one configuration.
+ *
+ * Applied in order, ONCE. The operator is a filter, not a solver:
+ *
+ *  1. NODE EXCLUSION. A node is dropped when it declares variance on an axis
+ *     named in `configuration` and the chosen value is not in its
+ *     `present_under`. A node that says nothing about a named axis is retained,
+ *     because silence means invariant.
+ *  2. EDGE DEACTIVATION. An edge is dropped when its own `active_when` names an
+ *     axis in `configuration` and the chosen value is not among its values.
+ *  3. DANGLING REMOVAL. Any surviving edge with an endpoint dropped in step 1
+ *     goes too.
+ *
+ * NO CASCADE, AND THIS IS THE SUBTLE PART. A child surface is NOT dropped
+ * because its parent was. The motivating field case is precisely a surface
+ * whose PARENT changes under the flag (a navigation row splits in two and an
+ * occupant moves into the new row), so cascading would delete a surface that is
+ * genuinely present. A surface that survives with no containment parent in that
+ * projection is a modelling gap for the validator to report, not a deletion for
+ * the operator to guess at.
+ *
+ * COMMUTATIVE ACROSS AXES. Each axis's predicate reads only that axis, so
+ * projecting on two axes in either order, or both at once, gives the same
+ * result. Multi-axis projection therefore needs no ordering rule.
+ *
+ * @example
+ * // A graph where the inspector exists only under the split-nav flag.
+ * projectGraph(nodes, edges, { axis_nav: 'legacy_nav' }).nodes
+ * // → every node except the split-nav-only surfaces
+ */
+declare function projectGraph<N extends ProjectableNode = ProjectableNode, E extends ProjectableEdge = ProjectableEdge>(nodes: N[], edges: E[], configuration: Configuration): ProjectionResult<N, E>;
+/**
+ * Every configuration this graph can be projected onto, one axis at a time.
+ *
+ * PER-AXIS, NOT CARTESIAN. The list is the union (an empty configuration) plus
+ * one entry per declared value of each axis: `1 + Σ|values|`, linear in the
+ * declarations. The cartesian product across axes is combinatorial and buys
+ * nothing here, because every v1 qualifier reads a single axis and every check
+ * that consumes a projection is surface-local. Cross-axis interaction is a
+ * stated non-goal; when a detector needs it, this is the function that grows.
+ */
+declare function enumerateProjections(nodes: ProjectableNode[]): Array<{
+    axis?: string;
+    value?: string;
+    configuration: Configuration;
+}>;
+
+/**
+ * UPG Configuration Drift (0.30.0).
+ *
+ * Structural checking of the configuration declarations themselves: that an
+ * axis is well formed, that every value named anywhere is a value the axis
+ * actually declares, that the qualifier appears only where it is legal, and
+ * that a declared alternation is consistent with what the declarations imply.
+ *
+ * DRIFT, NOT AN ANTI-PATTERN. These are contradictions inside the model, the
+ * same family as an unknown entity type or a status outside its lifecycle: a
+ * graph carrying one is saying something it cannot mean. Anti-patterns are the
+ * other thing, judgements about a graph that is internally consistent, and
+ * 0.30.0 deliberately mints none of those (a detector with no field evidence
+ * behind it is how a check family gets noisy).
+ *
+ * Runs on the UNION. The declarations are facts about the whole family, so they
+ * are checked once, not once per projection. The single exception is
+ * `orphaned_under_projection`, which by definition can only be seen by taking
+ * one.
+ *
+ * https://unifiedproductgraph.org/spec | MIT
+ */
+
+/** The kinds of configuration drift the validator reports. */
+type ConfigurationDriftKind = 'axis_values_empty' | 'axis_default_not_a_value' | 'present_under_empty' | 'present_under_unknown_value' | 'qualifier_axis_unresolved' | 'qualifier_values_empty' | 'qualifier_unknown_value' | 'qualifier_on_illegal_edge' | 'alternation_axis_mismatch' | 'alternation_overlap' | 'orphaned_under_projection';
+/** One configuration-drift finding. */
+interface ConfigurationDriftFinding {
+    kind: ConfigurationDriftKind;
+    /**
+     * `error` means the graph contradicts itself and a projection of it cannot be
+     * trusted. `warning` means the graph is coherent but a projection of it has a
+     * gap worth looking at.
+     */
+    severity: 'error' | 'warning';
+    /** The node this finding is about, when it is about a node. */
+    node_id?: string;
+    /** The edge this finding is about, when it is about an edge. */
+    edge_id?: string;
+    /** The axis involved, where one is identifiable. */
+    axis_id?: string;
+    /** Human-readable statement of what is wrong. */
+    message: string;
+}
+/**
+ * Check every configuration declaration in a graph.
+ *
+ * @param nodes All nodes in the union.
+ * @param edges All edges in the union.
+ * @returns Findings, in a stable order: axis checks, then variance, then
+ *   qualifiers, then alternation, then the per-projection orphan warning.
+ */
+declare function checkConfigurationDrift(nodes: ProjectableNode[], edges: ProjectableEdge[]): ConfigurationDriftFinding[];
+
 /**
  * UPG Lifecycles. Phase-and-state journeys for entity types with meaningful status.
  *
@@ -9297,9 +9663,29 @@ declare function getLifecycleRenderShape(entityType: string): LifecycleRenderSha
  *  encoding (value) so UIs can display labels and formulas can compute
  *  scores. */
 interface UPGAssessment {
-    /** The numeric value, used for computation. */
+    /** The numeric value, used for computation. Must fall within the referenced
+     *  scale's `min`..`max`. This is the ONLY field that carries cross-tool meaning. */
     value: number;
-    /** The qualitative label: what the assessor actually meant. */
+    /** The qualitative label: what the assessor actually meant.
+     *
+     *  FREE TEXT BY CONTRACT (docket wave 2 item 7; clarification STAGED, release
+     *  number assigned at release prep). This is the
+     *  assessor's own word and is NOT required to equal the `UPGScalePoint.label` of
+     *  the matching point. The two are different vocabularies serving different jobs:
+     *  `UPGScalePoint.label` is the scale's display name for a point (what a picker
+     *  offers); `UPGAssessment.label` is the judgment as it was actually authored
+     *  (what a human wrote). `{ value: 5, label: 'critical' }` on a `severity_5`
+     *  property is CONFORMANT even though point 5 displays as "Blocker" — indeed
+     *  several property descriptions instruct writers to "carry the old word in
+     *  `label`" when migrating a legacy enum.
+     *
+     *  Consequently: never reconcile stored labels against scale point labels, and
+     *  never widen a scale's `points` to admit authored words. Compare on `value`.
+     *
+     *  The one exception is `friendly_aliases`. An alias (`low`/`medium`/`high`) is a
+     *  writer-side shorthand, not a judgment — expanding it MUST yield both the
+     *  canonical `value` and the canonical point label, so an unexpanded alias left
+     *  sitting in `label` is a writer bug. */
     label: string;
     /** Which assessment scale this was rated on.
      *  References a scale definition in the spec or in the document's
@@ -10805,19 +11191,22 @@ interface ProductProperties {
     launched_at?: ISODateTime;
     /**
      * The product configuration this graph describes, named in plain language.
+     * A label for readers: nothing reads it to gate, filter, or alter how a tool
+     * interprets the graph.
+     *
+     * @example "Enterprise plan, split-navigation flag on"
      *
+     * @remarks
      * A product's composition often differs by feature flag, plan tier,
      * permission level or beta programme: surfaces appear, disappear, or are
      * replaced by different surfaces with different occupants. A graph that
-     * models one of those without saying which is qualified by a condition
-     * nobody wrote down, and every fact in it inherits that silence.
-     *
-     * NAMING, NOT CONFIGURING. This is a label for readers. Nothing reads it to
-     * gate, filter, or alter how a tool interprets the graph, and it makes no
-     * claim about which configuration most customers are on.
+     * models one of those without saying which is qualified by a condition nobody
+     * wrote down, and every fact in it inherits that silence.
      *
-     * @example "Enterprise plan, split-navigation flag on"
-     * @example "Default: free tier, all flags off"
+     * It makes no claim about which configuration most customers are on. Where a
+     * product genuinely ships several and the differences matter, declare a
+     * `configuration_axis` instead and let each fact say which values it holds
+     * under.
      */
     described_configuration?: string;
 }
@@ -11181,23 +11570,32 @@ interface PersonaProperties {
      *  @example "10+ years SaaS experience", "New to healthcare IT" */
     domain_expertise?: string;
     /**
-     * Role in the buying / adoption decision (the decision-making-unit split):
-     * who signs (buyer) vs who uses (user) vs who advocates internally (champion)
-     * vs who shapes the choice (influencer) vs who delivers / implements
-     * (partner). A portfolio must separate the economic buyer from the
-     * practitioner user; they are distinct personas with distinct jobs. Closed
-     * set so roles compare across products.
+     * Role in the buying or adoption decision: who signs (`buyer`), who uses
+     * (`user`), who advocates internally (`champion`), who shapes the choice
+     * (`influencer`), and who delivers it (`partner`). A closed set, so roles
+     * compare across products.
+     *
      * @example "buyer"
+     *
+     * @remarks
+     * A portfolio must separate the economic buyer from the practitioner user:
+     * they are distinct personas with distinct jobs, and collapsing them is how a
+     * product ends up built for whoever was easiest to interview.
      */
     audience_role?: 'buyer' | 'user' | 'champion' | 'influencer' | 'partner';
     /**
-     * Who performs the work: a human archetype (default), an autonomous AI agent
-     * (e.g. Content Agent), or a non-agentic platform service. Absent = `human`, so
-     * existing personas need no migration. An `agent` persona is a first-class actor
-     * that participates in journeys via the same persona machinery and that humans
-     * delegate to via `persona_delegates_to_persona`. Human-coverage / segmentation
-     * metrics count `human` only; agent/system are opt-in.
+     * Who performs the work: a human archetype, an autonomous AI agent, or a
+     * non-agentic platform service. Absent means `human`, so existing personas
+     * need no migration.
+     *
      * @example "agent"
+     *
+     * @remarks
+     * An `agent` persona is a first-class actor: it participates in journeys
+     * through the same persona machinery, and humans delegate to it via
+     * `persona_delegates_to_persona`. Human-coverage and segmentation metrics
+     * count `human` only, so agent and system personas are opt-in rather than
+     * silently inflating a coverage number.
      */
     actor_kind?: 'human' | 'agent' | 'system';
 }
@@ -11444,15 +11842,17 @@ interface HypothesisEvidenceProperties {
      */
     evidence_type?: 'experiment_run' | 'observation' | 'quote' | 'metric_change' | 'market_data' | 'interview';
     /**
-     * Direction relative to the parent claim. Canonical direction axis aligned to
-     * `Evidence.direction` so every direction-of-evidence property uses the same vocab.
-     *   `supports` = paired with the `supports` edge.
-     *   `refutes` = paired with the `refutes` edge.
-     *   `neutral` = data insufficient or noisy.
+     * Direction relative to the parent claim: `supports` and `refutes` pair with
+     * the edges of the same name, `neutral` means the data is insufficient or
+     * noisy.
+     *
+     * BREAKING in v0.4.0: `confirms`, `disconfirms` and `inconclusive` no longer
+     * type-check. Migration is one-to-one: confirms to supports, disconfirms to
+     * refutes, inconclusive to neutral.
      *
-     * BREAKING in v0.4.0: legacy `'confirms'`, `'disconfirms'`, `'inconclusive'` no
-     * longer type-check. Migration: `confirms → supports`, `disconfirms → refutes`,
-     * `inconclusive → neutral`.
+     * @remarks
+     * Aligned to `Evidence.direction` so every direction-of-evidence property in
+     * the spec shares one vocabulary.
      */
     direction?: EvidenceDirection;
     /** Strength of the evidence (UPGAssessment, scale `scale_5`). */
@@ -11561,6 +11961,20 @@ interface ExperimentPlanProperties {
  * }
  */
 interface ExperimentRunProperties {
+    /**
+     * What sort of experiment this run is: `ab_test` is a controlled split
+     * between variants, `growth` an acquisition or activation experiment,
+     * `pricing` a packaging or willingness-to-pay one. Distinct from
+     * `disposition`, which is the outcome axis.
+     *
+     * @remarks
+     * Three retired types (`ab_test`, `growth_experiment`, `pricing_experiment`)
+     * collapsed into `experiment_run` precisely along this axis, and the
+     * migration defaults stamp it so the distinction survives consolidation.
+     *
+     * Extensible: further kinds may be added in a minor release.
+     */
+    experiment_type?: 'ab_test' | 'growth' | 'pricing';
     /** ISO actual start date (may differ from the plan's `planned_start_date`) */
     actual_start_date?: ISODate;
     /** ISO actual end date */
@@ -11875,19 +12289,21 @@ interface CompetitiveAnalysisProperties {
      */
     framework_id?: string;
     /**
-     * Empty cells in a 2-axis classification matrix that earn explicit commentary.
-     * Only the strategically interesting cells. Opportunity-kind cells are the most
-     * valuable; they identify unoccupied strategic space.
+     * Empty cells in a two-axis classification matrix that earn explicit
+     * commentary, and only the strategically interesting ones. Opportunity-kind
+     * cells are the most valuable: they identify unoccupied strategic space.
      *
-     * Each entry references two `classification_value` nodes by id (one from each
-     * `classification_axis` child of this `competitive_analysis`). `validate_graph`
-     * enforces that the refs resolve to `classification_value` nodes whose parents
-     * are distinct `classification_axis` instances.
+     * @remarks
+     * Each entry references two `classification_value` nodes by id, one from each
+     * `classification_axis` child of this `competitive_analysis`.
+     * `validate_graph` enforces that the refs resolve to `classification_value`
+     * nodes whose parents are distinct `classification_axis` instances, so a cell
+     * cannot name two values from the same axis.
      *
      * See `ClassificationValueProperties.commitments` for the inverse
      * "occupied cell" structural-definition shape.
      *
-     * @example
+     * A worked pair, one of each rationale kind:
      *   [
      *     { axis_a_value_ref: 'val-git-based', axis_b_value_ref: 'val-structured-text',
      *       rationale_kind: 'opportunity',
@@ -11943,11 +12359,14 @@ interface CompetitorSignalProperties {
      */
     observed_at?: ISODateTime;
     /**
-     * Kind of move. `feature_launch` = shipped a feature. `pricing_change` = a plan
-     * or tier change. `acquisition` / `partnership` / `market_entry` = strategic moves.
-     * `reclassification` = the competitor moved between classification cells on an
-     * axis (e.g. ai_integrated to ai_agentic); auto-emitted at the classify-write
-     * chokepoint and carries `axis` / `from_value` / `to_value` / `competitor`.
+     * Kind of move: a shipped `feature_launch`, a `pricing_change`, the strategic
+     * `acquisition` / `partnership` / `market_entry`, or a `reclassification`
+     * when the competitor moves between classification cells on an axis.
+     *
+     * @remarks
+     * `reclassification` is auto-emitted at the classify-write chokepoint rather
+     * than authored, and carries `axis`, `from_value`, `to_value` and
+     * `competitor` so the move is reconstructable without diffing two snapshots.
      */
     signal_type?: 'feature_launch' | 'pricing_change' | 'acquisition' | 'partnership' | 'market_entry' | 'reclassification';
     /** One-line factual summary of the move (what shipped, not marketing copy). */
@@ -12106,14 +12525,19 @@ interface ClassificationAxisProperties {
      */
     axis_kind?: 'categorical' | 'ordinal' | 'continuous';
     /**
-     * How many values a subject may hold on this axis at once (UPG 0.11.3).
-     * `single` (default) = a subject sits at exactly one value; a re-classification
-     * to a new value SUPERSEDES the prior one (the classify writer retires the old
-     * same-axis edge and records the move in the reclassification history).
-     * `multi` = a subject may legitimately hold several values at once (e.g. an
-     * axis like "supported frameworks"); re-classifying ADDS a value and does not
-     * supersede. A separate axis from `axis_kind`: an axis can be `categorical`
-     * (unordered) yet `single`-select, or `categorical` yet `multi`-select.
+     * How many values a subject may hold on this axis at once. `single` (the
+     * default) means re-classifying SUPERSEDES the prior value; `multi` means it
+     * ADDS one.
+     *
+     * @remarks
+     * Under `single` the classify writer retires the old same-axis edge and
+     * records the move in the reclassification history, so the change is
+     * traceable rather than silent. `multi` suits an axis like "supported
+     * frameworks", where holding several values at once is the truth.
+     *
+     * A separate axis from `axis_kind`: an axis can be `categorical` (unordered)
+     * yet single-select, or `categorical` yet multi-select. The two answer
+     * different questions and neither implies the other.
      */
     cardinality?: 'single' | 'multi';
 }
@@ -12150,13 +12574,16 @@ interface ClassificationValueProperties {
      */
     exemplars?: string[];
     /**
-     * The N (typically 2–4) load-bearing commitments that define this category.
-     * Each commitment is a structural axis; removing it changes the category.
+     * The load-bearing commitments that define this category, typically two to
+     * four. Each is a structural axis: removing it changes the category.
      *
-     * Pairs with `capabilities`: commitments are the *load-bearing definition*;
-     * capabilities are the *surface offering*.
+     * @remarks
+     * Pairs with `capabilities`, and the distinction matters when deciding where
+     * a bullet belongs: commitments are the load-bearing DEFINITION, capabilities
+     * are the surface OFFERING. A capability can be dropped without the category
+     * changing; a commitment cannot.
      *
-     * @example
+     * A worked set:
      *   [
      *     { name: 'Typed content graph', description: 'Schemas in code; references as edges; content is structured data.' },
      *     { name: 'Real-time backend', description: 'Live queries, CRDT collaboration, sub-second propagation.' },
@@ -12165,11 +12592,14 @@ interface ClassificationValueProperties {
      */
     commitments?: Array<ClassificationCommitment>;
     /**
-     * Structured capability bullets across the six canonical surfaces.
-     * Each surface appears at most once per `classification_value`.
+     * Structured capability bullets across the six canonical surfaces. Each
+     * surface appears at most once per `classification_value`.
      *
-     * Pairs with `commitments`: capabilities describe what the category *offers*;
-     * commitments describe what *defines* it.
+     * @remarks
+     * Pairs with `commitments`, and the distinction decides where a bullet
+     * belongs: capabilities describe what the category OFFERS, commitments
+     * describe what DEFINES it. Dropping a capability leaves the category intact;
+     * dropping a commitment does not.
      *
      * @example
      *   [
@@ -12331,6 +12761,19 @@ interface InsightProperties {
      * @example "usability_study", "interview_series", "survey"
      */
     source_method?: string;
+    /**
+     * Which discipline the insight came out of. The second provenance axis,
+     * symmetrical with `source_method`: that one is HOW the insight was produced,
+     * this one is WHICH PRACTICE produced it, and neither substitutes for the
+     * other.
+     *
+     * @example "ux", "support", "sales", "data_science"
+     *
+     * @remarks
+     * Declared in v0.26.0 so the retired `ux_insight` type's migration default
+     * (`source_domain: 'ux'`) lands in a typed field rather than being lost.
+     */
+    source_domain?: string;
     /**
      * Insight statement in plain language. Write as an active, present-tense assertion.
      * @example "Users consistently skip the tutorial because they trust their ability to explore independently."
@@ -12692,6 +13135,20 @@ interface WireframeProperties {
  * }
  */
 interface UserFlowProperties {
+    /**
+     * What sort of flow this is. Free-form rather than a closed enum, because
+     * flow kinds are product-specific and the spec has no complete vocabulary
+     * for them.
+     *
+     * @example "onboarding", "checkout", "recovery", "upgrade"
+     *
+     * @remarks
+     * `user_flow` otherwise carries only structure (`trigger`, `steps`,
+     * `success_state`, `failure_state`) and no classification. The retired
+     * `onboarding_flow` type collapsed into `user_flow` along this axis, and its
+     * migration default stamps the value so the distinction survives.
+     */
+    flow_type?: string;
     /**
      * Display order of this flow among sibling flows (0-indexed). The scalar
      * ordering convention shared with `journey_step.step_order` and
@@ -12857,14 +13314,36 @@ type SurfaceCompositionMode = 'exclusive' | 'additive' | 'chained';
  *   mutually exclusive conditions). The most dangerous state, because it looks
  *   settled from the outside and breaks the first time an occupant is added.
  * - `none` — nobody ever decided. Remediation is a design meeting.
+ * - `no_contention_by_design` — there is no arbitration question to answer,
+ *   because the occupants never compete. The exact opposite of
+ *   `safe_by_coincidence`: designed absence of the question rather than
+ *   accidental absence of a collision.
  *
  * THIS IS NOT AN ESCAPE HATCH. Declaring `enforced_documented` does not by
  * itself silence `contended-surface-without-arbitration`: the detector still
  * requires a non-empty `arbitration_rule`, so claiming the rule is documented
  * without documenting it changes nothing. `safe_by_coincidence` and `none`
  * make the check fire whatever else is recorded, because both are admissions.
- */
-type SurfaceArbitrationState = 'enforced_documented' | 'enforced_undocumented' | 'safe_by_coincidence' | 'none';
+ * `no_contention_by_design` silences nothing that is not already silent: the
+ * contention branch is a separate check that exempts only on
+ * `composition_mode: 'chained'`, so a surface that claims this state while
+ * genuinely over capacity, ruleless and not chained is still caught there.
+ *
+ * WHY ABSENCE COULD NOT CARRY THIS. An unset `arbitration_state` already means
+ * "unassessed", and a surface whose occupants wrap rather than compete was
+ * previously forced to use that same emptiness to say something quite
+ * different. Certainty and ignorance became indistinguishable in one field.
+ * `no_contention_by_design` makes a positive design claim, which is what makes
+ * it declare-to-earn rather than an "I don't know". A generic `not_applicable`
+ * was considered and rejected for exactly this reason: it reads as
+ * "unassessed", collapses back into absence, and buys nothing.
+ *
+ * LEGALITY IS CONVENTION, NOT ENFORCEMENT. This value belongs on surfaces
+ * whose `composition_mode` is `chained`, and nothing checks that pairing. UPG
+ * has no cross-property conditional-enum mechanism, and a check must never
+ * fire on legal modelling. Enforce only if field drift appears.
+ */
+type SurfaceArbitrationState = 'enforced_documented' | 'enforced_undocumented' | 'safe_by_coincidence' | 'none' | 'no_contention_by_design';
 /** A place in the UI, its occupants, and the rule that arbitrates between them.
  *
  * `screen` answers *which route is this?*; `feature_area` answers *who owns
@@ -12918,37 +13397,35 @@ interface SurfaceProperties {
     visibility_condition?: string;
     /**
      * How many occupants ONE INSTANCE of the surface holds at once, as a
-     * non-negative count. Count the instances themselves with `cardinality`.
+     * non-negative count. Absent means unbounded, `0` means a reserved place
+     * nothing may occupy. Always the cap the design INTENDS, never what was
+     * observed rendering. Count the instances themselves with `cardinality`.
      *
-     * CAPACITY IS ALWAYS INTENT, NEVER OBSERVED BEHAVIOUR. It records the cap the
-     * design asserts, so a banner region declared `capacity: 1` keeps saying 1
-     * even after someone finds it rendering four. Reality that has drifted from
-     * the declared intent is recorded as a trackable, assignable debt item on
-     * `surface_deviates_via_technical_debt_item`, not by quietly editing this
-     * number up to match the bug. Editing it to match would destroy the only
-     * record that a gap exists.
+     * @remarks
+     * Intent, not observation: a banner region declared `capacity: 1` keeps
+     * saying 1 even after someone finds it rendering four. Reality that has
+     * drifted from the declared intent belongs on
+     * `surface_deviates_via_technical_debt_item` as a trackable, assignable debt
+     * item. Editing this number up to match the bug would destroy the only record
+     * that a gap exists.
      *
-     * ABSENT MEANS UNBOUNDED. UPG has no union-typed property primitive
-     * (`PropertyDefinition.type` is a single scalar kind), so the proposed
-     * `integer | unbounded` shape is expressed as an optional number whose
-     * absence carries the "no cap" reading, rather than a magic sentinel value
-     * that every consumer would have to special-case. `0` is a real cap meaning
-     * "nothing may occupy this surface" (a reserved place), not "unbounded".
+     * Why absence rather than a sentinel: UPG has no union-typed property
+     * primitive, so `integer | unbounded` is expressed as an optional number
+     * whose absence carries the "no cap" reading, instead of a magic value every
+     * consumer would have to special-case.
      *
-     * THREE STATES, AND THEY ARE ALL DIFFERENT. Absent = unbounded, no cap
-     * stated. `0` = a reserved place nothing may occupy. `null` = neither of
-     * those, and nothing this field defines; it is what you get by writing an
-     * explicit null rather than removing the key, and no consumer reads it as a
-     * cap. To return this property to ABSENT, remove the key with
-     * `update_node`'s or `batch_update_nodes`' `unset_properties`, since a
-     * property merge preserves anything you omit.
+     * Three states, all different. ABSENT is unbounded, no cap stated. `0` is a
+     * reserved place. `null` is neither, and nothing this field defines: it is
+     * what an explicit null write leaves behind, and no consumer reads it as a
+     * cap. To return the property to absent, remove the key with `update_node`'s
+     * or `batch_update_nodes`' `unset_properties`, since a property merge
+     * preserves anything omitted.
      *
-     * UNBOUNDED IS NOT AN EXEMPTION FROM SCRUTINY. The contention detector reads
-     * an absent capacity as a threshold of 1, on the reasoning that a surface
-     * which states no limit has stated no answer either, so several occupants is
-     * exactly the unrecorded decision worth naming. Declaring a real capacity is
-     * therefore the way to quiet the check honestly, and the only way that also
-     * records something true.
+     * Unbounded is not an exemption from scrutiny. The contention detector reads
+     * an absent capacity as a threshold of 1, because a surface that states no
+     * limit has stated no answer either, so several occupants is exactly the
+     * unrecorded decision worth naming. Declaring a real capacity is the way to
+     * quiet the check honestly, and the only way that also records something true.
      */
     capacity?: number;
     /**
@@ -12971,20 +13448,34 @@ interface SurfaceProperties {
     composition_mode?: SurfaceCompositionMode;
     /**
      * Who wins when more occupants want the surface than `capacity` allows, and
-     * why.
+     * why. Absence is meaningful: on a contested surface it means nobody decided.
      *
-     * ABSENCE IS MEANINGFUL: a null or empty `arbitration_rule` on a contested
-     * surface means nobody decided, which is exactly what the
-     * `contended-surface-without-arbitration` anti-pattern detects. Do not fill
-     * this in with a placeholder to silence the check.
      * @example "Highest priority wins; ties break to the most recently updated."
+     *
+     * @remarks
+     * An empty or absent rule on a contested surface is exactly what
+     * `contended-surface-without-arbitration` detects. Do not fill it in with a
+     * placeholder to silence the check: the check exists to find the unrecorded
+     * decision, and a placeholder hides it without settling anything.
+     *
+     * The field is overloaded across composition modes, which is worth knowing
+     * before writing one. On an `exclusive` surface it records DISPLACEMENT (who
+     * is not rendered). On an `additive` surface everyone fits, so what it
+     * records is ORDER. Only the displacement reading is what the contention
+     * detector reads.
      */
     arbitration_rule?: string;
     /**
-     * Whether the arbitration answer is enforced, written down, both, or neither.
-     * Separates "enforced in code but never transcribed" (ten minutes of typing)
-     * from "never decided" (a design meeting) from "safe only because nothing has
-     * collided yet" (the dangerous one).
+     * Whether the arbitration answer is enforced, written down, both, neither, or
+     * not owed at all. Leaving the field unset means unassessed, and always did.
+     *
+     * @remarks
+     * The separations are the whole point of the field, because absence alone
+     * conflates four situations with four different remediations: "enforced in
+     * code but never transcribed" is ten minutes of typing, "never decided" is a
+     * design meeting, "safe only because nothing has collided yet" is the
+     * dangerous one, and "nothing to decide, the occupants never compete" is a
+     * chained surface, which owes no arbitration rule at all.
      */
     arbitration_state?: SurfaceArbitrationState;
     /** Who may add occupants to the surface. */
@@ -13551,13 +14042,23 @@ interface FeatureProperties {
  *
  * @example
  * const properties: EpicProperties = {
- *   estimate: '3 person-weeks',
+ *   effort: '3 person-weeks',
  *   priority: 'high',
  *   owner: 'sam.patel@arkheiev.com',
  * }
  */
 interface EpicProperties {
-    /** Rough size estimate (e.g. "3 sprints", "L", "13 points") */
+    /** Effort estimate (e.g. "2h", "1d", "3 points"). Use a consistent unit within your team. Canonical name for the work-item size family (`epic`, `user_story`, `task`). */
+    effort?: string;
+    /**
+     * Rough size estimate (e.g. "3 sprints", "L", "13 points").
+     * @deprecated STAGED, release number assigned at release prep (docket Track "Docket wave 2").
+     * Use `effort`, the family-uniform name already carried by
+     * `user_story` and `task`. `estimate` was epic's lone divergent spelling of the same
+     * concept and it caused real misreads (the app read `estimate` on `user_story`, where
+     * only `effort` is declared). Kept (not removed) for back-compat; removal is a later
+     * major. Writers: emit `effort`. Readers: prefer `effort`, fall back to `estimate`.
+     */
     estimate?: string;
     /** Task-level priority */
     priority?: Priority;
@@ -13636,8 +14137,23 @@ interface AcceptanceCriterionProperties {
     condition: string;
     /** Test mode */
     test_type?: 'manual' | 'automated';
-    /** Current pass/fail */
-    pass_status?: 'untested' | 'pass' | 'fail';
+    /**
+     * Current verification state of this criterion. `untested` means never
+     * attempted; `blocked` means attempted but not verifiable for an
+     * environmental reason; `regressed` means previously passing, now failing.
+     *
+     * @remarks
+     * `blocked` is a distinct state from `untested` (a missing credential or an
+     * unreachable dependency is not the same as nobody having tried), which the
+     * earlier three-value enum conflated into a silent gap.
+     *
+     * `regressed` is a criterion-level state and is NOT derivable here, because
+     * `acceptance_criterion` stores current state only and keeps no result
+     * history. The history lives on the `test_case` to `test_result` series,
+     * where a single execution's outcome is `TestResultProperties.result_status`
+     * and can never itself be "regressed".
+     */
+    pass_status?: 'untested' | 'pass' | 'fail' | 'regressed' | 'blocked';
 }
 /** A shipped version or milestone of the product.
  *
@@ -13822,6 +14338,95 @@ interface PlanningCycleProperties {
     /** Shape Up appetite: the fixed time budget a cycle is willing to spend on a bet (e.g. "6 weeks", "2 weeks"). */
     appetite?: string;
 }
+/** What kind of lever this axis is. Names the mechanism family so a reader
+ * knows what changing the value would mean operationally.
+ *
+ * - `feature_flag` — a runtime toggle owned by the product team.
+ * - `plan_tier` — what the customer bought.
+ * - `permission_level` — what this user is allowed to see.
+ * - `beta_program` — enrolment in an early-access cohort.
+ * - `other` — a lever that is none of these and is described in the node's
+ *   description rather than forced into a category that fits badly.
+ */
+type ConfigurationAxisKind = 'feature_flag' | 'plan_tier' | 'permission_level' | 'beta_program' | 'other';
+/** A named dimension along which the product's composition differs.
+ *
+ * The stored graph is the UNION of a configuration family; an axis names one
+ * dimension of that family, and a projection picks one value on it. A graph
+ * that declares no axis describes a product with one configuration, which is
+ * what every graph written before this entity existed already meant. That is
+ * the zero-migration guarantee: silence still means "true everywhere".
+ *
+ * ONE AXIS PER SEMANTIC LEVER, NOT PER CODE FLAG. The unit is the decision a
+ * reader makes ("are we on the new navigation or the old one?"), not the
+ * boolean a deploy system stores. Two flags that cannot be set independently
+ * — one forcing the other on — are ONE axis with two values, and modelling
+ * them as two axes would assert a four-configuration family, three members of
+ * which do not exist. Link each driving flag with
+ * `feature_flag_drives_configuration_axis`: the mechanism lives in
+ * engineering, the lever lives here.
+ *
+ * VALUES ARE CLOSED. Every `present_under` and every `active_when.values`
+ * entry must name a member of this list, and `validate_graph`'s
+ * `configuration_drift` scope says so. An axis whose values are open cannot
+ * support a projection, because nothing bounds the family being projected
+ * from.
+ *
+ * NOT `classification_axis`. That instrument sorts SUBJECTS into cells: a
+ * subject may sit in several at once, each placement carries evidence and
+ * confidence, and the axis describes a landscape. This one selects WHICH
+ * GRAPH YOU ARE READING: exactly one value holds at a time, placements carry
+ * no evidence, and changing the value changes what exists. The shapes rhyme;
+ * the questions do not.
+ *
+ * Per UPG principle P14, structural relationships are edges:
+ *   the product that defines it: `product_defines_configuration_axis` (inbound)
+ *   the driving mechanism: `feature_flag_drives_configuration_axis` (inbound)
+ *   what varies along it: `surface_varies_by_configuration_axis` (inbound)
+ *
+ * @example
+ * const properties: ConfigurationAxisProperties = {
+ *   values: ['legacy_nav', 'split_nav'],
+ *   default_value: 'legacy_nav',
+ *   kind: 'feature_flag',
+ * }
+ */
+interface ConfigurationAxisProperties {
+    /**
+     * The closed set of values this axis can take. Required: an axis with no
+     * values selects nothing and cannot be projected along. Every `present_under`
+     * and `active_when.values` entry must name one of them.
+     *
+     * @remarks
+     * Two values is the common case and three is not unusual (a plan ladder).
+     * Order is not significant: the axis is categorical, not ordinal. Where the
+     * ordering does matter (an entitlement ladder in which each tier includes the
+     * one below), that is a classification question, and `classification_axis`
+     * with `axis_kind: 'ordinal'` is the instrument for it.
+     */
+    values: string[];
+    /**
+     * The value this axis is understood to sit at when nobody says otherwise.
+     * Must be a member of `values`. NOTHING APPLIES IT AUTOMATICALLY: an
+     * unqualified read returns the union, not this projection.
+     *
+     * @remarks
+     * The union is the honest answer to an unqualified question, because it is
+     * every configuration at once; silently substituting one of them would hide
+     * the others from a reader who did not know to ask. What the field does carry
+     * is the declaration convention for `surface_alternates_with_surface`
+     * (declare the edge from the surface present under the default) and a
+     * documented anchor for tools that later want to offer a starting
+     * configuration.
+     *
+     * It is a claim about the model, not about deployment: it says which value
+     * most of the graph was written against, not which configuration most
+     * customers are on.
+     */
+    default_value?: string;
+    /** What kind of lever this is. Names the mechanism family. */
+    kind?: ConfigurationAxisKind;
+}
 
 /**
  * UPG Property Schemas: Metrics. Unified measurement across the product.
@@ -13928,15 +14533,16 @@ interface MetricProperties {
     /** Person or team responsible for tracking this metric. Promote to a `node_owned_by_person` edge if ownership must be queryable. */
     owner?: string;
     /**
-     * Universal health rollup. Orthogonal to lifecycle and `guardrail_status`.
-     * Applies to every metric regardless of `designation`.
-     *   `healthy` = trending well against target / inside safe range.
-     *   `at_risk` = drifting, approaching breach or target shortfall.
-     *   `unhealthy` = missed target or breached; action needed.
-     *   `unknown` = no current reading or not yet measured.
+     * Universal health rollup, applying to every metric regardless of
+     * `designation`: `healthy` is inside range, `at_risk` is drifting toward a
+     * breach or shortfall, `unhealthy` has missed or breached, `unknown` has no
+     * current reading.
      *
-     * For guardrails specifically, `guardrail_status` remains the
-     * breach-specific signal (`safe`/`warning`/`breached`).
+     * @remarks
+     * Orthogonal to lifecycle and to `guardrail_status`. For guardrails
+     * specifically, `guardrail_status` remains the breach-specific signal
+     * (`safe` / `warning` / `breached`), so a guardrail carries both: one says
+     * how it is trending, the other says whether it has been crossed.
      */
     metric_health?: MetricHealth;
     /** Lower bound for guardrail safety (below this = breach) */
@@ -14970,10 +15576,14 @@ interface CiPipelineProperties {
 interface ReleaseStrategyProperties {
     /**
      * How a new version reaches production.
-     * `blue_green` = instant switch between two identical environments.
-     * `canary` = gradual percentage rollout. `rolling` = replace instances incrementally.
-     * `recreate` = take down old, bring up new. `feature_flag` = code ships, features gated.
+     *
      * @example "canary" for gradual rollout, "blue_green" for instant switch with instant rollback
+     *
+     * @remarks
+     * `blue_green` switches instantly between two identical environments.
+     * `canary` rolls out by percentage. `rolling` replaces instances
+     * incrementally. `recreate` takes the old down before bringing the new up.
+     * `feature_flag` ships the code with the features gated.
      */
     strategy_type?: 'blue_green' | 'canary' | 'rolling' | 'recreate' | 'feature_flag';
     /**
@@ -15118,8 +15728,18 @@ interface TestPlanProperties {
  * }
  */
 interface TestSuiteProperties {
-    /** Category of test suite */
-    suite_type?: 'unit' | 'integration' | 'e2e' | 'performance' | 'security' | 'accessibility';
+    /**
+     * Category of test suite. The single canonical verification-method vocabulary
+     * in the spec: do not mint a second one at criterion level.
+     *
+     * @remarks
+     * `visual` covers visual-regression and screenshot-diff suites, whose
+     * evidence is a rendered-output comparison rather than an assertion over
+     * behaviour. Before it existed, producers mapped visual suites onto
+     * `integration` as the least-wrong stock value, which made them
+     * indistinguishable from genuine integration coverage.
+     */
+    suite_type?: 'unit' | 'integration' | 'e2e' | 'performance' | 'security' | 'accessibility' | 'visual';
     /** Number of tests in the suite */
     test_count?: number;
     /** Percentage of tests passing (0-100) */
@@ -15193,6 +15813,21 @@ interface QaSessionProperties {
     duration_minutes?: number;
     /** Number of bugs found during the session */
     bugs_found?: number;
+    /**
+     * Environment the session was run against. Single-valued, unlike
+     * `TestPlanProperties.environments` (a plan spans several); the enum is the
+     * same one, mirroring `TestEnvironmentProperties.env_type`.
+     */
+    environment?: 'local' | 'ci' | 'staging' | 'sandbox' | 'production_mirror';
+    /**
+     * Plain-English outcome of the session: what it established, not how many
+     * bugs it counted (`bugs_found`). Named `outcome_summary`, matching
+     * `ExperimentRunProperties.outcome_summary`, because a bare `outcome` would
+     * collide with the `outcome` entity type.
+     */
+    outcome_summary?: string;
+    /** ISO timestamp of when the session was run. Mirrors `TestResultProperties.executed_at`. */
+    executed_at?: ISODateTime;
 }
 /** Regression test.
  *
@@ -15309,14 +15944,17 @@ interface TestResultProperties {
  */
 interface ThreatModelProperties {
     /**
-     * Methodology.
-     * `stride` = Spoofing, Tampering, Repudiation, Information Disclosure, DoS,
-     *   Elevation of Privilege (OWASP standard).
-     * `dread` = Damage, Reproducibility, Exploitability, Affected users,
-     *   Discoverability (numeric scoring).
-     * `pasta` = Process for Attack Simulation and Threat Analysis (7-stage).
-     * `attack_tree` = hierarchical tree of attack paths.
+     * Threat-modelling methodology: `stride`, `dread`, `pasta`, or `attack_tree`.
+     *
      * @example "stride" is the most widely used methodology for web applications
+     *
+     * @remarks
+     * `stride` is the OWASP standard (Spoofing, Tampering, Repudiation,
+     * Information Disclosure, Denial of Service, Elevation of Privilege).
+     * `dread` is numeric scoring (Damage, Reproducibility, Exploitability,
+     * Affected users, Discoverability). `pasta` is the seven-stage Process for
+     * Attack Simulation and Threat Analysis. `attack_tree` is a hierarchical tree
+     * of attack paths.
      */
     methodology?: 'stride' | 'dread' | 'pasta' | 'attack_tree' | 'other';
     /**
@@ -15409,13 +16047,17 @@ interface VulnerabilityProperties {
      */
     cvss_score?: number;
     /**
-     * Categorical severity derived from CVSS.
-     * Impact severity (UPGAssessment on the `severity_5` scale). Score alone is
-     * insufficient for triage; severity drives filtering and prioritisation.
-     * Migrated from the inline `critical|high|medium|low|informational` enum
-     * (UPG-579 Option C): map `critical` -> 5, `high` -> 4, `medium` -> 3,
-     * `low` -> 2, `informational` -> 1; carry the old word in `label`.
+     * Categorical severity derived from CVSS, as a UPGAssessment on the
+     * `severity_5` scale. Score alone is insufficient for triage: severity is
+     * what drives filtering and prioritisation.
+     *
      * @example value 5, label 'Critical', scale_id 'severity_5' (a remotely exploitable, no-auth vuln)
+     *
+     * @remarks
+     * Migrated from the inline `critical|high|medium|low|informational` enum
+     * (UPG-579 Option C): map `critical` to 5, `high` to 4, `medium` to 3, `low`
+     * to 2, `informational` to 1, carrying the old word in `label` so the
+     * original vocabulary survives the move.
      */
     severity?: UPGAssessment;
     /**
@@ -15507,6 +16149,8 @@ interface SecurityPolicyProperties {
     policy_status?: 'draft' | 'active' | 'under_review' | 'retired';
     /** Imperative force */
     rule_strength?: RuleStrength;
+    /** Owning person or team accountable for the policy. Promote to a `node_owned_by_team` edge if ownership must be queryable. */
+    owner?: string;
 }
 /** Penetration test.
  *
@@ -16006,6 +16650,8 @@ interface DataProductProperties {
     data_product_type?: 'report' | 'dataset' | 'stream' | 'api' | 'ml_feature' | 'other';
     /** Freshness SLA commitment (e.g. "< 1 hour") */
     sla_freshness?: string;
+    /** Owning person or team. Sibling of `data_domain.steward`: use `owner` for the accountable party of a single data product, `steward` for a whole domain. Promote to a `node_owned_by_team` edge if ownership must be queryable. */
+    owner?: string;
 }
 /** DataPipeline entity.
  *
@@ -16057,6 +16703,8 @@ interface GlossaryTermProperties {
     term_definition?: string;
     /** Alternative names or abbreviations for this term */
     synonyms?: string[];
+    /** Person or team accountable for keeping the definition current. Promote to a `node_owned_by_person` edge if ownership must be queryable. */
+    owner?: string;
 }
 /** DataDomain. A coarse-grained grouping of related data assets (sources,
  *  pipelines, products, glossary terms) under a single stewardship boundary.
@@ -16155,6 +16803,14 @@ interface BrandAssetProperties {
     usage_rights?: string;
 }
 /** Internal document.
+ *
+ * @deprecated since 0.2.0. Use `DocumentProperties` (`document` with an internal
+ * audience). `internal_doc` is absent from the entity-catalog union, so no
+ * conformant graph can hold a node of this type — these properties are
+ * unreachable in practice. Migration is lossless: `doc_type` → `document_type`
+ * (its enum already contains rfc/runbook/guide/spec/onboarding), `url` →
+ * `source_url`. Retained only because this interface is part of the published
+ * type surface; RETIREMENT SCHEDULED for the next MAJOR (docket wave 2, item 3).
  *
  * @example
  * const properties: InternalDocProperties = {
@@ -16163,9 +16819,9 @@ interface BrandAssetProperties {
  * }
  */
 interface InternalDocProperties {
-    /** Classification of the document */
+    /** Classification of the document. @deprecated use `document.document_type` */
     doc_type?: 'rfc' | 'runbook' | 'guide' | 'spec' | 'onboarding' | 'other';
-    /** URL or path to the document */
+    /** URL or path to the document. @deprecated use `document.source_url` */
     url?: string;
 }
 /** Document. Provenance container linking to source files.
@@ -16410,6 +17066,8 @@ interface ComplianceRequirementProperties {
     regulation?: 'gdpr' | 'ccpa' | 'hipaa' | 'soc2' | 'iso27001' | 'pci_dss' | 'other';
     /** Current compliance posture */
     compliance_status?: 'compliant' | 'non_compliant' | 'in_progress' | 'not_applicable';
+    /** Accountable person or team. Promote to a `node_owned_by_person` edge if ownership must be queryable. */
+    owner?: string;
 }
 /** Risk.
  *
@@ -16421,8 +17079,15 @@ interface ComplianceRequirementProperties {
  * }
  */
 interface RiskProperties {
-    /** Domain the risk belongs to */
-    risk_type?: 'technical' | 'business' | 'legal' | 'security' | 'operational';
+    /**
+     * Domain the risk belongs to. The single kind axis for `risk`: there is no
+     * second classification vocabulary.
+     *
+     * `program` added in v0.26.0 so the retired `risk_item` (Program Management)
+     * type has a home on the canonical `risk` after consolidation, rather than a
+     * parallel `risk_domain` field free to drift from this one.
+     */
+    risk_type?: 'technical' | 'business' | 'legal' | 'security' | 'operational' | 'program';
     /** How likely this risk is to materialise (1 = unlikely, 5 = near certain) */
     probability?: UPGAssessment;
     /** Severity of consequences if the risk materialises (1 = negligible, 5 = catastrophic) */
@@ -16446,6 +17111,8 @@ interface DataContractProperties {
     deletion_policy?: string;
     /** Whether data is shared with third parties */
     third_party_sharing?: boolean;
+    /** Owning person or team accountable for the contract. Promote to a `node_owned_by_team` edge if ownership must be queryable. */
+    owner?: string;
 }
 /** Audit log policy.
  *
@@ -16775,10 +17442,17 @@ interface ProjectProperties {
  */
 interface MilestoneProperties {
     /**
-     * Display order of this milestone within its parent project (0-indexed). The
-     * scalar ordering convention shared with `journey_step.step_order` and
+     * Display order of this milestone within its parent (0-indexed). The scalar
+     * ordering convention shared with `journey_step.step_order` and
      * `journey_action.action_order` (UPG-663 / UPG-674). Orders the delivery
-     * milestones a project moves through, independent of `due_date`.
+     * milestones a parent moves through, independent of `due_date`.
+     *
+     * @remarks
+     * The parent is whichever of the two milestone parents the graph actually
+     * uses: a `project` via `project_targets_milestone`, or a `product` directly
+     * via `product_targets_milestone` (Portfolio Phase 2, for milestones a
+     * product owns outright with no program or project above them). The order is
+     * scoped to that one parent, never global.
      */
     milestone_order?: number;
     /** Target due date (ISO format) */
@@ -16972,8 +17646,34 @@ interface PromptVersionProperties {
  * }
  */
 interface EvalBenchmarkProperties {
-    /** Measured dimension */
-    benchmark_type?: 'accuracy' | 'latency' | 'cost' | 'safety' | 'custom';
+    /**
+     * Measured dimension.
+     *
+     * @remarks
+     * Widened in 0.31.0 with the three dimensions an eval suite actually reports
+     * and this set could not express: `precision_recall` (two numbers, not one
+     * accuracy figure, and the pair is the point, because a detector that fires on
+     * everything scores perfectly on recall alone), `task_success` (did the agent
+     * achieve the goal), and `coherence` (rubric-graded, for multi-step runs).
+     *
+     * THIS ENUM IS A DIMENSION AXIS, AND IT SHOULD STAY ONE. An eval suite's
+     * families are a SUBJECT axis (what is under test), and a dimension cannot
+     * separate subjects, which is why several families legitimately share
+     * `task_success`.
+     *
+     * The subject is expressed on the EDGE, not here: `eval_benchmark_measures_node`
+     * names what a benchmark measures by pointing at it. So "which benchmarks cover
+     * the importer" is a traversal, and this property stays a clean answer to a
+     * different question, "what dimension does this benchmark report". The
+     * commissioning brief hoped the enum would carry both; splitting them across the
+     * enum and the edge is the better answer, and it needs no third mechanism.
+     *
+     * Corollary worth stating, since it is load-bearing: do NOT add subject-shaped
+     * values here. `tool_use` or `documentation` would encode on this axis what the
+     * edge already carries, and the two would drift the first time a benchmark
+     * measured something its enum value did not admit.
+     */
+    benchmark_type?: 'accuracy' | 'latency' | 'cost' | 'safety' | 'precision_recall' | 'task_success' | 'coherence' | 'custom';
     /** Test cases in the suite */
     test_case_count?: number;
     /** Minimum passing score */
@@ -16981,6 +17681,47 @@ interface EvalBenchmarkProperties {
     /** ISO date of the most recent run */
     last_run?: ISODate;
 }
+/** One metric's score inside `EvalRunProperties.metric_scores`.
+ *
+ * Every field is required, including `sample_size`. A score without its
+ * denominator is not a smaller measurement, it is not a measurement, and an
+ * optional denominator is how a run quietly stops reporting one.
+ *
+ * @example
+ * const scores: MetricScore[] = [
+ *   { metric: 'precision', value: 0.94, sample_size: 250 },
+ *   { metric: 'recall', value: 0.71, sample_size: 250 },
+ * ]
+ */
+interface MetricScore {
+    /** What was measured, named as the metric names itself: `precision`, `recall`, `faithfulness`. */
+    metric: string;
+    /**
+     * The score, normalized to 0 through 1, where 1 is the best result.
+     *
+     * @remarks
+     * Normalization is the contract rather than a suggestion, because comparing
+     * runs is the whole reason this array exists and two runs on different raw
+     * scales do not compare. A rating collected on 1 through 5 is divided before
+     * it lands here, and the raw scale belongs in the metric name if a reader
+     * needs it (`faithfulness_of_5`).
+     *
+     * Measurements that are not rates do not belong here at all. Wall-clock time,
+     * token counts, and cost already have typed fields on `eval_run`, so a metric
+     * that cannot be expressed as a rate is a sign the value wanted one of those.
+     */
+    value: number;
+    /**
+     * How many cases the score was computed over.
+     *
+     * @remarks
+     * Required so a comparison across runs can never quietly compare different
+     * sample sizes. It is the one field an author is most tempted to omit and the
+     * one whose absence is least visible afterwards: a precision of 0.94 reads the
+     * same whether it was measured over 250 cases or 4.
+     */
+    sample_size: number;
+}
 /** Evaluation run.
  *
  * @example
@@ -17011,6 +17752,32 @@ interface EvalRunProperties {
     error_rate?: number;
     /** Feedback score summary (human or automated) */
     feedback_scores?: string;
+    /**
+     * Per-metric scores, one entry per measured metric.
+     *
+     * @remarks
+     * Added in 0.31.0 because `score` is a single aggregate and the forcing case
+     * needs two numbers: precision and recall, reported separately. An aggregate
+     * hides the only interesting failure mode, which is a detector that catches
+     * everything by firing on everything.
+     *
+     * `sample_size` is not optional decoration, and as of 0.31.0 the type says so:
+     * it is a REQUIRED member of `MetricScore`. A sampled run reports its sample
+     * size beside its score, always, so a comparison across runs can never quietly
+     * compare different sample sizes. A number without its denominator is not a
+     * smaller measurement, it is not a measurement, and a remark saying `always`
+     * over a field typed optional is a contract only the careful reader honours.
+     *
+     * The entry shape is the exported `MetricScore` interface rather than an
+     * anonymous literal, so a consumer can name the thing it is building. This is
+     * one of two `object[]` properties in the spec; the other, `composition.members`,
+     * already exports `CompositionMember`.
+     *
+     * The rejected alternative was two runs per benchmark, which needs no spec
+     * change and makes every question about a benchmark's quality a join, encoding
+     * a measurement artifact as graph structure.
+     */
+    metric_scores?: MetricScore[];
 }
 /** AI cost tracker.
  *
@@ -18321,12 +19088,18 @@ interface ContactProperties {
     /** Whether this person has purchasing authority */
     is_decision_maker?: boolean;
     /**
-     * Role this contact plays in the buying committee (the decision-making unit).
+     * Role this contact plays in the buying committee, the decision-making unit.
+     *
+     * @example 'economic_buyer'
+     *
+     * @remarks
      * The substrate of enterprise multi-threading and of qualification frameworks
-     * (MEDDICC/SPICED): a deal with no `champion` and no `economic_buyer` mapped is
-     * single-threaded and at risk. `is_decision_maker` becomes largely derivable
+     * such as MEDDICC and SPICED: a deal with no `champion` and no
+     * `economic_buyer` mapped is single-threaded and at risk, which is a fact the
+     * graph can answer rather than a judgement someone has to make.
+     *
+     * `is_decision_maker` becomes largely derivable from this
      * (`buying_role = economic_buyer`) but is kept for back-compat.
-     * @example 'economic_buyer'
      */
     buying_role?: 'champion' | 'economic_buyer' | 'technical_evaluator' | 'end_user' | 'detractor' | 'influencer' | 'procurement' | 'legal' | 'security';
 }
@@ -18365,13 +19138,16 @@ interface DealProperties {
     /** Likelihood of closing (0-100%) */
     probability?: number;
     /**
-     * Terminal result of the deal. An Event-axis outcome (the verdict on a
-     * one-time event), NOT a lifecycle phase, so it is `deal_outcome` and not
-     * `deal_status` per the status-convention Rule 3. Lifecycle (open/won/lost as
-     * phases) belongs on the base `status` slot; this records the win/loss verdict
-     * a closed deal carries and gives `deal_lost_to_competitor` / win-loss study
-     * derivations their anchor.
+     * Terminal result of the deal: the win or loss verdict a closed deal carries.
+     *
      * @example 'won'
+     *
+     * @remarks
+     * An Event-axis outcome (the verdict on a one-time event) and NOT a lifecycle
+     * phase, so it is `deal_outcome` rather than `deal_status`, per
+     * status-convention Rule 3. Lifecycle (open, won and lost as phases) belongs
+     * on the base `status` slot. This field is what gives
+     * `deal_lost_to_competitor` and win-loss study derivations their anchor.
      */
     deal_outcome?: 'won' | 'lost' | 'no_decision';
     /**
@@ -18403,6 +19179,8 @@ interface DealProperties {
      * `qualification_framework`).
      */
     qualification_score?: UPGAssessment;
+    /** Accountable person or team carrying the deal. Promote to a `node_owned_by_person` edge if ownership must be queryable. */
+    owner?: string;
 }
 /** Sales pipeline.
  *
@@ -19345,7 +20123,16 @@ interface PartnerRevenueShareProperties {
  *   members: `team_works_in_workspace` / `persona_collaborates_in_workspace`
  *     (the `member_count` and `owner` properties are display-time aggregates;
  *     canonical membership is the edge set)
- *   contained entities: spatial placement is recorded on edge metadata
+ *   contained entities: `workspace_arranges_node`, whose edge `properties`
+ *     carry the spatial placement (`x`, `y`, `expanded`, `frame_id`)
+ *
+ * Two meanings of "workspace" travel together in shipped tools and are
+ * unrelated. THIS is the CANVAS workspace: a thinking space, an entity in the
+ * graph. The FILE workspace is a folder of `.upg` products, addressed by the
+ * CLI and MCP surfaces (`init_workspace`, `switch_product`, `workspace.json`).
+ * A third, `UPGSource.workspace_id`, is the source tool's own project id.
+ * Neither is renamed: all three are entrenched, and the ambiguity is smaller
+ * than the rename would be.
  *
  * @example
  * const properties: WorkspaceProperties = {
@@ -19365,14 +20152,15 @@ interface WorkspaceProperties {
     /** Free-text description. Pairs with the closed-enum `workspace_purpose`. */
     purpose?: string;
     /**
-     * Closed-enum classifier. Drives template suggestions and surfaces in workspace browsers.
-     *   `discovery` = persona/job/opportunity exploration.
-     *   `planning` = roadmap and decision sessions.
-     *   `retrospective` = reflection on shipped work.
-     *   `design` = experience or UI exploration.
-     *   `research` = organising study data and synthesis.
-     *   `strategy` = high-level direction setting.
-     *   `general` = catch-all.
+     * What the workspace is for. Drives template suggestions and surfaces in
+     * workspace browsers.
+     *
+     * @remarks
+     * `discovery` is persona, job and opportunity exploration. `planning` covers
+     * roadmap and decision sessions. `retrospective` is reflection on shipped
+     * work. `design` is experience or UI exploration. `research` organises study
+     * data and synthesis. `strategy` is high-level direction setting. `general`
+     * is the catch-all.
      */
     workspace_purpose?: 'discovery' | 'planning' | 'retrospective' | 'design' | 'research' | 'strategy' | 'general';
     /** Workspace owner (handle or email). Display label; canonical owner is `team_owns_workspace` or `persona_owns_workspace`. */
@@ -19385,6 +20173,256 @@ interface WorkspaceProperties {
     archived_at?: ISODateTime;
     /** Display icon (emoji or icon name) */
     icon?: string;
+    /**
+     * Retention intent. Absent means `transient`.
+     *
+     * @remarks
+     * A workspace is a free-form thinking space and is transient by default, so
+     * the spec makes both intents EXPRESSIBLE and takes no position on which
+     * reaches the file. Whether to write a transient canvas at all is a tool
+     * decision, and the recommended posture is not to: a scratch canvas nobody
+     * named has no business in a shared, git-tracked graph, where it lands in
+     * everyone's diff. Writing only `durable` workspaces is what keeps a
+     * canonical graph entity comfortable with a transient-by-default object.
+     */
+    retention?: 'transient' | 'durable';
+    /**
+     * Opaque canvas furniture: the parts of a canvas with no graph referent.
+     * Preserved verbatim on round-trip and never interpreted. Tool extension keys
+     * are namespaced `<tool>:<key>` with a colon, and no consumer interprets a key
+     * it does not own.
+     *
+     * @remarks
+     * The cut here is UPG principle P14 applied literally. Anything that is a
+     * REFERENCE TO A GRAPH NODE is an edge, which is why placed entities ride
+     * `workspace_arranges_node` and not this bag: a node id held as a scalar
+     * inside a blob is a foreign key in disguise, and a deleted node would leave
+     * a stale reference nothing can detect. Anything that is pure UI chrome with
+     * no graph referent stays here, because minting `annotation` and `frame`
+     * entity types would add catalog surface that is meaningless to every
+     * consumer outside the tool that drew it.
+     *
+     * WHY THE COLON, and why the rule is in the summary rather than buried here.
+     * An underscore key is indistinguishable from an ordinary property name, so a
+     * migration that targets namespaced keys cannot match it and no validator can
+     * detect one that should have been namespaced. That undetectability is why
+     * enforcement lives in the type and the documentation instead of in a check:
+     * a check would report clean on a bag full of underscore keys, which is worse
+     * than no check. Two conventions were already coexisting when this was ruled
+     * (`entopo_views` in a live writer, `entopo:view_blocks` in the contract test
+     * certifying preservation), which is how a cheap rule becomes a migration.
+     *
+     * PRESERVATION IS NOT PERMISSION TO RENDER. Preserving every byte says nothing
+     * about meaning: a field-measured canvas carried `excluded: true` tombstones,
+     * and a consumer that preserved them faithfully while rendering every entry
+     * showed the user images they had deleted.
+     */
+    canvas?: WorkspaceCanvas;
+}
+/** The opaque half of a canvas: furniture with no graph referent.
+ *
+ * Carried on `WorkspaceProperties.canvas`. A consumer MUST preserve this object
+ * verbatim and MUST NOT act on it. That preservation is already guaranteed by
+ * the canonical serialiser, which passes `properties` through as an open bag,
+ * so honouring the rule costs nothing; it just needs saying.
+ *
+ * @example
+ * const canvas: WorkspaceCanvas = {
+ *   canvas_version: 1,
+ *   viewport: { x: 0, y: 0, zoom: 1 },
+ * }
+ */
+interface WorkspaceCanvas {
+    /** Schema version of this bag, versioned by the tool that writes it and independent of the spec version. */
+    canvas_version: number;
+    /** Free-text note cards placed on the canvas. */
+    annotations?: Array<{
+        id: string;
+        text: string;
+        color?: string;
+        x: number;
+        y: number;
+    }>;
+    /** Visual grouping containers. `children` holds the ids of arranged nodes inside the frame. */
+    frames?: Array<{
+        id: string;
+        label: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        children?: string[];
+    }>;
+    /**
+     * Lightweight visual associations drawn between two cards.
+     *
+     * @remarks
+     * Called RIDGES, not edges, and the rename is the point. Inside a `.upg` file
+     * the word "edge" already means a graph edge, and a ridge is emphatically not
+     * one: `promoted` exists precisely to mark the moment a ridge has BECOME a
+     * real edge. Two different things under one word in the file format would be
+     * a genuine ambiguity, and removing it costs nothing.
+     */
+    ridges?: Array<{
+        id: string;
+        source: string;
+        target: string;
+        label?: string;
+        promoted?: boolean;
+    }>;
+    /** Last camera position on the canvas. */
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    /**
+     * Canvas cards that are not yet entities in the graph.
+     *
+     * @remarks
+     * A draft stays here rather than being materialised as a `status: 'draft'`
+     * node because a draft is BY DEFINITION not in the graph yet. That is what
+     * committing means, and `workspace_produced_node` exists to record the moment
+     * it enters. Auto-materialising would empty that edge of meaning and litter
+     * graphs with abandoned drafts.
+     */
+    drafts?: Array<{
+        id: string;
+        type: string;
+        title: string;
+        description?: string;
+        x: number;
+        y: number;
+    }>;
+    /** Seed provenance, when the canvas was opened from a gap prompt rather than blank. */
+    gap_context?: {
+        scope_label: string;
+        region_slug?: string;
+        note?: string;
+        gaps: Array<{
+            type: string;
+            label: string;
+            count?: number;
+            detail?: string;
+        }>;
+    };
+    /**
+     * Tool-namespaced extension keys, written by a tool and preserved by everyone.
+     *
+     * The doc above has always promised an open bag; until 0.31.0 this interface
+     * closed, so every doc-honouring consumer widened locally (`graph-service`
+     * shipped `WorkspaceCanvas & Record<string, unknown>` as its boundary type). A
+     * type that forces every conforming consumer to work around it is describing
+     * the wrong thing, so the type now says what the doc always did.
+     *
+     * THE RULE FOR THESE KEYS (0.31.0):
+     *  - Syntax is `<tool>:<key>`, with a COLON. An underscore key is indistinguishable
+     *    from an ordinary property name, so it cannot be reliably matched, which is
+     *    exactly what makes a future migration miss half of what it targets.
+     *  - Every consumer PRESERVES unknown keys byte for byte.
+     *  - No consumer INTERPRETS a key it does not own. Preservation is a storage
+     *    guarantee that says nothing about meaning: a field-measured canvas carried
+     *    `excluded: true` tombstones, and a consumer that preserved every byte while
+     *    rendering every entry showed the user images they had deleted.
+     *  - The prefix is the owner. No registry at present scale.
+     *
+     * The declared members above keep their exact types, so the enumeration guard
+     * is unaffected: adding a known layer still breaks exhaustive call sites at
+     * compile time.
+     *
+     * THE COLON IS IN THE TYPE, and this is the only place the syntax rule is
+     * enforceable at all. No runtime check can catch a key that should have been
+     * namespaced and was not, because an underscore key is indistinguishable from
+     * an ordinary property by construction, and a write-time rejection would
+     * contradict the preservation guarantee the bag is built on. A bare
+     * `[key: string]: unknown` would have accepted every form the rule forbids, so
+     * the pattern index signature is what makes the rule cost anything.
+     *
+     * The declared members are exempt because none of them matches the pattern,
+     * which is the mechanism working rather than a hole in it: they are the keys
+     * the spec owns, and the pattern governs the keys it does not.
+     *
+     * The cost paid for the openness is narrower than the old closure but real: a
+     * misspelled namespaced key resolves to `unknown` and surfaces at first use
+     * rather than at the typo. A misspelled DECLARED member (`canvas.anotations`)
+     * is still a compile error, because it does not match the pattern either.
+     */
+    [namespacedKey: `${string}:${string}`]: unknown;
+}
+/** Composition: a named, published view assembled from a canvas.
+ *
+ * The durable counterpart to `workspace`. Where a workspace is a free-form
+ * thinking space with an audience of one, a composition is a stable artifact
+ * with a slug people link to, a publisher, and a revision history. Its node
+ * `id` IS the slug: `.upg` ids are slugs by convention, and minting a separate
+ * `slug` property would give one thing two identities.
+ *
+ * SCOPE OF THAT RULE, stated because assuming it generalised produced a
+ * `not_found` refusal in the field (the invariant working, the documentation
+ * failing): id-is-slug holds for `composition` and `workspace`. It does NOT hold
+ * for `product`, which carries a uuid id and a separate slug. A rule whose scope
+ * is undocumented gets over-generalised by the next reader.
+ *
+ * THE ARRANGEMENT IS FROZEN, THE CONTENT IS NOT. `members` captures layout and
+ * pointers at publish time and never resolved data. Each member's `href` is
+ * still a QUERY, re-resolved against current graph data at render, which is
+ * what makes a composition a live UPG surface rather than a stale screenshot.
+ * A consumer must not treat `members` as cached content.
+ *
+ * Provenance reuses `workspace_produced_node`: which canvas a composition was
+ * published from is already expressible, so nothing new is minted for it. What
+ * a composition SHOWS is `composition_focuses_node`, which is what makes
+ * "which published views show this persona?" answerable to a tool that cannot
+ * parse the publishing tool's URLs.
+ *
+ * @example
+ * const properties: CompositionProperties = {
+ *   members: [
+ *     { id: 'blk_1', href: '/view/personas?segment=smb', title: 'SMB personas', x: 0, y: 0, width: 6, height: 4 },
+ *   ],
+ *   rev: 3,
+ *   published_at: '2026-08-17T09:00:00Z',
+ *   published_by: 'sam.patel@arkheiev.com',
+ * }
+ */
+interface CompositionMember {
+    /** Stable id of the block within this composition. */
+    id: string;
+    /** Tool-namespaced view reference, opaque to every other tool and preserved verbatim. */
+    href: string;
+    /** Display title captured at publish, used as a fallback while the target resolves. */
+    title: string;
+    /** Horizontal position of the block in the frozen arrangement. */
+    x: number;
+    /** Vertical position of the block in the frozen arrangement. */
+    y: number;
+    /** Width of the block in the frozen arrangement. */
+    width: number;
+    /** Height of the block in the frozen arrangement. */
+    height: number;
+    /** Whether the block is drawn collapsed. */
+    collapsed?: boolean;
+}
+interface CompositionProperties {
+    /**
+     * The frozen member arrangement, captured at publish. Layout and pointers
+     * only, never resolved content.
+     */
+    members: CompositionMember[];
+    /**
+     * Monotonic revision, bumped on each republish of the same slug.
+     *
+     * @remarks
+     * A published revision is a fact about the composition, user-visible as a new
+     * print from the same plate, so it is serialised. Worth distinguishing from a
+     * store's concurrency token, which shares the name in some backends but is a
+     * fact about the table rather than about the thing, and is not spec data.
+     */
+    rev: number;
+    /** ISO timestamp of the most recent publish or republish. */
+    published_at: ISODateTime;
+    /** Publisher handle or email. Display scalar, same posture as `WorkspaceProperties.owner`. */
+    published_by?: string;
 }
 /** Framework exercise: one run of a framework over a set of entities.
  *
@@ -19415,6 +20453,29 @@ interface FrameworkExerciseProperties {
      * later evolves (inputs added, removed, or rescaled).
      */
     inputs_snapshot?: Record<string, unknown>;
+    /**
+     * Relative multiplier per framework input for this run, keyed by input id.
+     *
+     * @remarks
+     * A weight belongs to the RUN, not to any entity it scores: one weight per
+     * input, shared by every scored entity, which is why it sits here and not on
+     * the `framework_exercise_includes_node` edge alongside the per-entity result.
+     *
+     * Named `input_weights` rather than a bare `weight` deliberately, and the
+     * collision is live rather than hypothetical: `getPropertyDefaultScale` keys
+     * on property NAME alone and ignores entity type, and `PROPERTY_SCALE_MAP`
+     * already maps `weight` to the `importance_5` ordinal. A bare `weight` here
+     * would silently resolve to a 1-5 assessment scale, which is the wrong type,
+     * range and meaning for a multiplier. The plural also matches the spec's own
+     * vocabulary: a framework declares *inputs*, not dimensions.
+     *
+     * @example
+     * const properties: FrameworkExerciseProperties = {
+     *   framework_id: 'rice-scoring',
+     *   input_weights: { reach: 1, impact: 2, confidence: 1, effort: 1.5 },
+     * }
+     */
+    input_weights?: Record<string, number>;
 }
 
 /**
@@ -19718,6 +20779,7 @@ interface UPGPropertyMap {
     changelog: ChangelogProperties;
     /** A named, dated, self-nesting planning interval (sprint / iteration / quarter / PI / cooldown) work is scheduled through: the cadence axis */
     planning_cycle: PlanningCycleProperties;
+    configuration_axis: ConfigurationAxisProperties;
     /** A governed specification (query language, protocol, format) products implement, expose, or conform to */
     specification: SpecificationProperties;
     /** A foundational compositional unit a specification defines (a block, a reference, a query value) */
@@ -20064,6 +21126,8 @@ interface UPGPropertyMap {
     workspace: WorkspaceProperties;
     /** A framework exercise: one run of a framework over a set of entities */
     framework_exercise: FrameworkExerciseProperties;
+    /** A composition: a named, published view assembled from a canvas */
+    composition: CompositionProperties;
     /** An account: a company or organisation in the CRM */
     account: AccountProperties;
     /** A contact: an individual person at an account */
@@ -20637,6 +21701,18 @@ interface EntityCheck {
      *    field nobody filled in, e.g. a `surface` with no `arbitration_rule`.
      *    A value-keyed filter cannot express absence, because the collector only
      *    indexes values that exist.
+     *
+     *    NON-EMPTY VALUE HERE MEANS NON-EMPTY *STRING*. The aggregate indexes
+     *    backing this form record string values only, so a numeric `0` or a
+     *    boolean `false` counts as ABSENT to this filter. That is a known wart,
+     *    documented rather than fixed in 0.29.0: broadening it would change which
+     *    graphs existing detectors fire on, which is not a change to make in a
+     *    release already carrying correctness fixes. It costs nothing today (no
+     *    catalog filter uses this form since the contention branch moved to
+     *    `EdgeCountVsPropertyCheck`), and the broadening question is banked as
+     *    a tracked follow-up. A detector that needs to see a declared
+     *    zero should use `EdgeCountVsPropertyCheck.node_filter`, whose presence
+     *    test is deliberately broader.
      * 2. `{ property, value }` (0.17.0) — count entities whose `property` equals
      *    `value`, e.g. `metric` where `designation === 'north_star'`.
      * 3. `{ status }` — count entities in a given lifecycle status.
@@ -20796,12 +21872,25 @@ interface EdgeCountVsPropertyCheck {
      */
     node_comparison: 'gt' | 'gte' | 'lt' | 'lte' | 'eq';
     /**
-     * Optional additional per-node requirement, stated in the vocabulary of
-     * `EntityCheck.filter`'s presence form: the node must carry
-     * (`present: true`) or must not carry (`present: false`) a non-empty value
-     * for `property`.
+     * Optional additional per-node requirement: the node must carry
+     * (`present: true`) or must not carry (`present: false`) a value for
+     * `property`.
      *
-     * THIS IS WHY THE FORM IS PER-NODE RATHER THAN TWO ANDED AGGREGATES.
+     * PRESENT MEANS ANY VALUE, NOT ANY NON-EMPTY STRING. Only `undefined`,
+     * `null` and the empty string read as absent here. `capacity: 0` is a real
+     * cap (a reserved place nothing may occupy) and `mutates_content: false` is a
+     * real answer, so treating either as an omission would be wrong: this check
+     * form exists to read NUMERIC intents, and a form that could not see a
+     * declared zero would misread the surfaces it was built for.
+     *
+     * THIS DELIBERATELY DIFFERS FROM `EntityCheck.filter`'s presence form, which
+     * is string-only because the aggregate indexes behind it only hold strings.
+     * The asymmetry is a real difference in what the two can see, not a style
+     * choice, so this field does not borrow that vocabulary. Collectors express
+     * the split as two named predicates (`isPropertyPresent` here,
+     * `isStringPropertyPresent` there) rather than one helper with a comment.
+     *
+     * THIS IS ALSO WHY THE FORM IS PER-NODE RATHER THAN TWO ANDED AGGREGATES.
      * "Some surface is over capacity" AND "some surface has no arbitration rule"
      * are both true of a graph where those are DIFFERENT surfaces, so composing
      * two aggregate checks would keep firing on exactly the graphs this release
@@ -22045,10 +23134,17 @@ interface UPGEntityFilterSpec {
  * Every `entity_count` filter the catalog declares (0.29.0), so collectors can
  * record which nodes matched each one without indexing the whole graph.
  *
- * The catalog declares five filters in total, which is what makes per-node
- * attribution affordable here: a handful of predicate evaluations per node,
- * rather than an id list for every (type, property, value) triple that happens
- * to exist in the data.
+ * The catalog declares FOUR filters in total (one status form, three value
+ * forms), which is what makes per-node attribution affordable here: a handful
+ * of predicate evaluations per node, rather than an id list for every (type,
+ * property, value) triple that happens to exist in the data.
+ *
+ * Note there is no `present` form among them since 0.29.0, when the contention
+ * branch moved to `EdgeCountVsPropertyCheck`. The only `present: false` left in
+ * the catalog is that check's `node_filter`, which this walk correctly does not
+ * collect: it is a per-node clause on a different check type, tallied through
+ * `UPG_EDGE_COUNT_SPECS` instead. The count is asserted in the tests rather
+ * than trusted to this comment.
  */
 declare const UPG_ENTITY_FILTER_SPECS: readonly UPGEntityFilterSpec[];
 /**
@@ -22291,7 +23387,7 @@ interface AntiPatternInputs {
      * collector that omits it loses attribution and changes no verdict.
      *
      * Bounded by declaration, like every other spec-driven input here: the whole
-     * catalog declares five filters, so this is a handful of predicate
+     * catalog declares four filters, so this is a handful of predicate
      * evaluations per node rather than an index over every property.
      */
     nodesByEntityFilter?: Record<string, string[]>;
@@ -22588,6 +23684,74 @@ declare const UPG_STRUCTURE_PATTERNS: readonly StructurePattern[];
  * https://unifiedproductgraph.org/spec | MIT
  */
 
+/**
+ * One declared, deterministic test over a single property. Atoms combine into a
+ * slot's membership rule; an atom is never a membership rule by itself.
+ *
+ * `scope` says whose property is read, reusing the discriminator that already
+ * exists on `PropertyRequirementLike` rather than inventing a parallel axis:
+ * `'entity'` reads a property of the entity itself (an assumption's
+ * `risk_level`), `'framework'` reads a measured property held on the exercise
+ * edge (Kano's `functional_response`).
+ *
+ * Semantics a consumer must honour — each exists because its violation is a way
+ * a grid could silently lie:
+ *
+ * - **Pure and total.** A function of the entity's and the exercise edge's
+ *   properties, and nothing else. No clock, no random, no ambient read.
+ * - **Mutually exclusive.** No entity may satisfy two sibling predicates.
+ *   Overlapping predicates make a framework invalid; that is an authoring bug to
+ *   reject, never a tie for the renderer to break by declaration order.
+ * - **Not exhaustive.** The complement of the union is the legitimate, expected
+ *   set of unplaced entities. Do not add a catch-all.
+ * - **Absence is not a value.** A missing property, a null, or an assessment
+ *   without a value fails every predicate. It never compares as zero and never
+ *   sorts into a corner cell.
+ * - **Thresholds are declared, never inferred.** Every boundary is a literal
+ *   here; the renderer contributes no default of its own.
+ *
+ * Ruling and rationale (including Amendment 1, which set the arity):
+ * the zone-predicate hook ruling (internal decision record, 2026-08-07)
+ */
+type FrameworkSlotPredicateAtom = {
+    /** Whose property is being read: the entity's own, or the framework exercise's */
+    scope: 'entity' | 'framework';
+    /** The property name being tested */
+    property: string;
+} & ({
+    op: 'eq';
+    value: string | number | boolean;
+} | {
+    op: 'in';
+    value: ReadonlyArray<string | number>;
+} | {
+    op: 'gte';
+    value: number;
+} | {
+    op: 'lt';
+    value: number;
+}
+/** Half-open interval `[min, max)` — min inclusive, max exclusive */
+ | {
+    op: 'band';
+    value: readonly [number, number];
+});
+/**
+ * A slot's membership rule: a conjunction. An entity belongs iff EVERY atom
+ * holds; absence of any atom's property fails the whole conjunction.
+ *
+ * A list rather than a single atom because every real quadrant framework
+ * partitions on two properties at once — an assumption map on risk AND
+ * confidence, Kano on functional AND dysfunctional response. A one-atom rule
+ * cannot tell "test first" from "monitor", and declaring both as "risk is high"
+ * would make them overlap, which is invalid.
+ *
+ * Always a list, even for one atom, so consumers never branch on arity.
+ * Conjunction only: express a disjunction as two slots, which gives each
+ * disjunct its own visible cell. Empty is invalid — it would match everything,
+ * which is a catch-all cell in disguise.
+ */
+type FrameworkSlotPredicate = readonly FrameworkSlotPredicateAtom[];
 /** A named position within a framework's visual structure, populated by an entity type */
 interface FrameworkSlot {
     /** Display label for this slot (e.g. "Key Partners", "Problem", "Reach") */
@@ -22611,6 +23775,18 @@ interface FrameworkSlot {
      * off `scope: 'framework'` properties, not roles.
      */
     role?: string;
+    /**
+     * The membership rule for this slot, when membership is decided by a property
+     * value rather than by entity type or framework role.
+     *
+     * Carrying it here — beside `role` — is what keeps the zone class computable
+     * from the spec record alone: a slot with a `predicate` is a PREDICATE-zone.
+     * The two are not alternatives. On a predicate zone, `role` stops being the
+     * membership channel and becomes the manual-override channel.
+     *
+     * Additive and optional. A slot without one is unaffected.
+     */
+    predicate?: FrameworkSlotPredicate;
     /** Explanation of what this slot represents in the framework */
     description?: string;
 }
@@ -22969,6 +24145,165 @@ interface FrameworkPresentationSpec {
     /** Custom colour map: keys are values of the colour_by dimension, values are CSS colours */
     colour_map?: Record<string, string>;
 }
+/**
+ * One traversal step along a declared edge path.
+ *
+ * `direction` is EXPLICIT and never inferred. Inferring it from endpoint types
+ * fails on self-edges — the experiment family has one
+ * (`experiment_run_tested_via_experiment_run`), where source and target are the
+ * same type and the endpoint types cannot disambiguate the reading.
+ *
+ * `forward` walks source → target as the catalog declares it; `reverse` walks
+ * target → source.
+ */
+interface RelationalEdgeStep {
+    /** Canonical edge type id from the UPG edge catalog */
+    edge: string;
+    /** Which way this step traverses the edge. Never inferred. */
+    direction: 'forward' | 'reverse';
+}
+/**
+ * A column rendering a property of the ROW entity itself.
+ *
+ * A field column declares NO entity type, deliberately. Its entity is the spine
+ * by definition, and asking what type it "contains" is a category error. This is
+ * the difference that dissolves the Status trap: under `slots`, a column showing
+ * a property of the row had to name an `entityTypeId`, which made it look like a
+ * second zone holding the same type as the first — something a partition forbids.
+ * A field column has no such artefact to explain away.
+ */
+interface RelationalFieldColumn {
+    kind: 'field';
+    /** Stable machine-readable column id (snake_case), unique within the surface */
+    id: string;
+    /** Display header */
+    label: string;
+    /** Property key on the spine entity */
+    property: string;
+    /** Whether the column can be sorted */
+    sortable?: boolean;
+}
+/**
+ * A column rendering a declared expression over the ROW entity's own properties.
+ *
+ * Every operand must be a property the spine entity actually declares. An
+ * expression reaching a property held by another entity on a path is INVALID —
+ * it would evaluate to nothing for every row forever, which is a column that is
+ * 100% honest gap, i.e. a lie about what the framework measures.
+ */
+interface RelationalComputedColumn {
+    kind: 'computed';
+    /** Stable machine-readable column id (snake_case), unique within the surface */
+    id: string;
+    /** Display header */
+    label: string;
+    /** Arithmetic expression over spine properties */
+    expression: string;
+    /** How to render the computed value */
+    format?: 'number' | 'percentage' | 'currency' | 'duration';
+    /** Whether the column can be sorted */
+    sortable?: boolean;
+}
+/**
+ * A column rendering the entities reached from the row along a declared edge path.
+ *
+ * A PROJECTION IS NOT A PARTITION, and the distinction is load-bearing rather
+ * than stylistic. A partition claims exclusive membership and is a function of
+ * the entity alone; a projection reports a relationship and is a function of the
+ * (row, path) pair. The same entity legitimately appears in several columns, and
+ * in the same column of several rows — that is the edge structure being reported
+ * accurately, not the "rendering illusion" that property-partitioned frameworks
+ * suffer from. Nothing lands in a projection cell by index, by order, or by
+ * count: the edge exists in the graph or it does not.
+ *
+ * Consequently, and this is a rule rather than an observation: **sibling columns
+ * are NOT required to be mutually exclusive, and must not be validated as if
+ * they were.** Mutual exclusivity is a predicate-zone rule. Enforcing it on a
+ * join would forbid the join.
+ *
+ * EVERY PROJECTION IS MANY-VALUED. The edge catalog declares no cardinality on
+ * any edge, so a projection resolves to a set of size 0..n and must be rendered
+ * as one. Taking the first member because "a run has one hypothesis" asserts a
+ * cardinality the spec does not declare, and selecting from an unordered set by
+ * position is the offset-windowing defect at a different arity.
+ *
+ * ABSENCE IS NOT A VALUE. An empty projection renders as a typed, labelled gap,
+ * never as a blank cell — three states must stay distinguishable: no edge along
+ * the path, an edge to an entity whose rendered field is empty, and not yet
+ * loaded. A blank cell collapses all three into one shrug.
+ */
+interface RelationalProjectionColumn {
+    kind: 'projection';
+    /** Stable machine-readable column id (snake_case), unique within the surface */
+    id: string;
+    /** Display header */
+    label: string;
+    /**
+     * The traversal from the spine to the projected entities. A LIST, not a single
+     * edge.
+     *
+     * Multi-hop is required, not a generality. Reaching a `hypothesis` from an
+     * `experiment_run` is a two-hop reverse traversal, and the spec has twice
+     * REFUSED to mint the shortcut edge that would flatten it, because doing so
+     * would dissolve the plan/run split made in ENTP-322/323. A single-hop-only
+     * declaration would leave authors needing that column with no legal way to
+     * declare it — and the illegal way is the edge the spec already rejected.
+     */
+    path: RelationalEdgeStep[];
+    /** Property keys to render for each projected entity */
+    fields: string[];
+    /**
+     * Maximum entities to RENDER in a cell. A declared literal; the renderer
+     * contributes no default. Truncates rendering only, never membership, and a
+     * truncated cell must report the full count.
+     */
+    limit?: number;
+    /** Whether the column can be sorted */
+    sortable?: boolean;
+}
+/** Any column on a relational surface */
+type RelationalColumn = RelationalFieldColumn | RelationalComputedColumn | RelationalProjectionColumn;
+/**
+ * A relational / join surface: rows are the instances of one declared spine
+ * type, columns are fields of the row or projections along declared edge paths.
+ *
+ * Additive and optional. A framework without this block is unaffected; a
+ * consumer that does not understand it ignores it. It exists because the zoned
+ * grid partitions ONE set into cells and cannot express a surface that JOINS
+ * several sets along the relationships between them — the shape of the `table`
+ * pattern, the second-largest structural family in this spec.
+ *
+ * Rules a consumer must honour, stated here because they are contract, not
+ * rendering preference:
+ *
+ * 1. **The spine is the population.** Row count is the number of spine entities
+ *    in scope. No column may filter the row set; a column that removes rows is a
+ *    partition wearing a projection's clothes.
+ * 2. **Counts are entity-distinct per column** — the number of DISTINCT entities
+ *    appearing anywhere in the column, never the sum of cell sizes. Where the two
+ *    differ, both may be shown only if labelled ("7 learnings across 9 rows").
+ *    Reporting the sum as a population is this surface's characteristic lie.
+ * 3. **Unreferenced entities must be reported.** An entity of a type appearing in
+ *    any declared path — endpoint OR intermediate — that no row reaches is
+ *    invisible by construction. It must be surfaced, always, with a count and its
+ *    type, even at zero. Otherwise the surface silently under-reports the graph.
+ * 4. **Determinism.** A projection is a function of the graph's edges and the
+ *    projected entities' properties, and nothing else. No clock, no random, no
+ *    ambient read. Same graph, same table, every machine.
+ */
+interface RelationalSurfaceSpec {
+    /** The UPG entity type whose instances are the rows */
+    spine: string;
+    /** Ordered columns; at least one */
+    columns: RelationalColumn[];
+    /** Declared row order. Never inferred; the renderer contributes no default. */
+    sort: {
+        /** `id` of a column in `columns` */
+        column: string;
+        /** Sort direction */
+        direction: 'asc' | 'desc';
+    };
+}
 /** One step in a guided walkthrough of how to use a framework */
 interface FrameworkStep {
     /** Step order (1-based) */
@@ -23072,6 +24407,18 @@ interface UPGFramework {
     structure: FrameworkStructureSpec;
     /** How the framework should be rendered */
     presentation: FrameworkPresentationSpec;
+    /**
+     * A relational / join surface, for frameworks whose columns are projections
+     * along edges rather than a partition of one set.
+     *
+     * Additive and optional. When present it is the authoritative column
+     * declaration and `presentation.layout` describes only chrome — the two must
+     * not be read as competing rosters. `slots` should be omitted on a framework
+     * that declares this block: a slot cannot express an edge path, and forcing a
+     * table into slots is what produced the duplicate-`entityTypeId` artefact this
+     * block removes.
+     */
+    relational?: RelationalSurfaceSpec;
     /** Educational context and guided walkthrough */
     education: FrameworkEducation;
     /** IDs of other frameworks this one can be composed with */
@@ -23317,6 +24664,7 @@ declare const UPG_REGION_COUNT: number;
 /**
  * Framework validation: validates UPGFramework objects against the spec.
  */
+
 /** Result of validating a UPGFramework object */
 interface FrameworkValidationResult {
     /** Whether the framework passed all required checks */
@@ -23359,6 +24707,24 @@ interface FrameworkValidationResult {
  * // result.errors === []
  */
 declare function validateUPGFramework(framework: unknown): FrameworkValidationResult;
+/**
+ * Whether two sibling predicates are PROVABLY disjoint — the test that decides
+ * whether a framework's zones are mutually exclusive.
+ *
+ * Two conjunctions cannot both hold if they share a `(scope, property)` on
+ * which their atoms cannot both hold: one such property is enough, because an
+ * entity would have to satisfy both atoms on it simultaneously.
+ *
+ * Note the direction: this returns `true` only when disjointness is PROVED.
+ * An unprovable pair is rejected by the validator, not accepted. Over-rejection
+ * costs the author a loud error they fix by adding a discriminating atom;
+ * accepted overlap costs a silent misclassification at render time. See
+ * Amendment 1 §B of the zone-predicate-hook decision.
+ *
+ * Exported so the renderer resolves membership with the same rule the validator
+ * enforced, rather than a second implementation that can drift from it.
+ */
+declare function predicatesProvablyDisjoint(a: FrameworkSlotPredicate, b: FrameworkSlotPredicate): boolean;
 
 /**
  * Canonical Framework Library: v1 public surface.
@@ -23381,6 +24747,66 @@ declare const UPG_FRAMEWORKS_BY_ID: Record<string, UPGFramework>;
 /** Frameworks grouped by category */
 declare const UPG_FRAMEWORKS_BY_CATEGORY: Record<string, UPGFramework[]>;
 
+/**
+ * Relational path resolution: the shared type-composition logic for the
+ * `relational` block's edge paths.
+ *
+ * One implementation, two consumers — the framework validator (which reports
+ * malformed paths as authoring errors) and the shape audit (which checks that
+ * every type a path reaches is declared in `data.entity_types`). They must agree
+ * on what a path means, so they resolve it with the same function rather than
+ * two that drift.
+ *
+ * https://unifiedproductgraph.org/spec | MIT
+ */
+
+type EdgeCatalog = Record<string, {
+    source_type: string;
+    target_type: string;
+}>;
+/** One resolved hop: where the traversal was, and where the step lands it. */
+interface ResolvedStep {
+    /** Entity type the traversal is at BEFORE this step */
+    from: string;
+    /** Entity type the traversal is at AFTER this step */
+    to: string;
+}
+/** Why a path failed to resolve. `null` `reason` means it resolved cleanly. */
+interface PathResolution {
+    /** The type each step lands on, in order */
+    steps: ResolvedStep[];
+    /** Entity type the whole path lands on, or `null` if it did not resolve */
+    endpoint: string | null;
+    /** Human-readable failure, or `null` on success */
+    reason: string | null;
+    /** Index of the step that failed, or `-1` */
+    failedAt: number;
+}
+/**
+ * Walk a declared path from a starting entity type.
+ *
+ * `direction` is read, never inferred: `forward` goes source → target as the
+ * catalog declares the edge, `reverse` goes target → source. A step whose
+ * starting type does not match the end it claims to enter is a TYPE-COMPOSITION
+ * failure and is reported with both types named, because "invalid path" without
+ * the mismatch is not actionable.
+ */
+declare function resolveRelationalPath(spine: string, path: RelationalEdgeStep[], catalog?: EdgeCatalog): PathResolution;
+/**
+ * Every entity type a framework's relational block touches: the spine, plus each
+ * type any path passes through or lands on.
+ *
+ * INTERMEDIATES COUNT. A type that a path merely passes through is still a type
+ * the framework depends on, and an instance of it that no row reaches is exactly
+ * as invisible as an unreferenced endpoint — an experiment plan with no runs is
+ * the motivating case. Excluding intermediates would let a framework depend on a
+ * type it never declares.
+ *
+ * Unresolvable paths contribute the types they reached before failing; the
+ * validator reports the failure itself.
+ */
+declare function relationalCoveredEntityTypes(fw: UPGFramework): Set<string>;
+
 /**
  * Canonical `.upg` serialisation, the `upg fmt` reference implementation.
  *
@@ -23605,7 +25031,7 @@ declare function checkHeaderSealText(text: string): UPGHeaderSealReport;
  * it stamps the `upg_version` field of every `.upg` file written by the SDK.
  * The `check:version-lockstep` gate enforces this at release time.
  */
-declare const UPG_VERSION: "0.29.0";
+declare const UPG_VERSION: "0.31.0";
 /**
  * The `.upg` JSON document format version. Written to the `upg_version` field.
  * Evolves independently from `UPG_VERSION` (the catalogue version).
@@ -23730,4 +25156,4 @@ declare const UPG_EDGE_COUNT: number;
  */
 declare const UPG_META_COUNT: number;
 
-export { type A11yAnnotationProperties, type A11yAuditProperties, type A11yGuidelineProperties, type A11yIssueProperties, type A11yStandardProperties, ANALYTICS_DATA_PLAYBOOK, type AcceptanceCriterionProperties, type AccessPolicyProperties, type AccountProperties, type AcquisitionChannelProperties, type AdCreativeProperties, type AffinityClusterProperties, type AgentDefinitionProperties, type AgentHookProperties, type AgentSessionProperties, type AgentSkillProperties, type AgentTaskProperties, type AggregateProperties, type AiCostTrackerProperties, type AiDatasetProperties, type AiExperimentProperties, type AiGuardrailProperties, type AiModelProperties, type AiTraceProperties, type AlertRuleProperties, type AnnotationProperties, type AntiPatternInputs, type AntiPatternViolation, type AnyUPGEntityType, type ApiContractProperties, type ApiEcosystemProperties, type ApiEndpointProperties, type ApproachBinding, type ApproachFilter, type ApproachRun, type ApproachRuntime, type ApprovalRecordProperties, type AssumptionProperties, type AttributionModelProperties, type AuditLogPolicyProperties, BUSINESS_GROWTH_METRIC_DRIVEN_PLAYBOOK, BUSINESS_GTM_GROWTH_PLAYBOOK, BUSINESS_MARKETING_AUDIENCE_FIRST_PLAYBOOK, type BehavioralSegmentProperties, type BenchmarkCheck, type BetaProgramProperties, type BoundedContextProperties, type BrandAssetProperties, type BrandColourProperties, type BrandIdentityProperties, type BrandImageryProperties, type BrandLogoProperties, type BrandTypographyProperties, type BrandVoiceProperties, type BugProperties, type BuildArtifactProperties, type BusinessModelProperties, CLASSIFICATION_EDGE_PROPERTY_SCHEMA, CONTENT_DEPTH_WARNING_RULES, COVERAGE_ANTI_PATTERNS, type Cadence, type CapabilityProperties, type CapacityPlanProperties, type CauseConfidence, type CeremonyProperties, type CertificationProperties, type ChangeRequestProperties, type ChangelogProperties, type ChurnReasonProperties, type CiPipelineProperties, type ClassificationAxisProperties, type ClassificationCapability, type ClassificationCapabilitySurface, type ClassificationCommitment, type ClassificationValueProperties, type CodeRepositoryProperties, type CohortProperties, type ComfortLevel, type CommandProperties, type CommunityInitiativeProperties, type CompetitiveAnalysisProperties, type CompetitiveBattleCardProperties, type CompetitorFeatureProperties, type CompetitorProperties, type CompetitorSignalProperties, type ComplianceFrameworkProperties, type ComplianceRequirementProperties, type Confidence, type ConformanceLevel, type ConstraintKind, type ConstraintOrigin, type ConstraintProperties, type ConstraintStatus, type ContactProperties, type ContentCalendarProperties, type ContentPieceProperties, type ContentStrategyProperties, type ContentThemeProperties, type ContractClauseProperties, type ContractProperties, type CostStructureProperties, type CountBenchmark, type Cron, type CrossProductEligibleEdgeType, type CrossProductScope, type CulturalAdaptationProperties, type CustomerFeedbackProperties, type CustomerHealthScoreProperties, type CustomerJourneyStageProperties, type CustomerRelationshipProperties, DEFAULT_ENTITY_EMOJI, DEFERRED_PROPOSED_BY_CONTRACT, DEFER_EDGE_PROPERTY_SCHEMA, DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK, type DashboardProperties, type DataClassificationProperties, type DataContractProperties, type DataDomainProperties, type DataFlowProperties, type DataLineageProperties, type DataModelProperties, type DataPipelineProperties, type DataProductProperties, type DataQualityRuleProperties, type DataSensitivity, type DataSourceProperties, type DatabaseSchemaProperties, type DealProperties, type DecisionProperties, type DeliberateOnlyEdgeType, type DeliverableProperties, type DemandGenProgramProperties, type DepartmentProperties, type DependencyProperties, type DeploymentProperties, type DeprecatedUPGEntityType, type DesignComponentProperties, type DesignConceptProperties, type DesignGuidelineProperties, type DesignPatternProperties, type DesignQuestionProperties, type DesignSprintProperties, type DesignSystemProperties, type DesignTokenProperties, type DesiredOutcomeProperties, type DeveloperPortalProperties, type DifficultyLevel, type DiscountStrategyProperties, type DistributionChannelProperties, type DocumentProperties, type DocumentationTemplateProperties, type DomainActivation, type DomainCountCheck, type DomainEntityProperties, type DomainEventProperties, type DomainGuideStep, type DomainPopulationCheck, type Duration, ENGINEERING_PLATFORM_PLAYBOOK, ENTITY_EMOJI, EXPERIENCE_DESIGN_BRAND_PLAYBOOK, type EdgeCountVsPropertyCheck, type EducationProgramProperties, type EmailSequenceProperties, type EmptyCell, type EmptyCellRationaleKind, type EntityCheck, type EntitySequenceStep, type EntityTypeMeta, type EntityTypeResolution, type EntryMode, type EpicProperties, type ErrorBudgetProperties, type EvalBenchmarkProperties, type EvalRunProperties, type EvaluateAntiPatternsOptions, type EventProperties, type EventSchemaProperties, type EvidenceDirection, type EvidenceProperties, type ExperimentPlanProperties, type ExperimentProperties, type ExperimentRunProperties, type ExternalApiProperties, FOUNDATIONS_PLAYBOOK, type FeasibilityStudyProperties, type FeatureAreaProperties, type FeatureFlagProperties, type FeatureProperties, type FeatureRequestProperties, type FeedbackProgramProperties, type FeedbackThemeProperties, type FeedbackVoteProperties, type FixProperties, type ForecastProperties, type FrameworkCategory, type FrameworkComputedProperty, type FrameworkConstant, type FrameworkDataSpec, type FrameworkEducation, type FrameworkEntityTypeSpec, type FrameworkExerciseProperties, type FrameworkInvocationStep, type FrameworkLayout, type FrameworkLevel, type FrameworkOrigin, type FrameworkPresentationSpec, type FrameworkPropertyRequirement, type FrameworkScoringMethod, type FrameworkSlot, type FrameworkStep, type FrameworkStructureSpec, type FrameworkValidationResult, type FrequencyRating, type FunnelProperties, type FunnelStage, type FunnelStepProperties, type GlossaryTermProperties, type GrowthCampaignProperties, type GrowthLoopProperties, type GtmStrategyProperties, type GuardrailStatus, type HallucinationReportProperties, type HealthStatus, type HelpVideoProperties, type HypothesisEvidenceProperties, type HypothesisProperties, type ISO4217, type ISODate, type ISODateTime, type IdealCustomerProfileProperties, type IncidentProperties, type IncidentSeverity, type InfrastructureComponentProperties, type InitiativeProperties, type InsightProperties, type IntegrationPartnerProperties, type IntegrationPatternProperties, type IntelligenceCondition, type InteractionSpecProperties, type InternalDocProperties, type InterviewGuideProperties, type InvestigationProperties, type InvoiceProperties, type IpAssetProperties, type JobProperties, type JobStepProperties, type JourneyActionProperties, type JourneyPhaseProperties, type JourneyStepProperties, type JourneyType, type KeyActivityProperties, type KeyResourceProperties, type KeyResultProperties, type KnowledgeBaseArticleProperties, LEGACY_PRODUCT_STAGES, type LaunchProperties, type LeadProperties, type LearningPathProperties, type LearningProperties, type LegalEntityProperties, type LibraryDependencyProperties, type LifecyclePhase, type LifecycleRenderShape, type LifecycleRenderState, type LifecycleRenderTransition, type LifecycleState, type LocaleConfigProperties, type LocaleProperties, type LogLevel, type LowMedHigh, MARKDOWN_FORMAT_VERSION, MARKET_COMPETITIVE_PLAYBOOK, type MarketSegmentProperties, type MarketTrendProperties, type MarketingCampaignPlanProperties, type MarketingChannelProperties, type MarketingPlatform, type MarketingStrategyProperties, type MarketplaceListingProperties, type MatrixSlot, type MaturityLevel, type MessagingProperties, type MetricCategory, type MetricDataPoint, type MetricDesignation, type MetricHealth, type MetricImpactLevel, type MetricIndicatorDirection, type MetricProperties, type MetricQualityAssessmentProperties, type MetricSegmentType, type MetricStatisticalFunction, type MilestoneProperties, type MissionProperties, type ModelComparisonProperties, type ModifiedProperty, type MonitorProperties, type NamedGroup, type NeedMaturity, type NeedProperties, type NeedValence, type NpsCampaignProperties, OPERATIONS_QUALITY_PLAYBOOK, type ObjectionProperties, type ObjectiveProperties, type ObservationProperties, type OnCallRotationProperties, type OperatingLifecycleProperties, type OperatingStageProperties, type OpportunityProperties, type OrganizationProperties, type OrphanCheck, type OutcomeProperties, PRODUCT_DELIVERY_PLAYBOOK, PROPERTY_MODIFIERS, PROPERTY_MODIFIER_SEMANTICS, PROPERTY_SCALE_MAP, type ParticipantProperties, type PartnerProgramProperties, type PartnerRevenueShareProperties, type PartnerTierProperties, type PartnershipProperties, type PaywallProperties, type PenetrationTestProperties, type PersonProperties, type PersonaProperties, type PipelineSalesProperties, type PipelineStageProperties, type PlanningCycleProperties, type PlaybookBinding, type PlaybookFilter, type PlaybookProperties, type PlaybookRun, type PlaybookRuntime, type PortfolioProperties, type PositioningProperties, type PostmortemProperties, type PressReleaseProperties, type PricingStrategyProperties, type PricingTierProperties, type PrimitiveProperties, type Priority, type PrivacyPolicyProperties, type ProductAreaProperties, type ProductProperties, type ProductStageCoercion, type ProgramProperties, type ProjectProperties, type PromptTemplateProperties, type PromptVersionProperties, type ProofPointProperties, type PropertyDefinition, type PropertyModifier, type PropertySchema, type Protocol, type PrototypeProperties, type ProxyConfidence, type ProxyReason, type QaSessionProperties, type QueueTopicProperties, type QuoteDocumentProperties, type QuoteProperties, RECORD_ENTITY_TYPES, REFLECT_MODES, REGISTRY_PRODUCT_ID, type RatioBenchmark, type ReadModelProperties, type RebuttalProperties, type ReflectMode, type RegionalPricingProperties, type RegressionTestProperties, type RelationshipBenchmark, type RelationshipCheck, type ReleaseProperties, type ReleaseStrategyProperties, type ReportProperties, type ResearchPlanProperties, type ResearchQuestionProperties, type ResearchStudyProperties, type ResourceAllocationProperties, type RetrospectiveProperties, type RevenueStreamProperties, type ReviewGateProperties, type RiskProperties, type RiskRegisterProperties, type RoadmapItemProperties, type RoadmapProperties, type RoadmapThemeProperties, type RoleProperties, type RootCauseProperties, type RuleStrength, type RunContext, type RunbookProperties, STRATEGY_OUTCOMES_PLAYBOOK, type SalesMotionProperties, type ScreenProperties, type ScreenStateProperties, type SecurityAuditProperties, type SecurityControlProperties, type SecurityPolicyProperties, type SecurityReviewProperties, type Semver, type SeoKeywordProperties, type SerializeOptions, type ServiceBlueprintProperties, type ServiceLevelAgreementProperties, type ServiceLevelIndicatorProperties, type ServiceLevelObjectiveProperties, type ServiceProperties, type SignalChannel, type SignalSentiment, type SignalUrgency, type SkillProperties, type SocialPostProperties, type SolutionProperties, type SpecificationProperties, type StageRange, type StakeholderProperties, type StatusCategory, type StatusReportProperties, type Step, type StepKind, type StepOutput, type StepOutputKind, type StoryTaskProperties, type StrategicPillarProperties, type StrategicQuestionProperties, type StrategicThemeProperties, type StructurePattern, type SubSequenceStep, type SubscriptionProperties, type SuccessMilestoneProperties, type SupportTicketProperties, type SurfaceArbitrationState, type SurfaceCardinality, type SurfaceCompositionMode, type SurfaceExtensibility, type SurfaceId, type SurfaceInstanceScope, type SurfaceKind, type SurfacePersistence, type SurfaceProperties, type SurveyResponseProperties, type SwitchingCostProperties, type SymptomProperties, THIN_GRAPH_THRESHOLD, type TableColumn, type TargetCustomerSegmentProperties, type TaskProperties, type TeamOkrProperties, type TeamProperties, type TechnicalDebtItemProperties, type TerritoryProperties, type TestCaseProperties, type TestCoverageReportProperties, type TestEnvironmentProperties, type TestPlanProperties, type TestResultProperties, type TestSuiteProperties, type ThreatModelProperties, type ThreatProperties, type Timeframe, type TotalEntityCountCheck, type TouchpointProperties, type TranslationBundleProperties, type TranslationKeyProperties, type TrialConfigProperties, type TutorialProperties, type UPGAnchorEntity, type UPGAntiPattern, type UPGAntiPatternConcern, type UPGAntiPatternSeverity, type UPGApproach, type UPGApproachEnvelope, type UPGApproachId, type UPGAreaTaxonomyEntry, type UPGAssessment, type UPGBaseNode, type UPGBenchmarkSource, type UPGBoundaryDirection, type UPGBoundaryEdge, type UPGCrossEdge, type UPGCrossEdgeType, type UPGCrossOnlyEdgeType, type UPGCuratedAntiPattern, type UPGDocument, type UPGDomain, type UPGDomainBridge, type UPGDomainId, type UPGDomainPattern, type UPGDomainRing, type UPGDomainUsageGuide, type UPGEdge, type UPGEdgeCountSpec, type UPGEdgeDefinition, type UPGEdgeMigration, type UPGEdgeMigrationEndpoints, type UPGEdgePickHint, type UPGEdgeType, type UPGEntityFilterSpec, type UPGEntityType, type UPGEntityTypeMaturity, type UPGEnumScaleDefinition, type UPGEnumScaleValue, type UPGFramework, type UPGFrameworkMeta, type UPGHeader, type UPGHeaderCountsMismatch, type UPGHeaderIntegrity, type UPGHeaderIntegrityMismatch, type UPGHeaderProvenance, type UPGHeaderSealReport, type UPGIntegrity, type UPGLens, type UPGLensIntelligencePrompt, type UPGLifecycle, type UPGMappingConfidence, type UPGMemberKindKey, type UPGNode, type UPGOrganization, type UPGPlaybook, type UPGPortfolio, type UPGPortfolioDocument, type UPGPortfolioKind, type UPGPresenceExceptSpec, type UPGProduct, type UPGProductArea, type UPGProductStage, type UPGPropertyMap, type UPGPropertyMigration, type UPGPropertyMigrationChange, type UPGRegion, type UPGRegionEntityMembership, type UPGRegionEntityRole, type UPGRegionId, type UPGRegionShape, type UPGRegistry, type UPGScalarToEdgeMigration, type UPGScaleDefinition, type UPGScalePoint, type UPGSource, type UPGSplitEdge, type UPGSplitMigration, type UPGSplitRoute, type UPGSplitRouteTarget, type UPGSplitTarget, type UPGTreeChild, type UPGTreeGapPolicy, type UPGTreePattern, type UPGTreePatternDetail, type UPGTreePatternEdge, type UPGTreePatternSummary, type UPGTypeLabel, type UPGTypeMigration, type UPGValidationError, type UPGValidationProfile, type UPGValidationResult, type UPGValidationWarning, type UPGWildcardEndpoint, UPG_ACTIVE_TYPES, UPG_ANTI_PATTERNS, UPG_ANTI_PATTERN_CONCERNS, UPG_APPROACHES, UPG_APPROACHES_BY_ID, UPG_AREA_TAXONOMY, UPG_AREA_TAXONOMY_BY_COVERAGE_KEY, UPG_CANONICAL_FORMAT_VERSION, UPG_CONTAINMENT_FREE_TYPES, UPG_COUNT_BENCHMARKS, UPG_CROSS_EDGE_TYPES, UPG_CROSS_ELIGIBLE_CATALOG_EDGE_TYPES, UPG_CROSS_ONLY_EDGE_TYPES, UPG_DELIBERATE_ONLY_EDGE_TYPES, UPG_DEPRECATED_TYPES, UPG_DOMAINS, UPG_DOMAIN_ACTIVATION, UPG_DOMAIN_COUNT, UPG_DOMAIN_GUIDES, UPG_DOMAIN_RINGS, UPG_EDGE_CATALOG, UPG_EDGE_COUNT, UPG_EDGE_COUNT_SPECS, UPG_EDGE_MIGRATIONS, UPG_EDGE_PAIR_MAP, UPG_EDGE_TYPES, UPG_ENTITY_COUNT, UPG_ENTITY_FILTER_SPECS, UPG_ENTITY_META, UPG_ENTITY_META_BY_ID, UPG_ENTITY_META_BY_NAME, UPG_ENTITY_TO_DOMAIN, UPG_ENUM_SCALES, UPG_FORMAT_VERSION, UPG_FRAMEWORKS, UPG_FRAMEWORKS_BY_CATEGORY, UPG_FRAMEWORKS_BY_ID, UPG_FRAMEWORK_CATEGORIES, UPG_LENSES, UPG_LIFECYCLES, UPG_LIFECYCLE_FREE_TYPES, UPG_LIFECYCLE_PLANNED_TYPES, UPG_META_COUNT, UPG_MIGRATIONS, UPG_PLAYBOOKS, UPG_POLYMORPHIC_EDGE_KEYS, UPG_PORTFOLIO_KINDS, UPG_PORTFOLIO_SHARED_TYPES, UPG_PRESENCE_EXCEPT_SPECS, UPG_PRODUCT_STAGES, UPG_PRODUCT_STAGE_COERCION_MAP, UPG_PROPERTY_MIGRATIONS, UPG_PROPERTY_SCHEMA, UPG_RATIO_BENCHMARKS, UPG_REGIONS, UPG_REGION_COUNT, UPG_REGION_MAP, UPG_RELATIONSHIP_BENCHMARKS, UPG_SCALAR_TO_EDGE_MIGRATIONS, UPG_SCALES, UPG_SPLIT_MIGRATIONS, UPG_STATUS_MIGRATIONS, UPG_STRUCTURE_PATTERNS, UPG_TREE_PATTERNS, UPG_TREE_PATTERNS_BY_ID, UPG_TYPES, UPG_TYPES_SET, UPG_TYPE_ALIASES, UPG_TYPE_LABELS, UPG_TYPE_LABELS_MAP, UPG_TYPE_NAMES, UPG_VALIDATION_PROFILES, UPG_VALID_CHILDREN, UPG_VERSION, UPG_WILDCARD_ENDPOINT, USERS_NEEDS_PLAYBOOK, type UnitEconomicsProperties, UnknownEntityTypeError, type UserAdvisoryBoardProperties, type UserFlowProperties, type UserJourneyProperties, type UserStoryProperties, type ValueObjectProperties, type ValuePropositionProperties, type ValueStreamProperties, type VariantProperties, type VisionProperties, type VulnerabilityProperties, type WalkMigrationChainResult, type WalkthroughProperties, type WebinarProperties, type WireframeProperties, type WorkflowArtifactProperties, type WorkflowRunProperties, type WorkflowTemplateProperties, type WorkspaceProperties, backfillSlug, buildTypeAliases, canBeChildOf, checkHeaderSeal, checkHeaderSealText, checkToEdgeCountSpec, classifyEntityFilter, coerceProductStage, collectSlugsForType, collectTargetEntities, compareVersions, computeBodyChecksum, concernEvaluatedFor, concernFor, concernGatesFor, crossProductScope, deriveCounts, derivePortfolioCounts, deriveSingleCounts, describeTreePattern, edgeCarriesProperties, edgeCountSpecKey, entityFilterKey, evaluateAntiPatterns, findInvalidStatusMigrationTargets, formatUpgText, friendlyToAssessment, generateSlug, getAnchorEntity, getAntiPatternById, getAntiPatterns, getAntiPatternsBySeverity, getAntiPatternsForStage, getAreaTaxonomyEntry, getBenchmark, getBenchmarksByDomain, getBusinessAreasForRegion, getCanonicalPlaybookForRegion, getCoverageKeysForRegion, getDefaultLens, getDeprecatedTypes, getDomainForType, getDomainIdForType, getDomainsInRing, getEdgePropertySchema, getEntityModifierSummary, getEnumScale, getEnumValueMeta, getGuideForDomain, getLens, getLensIds, getLensPlaybook, getLensesForDomain, getLifecycleForType, getLifecycleRenderShape, getMigrationMap, getPlaybookById, getPlaybooksForRegion, getPropertiesForScale, getPropertyDefaultScale, getPropertyMigrations, getPropertyModifier, getPropertySchema, getRegion, getRegionForEntityType, getReplacementType, getRingForDomain, getScalarToEdgeMigrations, getScale, getSplitMigrations, getTreePattern, getTypeId, getTypeName, getTypes, getUPGEdgeMigrations, getValidChildren, getVisibleTypes, hasStatusMigration, isAggregateShapedProperty, isCanonical, isCanonicalProductStage, isContainmentFreeType, isCrossCapable, isCrossProductEligible, isCuratedCrossEligible, isDeliberateOnlyEdge, isDeprecatedType, isDomainGuideStep, isEntitySequenceStep, isFrameworkInvocationStep, isLegacyProductStage, isLifecycleFreeType, isLifecyclePlannedType, isPolymorphicEdge, isPortfolio, isPortfolioSharedType, isRecordEntity, isRegisteredPolymorphicEdge, isRuntimeStateShapedProperty, isSubSequenceStep, isThinCoverageAdvisory, isUPGDocument, listPropertiesByModifier, listStatusMigrations, listTreePatternSummaries, migrateEdge, migrateNode, migrateNodeProperties, migrateProductStage, migrateStatusValue, normalizeDocument, parseUpg, pickCanonicalEdge, presenceExceptKey, resolveAllEdges, resolveContainmentEdge, resolveEntityType, resolveLabel, resolveSlugCollision, resolveTreePatternEdges, ringOrderedDomainIds, rotateSlug, serializeCanonical, validateEdgeProperties, validateProductStageStrict, validateUPGDocument, validateUPGFramework, validationProfileFor, walkMigrationChainToCanonical };
+export { type A11yAnnotationProperties, type A11yAuditProperties, type A11yGuidelineProperties, type A11yIssueProperties, type A11yStandardProperties, ACTIVE_WHEN_PROPERTY, ANALYTICS_DATA_PLAYBOOK, type AcceptanceCriterionProperties, type AccessPolicyProperties, type AccountProperties, type AcquisitionChannelProperties, type AdCreativeProperties, type AffinityClusterProperties, type AgentDefinitionProperties, type AgentHookProperties, type AgentSessionProperties, type AgentSkillProperties, type AgentTaskProperties, type AggregateProperties, type AiCostTrackerProperties, type AiDatasetProperties, type AiExperimentProperties, type AiGuardrailProperties, type AiModelProperties, type AiTraceProperties, type AlertRuleProperties, type AnnotationProperties, type AntiPatternInputs, type AntiPatternViolation, type AnyUPGEntityType, type ApiContractProperties, type ApiEcosystemProperties, type ApiEndpointProperties, type ApproachBinding, type ApproachFilter, type ApproachRun, type ApproachRuntime, type ApprovalRecordProperties, type AssumptionProperties, type AttributionModelProperties, type AuditLogPolicyProperties, BUSINESS_GROWTH_METRIC_DRIVEN_PLAYBOOK, BUSINESS_GTM_GROWTH_PLAYBOOK, BUSINESS_MARKETING_AUDIENCE_FIRST_PLAYBOOK, type BehavioralSegmentProperties, type BenchmarkCheck, type BetaProgramProperties, type BoundedContextProperties, type BrandAssetProperties, type BrandColourProperties, type BrandIdentityProperties, type BrandImageryProperties, type BrandLogoProperties, type BrandTypographyProperties, type BrandVoiceProperties, type BugProperties, type BuildArtifactProperties, type BusinessModelProperties, CLASSIFICATION_EDGE_PROPERTY_SCHEMA, CONFIGURATION_QUALIFIER_EDGE_PROPERTY_SCHEMA, CONFIGURATION_VARIANCE_EDGE_PROPERTY_SCHEMA, CONTENT_DEPTH_WARNING_RULES, COVERAGE_ANTI_PATTERNS, type Cadence, type CapabilityProperties, type CapacityPlanProperties, type CauseConfidence, type CeremonyProperties, type CertificationProperties, type ChangeRequestProperties, type ChangelogProperties, type ChurnReasonProperties, type CiPipelineProperties, type ClassificationAxisProperties, type ClassificationCapability, type ClassificationCapabilitySurface, type ClassificationCommitment, type ClassificationValueProperties, type CodeRepositoryProperties, type CohortProperties, type ComfortLevel, type CommandProperties, type CommunityInitiativeProperties, type CompetitiveAnalysisProperties, type CompetitiveBattleCardProperties, type CompetitorFeatureProperties, type CompetitorProperties, type CompetitorSignalProperties, type ComplianceFrameworkProperties, type ComplianceRequirementProperties, type CompositionMember, type CompositionProperties, type Confidence, type Configuration, type ConfigurationAxisKind, type ConfigurationAxisProperties, type ConfigurationDriftFinding, type ConfigurationDriftKind, type ConformanceLevel, type ConstraintKind, type ConstraintOrigin, type ConstraintProperties, type ConstraintStatus, type ContactProperties, type ContentCalendarProperties, type ContentPieceProperties, type ContentStrategyProperties, type ContentThemeProperties, type ContractClauseProperties, type ContractProperties, type CostStructureProperties, type CountBenchmark, type Cron, type CrossProductEligibleEdgeType, type CrossProductScope, type CulturalAdaptationProperties, type CustomerFeedbackProperties, type CustomerHealthScoreProperties, type CustomerJourneyStageProperties, type CustomerRelationshipProperties, DEFAULT_ENTITY_EMOJI, DEFERRED_PROPOSED_BY_CONTRACT, DEFER_EDGE_PROPERTY_SCHEMA, DISCOVERY_RESEARCH_VALIDATION_PLAYBOOK, type DashboardProperties, type DataClassificationProperties, type DataContractProperties, type DataDomainProperties, type DataFlowProperties, type DataLineageProperties, type DataModelProperties, type DataPipelineProperties, type DataProductProperties, type DataQualityRuleProperties, type DataSensitivity, type DataSourceProperties, type DatabaseSchemaProperties, type DealProperties, type DecisionProperties, type DeliberateOnlyEdgeType, type DeliverableProperties, type DemandGenProgramProperties, type DepartmentProperties, type DependencyProperties, type DeploymentProperties, type DeprecatedUPGEntityType, type DesignComponentProperties, type DesignConceptProperties, type DesignGuidelineProperties, type DesignPatternProperties, type DesignQuestionProperties, type DesignSprintProperties, type DesignSystemProperties, type DesignTokenProperties, type DesiredOutcomeProperties, type DeveloperPortalProperties, type DifficultyLevel, type DiscountStrategyProperties, type DistributionChannelProperties, type DocumentProperties, type DocumentationTemplateProperties, type DomainActivation, type DomainCountCheck, type DomainEntityProperties, type DomainEventProperties, type DomainGuideStep, type DomainPopulationCheck, type Duration, ENGINEERING_PLATFORM_PLAYBOOK, ENTITY_EMOJI, EXPERIENCE_DESIGN_BRAND_PLAYBOOK, type EdgeCountVsPropertyCheck, type EducationProgramProperties, type EmailSequenceProperties, type EmptyCell, type EmptyCellRationaleKind, type EntityCheck, type EntitySequenceStep, type EntityTypeMeta, type EntityTypeResolution, type EntryMode, type EpicProperties, type ErrorBudgetProperties, type EvalBenchmarkProperties, type EvalRunProperties, type EvaluateAntiPatternsOptions, type EventProperties, type EventSchemaProperties, type EvidenceDirection, type EvidenceProperties, type ExperimentPlanProperties, type ExperimentProperties, type ExperimentRunProperties, type ExternalApiProperties, FOUNDATIONS_PLAYBOOK, type FeasibilityStudyProperties, type FeatureAreaProperties, type FeatureFlagProperties, type FeatureProperties, type FeatureRequestProperties, type FeedbackProgramProperties, type FeedbackThemeProperties, type FeedbackVoteProperties, type FixProperties, type ForecastProperties, type FrameworkCategory, type FrameworkComputedProperty, type FrameworkConstant, type FrameworkDataSpec, type FrameworkEducation, type FrameworkEntityTypeSpec, type FrameworkExerciseProperties, type FrameworkInvocationStep, type FrameworkLayout, type FrameworkLevel, type FrameworkOrigin, type FrameworkPresentationSpec, type FrameworkPropertyRequirement, type FrameworkScoringMethod, type FrameworkSlot, type FrameworkSlotPredicate, type FrameworkSlotPredicateAtom, type FrameworkStep, type FrameworkStructureSpec, type FrameworkValidationResult, type FrequencyRating, type FunnelProperties, type FunnelStage, type FunnelStepProperties, type GlossaryTermProperties, type GrowthCampaignProperties, type GrowthLoopProperties, type GtmStrategyProperties, type GuardrailStatus, type HallucinationReportProperties, type HealthStatus, type HelpVideoProperties, type HypothesisEvidenceProperties, type HypothesisProperties, type ISO4217, type ISODate, type ISODateTime, type IdealCustomerProfileProperties, type IncidentProperties, type IncidentSeverity, type InfrastructureComponentProperties, type InitiativeProperties, type InsightProperties, type IntegrationPartnerProperties, type IntegrationPatternProperties, type IntelligenceCondition, type InteractionSpecProperties, type InternalDocProperties, type InterviewGuideProperties, type InvestigationProperties, type InvoiceProperties, type IpAssetProperties, type JobProperties, type JobStepProperties, type JourneyActionProperties, type JourneyPhaseProperties, type JourneyStepProperties, type JourneyType, type KeyActivityProperties, type KeyResourceProperties, type KeyResultProperties, type KnowledgeBaseArticleProperties, LEGACY_PRODUCT_STAGES, type LaunchProperties, type LeadProperties, type LearningPathProperties, type LearningProperties, type LegalEntityProperties, type LibraryDependencyProperties, type LifecyclePhase, type LifecycleRenderShape, type LifecycleRenderState, type LifecycleRenderTransition, type LifecycleState, type LocaleConfigProperties, type LocaleProperties, type LogLevel, type LowMedHigh, MARKDOWN_FORMAT_VERSION, MARKET_COMPETITIVE_PLAYBOOK, type MarketSegmentProperties, type MarketTrendProperties, type MarketingCampaignPlanProperties, type MarketingChannelProperties, type MarketingPlatform, type MarketingStrategyProperties, type MarketplaceListingProperties, type MatrixSlot, type MaturityLevel, type MessagingProperties, type MetricCategory, type MetricDataPoint, type MetricDesignation, type MetricHealth, type MetricImpactLevel, type MetricIndicatorDirection, type MetricProperties, type MetricQualityAssessmentProperties, type MetricScore, type MetricSegmentType, type MetricStatisticalFunction, type MilestoneProperties, type MissionProperties, type ModelComparisonProperties, type ModifiedProperty, type MonitorProperties, type NamedGroup, type NeedMaturity, type NeedProperties, type NeedValence, type NpsCampaignProperties, OPERATIONS_QUALITY_PLAYBOOK, type ObjectionProperties, type ObjectiveProperties, type ObservationProperties, type OnCallRotationProperties, type OperatingLifecycleProperties, type OperatingStageProperties, type OpportunityProperties, type OrganizationProperties, type OrphanCheck, type OutcomeProperties, PRESENT_UNDER_PROPERTY, PRODUCT_DELIVERY_PLAYBOOK, PROPERTY_MODIFIERS, PROPERTY_MODIFIER_SEMANTICS, PROPERTY_SCALE_MAP, type ParticipantProperties, type PartnerProgramProperties, type PartnerRevenueShareProperties, type PartnerTierProperties, type PartnershipProperties, type PathResolution, type PaywallProperties, type PenetrationTestProperties, type PersonProperties, type PersonaProperties, type PipelineSalesProperties, type PipelineStageProperties, type PlanningCycleProperties, type PlaybookBinding, type PlaybookFilter, type PlaybookProperties, type PlaybookRun, type PlaybookRuntime, type PortfolioProperties, type PositioningProperties, type PostmortemProperties, type PressReleaseProperties, type PricingStrategyProperties, type PricingTierProperties, type PrimitiveProperties, type Priority, type PrivacyPolicyProperties, type ProductAreaProperties, type ProductProperties, type ProductStageCoercion, type ProgramProperties, type ProjectProperties, type ProjectableEdge, type ProjectableNode, type ProjectionResult, type PromptTemplateProperties, type PromptVersionProperties, type ProofPointProperties, type PropertyDefinition, type PropertyModifier, type PropertySchema, type Protocol, type PrototypeProperties, type ProxyConfidence, type ProxyReason, QUALIFIABLE_EDGE_TYPES, type QaSessionProperties, type QueueTopicProperties, type QuoteDocumentProperties, type QuoteProperties, RECORD_ENTITY_TYPES, REFLECT_MODES, REGISTRY_PRODUCT_ID, type RatioBenchmark, type ReadModelProperties, type RebuttalProperties, type ReflectMode, type RegionalPricingProperties, type RegressionTestProperties, type RelationalColumn, type RelationalComputedColumn, type RelationalEdgeStep, type RelationalFieldColumn, type RelationalProjectionColumn, type RelationalSurfaceSpec, type RelationshipBenchmark, type RelationshipCheck, type ReleaseProperties, type ReleaseStrategyProperties, type ReportProperties, type ResearchPlanProperties, type ResearchQuestionProperties, type ResearchStudyProperties, type ResolvedStep, type ResourceAllocationProperties, type RetrospectiveProperties, type RevenueStreamProperties, type ReviewGateProperties, type RiskProperties, type RiskRegisterProperties, type RoadmapItemProperties, type RoadmapProperties, type RoadmapThemeProperties, type RoleProperties, type RootCauseProperties, type RuleStrength, type RunContext, type RunbookProperties, STRATEGY_OUTCOMES_PLAYBOOK, type SalesMotionProperties, type ScreenProperties, type ScreenStateProperties, type SecurityAuditProperties, type SecurityControlProperties, type SecurityPolicyProperties, type SecurityReviewProperties, type Semver, type SeoKeywordProperties, type SerializeOptions, type ServiceBlueprintProperties, type ServiceLevelAgreementProperties, type ServiceLevelIndicatorProperties, type ServiceLevelObjectiveProperties, type ServiceProperties, type SignalChannel, type SignalSentiment, type SignalUrgency, type SkillProperties, type SocialPostProperties, type SolutionProperties, type SpecificationProperties, type StageRange, type StakeholderProperties, type StatusCategory, type StatusReportProperties, type Step, type StepKind, type StepOutput, type StepOutputKind, type StoryTaskProperties, type StrategicPillarProperties, type StrategicQuestionProperties, type StrategicThemeProperties, type StructurePattern, type SubSequenceStep, type SubscriptionProperties, type SuccessMilestoneProperties, type SupportTicketProperties, type SurfaceArbitrationState, type SurfaceCardinality, type SurfaceCompositionMode, type SurfaceExtensibility, type SurfaceId, type SurfaceInstanceScope, type SurfaceKind, type SurfacePersistence, type SurfaceProperties, type SurveyResponseProperties, type SwitchingCostProperties, type SymptomProperties, THIN_GRAPH_THRESHOLD, type TableColumn, type TargetCustomerSegmentProperties, type TaskProperties, type TeamOkrProperties, type TeamProperties, type TechnicalDebtItemProperties, type TerritoryProperties, type TestCaseProperties, type TestCoverageReportProperties, type TestEnvironmentProperties, type TestPlanProperties, type TestResultProperties, type TestSuiteProperties, type ThreatModelProperties, type ThreatProperties, type Timeframe, type TotalEntityCountCheck, type TouchpointProperties, type TranslationBundleProperties, type TranslationKeyProperties, type TrialConfigProperties, type TutorialProperties, type UPGAnchorEntity, type UPGAntiPattern, type UPGAntiPatternConcern, type UPGAntiPatternSeverity, type UPGApproach, type UPGApproachEnvelope, type UPGApproachId, type UPGAreaTaxonomyEntry, type UPGAssessment, type UPGBaseNode, type UPGBenchmarkSource, type UPGBoundaryDirection, type UPGBoundaryEdge, type UPGCrossEdge, type UPGCrossEdgeType, type UPGCrossOnlyEdgeType, type UPGCuratedAntiPattern, type UPGDocument, type UPGDomain, type UPGDomainBridge, type UPGDomainId, type UPGDomainPattern, type UPGDomainRing, type UPGDomainUsageGuide, type UPGEdge, type UPGEdgeCountSpec, type UPGEdgeDefinition, type UPGEdgeMigration, type UPGEdgeMigrationEndpoints, type UPGEdgePickHint, type UPGEdgeType, type UPGEntityFilterSpec, type UPGEntityType, type UPGEntityTypeMaturity, type UPGEnumScaleDefinition, type UPGEnumScaleValue, type UPGFramework, type UPGFrameworkMeta, type UPGHeader, type UPGHeaderCountsMismatch, type UPGHeaderIntegrity, type UPGHeaderIntegrityMismatch, type UPGHeaderProvenance, type UPGHeaderSealReport, type UPGIntegrity, type UPGLens, type UPGLensIntelligencePrompt, type UPGLifecycle, type UPGMappingConfidence, type UPGMemberKindKey, type UPGNode, type UPGOrganization, type UPGPlaybook, type UPGPortfolio, type UPGPortfolioDocument, type UPGPortfolioKind, type UPGPresenceExceptSpec, type UPGProduct, type UPGProductArea, type UPGProductStage, type UPGPropertyMap, type UPGPropertyMigration, type UPGPropertyMigrationChange, type UPGRegion, type UPGRegionEntityMembership, type UPGRegionEntityRole, type UPGRegionId, type UPGRegionShape, type UPGRegistry, type UPGScalarToEdgeMigration, type UPGScaleDefinition, type UPGScalePoint, type UPGSource, type UPGSplitEdge, type UPGSplitMigration, type UPGSplitRoute, type UPGSplitRouteTarget, type UPGSplitTarget, type UPGTreeChild, type UPGTreeGapPolicy, type UPGTreePattern, type UPGTreePatternDetail, type UPGTreePatternEdge, type UPGTreePatternSummary, type UPGTypeLabel, type UPGTypeMigration, type UPGValidationError, type UPGValidationProfile, type UPGValidationResult, type UPGValidationWarning, type UPGWildcardEndpoint, UPG_ACTIVE_TYPES, UPG_ANTI_PATTERNS, UPG_ANTI_PATTERN_CONCERNS, UPG_APPROACHES, UPG_APPROACHES_BY_ID, UPG_AREA_TAXONOMY, UPG_AREA_TAXONOMY_BY_COVERAGE_KEY, UPG_CANONICAL_FORMAT_VERSION, UPG_CONTAINMENT_FREE_TYPES, UPG_COUNT_BENCHMARKS, UPG_CROSS_EDGE_TYPES, UPG_CROSS_ELIGIBLE_CATALOG_EDGE_TYPES, UPG_CROSS_ONLY_EDGE_TYPES, UPG_DELIBERATE_ONLY_EDGE_TYPES, UPG_DEPRECATED_TYPES, UPG_DOMAINS, UPG_DOMAIN_ACTIVATION, UPG_DOMAIN_COUNT, UPG_DOMAIN_GUIDES, UPG_DOMAIN_RINGS, UPG_EDGE_CATALOG, UPG_EDGE_COUNT, UPG_EDGE_COUNT_SPECS, UPG_EDGE_MIGRATIONS, UPG_EDGE_PAIR_MAP, UPG_EDGE_TYPES, UPG_ENTITY_COUNT, UPG_ENTITY_FILTER_SPECS, UPG_ENTITY_META, UPG_ENTITY_META_BY_ID, UPG_ENTITY_META_BY_NAME, UPG_ENTITY_TO_DOMAIN, UPG_ENUM_SCALES, UPG_FORMAT_VERSION, UPG_FRAMEWORKS, UPG_FRAMEWORKS_BY_CATEGORY, UPG_FRAMEWORKS_BY_ID, UPG_FRAMEWORK_CATEGORIES, UPG_LENSES, UPG_LIFECYCLES, UPG_LIFECYCLE_FREE_TYPES, UPG_LIFECYCLE_PLANNED_TYPES, UPG_META_COUNT, UPG_MIGRATIONS, UPG_PLAYBOOKS, UPG_POLYMORPHIC_EDGE_KEYS, UPG_PORTFOLIO_KINDS, UPG_PORTFOLIO_SHARED_TYPES, UPG_PRESENCE_EXCEPT_SPECS, UPG_PRODUCT_STAGES, UPG_PRODUCT_STAGE_COERCION_MAP, UPG_PROPERTY_MIGRATIONS, UPG_PROPERTY_SCHEMA, UPG_RATIO_BENCHMARKS, UPG_REGIONS, UPG_REGION_COUNT, UPG_REGION_MAP, UPG_RELATIONSHIP_BENCHMARKS, UPG_SCALAR_TO_EDGE_MIGRATIONS, UPG_SCALES, UPG_SPLIT_MIGRATIONS, UPG_STATUS_MIGRATIONS, UPG_STRUCTURE_PATTERNS, UPG_TREE_PATTERNS, UPG_TREE_PATTERNS_BY_ID, UPG_TYPES, UPG_TYPES_SET, UPG_TYPE_ALIASES, UPG_TYPE_LABELS, UPG_TYPE_LABELS_MAP, UPG_TYPE_NAMES, UPG_VALIDATION_PROFILES, UPG_VALID_CHILDREN, UPG_VERSION, UPG_WILDCARD_ENDPOINT, USERS_NEEDS_PLAYBOOK, type UnitEconomicsProperties, UnknownEntityTypeError, type UserAdvisoryBoardProperties, type UserFlowProperties, type UserJourneyProperties, type UserStoryProperties, VARIES_BY_EDGE, type ValueObjectProperties, type ValuePropositionProperties, type ValueStreamProperties, type VariantProperties, type VisionProperties, type VulnerabilityProperties, WORKSPACE_ARRANGEMENT_EDGE_PROPERTY_SCHEMA, type WalkMigrationChainResult, type WalkthroughProperties, type WebinarProperties, type WireframeProperties, type WorkflowArtifactProperties, type WorkflowRunProperties, type WorkflowTemplateProperties, type WorkspaceCanvas, type WorkspaceProperties, backfillSlug, buildTypeAliases, canBeChildOf, checkConfigurationDrift, checkHeaderSeal, checkHeaderSealText, checkToEdgeCountSpec, classifyEntityFilter, coerceProductStage, collectSlugsForType, collectTargetEntities, compareVersions, computeBodyChecksum, concernEvaluatedFor, concernFor, concernGatesFor, crossProductScope, deriveCounts, derivePortfolioCounts, deriveSingleCounts, describeTreePattern, edgeCarriesProperties, edgeCountSpecKey, entityFilterKey, enumerateProjections, evaluateAntiPatterns, findInvalidStatusMigrationTargets, formatUpgText, friendlyToAssessment, generateSlug, getAnchorEntity, getAntiPatternById, getAntiPatterns, getAntiPatternsBySeverity, getAntiPatternsForStage, getAreaTaxonomyEntry, getBenchmark, getBenchmarksByDomain, getBusinessAreasForRegion, getCanonicalPlaybookForRegion, getCoverageKeysForRegion, getDefaultLens, getDeprecatedTypes, getDomainForType, getDomainIdForType, getDomainsInRing, getEdgePropertySchema, getEntityModifierSummary, getEnumScale, getEnumValueMeta, getGuideForDomain, getLens, getLensIds, getLensPlaybook, getLensesForDomain, getLifecycleForType, getLifecycleRenderShape, getMigrationMap, getPlaybookById, getPlaybooksForRegion, getPropertiesForScale, getPropertyDefaultScale, getPropertyMigrations, getPropertyModifier, getPropertySchema, getRegion, getRegionForEntityType, getReplacementType, getRingForDomain, getScalarToEdgeMigrations, getScale, getSplitMigrations, getTreePattern, getTypeId, getTypeName, getTypes, getUPGEdgeMigrations, getValidChildren, getVisibleTypes, hasStatusMigration, isAggregateShapedProperty, isCanonical, isCanonicalProductStage, isContainmentFreeType, isCrossCapable, isCrossProductEligible, isCuratedCrossEligible, isDeliberateOnlyEdge, isDeprecatedType, isDomainGuideStep, isEntitySequenceStep, isFrameworkInvocationStep, isLegacyProductStage, isLifecycleFreeType, isLifecyclePlannedType, isPolymorphicEdge, isPortfolio, isPortfolioSharedType, isRecordEntity, isRegisteredPolymorphicEdge, isRuntimeStateShapedProperty, isSubSequenceStep, isThinCoverageAdvisory, isUPGDocument, listPropertiesByModifier, listStatusMigrations, listTreePatternSummaries, migrateEdge, migrateNode, migrateNodeProperties, migrateProductStage, migrateStatusValue, normalizeDocument, parseUpg, pickCanonicalEdge, predicatesProvablyDisjoint, presenceExceptKey, projectGraph, readActiveWhen, readStringArray, relationalCoveredEntityTypes, resolveAllEdges, resolveContainmentEdge, resolveEntityType, resolveLabel, resolveRelationalPath, resolveSlugCollision, resolveTreePatternEdges, ringOrderedDomainIds, rotateSlug, serializeCanonical, validateEdgeProperties, validateProductStageStrict, validateUPGDocument, validateUPGFramework, validationProfileFor, walkMigrationChainToCanonical };