In++ 2.0

Meta-Model

20 Core Entities

intenture, Intent, Object, Conception, Vision, Will to Embodiment, Actor, Artifact, Constraint, Value, Metric, State, Transition, Signal, Evidence, Expected Output, Explication Record, Knowledge Card, Composition (v1.8), Vergil (v1.8).

> New in v1.8: Composition is the hierarchical parent-contains-children relation with constraint inheritance and value aggregation. Vergil is the Intenture Guide agent, primary decision-maker for operational matters of intenture realization.

Core Relations

expresses, explicates, acts_on, shapes, constrains, creates_value_for, informs, is_evidenced_by, is_measured_by, transitions_to, is_triggered_by, is_realized_as, is_performed_by, produces, targets, results_in, records, depends_on, enables, conflicts_with, shares_constraint_with, shares_actor_with, informed_by + Composition relations (contains, parent_of, inherits_constraint_from, allocates_from, contributes_to_value) (v1.8).

22 Semantic Formulas

#	Formula
1	Intent acts_on Object
2	intenture is_constrained_by Constraint
3	intenture creates_value_for Actor
4	intenture is_evidenced_by Evidence
5	Value is_measured_by Metric
6	Explication (process) produces Explication Record
7	Explication (process) is_performed_by Actor (Vergil)
8	intenture results_in Expected Output
9	Artifact creates_value_for Actor
10	Transition is_triggered_by Signal
11	Explication Record records intenture
12	intenture depends_on intenture (cascading dependency between intents)
13	intenture enables intenture (realization of one opens possibility for another)
14	intenture conflicts_with intenture (potential conflict between intents)
15	intenture shares_constraint_with intenture (shared constraints)
16	intenture shares_actor_with intenture (shared actors)
17	intenture informed_by Knowledge Card (intenture uses structured knowledge from card)
18	Knowledge Card informed_by Knowledge Card (one card references another)
19	intenture contains intenture (parent compositionally contains child; hierarchy, not graph)
20	Constraint inherits_into intenture (parent's Constraint inherits into child via fixed pattern)
21	Value contributes_to Value (child's Value item covers parent's Value item)
22	Vergil governs intenture (Vergil manages lifecycle transitions, override approvals, complexity signaling in operational scope)

Inter-intenture Relations (graph - V2)

Relations between separate intenture within an Intenture Portfolio. Each linked intenture is a full entity with its own Canvas and Lifecycle.

Relation	Directionality	Semantics
depends_on	Directed (A depends_on B)	Realization of A is impossible or significantly hindered without realization of B
enables	Directed (A enables B)	Realization of A opens the possibility for realization of B
conflicts_with	Symmetric	A and B contain a potential conflict (in Constraints, resources, or goals)
shares_constraint_with	Symmetric	A and B share common Constraints (type specified: [budget], [timeline], [resource], etc.)
shares_actor_with	Symmetric	A and B share common Actors

Rules:

Cascading blocking via depends_on: if B is not Realizable or above, A cannot transition to Realizable

Conflict requires resolution: conflicts_with is a signal for Vergil to show and resolve

Shared constraints tracked jointly

Relations recorded on both sides

Composition Relations (tree - V1, introduced in v1.8)

Composition Relations describe the hierarchical structure of intenture (a tree), parallel to the graph of Inter-intenture Relations. Hierarchy differs from graph: parent intenture contains children as its parts with constraint inheritance, value aggregation, and readiness roll-up.

Relation	Directionality	Semantics
contains	Directed (P contains C)	C is part of P; P inherits C structurally; C inherits Constraints from P
parent_of	Reverse of contains (C parent_of P)	C declares its parent P
inherits_constraint_from	Derived (C inherits_constraint_from P)	Constraint Inheritance in one of 2 patterns
allocates_from	Derived (C allocates X from P)	Pool & Allocate: C gets allocated share of parent's resource
contributes_to_value	Directed (C value contributes_to P value)	Child's Value item covers parent's Value item

Composition rules:

Tree (not graph): one parent per child; cycles forbidden

Separability: child qualifies as sub-intenture only if it passes 4 tests (see Composition Hierarchy chapter)

Inheritance Pattern per Constraint type: each Constraint type has a fixed pattern (Inherit & Restrict or Pool & Allocate)

Override governance: override of inherited constraint allowed only for [quality] and [coordination]; forbidden always for [safety], [legal], [scope], [timeline]

Readiness roll-up via Value coverage: parent is ready for Realizable when each must-have Value item has at least one child with status ≥ Structured contributing_to it

Composition is separate from Inter-intenture Relations: the same child can simultaneously have composition.parent (hierarchy) and linked_intenture[].depends_on to cross-tree intentures (graph)

Minimum Unit

The minimum unit of Intenture is a structured fragment of intent in which at least one entity + one semantically valid relation with another entity, context, or expected result is fixed.

However, the minimum unit of the language does not equal the readiness threshold for realization. Realization begins only after passing the Critical Readiness Threshold.

Next:Syntax