Use diagram choice messages in Allocation drawing tests

crates/oa-desktop/src/app.rs

@@ -22,6 +22,8 @@ pub(crate) mod source_rename;
 mod source_symbols;
 pub(crate) mod text_workspace;
 #[cfg(test)]
+mod traceability_navigation_tests;
+#[cfg(test)]
 mod transition_context_tests;
 #[cfg(test)]
 mod view_copy_tests;
@@ -359,6 +361,7 @@ pub enum Message {
     Page(Page),
     Guide(crate::guide::Event),
     Traceability(crate::views::traceability::Event),
+    ReviewLayerTraces,
     Behavior(crate::behavior::Event),
     Layer(Layer),
     Select(Id),
@@ -2310,7 +2313,30 @@ impl App {
                         "Apply or revert pending edits before using modeling actions.".into();
                     return Task::none();
                 }
-                self.select(menu.request.object);
+                // Show acts on the diagram captured by the validated menu.
+                // Ordinary cross-layer selection would switch to that element's
+                // preferred same-layer view before the placement command runs.
+                let show_in_mixed_view = matches!(&*action, Message::PlaceSelected)
+                    && self
+                        .active_diagram
+                        .and_then(|id| self.project().diagrams.get(&id))
+                        .is_some_and(|d| {
+                            d.projection == ProjectionKind::Traceability
+                                && self
+                                    .project()
+                                    .elements
+                                    .get(&menu.request.object)
+                                    .is_some_and(|e| {
+                                        e.kind() != Kind::Port && d.projection.includes(e.kind())
+                                    })
+                        });
+                if show_in_mixed_view {
+                    self.selected = menu.request.object;
+                    self.selected_attachment = None;
+                    self.refresh_draft();
+                } else {
+                    self.select(menu.request.object);
+                }
                 self.selected_node = menu.request.placement;
                 self.selected_bend = menu.request.bend.map(|i| (menu.request.object, i));
                 return self.update(*action);
@@ -2508,6 +2534,23 @@ impl App {
                     iced::widget::scrollable::RelativeOffset::START,
                 );
             }
+            Message::ReviewLayerTraces => {
+                // Reuse Page navigation so modal, placement and behavior-form
+                // guards run before changing the transient inventory filter.
+                let navigation = self.update(Message::Page(Page::Traces));
+                if self.page == Page::Traces && !self.behavior.has_pending() {
+                    self.traceability.filter = crate::views::traceability::Filter::Traces;
+                    self.traceability.query.clear();
+                    return Task::batch([
+                        navigation,
+                        iced::widget::operation::snap_to(
+                            "traceability-list",
+                            iced::widget::scrollable::RelativeOffset::START,
+                        ),
+                    ]);
+                }
+                return navigation;
+            }
             Message::Search(value) => {
                 self.search = value;
                 self.explorer_page = 0;
@@ -4461,6 +4504,14 @@ impl App {
                 if !crate::connection_tool::Tool::for_layer(self.layer).contains(&tool) {
                     return;
                 }
+                if tool == crate::connection_tool::Tool::Allocation
+                    && !tool.available_in(
+                        self.layer,
+                        self.project().diagrams[&context.diagram].projection,
+                    )
+                {
+                    return;
+                }
                 self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
                 let context = self.route_context().unwrap();
                 self.connection = Some(Session::new(
@@ -4491,14 +4542,32 @@ impl App {
                 if let Some(source) = session.source {
                     match session.tool.command(self.project(), source, id) {
                         Ok(command) => {
+                            let previous_layer = self.layer;
+                            if session.tool == crate::connection_tool::Tool::Allocation {
+                                // Accepted edits belong to the captured view. A
+                                // retained mixed view can differ from the current
+                                // perspective; sync must not choose another view.
+                                self.layer = self.project().diagrams[&context.diagram].layer;
+                            }
                             if self.execute(command) {
                                 self.selected_node = None;
                                 self.inspector_tab = Default::default();
-                                self.status = format!(
-                                    "{} created · edit its name and carried items in Properties · Undo restores the complete operation",
-                                    session.tool.label()
-                                );
+                                self.status = if session.tool
+                                    == crate::connection_tool::Tool::Allocation
+                                {
+                                    format!(
+                                        "Allocated {} to {} · view filters are unchanged · Undo restores the complete operation",
+                                        self.project().named(id),
+                                        self.project().named(source)
+                                    )
+                                } else {
+                                    format!(
+                                        "{} created · edit its name and carried items in Properties · Undo restores the complete operation",
+                                        session.tool.label()
+                                    )
+                                };
                             } else {
+                                self.layer = previous_layer;
                                 self.connection = Some(session);
                             }
                         }
@@ -4513,7 +4582,18 @@ impl App {
                         &project_view(self.project(), context.diagram),
                         id,
                     );
-                    self.select(id);
+                    if session.tool == crate::connection_tool::Tool::Allocation
+                        && self.project().diagrams[&context.diagram].projection
+                            == ProjectionKind::Traceability
+                    {
+                        // Mixed views can allocate either perspective. Choosing
+                        // a visible source must not navigate to its preferred view.
+                        self.selected = id;
+                        self.selected_attachment = None;
+                        self.refresh_draft();
+                    } else {
+                        self.select(id);
+                    }
                     self.status = if session.candidates.is_empty() {
                         "No compatible targets are visible. Expand containers or show a compatible endpoint in this view; Esc cancels drawing.".into()
                     } else {

crates/oa-desktop/src/app/architecture_authoring.rs

@@ -301,6 +301,17 @@ impl App {
                     _ => return Task::none(),
                 };
                 let placing = point.is_none() && matches!(intent, Intent::Create { .. });
+                let filter = if matches!(intent, Intent::Existing { .. })
+                    && self
+                        .project()
+                        .diagrams
+                        .get(&diagram)
+                        .is_some_and(|d| d.projection == ProjectionKind::Traceability)
+                {
+                    Filter::AllCompatible
+                } else {
+                    Filter::Context
+                };
                 let saved = Saved {
                     version: 1,
                     base: oa_core::transitions::project_fingerprint(self.project()),
@@ -309,7 +320,7 @@ impl App {
                     point,
                     placing,
                     query: String::new(),
-                    filter: Filter::Context,
+                    filter,
                     show_placed: false,
                     page: 0,
                 };

crates/oa-desktop/src/app/architecture_authoring/palette.rs

@@ -229,13 +229,7 @@ pub fn view(app: &App) -> Element<'_, Message> {
     content = content.push(group("Connections"));
     for connection in crate::connection_tool::Tool::for_layer(app.layer) {
         let d = &app.project().diagrams[&app.active_diagram.unwrap()];
-        let kind = match connection {
-            crate::connection_tool::Tool::Interaction => Kind::Activity,
-            crate::connection_tool::Tool::FunctionalExchange => Kind::Function,
-            crate::connection_tool::Tool::CommunicationMean => Kind::Entity,
-            crate::connection_tool::Tool::BoundaryExchange => Kind::System,
-        };
-        if !d.projection.includes(kind) {
+        if !connection.available_in(app.layer, d.projection) {
             continue;
         }
         content = content.push(tool(

crates/oa-desktop/src/app/architecture_authoring/tests.rs

@@ -1,4 +1,5 @@
 use super::*;
+mod traceability;
 
 fn setup(layer: Layer) -> App {
     let mut app = App::with_project(Project::empty());

crates/oa-desktop/src/app/architecture_authoring/tests/traceability.rs

@@ -0,0 +1,124 @@
+use super::*;
+
+#[test]
+fn traceability_existing_defaults_show_opposite_layer_and_place_only_one_node() {
+    let mut project = Project::empty();
+    let sa = project
+        .add_element(Kind::Function, Layer::Sa, "Deliver report", None)
+        .unwrap();
+    let system = project
+        .add_element(Kind::System, Layer::Sa, "System", None)
+        .unwrap();
+    let diagram = project.ensure_diagram(Layer::Oa);
+    project.diagrams.get_mut(&diagram).unwrap().projection = ProjectionKind::Traceability;
+    let mut app = App::with_project(project);
+    app.page = Page::Diagram;
+    app.layer = Layer::Oa;
+    app.active_diagram = Some(diagram);
+    let before = app.document.snapshot();
+    send(&mut app, Event::Existing(None));
+    assert_eq!(
+        app.architecture.as_ref().unwrap().saved.filter,
+        Filter::AllCompatible
+    );
+    let listed = candidates(&app);
+    assert!(listed.iter().any(|(id, _, shown)| *id == sa && !shown));
+    assert!(listed.iter().any(|(id, _, shown)| *id == system && !shown));
+    send(&mut app, Event::Pick(sa));
+    assert!(app.architecture.as_ref().unwrap().saved.placing);
+    assert_eq!(app.project(), &before.decoded.project);
+    let context = app.route_context().unwrap();
+    let point = Position { x: 345., y: 215. };
+    send(&mut app, Event::Click(context, point));
+    assert!(app.architecture.is_none(), "{}", app.status);
+    assert_eq!(app.active_diagram, Some(diagram));
+    let placed = app.project().diagrams[&diagram]
+        .nodes
+        .values()
+        .find(|n| n.element == sa)
+        .unwrap()
+        .clone();
+    assert_eq!(placed.position, point);
+    let mut expected = before.decoded.project.clone();
+    expected
+        .diagrams
+        .get_mut(&diagram)
+        .unwrap()
+        .nodes
+        .insert(placed.id, placed);
+    assert_eq!(app.project(), &expected);
+    let accepted = app.document.bundle().clone();
+    let _ = app.update(Message::Undo);
+    assert_eq!(app.document.bundle(), &before.bundle);
+    assert!(!app.document.can_undo());
+    let _ = app.update(Message::Redo);
+    assert_eq!(app.project(), &expected);
+    assert_eq!(app.document.bundle(), &accepted);
+}
+
+#[test]
+fn traceability_default_does_not_change_creation_or_ordinary_picker_guards() {
+    let mut app = setup(Layer::Oa);
+    let diagram = app.active_diagram.unwrap();
+    send(&mut app, Event::Existing(None));
+    assert_eq!(
+        app.architecture.as_ref().unwrap().saved.filter,
+        Filter::Context
+    );
+    send(&mut app, Event::Cancel);
+    let _ = app.update(Message::Projection(ProjectionKind::Traceability));
+    send(&mut app, Event::Start(Kind::Entity, None));
+    assert_eq!(
+        app.architecture.as_ref().unwrap().saved.filter,
+        Filter::Context
+    );
+    send(&mut app, Event::Cancel);
+    assert_eq!(app.active_diagram, Some(diagram));
+
+    let mut project = app.project().clone();
+    let sa = project
+        .add_element(Kind::Function, Layer::Sa, "Other layer", None)
+        .unwrap();
+    let port = Id::new_v4();
+    project.elements.insert(
+        port,
+        oa_core::Element {
+            id: port,
+            alias: "legacy_port".into(),
+            name: "Port".into(),
+            description: String::new(),
+            parent: Some(sa),
+            body: ElementBody::shared_in(
+                Layer::Sa,
+                SharedBody::Port {
+                    contract: PortContract::Legacy,
+                    legacy: Some(LegacyPortContract {
+                        direction: PortDirection::InOut,
+                        interface: None,
+                    }),
+                },
+            ),
+        },
+    );
+    oa_core::validate_candidate(&project).unwrap();
+    for projection in [ProjectionKind::Overview, ProjectionKind::Traceability] {
+        let mut p = project.clone();
+        p.diagrams.get_mut(&diagram).unwrap().projection = projection;
+        let mut trial = App::with_project(p);
+        trial.page = Page::Diagram;
+        trial.active_diagram = Some(diagram);
+        trial.layer = Layer::Oa;
+        let before = trial.document.bundle().clone();
+        send(&mut trial, Event::Existing(None));
+        send(&mut trial, Event::Filter(Filter::AllCompatible));
+        assert_eq!(
+            candidates(&trial).iter().any(|(id, _, _)| *id == sa),
+            projection == ProjectionKind::Traceability
+        );
+        assert!(!candidates(&trial).iter().any(|(id, _, _)| *id == port));
+        send(&mut trial, Event::Pick(port));
+        assert!(!trial.architecture.as_ref().unwrap().saved.placing);
+        send(&mut trial, Event::Cancel);
+        assert_eq!(trial.document.bundle(), &before);
+    }
+}

crates/oa-desktop/src/app/traceability_navigation_tests.rs

@@ -0,0 +1,277 @@
+use super::*;
+use crate::{context_menu::Entry, model_menu, views::traceability::Filter};
+
+fn send(app: &mut App, message: Message) {
+    let _ = app.update(message);
+}
+
+fn fixture() -> (App, Id, Id, Id, Id) {
+    let mut p = Project::empty();
+    let oa = p
+        .add_element(Kind::Activity, Layer::Oa, "Observe", None)
+        .unwrap();
+    let sa = p
+        .add_element(Kind::Function, Layer::Sa, "Detect", None)
+        .unwrap();
+    let mixed = p.ensure_diagram(Layer::Oa);
+    p.diagrams.get_mut(&mixed).unwrap().projection = ProjectionKind::Traceability;
+    p.place(mixed, oa, Position { x: 300., y: 200. });
+    let system = p.ensure_diagram(Layer::Sa);
+    p.place(system, sa, Position { x: 700., y: 200. });
+    oa_core::validate_candidate(&p).unwrap();
+    let mut app = App::with_project(p);
+    app.page = Page::Diagram;
+    app.layer = Layer::Oa;
+    app.active_diagram = Some(mixed);
+    app.selected = oa;
+    app.refresh_draft();
+    app.traceability.filter = Filter::Artifacts;
+    app.traceability.query = "stale artifact query".into();
+    (app, mixed, system, oa, sa)
+}
+
+fn show_action(app: &mut App, element: Id) -> Message {
+    send(app, model_menu::open(element, iced::Point::ORIGIN));
+    model_menu::popup(app)
+        .unwrap()
+        .entries
+        .into_iter()
+        .find_map(|entry| match entry {
+            Entry::Action { label, message, .. } if label == "Show in this diagram" => {
+                Some(message)
+            }
+            _ => None,
+        })
+        .expect("eligible real menu action")
+        .expect("eligible menu action must be enabled")
+}
+
+#[test]
+fn review_layer_traces_resets_inventory_without_applying_property_or_source_drafts() {
+    for source_draft in [false, true] {
+        let (mut app, mixed, _, oa, _) = fixture();
+        if source_draft {
+            send(&mut app, Message::Page(Page::Text));
+            send(
+                &mut app,
+                Message::SourceEdit(iced::widget::text_editor::Action::Edit(
+                    iced::widget::text_editor::Edit::Insert('x'),
+                )),
+            );
+            assert!(app.source_dirty());
+        } else {
+            send(
+                &mut app,
+                Message::Field("/alias".into(), "invalid alias".into()),
+            );
+            assert!(app.draft_dirty());
+        }
+        let raw = serde_json::to_value(app.draft.as_ref().unwrap().recovery_snapshot()).unwrap();
+        let source = app.source_editor.text();
+        let before = app.document.snapshot();
+        let camera = (app.zoom, app.pan);
+        send(&mut app, Message::ReviewLayerTraces);
+        assert_eq!(app.page, Page::Traces);
+        assert_eq!(app.traceability.filter, Filter::Traces);
+        assert!(app.traceability.query.is_empty());
+        assert_eq!(
+            (app.layer, app.active_diagram, app.selected),
+            (Layer::Oa, Some(mixed), oa)
+        );
+        assert_eq!((app.zoom, app.pan), camera);
+        assert_eq!(
+            serde_json::to_value(app.draft.as_ref().unwrap().recovery_snapshot()).unwrap(),
+            raw
+        );
+        assert_eq!(app.source_editor.text(), source);
+        assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
+        assert!(!app.document.can_undo());
+    }
+}
+
+#[test]
+fn review_layer_traces_respects_busy_modal_and_active_placement_guards() {
+    for already_traces in [false, true] {
+        for guard in 0..5 {
+            let (mut app, mixed, _, oa, _) = fixture();
+            match guard {
+                0 => app.busy = true,
+                1 => app.delete_pending = true,
+                2 => app.hosted.visible = true,
+                3 => send(
+                    &mut app,
+                    Message::Architecture(architecture_authoring::Event::Existing(None)),
+                ),
+                4 => {
+                    app.page = Page::Behavior;
+                    let p = app.project().clone();
+                    app.behavior
+                        .creation
+                        .update(&p, behavior::creation::Event::Open(Layer::Oa))
+                        .unwrap();
+                    assert!(app.behavior.has_pending());
+                }
+                _ => unreachable!(),
+            }
+            if already_traces {
+                app.page = Page::Traces;
+            }
+            let original_page = app.page;
+            let before = app.document.snapshot();
+            let behavior_before = app.behavior.recovery_snapshot().unwrap();
+            send(&mut app, Message::ReviewLayerTraces);
+            assert_eq!(
+                app.page, original_page,
+                "guard {guard}, already traces {already_traces}"
+            );
+            assert_eq!(app.traceability.filter, Filter::Artifacts);
+            assert_eq!(app.traceability.query, "stale artifact query");
+            assert_eq!(
+                (app.layer, app.active_diagram, app.selected),
+                (Layer::Oa, Some(mixed), oa)
+            );
+            assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
+            assert_eq!(app.behavior.recovery_snapshot().unwrap(), behavior_before);
+            if guard == 3 {
+                assert!(app.architecture.is_some());
+            }
+        }
+    }
+}
+
+#[test]
+fn mixed_view_show_keeps_its_context_for_every_diagram_app_and_target_layer() {
+    for diagram_layer in [Layer::Oa, Layer::Sa] {
+        for app_layer in [Layer::Oa, Layer::Sa] {
+            for target_layer in [Layer::Oa, Layer::Sa] {
+                let mut p = Project::empty();
+                let oa = p
+                    .add_element(Kind::Activity, Layer::Oa, "Observe", None)
+                    .unwrap();
+                let sa = p
+                    .add_element(Kind::Function, Layer::Sa, "Detect", None)
+                    .unwrap();
+                let target = if target_layer == Layer::Oa { oa } else { sa };
+                let other = if target_layer == Layer::Oa { sa } else { oa };
+                let mixed = p.ensure_diagram(diagram_layer);
+                p.diagrams.get_mut(&mixed).unwrap().projection = ProjectionKind::Traceability;
+                // An attractive same-layer alternative makes accidental
+                // semantic-selection navigation observable in both directions.
+                let mut alternative = p.diagrams[&mixed].clone();
+                alternative.id = Id::new_v4();
+                alternative.alias = "same_layer_alternative".into();
+                alternative.layer = target_layer;
+                alternative.projection = ProjectionKind::Overview;
+                let alternative_id = alternative.id;
+                p.diagrams.insert(alternative_id, alternative);
+                p.place(alternative_id, target, Position { x: 700., y: 200. });
+                oa_core::validate_candidate(&p).unwrap();
+                let mut app = App::with_project(p);
+                app.page = Page::Diagram;
+                app.layer = app_layer;
+                app.active_diagram = Some(mixed);
+                app.selected = other;
+                app.refresh_draft();
+                let before = app.project().clone();
+                let action = show_action(&mut app, target);
+                send(&mut app, action);
+                // The existing RevealInDiagram action synchronizes the layer
+                // to the captured view, even if the prior perspective differed.
+                assert_eq!(
+                    (app.active_diagram, app.layer, app.selected),
+                    (Some(mixed), diagram_layer, target)
+                );
+                let added = app.project().diagrams[&mixed]
+                    .nodes
+                    .values()
+                    .find(|n| n.element == target)
+                    .unwrap()
+                    .clone();
+                assert_eq!(app.selected_node, Some(added.id));
+                let mut expected = before;
+                expected
+                    .diagrams
+                    .get_mut(&mixed)
+                    .unwrap()
+                    .nodes
+                    .insert(added.id, added);
+                assert_eq!(app.project(), &expected);
+            }
+        }
+    }
+}
+
+#[test]
+fn mixed_view_show_menu_places_in_captured_view_with_exact_undo_redo() {
+    let (mut app, mixed, system, _, sa) = fixture();
+    let before = app.document.snapshot();
+    let action = show_action(&mut app, sa);
+    send(&mut app, action);
+    assert_eq!(
+        (app.active_diagram, app.layer, app.selected),
+        (Some(mixed), Layer::Oa, sa)
+    );
+    let added = app.project().diagrams[&mixed]
+        .nodes
+        .values()
+        .find(|n| n.element == sa)
+        .unwrap()
+        .clone();
+    assert_eq!(added.position, Position { x: 60., y: 60. });
+    let mut expected = before.decoded.project.clone();
+    expected
+        .diagrams
+        .get_mut(&mixed)
+        .unwrap()
+        .nodes
+        .insert(added.id, added);
+    assert_eq!(app.project(), &expected);
+    assert_eq!(
+        app.project().diagrams[&system],
+        before.decoded.project.diagrams[&system]
+    );
+    let after = app.document.snapshot();
+    send(&mut app, Message::Undo);
+    assert_eq!(app.project(), &before.decoded.project);
+    assert_eq!(app.document.bundle(), &before.bundle);
+    assert!(!app.document.can_undo());
+    send(&mut app, Message::Redo);
+    assert_eq!(app.project(), &after.decoded.project);
+    assert_eq!(app.document.bundle(), &after.bundle);
+}
+
+#[test]
+fn mixed_view_show_menu_rejects_stale_context_and_pending_property_changes() {
+    for refusal in 0..3 {
+        let (mut app, mixed, system, oa, sa) = fixture();
+        let action = show_action(&mut app, sa);
+        match refusal {
+            0 => app.active_diagram = Some(system),
+            1 => app.canvas_epoch = app.canvas_epoch.wrapping_add(1),
+            2 => {
+                // A queued action must not apply a draft that became dirty
+                // after the menu was rendered, even when its context is valid.
+                app.draft
+                    .as_mut()
+                    .unwrap()
+                    .input("/name", "Unapplied name".into());
+                assert!(app.draft_dirty());
+            }
+            _ => unreachable!(),
+        }
+        let before = app.document.snapshot();
+        let raw = serde_json::to_value(app.draft.as_ref().unwrap().recovery_snapshot()).unwrap();
+        send(&mut app, action);
+        assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
+        assert_eq!(app.selected, oa);
+        assert_eq!(
+            app.active_diagram,
+            Some(if refusal == 0 { system } else { mixed })
+        );
+        assert_eq!(
+            serde_json::to_value(app.draft.as_ref().unwrap().recovery_snapshot()).unwrap(),
+            raw
+        );
+        assert!(!app.document.can_undo());
+    }
+}

crates/oa-desktop/src/connection_allocation_tests.rs

@@ -0,0 +1,480 @@
+// Included in connection_edit::tests: exercise the real application event path.
+use oa_core::projection::project_view;
+
+fn allocation_fixture(layer: Layer, projection: ProjectionKind) -> (App, Id, Id, Id) {
+    let mut project = Project::empty();
+    let (performer_kind, work_kind) = match layer {
+        Layer::Oa => (Kind::Entity, Kind::Activity),
+        Layer::Sa => (Kind::System, Kind::Function),
+    };
+    let performer = project.add(performer_kind, "Assigned performer", 20., 20.);
+    let work = project.add(work_kind, "Existing leaf work", 420., 20.);
+    let diagram = project.ensure_diagram(layer);
+    project.diagrams.get_mut(&diagram).unwrap().projection = projection;
+    let reference_id = Id::new_v4();
+    let mut reference = project.diagrams[&diagram].clone();
+    reference.id = reference_id;
+    reference.alias = project.fresh_alias("Reference view", "diagram", reference_id);
+    reference.name = "Reference view".into();
+    reference.nodes.clear();
+    project.diagrams.insert(reference_id, reference);
+    project.place(reference_id, performer, Position { x: 80., y: 100. });
+    project.place(reference_id, work, Position { x: 500., y: 300. });
+    let mut app = App::with_project(project);
+    let _ = app.update(Message::Diagram(crate::app::Choice {
+        id: diagram,
+        label: app.project().diagrams[&diagram].name.clone(),
+    }));
+    (app, performer, work, diagram)
+}
+
+fn start_allocation(app: &mut App, performer: Id) -> Context {
+    send(app, Event::Choose(Some(Tool::Allocation)));
+    let context = app.route_context().unwrap();
+    assert!(
+        app.connection
+            .as_ref()
+            .unwrap()
+            .candidates
+            .contains(&performer)
+    );
+    send(app, Event::Endpoint(context, performer));
+    assert_eq!(app.connection.as_ref().unwrap().source, Some(performer));
+    context
+}
+
+#[test]
+fn allocation_projection_eligibility_requires_both_endpoint_categories() {
+    for layer in [Layer::Oa, Layer::Sa] {
+        for projection in [
+            ProjectionKind::Overview,
+            ProjectionKind::Decomposition,
+            ProjectionKind::Traceability,
+            ProjectionKind::Allocation,
+        ] {
+            assert!(Tool::Allocation.available_in(layer, projection));
+        }
+        for projection in [
+            ProjectionKind::FunctionalDataflow,
+            ProjectionKind::Capabilities,
+            ProjectionKind::StateMachine {
+                machine: Id::new_v4(),
+            },
+        ] {
+            assert!(!Tool::Allocation.available_in(layer, projection));
+        }
+        for projection in [
+            ProjectionKind::FunctionalDataflow,
+            ProjectionKind::Capabilities,
+        ] {
+            let (mut app, _, _, _) = allocation_fixture(layer, projection);
+            let before = app.document.bundle().clone();
+            send(&mut app, Event::Choose(Some(Tool::Allocation)));
+            assert!(app.connection.is_none());
+            assert_eq!(app.document.bundle(), &before);
+        }
+    }
+    // The new predicate retains the four established exchange-tool policies.
+    assert!(Tool::Interaction.available_in(Layer::Oa, ProjectionKind::FunctionalDataflow));
+    assert!(Tool::FunctionalExchange.available_in(Layer::Sa, ProjectionKind::FunctionalDataflow));
+    assert!(Tool::CommunicationMean.available_in(Layer::Oa, ProjectionKind::Capabilities));
+    assert!(Tool::BoundaryExchange.available_in(Layer::Sa, ProjectionKind::Capabilities));
+    assert!(!Tool::FunctionalExchange.available_in(Layer::Oa, ProjectionKind::Overview));
+}
+
+#[test]
+fn allocation_canvas_commits_only_one_relation_with_exact_source_undo_redo() {
+    use oa_core::source_project::{ProjectLimits, compile_bundle};
+    for layer in [Layer::Oa, Layer::Sa] {
+        for projection in [
+            ProjectionKind::Overview,
+            ProjectionKind::Decomposition,
+            ProjectionKind::Traceability,
+            ProjectionKind::Allocation,
+        ] {
+            let (mut app, performer, work, diagram) = allocation_fixture(layer, projection);
+            let original = app.project().clone();
+            let before = app.document.bundle().clone();
+            let revision = app.document.revision();
+            let context = start_allocation(&mut app, performer);
+            assert_eq!(app.document.bundle(), &before);
+            send(&mut app, Event::Endpoint(context, work));
+            assert!(app.connection.is_none());
+            assert_eq!(app.document.revision(), revision + 1);
+            let relation = &app.project().relations[&app.selected];
+            let name = "Allocation: Assigned performer → Existing leaf work";
+            let expected_relation = Relation {
+                id: relation.id,
+                alias: original.fresh_alias(name, "relation", relation.id),
+                name: name.into(),
+                description: String::new(),
+                body: RelationBody::new(RelationKind::Allocation, performer, work),
+            };
+            let relation_id = relation.id;
+            let mut expected = original.clone();
+            expected.relations.insert(relation_id, expected_relation);
+            assert_eq!(app.project(), &expected, "Only the new relation may change");
+            assert_eq!(app.active_diagram, Some(diagram));
+            assert!(
+                app.status
+                    .contains("Allocated Existing leaf work to Assigned performer")
+            );
+            let projected = project_view(app.project(), diagram);
+            if projection == ProjectionKind::Allocation {
+                assert!(!projected.edges.iter().any(|edge| edge.id == relation_id));
+                let owner = projected
+                    .nodes
+                    .iter()
+                    .find(|node| node.element == performer)
+                    .unwrap();
+                let child = projected
+                    .nodes
+                    .iter()
+                    .find(|node| node.element == work)
+                    .unwrap();
+                assert_eq!(child.visual_parent, Some(owner.id));
+            } else {
+                assert!(projected.edges.iter().any(|edge| edge.id == relation_id));
+            }
+            let after = app.document.bundle().clone();
+            assert_eq!(
+                compile_bundle(&after, ProjectLimits::default())
+                    .unwrap()
+                    .decoded
+                    .project,
+                expected
+            );
+            send(&mut app, Event::Endpoint(context, work));
+            assert_eq!(
+                app.document.revision(),
+                revision + 1,
+                "Repeated release is not another transaction"
+            );
+            let _ = app.update(Message::Undo);
+            assert_eq!(app.project(), &original);
+            assert_eq!(app.document.bundle(), &before);
+            let _ = app.update(Message::Redo);
+            assert_eq!(app.project(), &expected);
+            assert_eq!(app.document.bundle(), &after);
+        }
+    }
+}
+
+#[test]
+fn allocation_candidates_reject_nonleaf_occupied_cross_layer_port_and_hidden_work() {
+    for layer in [Layer::Oa, Layer::Sa] {
+        let (base, performer, work, diagram) =
+            allocation_fixture(layer, ProjectionKind::Traceability);
+        let mut project = base.project().clone();
+        let work_kind = project.elements[&work].kind();
+        let composite = project
+            .add_element(work_kind, layer, "Composite work", None)
+            .unwrap();
+        project
+            .add_element(work_kind, layer, "Child work", Some(composite))
+            .unwrap();
+        let occupied = project
+            .add_element(work_kind, layer, "Occupied work", None)
+            .unwrap();
+        let allocation = Tool::Allocation
+            .command(&project, performer, occupied)
+            .unwrap();
+        project = prepare_command(&project, &allocation).unwrap().project;
+        let hidden = project
+            .add_element(work_kind, layer, "Unplaced work", None)
+            .unwrap();
+        let other_layer = if layer == Layer::Oa {
+            Layer::Sa
+        } else {
+            Layer::Oa
+        };
+        let other_kind = if other_layer == Layer::Oa {
+            Kind::Activity
+        } else {
+            Kind::Function
+        };
+        let foreign = project
+            .add_element(other_kind, other_layer, "Other perspective", None)
+            .unwrap();
+        let foreign_performer_kind = if other_layer == Layer::Oa {
+            Kind::Actor
+        } else {
+            Kind::SystemActor
+        };
+        let foreign_performer = project
+            .add_element(foreign_performer_kind, other_layer, "Other performer", None)
+            .unwrap();
+        for (index, id) in [composite, occupied, foreign, foreign_performer]
+            .into_iter()
+            .enumerate()
+        {
+            project.place(
+                diagram,
+                id,
+                Position {
+                    x: index as f32 * 300.,
+                    y: 400.,
+                },
+            );
+        }
+        let port_owner = if layer == Layer::Sa { work } else { foreign };
+        let port_id = Id::new_v4();
+        let port = make_port(
+            &project,
+            port_id,
+            port_owner,
+            "Work input",
+            PortContract::FunctionInput {
+                incoming_items: vec![],
+            },
+        )
+        .unwrap();
+        project.elements.insert(port_id, port);
+        let mut app = App::with_project(project);
+        let _ = app.update(Message::Diagram(crate::app::Choice {
+            id: diagram,
+            label: app.project().diagrams[&diagram].name.clone(),
+        }));
+        let before = app.document.bundle().clone();
+        let original = app.project().clone();
+        let revision = app.document.revision();
+        send(&mut app, Event::Choose(Some(Tool::Allocation)));
+        assert!(
+            app.connection
+                .as_ref()
+                .unwrap()
+                .candidates
+                .contains(&foreign_performer)
+        );
+        let context = app.route_context().unwrap();
+        send(&mut app, Event::Endpoint(context, performer));
+        assert!(app.connection.as_ref().unwrap().candidates.contains(&work));
+        assert!(Tool::Allocation.can_connect(app.project(), performer, hidden));
+        for target in [composite, occupied, foreign, port_id, hidden, performer] {
+            assert!(
+                !app.connection
+                    .as_ref()
+                    .unwrap()
+                    .candidates
+                    .contains(&target)
+            );
+            send(&mut app, Event::Endpoint(context, target));
+            assert_eq!(app.document.revision(), revision);
+            assert_eq!(app.project(), &original);
+            assert_eq!(app.document.bundle(), &before);
+        }
+        for target in [composite, occupied, foreign, port_id, performer] {
+            assert!(
+                Tool::Allocation
+                    .command(app.project(), performer, target)
+                    .is_err()
+            );
+        }
+        send(&mut app, Event::Endpoint(context, work));
+        assert_eq!(
+            app.document.revision(),
+            revision + 1,
+            "Invalid clicks do not prevent recovery"
+        );
+    }
+}
+
+#[test]
+fn allocation_creation_preserves_saved_edge_filters() {
+    let (base, performer, work, diagram) =
+        allocation_fixture(Layer::Oa, ProjectionKind::Decomposition);
+    let mut project = base.project().clone();
+    project
+        .diagrams
+        .get_mut(&diagram)
+        .unwrap()
+        .view_options
+        .relation_kinds = oa_core::view_options::RelationKinds::Only(vec![]);
+    let diagrams = project.diagrams.clone();
+    let mut app = App::with_project(project);
+    let _ = app.update(Message::Diagram(crate::app::Choice {
+        id: diagram,
+        label: app.project().diagrams[&diagram].name.clone(),
+    }));
+    let context = start_allocation(&mut app, performer);
+    send(&mut app, Event::Endpoint(context, work));
+    assert_eq!(
+        app.project().relations[&app.selected].kind(),
+        RelationKind::Allocation
+    );
+    assert_eq!(app.project().diagrams, diagrams);
+    assert!(project_view(app.project(), diagram).edges.is_empty());
+    assert!(app.status.contains("view filters are unchanged"));
+}
+
+#[test]
+fn allocation_mixed_view_keeps_captured_canvas_for_opposite_layer_pairs() {
+    for owner_layer in [Layer::Oa, Layer::Sa] {
+        for app_layer in [Layer::Oa, Layer::Sa] {
+            let (base, owner_performer, owner_work, diagram) =
+                allocation_fixture(owner_layer, ProjectionKind::Traceability);
+            let mut project = base.project().clone();
+            let layer = if owner_layer == Layer::Oa {
+                Layer::Sa
+            } else {
+                Layer::Oa
+            };
+            let (performer_kind, work_kind) = if layer == Layer::Oa {
+                (Kind::Actor, Kind::Activity)
+            } else {
+                (Kind::SystemActor, Kind::Function)
+            };
+            let performer = project.add(performer_kind, "Opposite-layer performer", 40., 60.);
+            let work = project.add(work_kind, "Opposite-layer work", 420., 60.);
+            project.place(diagram, performer, Position { x: 40., y: 350. });
+            project.place(diagram, work, Position { x: 420., y: 350. });
+            let mut app = App::with_project(project);
+            let _ = app.update(Message::Diagram(crate::app::Choice {
+                id: diagram,
+                label: app.project().diagrams[&diagram].name.clone(),
+            }));
+            let _ = app.update(Message::Pan(iced::Vector::new(73., 29.)));
+            app.layer = app_layer;
+            let camera = (app.pan, app.zoom);
+            let before = app.document.bundle().clone();
+            let original = app.project().clone();
+            let revision = app.document.revision();
+            let cancelled = start_allocation(&mut app, performer);
+            let _ = app.update(Message::Escape);
+            send(&mut app, Event::Endpoint(cancelled, work));
+            assert!(app.connection.is_none());
+            assert_eq!(app.layer, app_layer);
+            assert_eq!(app.active_diagram, Some(diagram));
+            assert_eq!((app.pan, app.zoom), camera);
+            assert_eq!(app.document.bundle(), &before);
+            let context = start_allocation(&mut app, performer);
+            assert_eq!(app.active_diagram, Some(diagram));
+            assert_eq!(app.layer, app_layer);
+            assert_eq!(app.route_context(), Some(context));
+            assert_eq!((app.pan, app.zoom), camera);
+            assert_eq!(app.selected, performer);
+            assert!(app.connection.as_ref().unwrap().candidates.contains(&work));
+            for wrong_target in [owner_performer, owner_work] {
+                assert!(
+                    !app.connection
+                        .as_ref()
+                        .unwrap()
+                        .candidates
+                        .contains(&wrong_target)
+                );
+                send(&mut app, Event::Endpoint(context, wrong_target));
+                assert_eq!(app.project(), &original);
+                assert_eq!(app.layer, app_layer);
+                assert_eq!(app.active_diagram, Some(diagram));
+                assert_eq!((app.pan, app.zoom), camera);
+                assert_eq!(app.document.bundle(), &before);
+            }
+            send(&mut app, Event::Endpoint(context, work));
+            assert!(app.connection.is_none());
+            assert_eq!(app.document.revision(), revision + 1);
+            assert_eq!(app.active_diagram, Some(diagram));
+            assert_eq!(app.layer, owner_layer);
+            assert_eq!((app.pan, app.zoom), camera);
+            let relation = &app.project().relations[&app.selected];
+            assert_eq!(
+                relation.body,
+                RelationBody::new(RelationKind::Allocation, performer, work)
+            );
+            let mut expected = original.clone();
+            expected.relations.insert(relation.id, relation.clone());
+            assert_eq!(app.project(), &expected);
+            let after = app.document.bundle().clone();
+            let _ = app.update(Message::Undo);
+            assert_eq!(app.project(), &original);
+            assert_eq!(app.document.bundle(), &before);
+            assert_eq!(app.active_diagram, Some(diagram));
+            assert_eq!((app.pan, app.zoom), camera);
+            let _ = app.update(Message::Redo);
+            assert_eq!(app.project(), &expected);
+            assert_eq!(app.document.bundle(), &after);
+            assert_eq!(app.active_diagram, Some(diagram));
+            assert_eq!((app.pan, app.zoom), camera);
+        }
+    }
+}
+
+#[test]
+fn allocation_cancel_navigation_stale_context_and_pending_edits_preserve_model() {
+    let (mut app, performer, work, diagram) =
+        allocation_fixture(Layer::Oa, ProjectionKind::Decomposition);
+    let original = app.project().clone();
+    let before = app.document.bundle().clone();
+    let old = start_allocation(&mut app, performer);
+    let _ = app.update(Message::Escape);
+    assert!(app.connection.is_none());
+    send(&mut app, Event::Endpoint(old, work));
+    let current = start_allocation(&mut app, performer);
+    send(&mut app, Event::Endpoint(old, work));
+    assert_eq!(app.connection.as_ref().unwrap().context, current);
+    let _ = app.update(Message::Page(Page::Catalog));
+    assert!(app.connection.is_none());
+    let _ = app.update(Message::Page(Page::Diagram));
+    let _ = app.update(Message::Diagram(crate::app::Choice {
+        id: diagram,
+        label: app.project().diagrams[&diagram].name.clone(),
+    }));
+    start_allocation(&mut app, performer);
+    send(&mut app, Event::Choose(None));
+    assert!(app.connection.is_none());
+    start_allocation(&mut app, performer);
+    send(&mut app, Event::Choose(Some(Tool::Interaction)));
+    assert_eq!(app.connection.as_ref().unwrap().tool, Tool::Interaction);
+    assert_eq!(app.project(), &original);
+    let current = start_allocation(&mut app, performer);
+    for stale in [
+        Context {
+            document: Id::new_v4(),
+            ..current
+        },
+        Context {
+            diagram: Id::new_v4(),
+            ..current
+        },
+        Context {
+            revision: current.revision + 1,
+            ..current
+        },
+    ] {
+        send(&mut app, Event::Endpoint(stale, work));
+        assert_eq!(app.connection.as_ref().unwrap().context, current);
+    }
+    app.delete_pending = true;
+    send(&mut app, Event::Endpoint(current, work));
+    assert_eq!(app.project(), &original);
+    let _ = app.update(Message::CancelDelete);
+    let _ = app.update(Message::Escape);
+    let _ = app.update(Message::Select(performer));
+    let _ = app.update(Message::Field(
+        "/name".into(),
+        "Unapplied performer name".into(),
+    ));
+    send(&mut app, Event::Choose(Some(Tool::Allocation)));
+    assert!(app.connection.is_none());
+    assert!(app.draft_dirty());
+    assert_eq!(app.project(), &original);
+    assert_eq!(app.document.bundle(), &before);
+
+    let (mut source_app, performer, work, _) =
+        allocation_fixture(Layer::Sa, ProjectionKind::Decomposition);
+    let before = source_app.document.bundle().clone();
+    let context = start_allocation(&mut source_app, performer);
+    use iced::widget::text_editor;
+    let _ = source_app.update(Message::SourceEdit(text_editor::Action::SelectAll));
+    let _ = source_app.update(Message::SourceEdit(text_editor::Action::Edit(
+        text_editor::Edit::Paste(std::sync::Arc::new("invalid raw source retained".into())),
+    )));
+    send(&mut source_app, Event::Endpoint(context, work));
+    send(&mut source_app, Event::Choose(Some(Tool::Allocation)));
+    assert!(source_app.connection.is_none());
+    assert!(source_app.source_dirty());
+    assert_eq!(
+        source_app.source_editor.text(),
+        "invalid raw source retained"
+    );
+    assert_eq!(source_app.document.bundle(), &before);
+}

crates/oa-desktop/src/connection_edit.rs

@@ -52,6 +52,8 @@ mod tests {
     use crate::app::{App, Message, Page};
     use oa_core::*;
 
+    include!("connection_allocation_tests.rs");
+
     fn fixture() -> (App, Id, Id, Id) {
         let mut p = Project::empty();
         let a = p.add(Kind::Function, "Send command", 0., 0.);

crates/oa-desktop/src/connection_tool.rs

@@ -9,13 +9,18 @@ pub enum Tool {
     CommunicationMean,
     FunctionalExchange,
     BoundaryExchange,
+    Allocation,
 }
 
 impl Tool {
     pub fn for_layer(layer: Layer) -> &'static [Self] {
         match layer {
-            Layer::Oa => &[Self::Interaction, Self::CommunicationMean],
-            Layer::Sa => &[Self::FunctionalExchange, Self::BoundaryExchange],
+            Layer::Oa => &[Self::Interaction, Self::CommunicationMean, Self::Allocation],
+            Layer::Sa => &[
+                Self::FunctionalExchange,
+                Self::BoundaryExchange,
+                Self::Allocation,
+            ],
         }
     }
 
@@ -25,11 +30,15 @@ impl Tool {
             Self::CommunicationMean => "Communication means",
             Self::FunctionalExchange => "Functional exchange",
             Self::BoundaryExchange => "Boundary exchange",
+            Self::Allocation => "Allocation",
         }
     }
 
     pub fn hint(self) -> &'static str {
         match self {
+            Self::Allocation => {
+                "Click a performer, then highlighted unallocated leaf work. In allocated-work views, allocation appears as nesting rather than a line."
+            }
             Self::Interaction => "Click a source activity, then a target activity.",
             Self::CommunicationMean => {
                 "Click an operational entity or actor, then another participant. Communication is bidirectional unless you change its orientation."
@@ -45,6 +54,10 @@ impl Tool {
 
     pub fn can_start(self, project: &Project, source: Id) -> bool {
         match self {
+            Self::Allocation => project
+                .elements
+                .get(&source)
+                .is_some_and(|e| e.kind().is_performer()),
             Self::CommunicationMean => project.elements.get(&source).is_some_and(|e| {
                 e.layer() == Layer::Oa && matches!(e.kind(), Kind::Entity | Kind::Actor)
             }),
@@ -65,6 +78,9 @@ impl Tool {
             return false;
         }
         match self {
+            Self::Allocation => {
+                validation::can_connect(project, RelationKind::Allocation, source, target)
+            }
             Self::CommunicationMean => {
                 validation::can_connect(project, RelationKind::CommunicationMean, source, target)
             }
@@ -140,6 +156,7 @@ impl Tool {
         }
         let name = engineering_name(project, self, source, target);
         let body = match self {
+            Self::Allocation => RelationBody::new(RelationKind::Allocation, source, target),
             Self::CommunicationMean => {
                 RelationBody::new(RelationKind::CommunicationMean, source, target)
             }
@@ -162,6 +179,28 @@ impl Tool {
         prepare_command(project, &command)?;
         Ok(command)
     }
+
+    /// Both endpoint categories must be supported before offering Allocation.
+    /// Preserve the established projection eligibility of the exchange tools.
+    pub fn available_in(self, layer: Layer, projection: ProjectionKind) -> bool {
+        if !Self::for_layer(layer).contains(&self) {
+            return false;
+        }
+        let kind = match self {
+            Self::Interaction => Kind::Activity,
+            Self::CommunicationMean => Kind::Entity,
+            Self::FunctionalExchange => Kind::Function,
+            Self::BoundaryExchange => Kind::System,
+            Self::Allocation => {
+                let (performer, work) = match layer {
+                    Layer::Oa => (Kind::Entity, Kind::Activity),
+                    Layer::Sa => (Kind::System, Kind::Function),
+                };
+                return projection.includes(performer) && projection.includes(work);
+            }
+        };
+        projection.includes(kind)
+    }
 }
 
 /// A clicked port determines its own function owner. It cannot be paired with
@@ -291,7 +330,7 @@ mod tests {
         let before = p.clone();
         assert_eq!(
             Tool::for_layer(Layer::Oa),
-            &[Tool::Interaction, Tool::CommunicationMean]
+            &[Tool::Interaction, Tool::CommunicationMean, Tool::Allocation]
         );
         assert_eq!(
             Tool::Interaction.targets(&p, source),
@@ -592,6 +631,8 @@ mod tests {
             (Tool::CommunicationMean, oa_team, oa_actor),
             (Tool::FunctionalExchange, sa_a, sa_b),
             (Tool::BoundaryExchange, boundary_a, boundary_b),
+            (Tool::Allocation, oa_team, oa_a),
+            (Tool::Allocation, system, sa_a),
         ] {
             let before = document.bundle().clone();
             let original = document.project().clone();

crates/oa-desktop/src/guide.rs

@@ -263,7 +263,8 @@ fn article(topic: Topic) -> Article {
                             &[
                                 "Choose the Operational or System perspective. Create participants using Entity/Actor in OA or System/System actor in SA.",
                                 "In the diagram's side palette, choose Activity in OA or Function in SA, click its position, enter a name and press Enter. Escape cancels without creating an element. Select a card and press F2 to rename it in place. For semantic decomposition, use Model explorer, select existing work and use + In selected to create smaller work units.",
-                                "Right-click a participant and choose Add activity or Add function to create new work and its allocation together. In Architecture · allocated work, drag existing work into a performer to assign it, between performers to reassign it, or onto empty canvas to remove its direct assignment. + Relationship with Allocation and Model explorer's + Allocated provide explicit alternatives.",
+                                "To allocate existing leaf work in Containment, choose Allocation in the diagram palette. Click a visible performer, then the highlighted Activity or Function it performs. The work must belong to the performer's layer and have no direct performer yet. In a mixed OA ↔ SA traceability view, either layer's performer can be used and the current view stays open. Completing the allocation sets the application perspective to that view's layer; choosing only a source or canceling leaves the prior perspective unchanged. Escape cancels. This creates a responsibility relationship without changing the work's semantic parent.",
+                                "Right-click a participant and choose Add activity or Add function to create new work and its allocation together. In Architecture · allocated work, drag existing work into a performer to assign it, between performers to reassign it, or onto empty canvas to remove its direct assignment. Create relationship… with Allocation and Model explorer's + Allocated provide explicit alternatives.",
                                 "Choose Architecture · allocated work to review responsibilities. Choose Functional dataflow to review the activity/function hierarchy and its exchanges independently.",
                             ],
                         ),
@@ -307,8 +308,8 @@ fn article(topic: Topic) -> Article {
                             "Choose and edit the relationship you mean",
                             &[
                                 "Use the diagram selector or + View to work with a focused diagram. View properties edits its name, perspective, projection and Saved view visibility. Apply changes commits the view settings.",
-                                "Choose Containment for semantic children, Architecture · allocated work for responsibilities, Functional dataflow for work and exchanges, or Missions & capabilities for outcomes. All relationships is a broader exploration view; OA ↔ SA traceability displays counterparts.",
-                                "Select an element and edit Semantic parent to change ownership. Use an Allocation relationship to change responsibility. Apply changes validates the semantic change.",
+                                "Choose Containment for semantic children, Architecture · allocated work for responsibilities, Functional dataflow for work and exchanges, or Missions & capabilities for outcomes. All relationships explores one layer; OA ↔ SA traceability can show placed elements from both layers and their correspondence lines alongside ordinary relationships.",
+                                "Select an element and edit Semantic parent to change ownership. Use the Allocation palette tool to connect a performer to existing unallocated leaf work in Containment. The relationship can appear as a line there; Architecture · allocated work shows responsibility through nesting instead. Saved visibility filters can hide a line without removing the relationship.",
                                 "Scroll to zoom and use Fit to frame the current view. In allocated-work views, dragging work changes its assignment and placement together. Choose Arrange next drag or press Alt+A to move work without changing responsibility for that one drag; Escape cancels the armed action. Auto-layout arranges the whole view. Export SVG produces a shareable view.",
                                 "Select a diagram node to access Placement, Fold / unfold and Hide. With the canvas focused, Delete hides its placement; Shift+Delete asks to remove the model element. Other views retain a hidden element. Undo restores either change.",
                             ],
@@ -317,6 +318,16 @@ fn article(topic: Topic) -> Article {
                             "Keep diagrams readable",
                             "Use separate views for responsibility, decomposition and cross-layer coverage. Place existing elements with Show in this diagram. A placement's Diagram field can relocate it while preserving its identity and artifact references. Do not duplicate a semantic element merely to show it in another view.",
                         ),
+                        walkthrough(
+                            "Show a correspondence between OA and SA",
+                            &[
+                                "Choose OA ↔ SA traceability in View content. Changing this setting does not create counterparts or add their placements, so an existing single-layer diagram can initially look unchanged.",
+                                "Use Review layer traces to inspect named Operational and System endpoints and the meaning of their link. This opens the model's layer-trace list with no search restriction; traces between relationships are reviewed here rather than drawn between element cards.",
+                                "In the chosen architecture view, use Add existing elements. The chooser offers compatible elements from both layers. Select an existing endpoint and click its position in the canvas; repeat for the other end if needed. This adds a placement, not a new semantic element or trace. For port correspondences, place the ports' owners.",
+                                "The view shows correspondence lines alongside ordinary relationships. The shown-line count reflects the current projection and visibility settings, not trace coverage. If a line is hidden, use View visibility and inspect Saved view visibility; placing an endpoint does not remove explicit hides or filters.",
+                                "If the counterpart is already placed, use Include already shown (Locate) in the chooser. Undo restores an added placement; saving preserves each view's placements independently. Use the Traceability page's existing counterpart or manual-trace workflow when the semantic link itself does not yet exist.",
+                            ],
+                        ),
                         walkthrough(
                             "Move work between performers",
                             &[

crates/oa-desktop/src/model_menu.rs

@@ -458,7 +458,8 @@ pub fn popup(app: &App) -> Option<Menu<Message>> {
                 entries.push(item(
                     "Show in this diagram",
                     Message::PlaceSelected,
-                    d.layer == e.layer() && d.projection.includes(e.kind()),
+                    (d.layer == e.layer() || d.projection == ProjectionKind::Traceability)
+                        && d.projection.includes(e.kind()),
                 ));
             }
         }
@@ -589,6 +590,7 @@ fn relation_actions(kind: Kind) -> &'static [(&'static str, RelationKind, bool)]
 #[cfg(test)]
 mod tests {
     use super::*;
+    include!("model_menu_traceability_tests.rs");
     fn send(app: &mut App, message: Message) {
         let _ = app.update(message);
     }

crates/oa-desktop/src/model_menu_traceability_tests.rs

@@ -0,0 +1,62 @@
+#[test]
+fn traceability_show_menu_matches_cross_layer_and_port_placement_eligibility() {
+    let mut project = Project::empty();
+    let sa = project
+        .add_element(Kind::Function, Layer::Sa, "Counterpart", None)
+        .unwrap();
+    let port = Id::new_v4();
+    project.elements.insert(
+        port,
+        Element {
+            id: port,
+            alias: "legacy_port".into(),
+            name: "Port".into(),
+            description: String::new(),
+            parent: Some(sa),
+            body: ElementBody::shared_in(
+                Layer::Sa,
+                SharedBody::Port {
+                    contract: PortContract::Legacy,
+                    legacy: Some(LegacyPortContract {
+                        direction: PortDirection::InOut,
+                        interface: None,
+                    }),
+                },
+            ),
+        },
+    );
+    let diagram = project.ensure_diagram(Layer::Oa);
+    oa_core::validate_candidate(&project).unwrap();
+    for projection in [ProjectionKind::Overview, ProjectionKind::Traceability] {
+        let mut p = project.clone();
+        p.diagrams.get_mut(&diagram).unwrap().projection = projection;
+        let mut app = App::with_project(p);
+        app.page = Page::Diagram;
+        app.layer = Layer::Oa;
+        app.active_diagram = Some(diagram);
+        for object in [sa, port] {
+            send(&mut app, open(object, Point::ORIGIN));
+            let action = popup(&app)
+                .unwrap()
+                .entries
+                .into_iter()
+                .find_map(|e| match e {
+                    Entry::Action { label, message, .. } if label == "Show in this diagram" => {
+                        Some(message)
+                    }
+                    _ => None,
+                });
+            if object == port {
+                assert!(
+                    action.is_none(),
+                    "Ports never acquire independent node placements"
+                );
+            } else {
+                assert_eq!(
+                    action.expect("non-port placement entry").is_some(),
+                    projection == ProjectionKind::Traceability
+                );
+            }
+        }
+    }
+}

crates/oa-desktop/src/views.rs

@@ -599,6 +599,28 @@ fn diagram(app: &App) -> View<'_, Message> {
     }
     if let Some(diagram) = app.active_diagram {
         let view = oa_core::projection::project_view(app.project(), diagram);
+        if projection == Some(ProjectionKind::Traceability) {
+            let correspondence_lines = view.edges.iter().filter(|edge| edge.trace).count();
+            tools = tools.push(
+                column![
+                    label("Shows OA and SA elements together, with correspondence lines alongside ordinary relationships."),
+                    label("Place both ends of a trace to show its line. Port traces use their owner cards; traces between relationships are reviewed on the Traceability page."),
+                    row![
+                        label(format!("{correspondence_lines} correspondence lines in this view")),
+                        action(
+                            "Add existing elements…",
+                            Message::Architecture(crate::app::architecture_authoring::Event::Existing(None))
+                        ),
+                        action("Review layer traces", Message::ReviewLayerTraces),
+                        action("View visibility…", Message::Select(diagram)),
+                    ]
+                    .spacing(7)
+                    .align_y(iced::Center)
+                    .wrap(),
+                ]
+                .spacing(4),
+            );
+        }
         let edge = view.edges.iter().find(|edge| edge.id == app.selected);
         let promoted = edge.is_some_and(|edge| {
             oa_core::projection::edge_endpoint_placements(

harness/allocation-drawing-20260923.md

@@ -0,0 +1,83 @@
+# Direct Allocation drawing — issue 30
+
+Branch-specific design above `17f1f89fef4a6bf520f4b09a2116548b967d030e`,
+on `codex/allocation-drawing-ytr83r-20260923`.
+[Issue 30](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/30)
+holds live scope and acceptance. This note records the intended interaction and
+verification criteria, not completed tests, native acceptance or integration.
+
+The user reports that Allocation cannot be drawn from the tools menu in
+Containment. Core semantics and the existing relationship form already support
+the relationship there; the direct canvas tool is the missing affordance.
+Adding that tool follows the same source/target workflow as neighboring tools.
+A form shortcut alone would still require a dropdown instead of clicking the
+visible endpoints, leaving the reported drawing task unresolved.
+
+## Interaction and scope
+
+Choose Allocation in the diagram palette, click any visible eligible performer,
+then click compatible unallocated leaf work in the same semantic layer as that
+performer. The performer's layer need not match a mixed traceability view's owner
+layer. OA uses an Entity or Actor and an
+Activity; SA uses a System or Actor and a Function. Highlighting and the current
+source identify the proposed semantic direction: performer to work, independent
+of where their cards are drawn. Escape cancels the unfinished connection.
+The existing Create relationship form remains an alternative for explicit
+relationship entry; no new Activity or Function is created by this tool.
+
+Projection eligibility requires support for both performer and work cards:
+Containment, All relationships, OA ↔ SA traceability and Architecture · allocated
+work offer Allocation; Functional dataflow, Missions & capabilities and dedicated
+State-machine views do not. Containment and All relationships can display the resulting Allocation line
+when its placements and filters permit. Architecture · allocated work represents
+the same responsibility through nesting, not an additional Allocation arrow.
+OA ↔ SA traceability can contain both layers, but Allocation endpoints must
+still belong to the same layer as each other. Selecting an opposite-layer source
+retains the captured mixed diagram and prior application perspective; cancellation
+also preserves that perspective. After successful creation, the ordinary model
+synchronization sets the application perspective to the captured diagram's owner
+layer while keeping that diagram open. A projection that omits one endpoint category
+must not offer an unusable drawing workflow. Existing filters remain unchanged;
+successful creation does not promise that a filtered line is visible.
+
+## Preservation rules
+
+- Allocate only eligible leaf work with no existing direct performer. Reject
+  duplicate, occupied, composite, cross-layer and Port endpoints; do not treat
+  drawing a new relation as permission to reassign existing work.
+- Core validation is authoritative at completion, in addition to candidate
+  highlighting. Candidates must be actual projected endpoints, not hidden
+  children or computed parent summaries.
+- Create one Allocation in one document transaction. Preserve semantic parents,
+  elements, other relationships, traces and every saved placement, route and
+  view option. Derived projection geometry may change because responsibility
+  changed; that is distinct from rewriting stored layout.
+- Arming, choosing only a source, refusal and cancellation do not alter model
+  history. Stale document/revision/diagram, navigation and pending property or
+  source edits must prevent delayed completion without discarding those drafts.
+- Moving cards in Containment remains ordinary arrangement. Assignment-changing
+  drag and Arrange next drag retain their existing allocated-work-view scope.
+
+No general relationship browser, new reassignment policy, port generation or
+change to ownership semantics is introduced. The existing connection lifecycle
+and ordinary validated command boundary are preferred over a parallel gesture
+framework. Broader form-only relationship kinds are outside this bounded fix.
+
+## Acceptance criteria
+
+Exercise real connection events for valid OA and SA endpoint pairs, rejected
+endpoint classes, cancel/retry, hidden endpoints, stale captures and pending
+drafts. Compare the complete Project so the only semantic difference is the new
+Allocation; bind its fresh identity explicitly. Check exact source Undo/Redo
+and unchanged stored reference-view records. Verify projection eligibility for
+the new tool without regressing the existing four connection tools.
+
+In the actual application, find Allocation in Containment's palette, choose a
+performer and existing leaf work directly, inspect the resulting relation,
+Undo/Redo, Save, close normally and reopen. Confirm feedback explains nesting
+when using the allocated-work projection, rather than promising a new line.
+Inspect nested-card hit selection and filtered-result feedback. Native evidence
+must distinguish observed interactions from automated coverage and bind source,
+binary, process and predeclared full-Project expectations. No successful result
+is asserted here. Linux remains user-paused; combined release acceptance belongs
+to the integration owner.

harness/traceability-view-20260923.md

@@ -0,0 +1,73 @@
+# Traceability view comprehension — issue 31
+
+Branch-specific work above `b8685416f56e53e30bd11ecf93a54cea10ac8458`.
+[Issue31](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/31)
+owns live progress. This note records the chosen design and acceptance plan,
+not completed validation or integration.
+
+The user's observed problem is that OA↔SA traceability looks like All
+relationships and its purpose is unclear. Existing core behavior already
+projects both layers' placed elements, ordinary relationships and explicit
+traces with available endpoints. Switching projection neither creates semantic
+counterparts nor adds missing placements. Existing Add existing supports both
+layers, but its default suggested-type filter conceals opposite-layer choices.
+Show in this diagram also has inconsistent cross-layer eligibility and selects
+an opposite-layer element before placement, potentially changing the target view.
+
+## Decision and criteria
+
+Make the existing workflow understandable and reachable before introducing a
+second counterpart browser. Criteria: a new user can explain the distinction,
+find both named ends, place existing counterparts in the chosen saved diagram,
+see/inspect correspondence, understand absent lines, and preserve semantic data.
+Keep the established mixed ordinary/trace contract, explicit semantic creation,
+saved view filters and single-operation placement history.
+
+Use concise projection-local explanation, the actual count of projected trace
+edges, Add existing elements, Review layer traces, and existing View visibility.
+Default the Existing chooser to All compatible types only for Traceability;
+creation and ordinary-view defaults stay scoped to their existing contexts.
+Align Show in this diagram with actual supported placement and retain the
+captured diagram across cross-layer selection. Review layer traces opens a
+predictable layer-trace inventory without a stale artifact filter/search, through
+existing navigation/draft guards. It does not promise that subsequently choosing
+an opposite-layer endpoint preserves the originating diagram.
+
+The count is exactly `project_view(...).edges.filter(trace).count()`, after saved
+filters. It is neither a project-wide trace total nor a coverage denominator.
+No overlapping missing/hidden reasons are added into invented totals. Port
+correspondences use owner-card placements; relation-to-relation correspondences
+remain reviewable semantic records and are not promised a diagram line.
+
+An expandable view-local counterpart browser with named Place/Locate actions
+was independently proposed. It can reduce name memorization, but introduces
+another scope, owner-mapping, omission-reason and targeted-placement interface.
+The existing chooser already completes the bounded placement task once its
+default and shortcut are corrected. Revisit the richer browser if the actual
+native task remains confusing. Tooltip-only, traces-only replacement, automatic
+counterpart creation/placement and forced OA/SA layout were rejected: respectively
+weak task completion, broken mixed-context contract, surprising semantics/history,
+and unwanted authored-layout changes.
+
+## Verification plan
+
+Exercise the real Existing chooser and actual Show menu path for opposite-layer
+elements, including stale/pending refusal and ordinary-view restrictions. Only
+the current diagram's intended placement may change; preserve semantic maps,
+other views, route/visibility choices, exact source Undo/Redo and save/reopen.
+Ports cannot become node placements. An already placed element must not acquire
+a duplicate placement. Predictable trace review must preserve drafts and obey
+the usual modal/navigation guards.
+
+Use core projection/filter evidence for no trace, missing endpoints, both placed,
+ordinary OA/SA edges, multiple traces, explicit hides plus disabled Trace kind,
+port owners and relation correspondence. Do not infer visible lines from
+unfiltered edge_availability or confuse unrelated model traces with counterparts.
+
+Native acceptance starts with an OA-owned mixed view, one already visible
+correspondence pair and another existing named SA counterpart not yet placed.
+Find/place it through the visible controls, see/select the additional trace,
+inspect an absent-line visibility reason, Undo/Redo and Save/reopen. Inspect
+toolbar/canvas space and chooser clarity at a realistic window size. Different
+help text or count tests alone do not resolve the user's comprehension complaint.
+Linux remains user-paused; Codex-956atf retains shared integration ownership.