Follow accepted placement relocation without losing inspection context

crates/oa-desktop/src/app.rs

@@ -23,6 +23,8 @@ mod hosted;
 pub(crate) mod multiselect;
 #[cfg(test)]
 mod multiselect_tests;
+#[cfg(test)]
+mod placement_relocation_regressions;
 mod reference_authoring;
 #[cfg(test)]
 mod review_navigation_tests;
@@ -953,6 +955,15 @@ impl App {
         }
         let original = self.selected;
         let canvas_surface = self.architecture_surface();
+        let placement_owner = self.draft.as_ref().and_then(|draft| match draft.kind {
+            crate::forms::RecordKind::Node(owner) => self
+                .project()
+                .diagrams
+                .get(&owner)
+                .filter(|diagram| diagram.nodes.contains_key(&draft.original))
+                .map(|diagram| diagram.id),
+            _ => None,
+        });
         let result = self
             .draft
             .as_ref()
@@ -1007,13 +1018,16 @@ impl App {
                 if let Some(layer) = self.project().layer_of(id) {
                     self.layer = layer;
                 }
-                if let Some((diagram, layer, node)) = self
+                let selected_surface = self
                     .project()
                     .diagrams
                     .values()
                     .find(|d| d.id == id || d.nodes.contains_key(&id))
-                    .map(|d| (d.id, d.layer, d.nodes.contains_key(&id).then_some(id)))
-                {
+                    .map(|d| (d.id, d.layer, d.nodes.contains_key(&id).then_some(id)));
+                let relocated_placement = placement_owner
+                    .zip(selected_surface.and_then(|(diagram, _, node)| node.map(|_| diagram)))
+                    .is_some_and(|(before, after)| before != after);
+                if let Some((diagram, layer, node)) = selected_surface {
                     self.layer = layer;
                     if self.page == Page::Behavior
                         && let Some(machine) =
@@ -1027,11 +1041,12 @@ impl App {
                         self.selected_node = node;
                     }
                 }
-                // Properties edit the inspected record; they do not request
-                // navigation away from the architecture view that owns them.
+                // Ordinary Properties edits retain their saved architecture view.
                 // Follow an explicitly edited diagram identity/layer, never an
                 // inferred replacement for an unrelated queued canvas click.
-                if let Some((diagram, _, _)) = canvas_surface {
+                // An accepted placement move explicitly chooses its new view.
+                // Same-owner edits (including a new UUID) still retain inspection.
+                if !relocated_placement && let Some((diagram, _, _)) = canvas_surface {
                     let diagram = if diagram == original { id } else { diagram };
                     if let Some(view) = self.project().diagrams.get(&diagram)
                         && view.projection.is_architecture()

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

@@ -0,0 +1,339 @@
+// Proposed tests against c7065db76ecca3faa733ccb5f09b87fd0a0958be.
+use super::*;
+
+struct RelocationFixture {
+    app: App,
+    source: Id,
+    target: Id,
+    node: Id,
+    other_node: Id,
+    edge: Id,
+}
+
+fn relocation_fixture(source_layer: Layer, target_layer: Layer) -> RelocationFixture {
+    let mut p = Project::empty();
+    let work = p
+        .add_element(Kind::Activity, Layer::Oa, "Observed work", None)
+        .unwrap();
+    let other = p
+        .add_element(Kind::Activity, Layer::Oa, "Other work", None)
+        .unwrap();
+    let edge = p.relate(RelationKind::Interaction, "Observed exchange", work, other);
+    let source = p.ensure_diagram(source_layer);
+    p.diagrams.get_mut(&source).unwrap().projection = ProjectionKind::Traceability;
+    let node = p.place(source, work, Position { x: 20., y: 20. });
+    let other_node = p.place(source, other, Position { x: 500., y: 20. });
+    let mut destination = p.diagrams[&source].clone();
+    destination.id = Id::new_v4();
+    destination.alias = "relocation_destination".into();
+    destination.name = "Relocation destination".into();
+    destination.layer = target_layer;
+    destination.nodes.clear();
+    let target = destination.id;
+    p.diagrams.insert(target, destination);
+    let mut app = App::with_project(p);
+    app.page = Page::Diagram;
+    app.layer = source_layer;
+    app.active_diagram = Some(source);
+    app.selected = node;
+    app.refresh_draft();
+    app.reconcile_multiselect();
+    assert!(
+        matches!(app.draft.as_ref().unwrap().kind, crate::forms::RecordKind::Node(d) if d == source)
+    );
+    assert!(!app.document.can_undo());
+    RelocationFixture {
+        app,
+        source,
+        target,
+        node,
+        other_node,
+        edge,
+    }
+}
+
+fn relocation_field(app: &mut App, path: &str, value: impl ToString) {
+    let _ = app.update(Message::Field(path.into(), value.to_string()));
+}
+
+fn relocation_source_pair(app: &App) {
+    let compiled = oa_core::source_project::compile_bundle(
+        app.document.bundle(),
+        oa_core::source_project::ProjectLimits::default(),
+    )
+    .unwrap();
+    assert_eq!(&compiled.decoded.project, app.project());
+    assert_eq!(&compiled.bundle, app.document.bundle());
+}
+
+fn relocation_selection(app: &App, diagram: Id, placement: Id) {
+    assert_eq!(app.page, Page::Diagram);
+    assert_eq!(app.active_diagram, Some(diagram));
+    assert_eq!(app.layer, app.project().diagrams[&diagram].layer);
+    assert_eq!(app.selected, placement);
+    assert_eq!(app.selected_node, Some(placement));
+    let draft = app.draft.as_ref().unwrap();
+    assert_eq!(draft.original, placement);
+    assert!(matches!(draft.kind, crate::forms::RecordKind::Node(d) if d == diagram));
+}
+
+fn relocation_expected(app: &App, command: Command) -> Document {
+    let mut expected = Document::from_bundle(
+        app.document.bundle().clone(),
+        oa_core::source_project::ProjectLimits::default(),
+    )
+    .unwrap();
+    expected.execute(command).unwrap();
+    expected
+}
+
+fn relocation_history(
+    app: &mut App,
+    before: &oa_core::source_project::CompiledSourceProject,
+    expected: &Document,
+) {
+    assert_eq!(app.project(), expected.project());
+    assert_eq!(app.document.bundle(), expected.bundle());
+    assert!(app.document.can_undo());
+    assert!(!app.document.can_redo());
+    let _ = app.update(Message::Undo);
+    assert_eq!(app.project(), &before.decoded.project);
+    assert_eq!(app.document.bundle(), &before.bundle);
+    assert!(!app.document.can_undo());
+    assert!(app.document.can_redo());
+    let _ = app.update(Message::Redo);
+    assert_eq!(app.project(), expected.project());
+    assert_eq!(app.document.bundle(), expected.bundle());
+    assert!(!app.document.can_redo());
+    relocation_source_pair(app);
+}
+
+#[test]
+fn explicit_placement_relocation_follows_actual_owner_with_optional_new_identity() {
+    for layer in [Layer::Oa, Layer::Sa] {
+        for reidentify in [false, true] {
+            let mut f = relocation_fixture(Layer::Oa, layer);
+            let before = f.app.document.snapshot();
+            let before_project = before.decoded.project.clone();
+            let revision = f.app.document.revision();
+            let id = if reidentify { Id::new_v4() } else { f.node };
+            let mut expected = before_project.clone();
+            let mut placement = expected
+                .diagrams
+                .get_mut(&f.source)
+                .unwrap()
+                .nodes
+                .remove(&f.node)
+                .unwrap();
+            placement.id = id;
+            expected
+                .diagrams
+                .get_mut(&f.target)
+                .unwrap()
+                .nodes
+                .insert(id, placement);
+            let expected_document = relocation_expected(
+                &f.app,
+                Command::Batch(vec![
+                    Command::EditNode {
+                        diagram: f.source,
+                        original: f.node,
+                        node: expected.diagrams[&f.target].nodes[&id].clone(),
+                    },
+                    Command::RelocateNode {
+                        node: id,
+                        diagram: f.target,
+                    },
+                ]),
+            );
+            assert_eq!(expected_document.project(), &expected);
+            relocation_field(&mut f.app, "/diagram", f.target);
+            if reidentify {
+                relocation_field(&mut f.app, "/id", id);
+            }
+            assert!(f.app.apply(), "{}", f.app.status);
+            assert_eq!(f.app.project(), &expected);
+            assert_eq!(f.app.document.revision(), revision + 1);
+            relocation_selection(&f.app, f.target, id);
+            relocation_source_pair(&f.app);
+            assert_eq!(f.app.document.bundle(), expected_document.bundle());
+            relocation_history(&mut f.app, &before, &expected_document);
+        }
+    }
+}
+
+#[test]
+fn same_owner_placement_position_alias_and_identity_keep_mixed_surface() {
+    for different_current_view in [false, true] {
+        for field in ["/position/x", "/alias", "/id"] {
+            let mut f = relocation_fixture(Layer::Sa, Layer::Oa);
+            // Ordinary Select plus the diagram picker can retain an independent
+            // placement Inspector while showing a different saved view. This is
+            // an App-handler workflow, not a claim of native menu execution.
+            let _ = f.app.update(Message::Select(f.app.project().id));
+            let _ = f.app.update(Message::Select(f.node));
+            let current = if different_current_view {
+                f.target
+            } else {
+                f.source
+            };
+            if different_current_view {
+                let _ = f.app.update(Message::Diagram(Choice {
+                    id: current,
+                    label: "Other current view".into(),
+                }));
+            }
+            assert_eq!(f.app.selected, f.node);
+            assert_eq!(f.app.active_diagram, Some(current));
+            assert!(
+                matches!(f.app.draft.as_ref().unwrap().kind, crate::forms::RecordKind::Node(d) if d == f.source)
+            );
+            let before = f.app.document.snapshot();
+            let revision = f.app.document.revision();
+            let mut expected = before.decoded.project.clone();
+            let mut placement = expected
+                .diagrams
+                .get_mut(&f.source)
+                .unwrap()
+                .nodes
+                .remove(&f.node)
+                .unwrap();
+            let value = match field {
+                "/position/x" => {
+                    placement.position.x = 123.;
+                    "123".to_owned()
+                }
+                "/alias" => {
+                    placement.alias = "renamed_placement".into();
+                    placement.alias.clone()
+                }
+                _ => {
+                    placement.id = Id::new_v4();
+                    placement.id.to_string()
+                }
+            };
+            let id = placement.id;
+            let expected_document = relocation_expected(
+                &f.app,
+                Command::EditNode {
+                    diagram: f.source,
+                    original: f.node,
+                    node: placement.clone(),
+                },
+            );
+            expected
+                .diagrams
+                .get_mut(&f.source)
+                .unwrap()
+                .nodes
+                .insert(id, placement);
+            assert_eq!(expected_document.project(), &expected);
+            relocation_field(&mut f.app, field, value);
+            assert!(f.app.apply(), "{}", f.app.status);
+            assert_eq!(f.app.project(), &expected);
+            assert_eq!(f.app.document.bundle(), expected_document.bundle());
+            assert_eq!(f.app.document.revision(), revision + 1);
+            assert_eq!(f.app.page, Page::Diagram);
+            assert_eq!(f.app.active_diagram, Some(current));
+            assert_eq!(f.app.layer, f.app.project().diagrams[&current].layer);
+            assert_eq!(f.app.selected, id);
+            assert_eq!(
+                f.app.selected_node,
+                if different_current_view {
+                    None
+                } else {
+                    Some(id)
+                }
+            );
+            let draft = f.app.draft.as_ref().unwrap();
+            assert_eq!(draft.original, id);
+            assert!(matches!(draft.kind, crate::forms::RecordKind::Node(d) if d == f.source));
+            relocation_source_pair(&f.app);
+            relocation_history(&mut f.app, &before, &expected_document);
+        }
+    }
+}
+
+#[test]
+fn accepted_relocation_refuses_queued_old_canvas_target_with_feedback() {
+    for edge_hit in [false, true] {
+        let mut f = relocation_fixture(Layer::Oa, Layer::Sa);
+        let before = f.app.document.snapshot();
+        let expected_document = relocation_expected(
+            &f.app,
+            Command::Batch(vec![
+                Command::EditNode {
+                    diagram: f.source,
+                    original: f.node,
+                    node: f.app.project().diagrams[&f.source].nodes[&f.node].clone(),
+                },
+                Command::RelocateNode {
+                    node: f.node,
+                    diagram: f.target,
+                },
+            ]),
+        );
+        let mut expected = before.decoded.project.clone();
+        let placement = expected
+            .diagrams
+            .get_mut(&f.source)
+            .unwrap()
+            .nodes
+            .remove(&f.node)
+            .unwrap();
+        expected
+            .diagrams
+            .get_mut(&f.target)
+            .unwrap()
+            .nodes
+            .insert(f.node, placement);
+        let revision = f.app.document.revision();
+        let captured = f.app.route_context().unwrap();
+        relocation_field(&mut f.app, "/diagram", f.target);
+        let message = if edge_hit {
+            Message::CanvasSelect(captured, f.edge)
+        } else {
+            Message::SelectNode(f.other_node)
+        };
+        let _ = f.app.update(message);
+        assert_eq!(f.app.project(), &expected);
+        assert_eq!(f.app.document.revision(), revision + 1);
+        relocation_selection(&f.app, f.target, f.node);
+        assert_eq!(
+            f.app.status,
+            "Properties applied. The view changed; select a visible target again."
+        );
+        assert!(
+            f.app.multiselect_snapshot().is_none_or(|snapshot| {
+                !snapshot.targets().iter().any(|target| {
+                matches!(target, crate::diagram_usage::Target::Placement(id) if *id == f.other_node)
+                    || matches!(target, crate::diagram_usage::Target::Edge(id) if *id == f.edge)
+            })
+            }),
+            "the rejected old hit must not enter the destination selection"
+        );
+        assert_eq!(expected_document.project(), &expected);
+        assert_eq!(f.app.document.bundle(), expected_document.bundle());
+        relocation_source_pair(&f.app);
+        relocation_history(&mut f.app, &before, &expected_document);
+    }
+}
+
+#[test]
+fn rejected_placement_destination_preserves_owner_model_source_and_draft() {
+    let mut f = relocation_fixture(Layer::Oa, Layer::Sa);
+    let before = f.app.document.snapshot();
+    let revision = f.app.document.revision();
+    relocation_field(&mut f.app, "/diagram", Id::new_v4());
+    let draft = serde_json::to_value(f.app.draft.as_ref().unwrap().recovery_snapshot()).unwrap();
+    assert!(!f.app.apply());
+    assert_eq!(f.app.project(), &before.decoded.project);
+    assert_eq!(f.app.document.bundle(), &before.bundle);
+    assert_eq!(f.app.document.revision(), revision);
+    assert!(!f.app.document.can_undo());
+    relocation_selection(&f.app, f.source, f.node);
+    assert_eq!(
+        serde_json::to_value(f.app.draft.as_ref().unwrap().recovery_snapshot()).unwrap(),
+        draft
+    );
+}

crates/oa-desktop/src/guide.rs

@@ -322,8 +322,8 @@ fn article(topic: Topic) -> Article {
                             "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.",
-                                "Switching back to Architecture or another single-layer projection shows only that view's layer. The other layer's placements, routing and saved visibility remain stored; return to OA ↔ SA traceability to show them again, subject to the view's filters. Selecting a displayed card, port or line and opening its Properties keeps the current view and perspective. Applying Properties keeps that saved architecture view open. Changes you make to the view's own perspective or identity still take effect. If the app asks you to select again, choose a visible target.",
-                                "In a mixed traceability view, use Draw from a visible source's canvas or Model explorer menu to connect from that source's OA or SA layer without leaving the view. Choose a highlighted compatible visible target; Escape cancels. The palette offers tools for the view's perspective. Opening an endpoint or choosing a record in Model explorer follows that record's perspective. Contextual relationship forms keep the view while opening; applying the reviewed relationship can navigate to its result.",
+                                "Switching back to Architecture or another single-layer projection shows only that view's layer. The other layer's placements, routing and saved visibility remain stored; return to OA ↔ SA traceability to show them again, subject to the view's filters. Selecting a displayed card, port or line and opening its Properties keeps the current view and perspective. Applying ordinary Properties edits keeps that saved architecture view open. Changing a placement's Diagram explicitly moves it and follows its destination. Changes you make to the view's own perspective or identity still take effect. If the app asks you to select again, choose a visible target.",
+                                "In a mixed traceability view, use Draw from a visible source's canvas menu or the Model explorer sidebar on the Architecture page to connect from that source's OA or SA layer without leaving the view. Choose a highlighted compatible visible target; Escape cancels. The palette offers tools for the view's perspective. Opening an endpoint or selecting a record in the Model explorer sidebar follows that record's perspective. Contextual relationship forms keep the view while opening; applying the reviewed relationship can navigate to its result.",
                                 "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.",

harness/navigation-draft-contract-20261001.md

@@ -6,13 +6,13 @@ This bounded desktop contract refines the peer [projection/navigation decision](
 
 Inspection and explicit navigation are distinct intents. Selecting a visible Architecture card, edge, label or port, or opening its Properties, retains the saved canvas and displayed perspective even when the semantic target belongs to the other layer. Explicit Select/Open-owner/Open-endpoint navigation may follow the target's layer.
 
-Applying an ordinary property draft must not accidentally turn inspection into navigation. Preserve the saved Architecture surface through the accepted transaction and reconciliation. If the user intentionally changes that active diagram's identity or layer, follow the accepted new identity/layer; do not overwrite it with the old surface. Complete model/source changes and their history remain those of the accepted property transaction.
+Applying an ordinary property draft must not accidentally turn inspection into navigation. Preserve the saved Architecture surface through the accepted transaction and reconciliation. If the user intentionally changes that active diagram's identity or layer, follow the accepted new identity/layer; do not overwrite it with the old surface. An accepted placement Diagram change is also explicit navigation: follow the actual destination, including a different diagram on the same layer or a simultaneous placement UUID change. Determine relocation from the actual pre-edit and accepted post-edit owners, not the requested draft text or the currently displayed canvas. Position, alias and UUID edits that keep the placement in its existing owner retain the current saved canvas, even when that canvas differs from the placement owner. Complete model/source changes and their history remain those of the accepted property transaction.
 
 A pending click captured before Apply is not automatically valid afterward. If the accepted edit changes its target, diagram or projection membership, do not replay a stale selection or gesture against the new document. Retain the accepted edit and require another selection. Invalid drafts remain uncommitted with recoverable draft state and no target change. This contract is scoped to saved Architecture surfaces; typed StateMachine/Scenario representations and their existing navigation/owner guards are not broadened.
 
 ## Contextual Draw
 
-Draw from a visible semantic source is contextual to the actual current diagram, whether its menu originated on the canvas or in Model explorer. A matching validated menu action must not navigate to a preferred same-layer view before starting. In Traceability, an OA source may start its OA tool in an SA view and vice versa. The source must exist, belong to a tool-supported semantic family/layer and be projected visibly in that current saved Architecture diagram. Opposite-layer latent records in ordinary projections are not actionable sources.
+Draw from a visible semantic source is contextual to the actual current diagram, whether its menu originated on the canvas or in the Model explorer sidebar on the Architecture page. The dedicated Model explorer page does not offer Draw. A matching validated menu action must not navigate to a preferred same-layer view before starting. In Traceability, an OA source may start its OA tool in an SA view and vice versa. The source must exist, belong to a tool-supported semantic family/layer and be projected visibly in that current saved Architecture diagram. Opposite-layer latent records in ordinary projections are not actionable sources.
 
 Targets remain compatible visible endpoints under the existing semantic validators. Allocation still requires a projection supporting performer and work, and same-layer compatible work; mixed visibility does not authorize cross-layer Allocation or bypass leaf/direct-assignment rules. Capabilities may show a performer while excluding work: its Draw allocation action must not be enabled. Overview, Decomposition, Allocation and Traceability support both endpoint categories.
 
@@ -28,10 +28,18 @@ Blindly restoring the old layer/diagram after an edit is rejected: it can erase
 
 ## Evaluators and evidence boundaries
 
-Use actual generated token-wrapped popup actions for both OA-in-SA and SA-in-OA Traceability, from canvas and non-canvas Model explorer requests. Begin must retain surface and full model/source/history; completion may add only its one relation plus the exact two newly referenced SA function ports when FunctionalExchange requires them. Verify complete Project equality against that permitted delta, source recompilation parity and one-step Undo/Redo. Cover Allocation enabledness, visible compatible/hidden/wrong-layer endpoints, cancellation, restart and stale messages.
+Use actual generated token-wrapped popup actions for both OA-in-SA and SA-in-OA Traceability, from canvas and non-canvas Architecture sidebar Model explorer requests. Begin must retain surface and full model/source/history; completion may add only its one relation plus the exact two newly referenced SA function ports when FunctionalExchange requires them. Verify complete Project equality against that permitted delta, source recompilation parity and one-step Undo/Redo. Cover Allocation enabledness, visible compatible/hidden/wrong-layer endpoints, cancellation, restart and stale messages.
 
 For draft inspection, cover a valid property edit applied while clicking another visible opposite-layer object, invalid drafts, accepted edits invalidating the captured target, and deliberate active-diagram layer/identity edits. Compare complete source/model/history; do not accept a preserved screenshot alone. Existing frozen-version admission, reversible projection and typed State/Scenario negative controls retain their original scope.
 
 Native acceptance must exercise actual pointer selection, menu opening, Apply/reselect feedback, visible target highlights, Escape/restart, Save and fresh reopen on an identified build. Source review and handler tests do not establish native or usability acceptance. No repaired runtime pass, fresh native acceptance, release or issue closure is claimed here.
 
 The initial correction was reviewed against the frozen source manifest for `repaired-targets`: all 554 input hashes matched the independent archive review. The parent executed 20 canvas-selection tests and five real-menu connection regressions successfully, with formatting passing and inputs unchanged. These are bounded handler/source results, not native acceptance. Complete workspace gates, the saved-source evaluator, actual Windows interaction and persisted history checks remain pending at this source checkpoint. A later validation record must identify the tested commit and publish the retained baseline failures, corrected raw gates, independent reviews, native observations and model/source comparisons. The original peer topic remains authoritative for its earlier evidence and limitations; failed or interrupted commands retain their actual outcomes.
+
+## Placement relocation regression boundary
+
+The full workspace run on `c7065db76ecca3faa733ccb5f09b87fd0a0958be` exposed the existing `tests::placement_relocation_follows_cross_layer_traceability_view` regression: the destination expected SA but the retained surface remained OA. Desktop reported 1552 passed, 1 failed and 7 ignored; preceding core/CLI tests passed, while server tests, doctests and Clippy were not reached. This is a failed workspace gate, not acceptance. The original regression remains unchanged.
+
+The scoped correction distinguishes actual owner changes from ordinary same-owner placement edits, including inspection from a different current saved canvas. Evaluate full expected Project and source bundle against explicit core EditNode/RelocateNode transactions, one-step Undo/Redo, invalid destinations, and refusal of queued old canvas hits with reselect feedback and no old target in multiselect. The test-only c706 baseline reports two passing controls and three failures, including the unchanged original regression. Failing loops stop at their first failed combination; this is not evidence that every later combination failed.
+
+On 2026-10-02 UTC, the applied correction's frozen `relocation-repaired-targets` gate passed formatting, all five relocation tests, all 20 canvas-selection tests and all five contextual-Draw tests. All 555 archived source inputs remained unchanged. Independent applied-source review checked every archive/current hash and found no new blocker. The relocation checks compare complete independently expected Projects and explicit-command source bundles, one-step history, same/cross-layer destinations, optional UUID changes, invalid destinations and queued-hit feedback. This bounded pass does not establish a complete corrected workspace, Clippy, fresh native build or release; the earlier c706 native observations retain their separate executable identity.