Checkpoint source 7 workflows and in-progress diagram authoring redesign

Preserve current core, source, REST, desktop, recovery, documentation and validation work, including AGENTS.md and the development summary. This is a work-in-progress checkpoint: the new compact palette has outstanding compilation errors and native acceptance; earlier passing gates retain their documented scope.

crates/oa-core/src/semantic/catalog.rs

@@ -81,6 +81,35 @@ impl Own {
         }
         let kind = enum_tag(value)?.to_string();
         prefix.push(kind.clone());
+        let mut whole = whole;
+        if let Some(SharedBody::Occurrence {
+            body:
+                OccurrenceBody::Exchange {
+                    message_kind: MessageKind::Call | MessageKind::Asynchronous,
+                    ..
+                },
+            ..
+        }) = project.elements.get(&id).and_then(Element::shared)
+            && project.layer_of(id) == Some(Layer::Sa)
+            && crate::validation::ancestor_of_kind(project, id, Kind::Scenario)
+                .and_then(|id| project.elements.get(&id))
+                .and_then(Element::shared)
+                .is_some_and(|body| {
+                    matches!(
+                        body,
+                        SharedBody::Scenario {
+                            viewpoint: ScenarioViewpoint::BoundaryInterface,
+                            ..
+                        }
+                    )
+                })
+        {
+            let mut operation_path = prefix.clone();
+            operation_path.extend(["body".into(), "Exchange".into()]);
+            if let Some(body) = at_mut(&mut whole, &operation_path).and_then(Value::as_object_mut) {
+                body.entry("operation").or_insert(Value::Null);
+            }
+        }
         Some(Self {
             whole,
             prefix,
@@ -163,6 +192,9 @@ fn path(own: &Own, facet: &FacetSelector) -> Option<Vec<String>> {
         F::Occurrence(OccurrenceFacet::ReplyTo) => {
             ("Occurrence", &["body", "Exchange", "reply_to"])
         }
+        F::Occurrence(OccurrenceFacet::Operation) => {
+            ("Occurrence", &["body", "Exchange", "operation"])
+        }
         F::Occurrence(OccurrenceFacet::Action) => ("Occurrence", &["body", "Action", "action"]),
         F::Occurrence(OccurrenceFacet::ActionLifeline) => {
             ("Occurrence", &["body", "Action", "lifeline"])
@@ -192,8 +224,12 @@ fn path(own: &Own, facet: &FacetSelector) -> Option<Vec<String>> {
         F::State(StateFacet::DoActivity) => ("State", &["do_activity"]),
         F::Constraint(ConstraintFacet::Expression) => ("Constraint", &["expression"]),
         F::Category(CategoryFacet::Family) => ("ExchangeCategory", &["family"]),
-        F::Relation(RelationFacet::Source) => ("*", &["source"]),
-        F::Relation(RelationFacet::Target) => ("*", &["target"]),
+        F::Relation(RelationFacet::Source) if own.kind != "ContextualLink" => ("*", &["source"]),
+        F::Relation(RelationFacet::Target) if own.kind != "ContextualLink" => ("*", &["target"]),
+        F::Relation(RelationFacet::ContextOwner) => ("ContextualLink", &["owner"]),
+        F::Relation(RelationFacet::ContextSource) => ("ContextualLink", &["source"]),
+        F::Relation(RelationFacet::ContextTarget) => ("ContextualLink", &["target"]),
+        F::Relation(RelationFacet::ContextPurpose) => ("ContextualLink", &["purpose"]),
         F::Relation(RelationFacet::AllocationOrder) => ("InterfaceItemAllocation", &["order"]),
         F::Relation(RelationFacet::Transmission) => ("InterfaceItemAllocation", &["transmission"]),
         F::Relation(RelationFacet::Acquisition) => ("InterfaceItemAllocation", &["acquisition"]),
@@ -926,6 +962,7 @@ mod coverage {
         ] {
             add(SharedBody::Occurrence {
                 body: OccurrenceBody::Exchange {
+                    operation: None,
                     exchange: Some(id),
                     sender: Some(id),
                     receiver: Some(id),

crates/oa-core/src/semantic/historical.rs

@@ -171,6 +171,31 @@ impl Historical for LifelineBinding {
         w.at("local", |w| self.local.walk(w));
     }
 }
+impl Historical for OperationUse {
+    fn walk(&mut self, w: &mut Walk<'_>) {
+        w.at("allocation", |w| self.allocation.walk(w));
+    }
+}
+impl Historical for OccurrenceEndpoint {
+    fn walk(&mut self, w: &mut Walk<'_>) {
+        if self.references.len() > crate::topology_context::MAX_REFERENCE_DEPTH {
+            w.error("historical contextual path depth exceeded");
+        }
+        w.at("references", |w| self.references.walk(w));
+        w.at("occurrence", |w| self.occurrence.walk(w));
+    }
+}
+impl Historical for ContextualLinkPurpose {
+    fn walk(&mut self, w: &mut Walk<'_>) {
+        match self {
+            Self::Precedence { guard } => w.at("Precedence", |w| w.at("guard", |w| guard.walk(w))),
+            Self::Exchange { exchange } => {
+                w.at("Exchange", |w| w.at("exchange", |w| exchange.walk(w)))
+            }
+            Self::CommonWork { work } => w.at("CommonWork", |w| w.at("work", |w| work.walk(w))),
+        }
+    }
+}
 impl Historical for DataValue {
     fn walk(&mut self, w: &mut Walk<'_>) {
         match self {

crates/oa-core/src/semantic/mutate.rs

@@ -518,7 +518,11 @@ pub(crate) fn constructor_contains(group: &FacetSelector, facet: &FacetSelector)
         }
         F::Occurrence(OccurrenceFacet::MessageKind) => matches!(
             facet,
-            F::Occurrence(OccurrenceFacet::MessageKind | OccurrenceFacet::TimerExpression)
+            F::Occurrence(
+                OccurrenceFacet::MessageKind
+                    | OccurrenceFacet::TimerExpression
+                    | OccurrenceFacet::Operation
+            )
         ),
         F::Event(EventFacet::Constructor) => matches!(
             facet,

crates/oa-core/src/semantic/types.rs

@@ -112,6 +112,7 @@ macro_rules! scalar_families {
             Constructor: OccurrenceConstructor, Precondition: String, Postcondition: String,
             Exchange: Option<Id>, Sender: Option<Id>, Receiver: Option<Id>,
             MessageKind: MessageConstructor, TimerExpression: String, ReplyTo: Option<Id>,
+            Operation: Option<OperationUse>,
             Action: Option<Id>, ActionLifeline: Option<Id>, ControlKind: ControlKind,
             Sequence: Option<Id>, Scenario: Option<Id>, State: Option<Id>,
             StateLifeline: Option<Id>, FragmentOperator: FragmentOperator, BranchGuard: String
@@ -129,6 +130,8 @@ macro_rules! scalar_families {
             SourcePort: Id, TargetPort: Id, Oriented: bool, ExtendCondition: String,
             SequenceGuard: String, TransitionKind: TransitionKind, Trigger: String,
             Guard: String, Effect: String, StateActionPhase: StateActionKind
+            , ContextOwner: Id, ContextSource: OccurrenceEndpoint, ContextTarget: OccurrenceEndpoint,
+            ContextPurpose: ContextualLinkPurpose
         }
     }};
 }