Sync agent instructions from main

crates/oa-desktop/src/behavior.rs

@@ -1117,6 +1117,10 @@ fn in_machine(p: &Project, id: Id, machine: Id) -> bool {
     false
 }
 
+#[cfg(test)]
+#[path = "../../../harness/experiments/behavior-layout-scene-20260912/mod.rs"]
+mod behavior_layout_scene_experiment;
+
 struct BoxItem {
     id: Id,
     rect: Rectangle,
@@ -1435,6 +1439,8 @@ impl Scene {
                 // the preceding action/state/reference box, before recording rows.
                 *y += 16.;
             }
+            #[cfg(test)]
+            behavior_layout_scene_experiment::resolve_row_anchor(*id, y);
             if ordered {
                 let slot = scenario::Slot {
                     parent: owner,

harness/experiments/behavior-layout-scene-20260912/README.md

@@ -0,0 +1,67 @@
+# Actual Scene anchor experiment — pending execution
+
+2026-09-12. Prepared by delegated reviewer `/root/diagram_usage_workflows` in branch `codex/diagram-coverage-fixes-ytr83r-20260912`, inspected base `f23615ffebdc3ca6872f98b6889ec49bb4e8abda` plus root's ongoing correction work. Only this experiment directory was authored. **Root applied the test-only wiring on isolated branch `codex/behavior-layout-scene-ytr83r-20260912`, based on `46b4f3c0d0f04050ad6d705051ee0199138e47a2`. Not compiled or executed.** Root owns the build checkpoint. No production schema choice, native acceptance or fix is claimed.
+
+## Question and candidates
+
+Can a minimal presentation input feed the actual current desktop Scene before it constructs rows, message polylines, nested frames and lifecycle geometry, while preserving the semantic Project and occurrence identities? Does explicit pointer intent preserve latent authored values on zero motion?
+
+The candidate is an occurrence-ID-to-desired-row map. A tiny test-only hook raises the current Scene cursor to a requested row before recording an occurrence. This deliberately retains the existing renderer's next-row floor: it is a **downward spacing adapter**, not a general absolute-coordinate projector. The competing gap policy remains meaningful but is not implemented here: this experiment first tests the proposed real-Scene integration boundary. It cannot select a production storage schema.
+
+Rejected experimental shortcuts: a standalone rectangle model would not test Scene; translating final polylines after rendering would bypass dependent frames/lifecycle; extracting the whole renderer would exceed the uncertainty being tested. This adapter uses the existing code that actually generates all those representations.
+
+## Files and exact root wiring
+
+- `fixture.arcadia`: hand-authored current source with explicit UUIDs, two occurrences sharing one communication mean, a fragment containing an operand/action box, and a self-call/reply. The self messages intentionally have unassigned global exchanges: current global relation validation rejects a self edge. Their explicit lifelines permit rendering; incomplete-exchange warnings are expected, semantic errors are not.
+- `mod.rs`: private child tests of `behavior`, a scoped thread-local anchor adapter, pointer-delta candidate operation, and independent numerical checks against actual Scene outputs.
+- `wiring.patch`: proposed two-site test-only wiring in `crates/oa-desktop/src/behavior.rs`. It adds the child module and calls `resolve_row_anchor(*id, y)` immediately before the `if ordered` block that records rows/slots in `Scene::occurrences`, **after** any self lifecycle clearance. The relative module path is from `crates/oa-desktop/src`. The line numbers are informational; verify the context against the exact integration version.
+
+On the isolated wired branch, run:
+
+```powershell
+cargo test -p oa-desktop behavior_layout_scene_experiment -- --nocapture
+```
+
+Use the project's configured Windows compiler/linker environment. No dependency, Cargo target or main-function changes are needed. The hook is compiled only under cfg(test), inactive unless the current thread installs an AnchorScope, and restored by Drop after normal return or unwind. A test checks that another thread does not inherit the anchor map and that an intentional panic restores the baseline. Do not catch or reinterpret that expected panic output as a product crash; its test must still pass.
+
+The isolated branch already contains this wiring; `wiring.patch` records its reviewable delta and must not be applied twice. If a compiler/parser assertion fails, preserve the failure, identify the exact reviewed source version, and correct the fixture or adapter at this boundary. Do not weaken independent geometric assertions solely to make the test green. Never claim a passing test from the existence of these files.
+
+## Independent evaluators
+
+The baseline is the actual `Scene::sequence` with no installed anchors. The hand-derived expected row coordinates are first148, second240, fragment332, nested action477, self-call636 and self-reply728. These follow the current seed metrics (message92, fragment header55, operand90, action95, trailing fragment64) and are observable implementation oracles, not proposed permanent UX rules. The nested box top is457; fragment height240; self-call endpoint y values are636 and660. Line identities and endpoints are asserted independently, not just compared between two calls to the same projector.
+
+Tests cover:
+
+1. Actual `oa_core::language::parse` and canonical format/reparse Project equality; baseline actual Scene equality after semantic source round trip; repeated exchange references retain distinct line UUIDs.
+2. Move only second delivery by40: its row becomes280, first stays148, nested action becomes517, fragment translates with unchanged height240, and self-call/reply geometry moves by40 with unchanged x and identity. Whole Project and canonical semantic source remain equal.
+3. Move the nested action by30: actual fragment grows from240 to270 while its top remains332; later self-call shifts. Move that self-call by18 and assert actual send/receive y684/708 and reply776; the nested box remains unchanged.
+4. Move first by200: second is visibly displaced to440 while its authored desired value stays240. Zero pointer delta returns the exact original candidate. Moving first back restores second240. Explicitly assigning second.desired=440 before moving first back deliberately preserves440 instead, exposing the distinction between pointer no-op and explicit latent-intent change.
+5. Reorder the repeated occurrences in actual source and parse it; the override stays attached to the second occurrence UUID. Its row is280 and the first follows at372. Projection does not write back any semantic model change.
+6. Scope restoration on panic and isolation from other test threads.
+7. Explicit upward-drag counterexample: the requested y200 remains rendered at240 under the current floor.
+
+Model equality compares the entire Project. Scene equality checks rows, scopes, size, lanes, lifecycle, open calls, lines/labels, boxes and insertion slots; it does not invoke GPU painting. Explicit UUIDs are necessary because parsing declarations without IDs allocates new identities, which would make separate source parses unsuitable for occurrence-address comparison.
+
+## Limits and next decision
+
+This is real parser/Scene construction evidence **only after it runs**. Layout maps remain external experimental data; source round trips cover the semantic Project, not persisted layout. No new parser syntax, Document transaction, REST operation, undo stack, dirty-source workflow, route bend, text measurement, native gesture, inspector, resize, or performance result is established.
+
+The current floor retains automatic whitespace and cannot establish all feasible free positions, upward drag, independent frame resize, gap-policy superiority or minimal displacement. Its limitation is useful evidence: if feeding requested anchors into the existing cursor still feels rigid, a real constraint/inverse policy is required, not more seed spacing. The next bounded choice is a declared anchor/constraint policy, then one typed layout record through source/Document/REST; broad renderer extraction is not justified by this probe.
+
+Self-call send/receive assertions intentionally follow the actual current polyline contract. They do **not** assert activation correctness or substitute for peer #21's work. Activation boxes are generated by the real existing Scene/lifecycle path, and source roundtrip equality includes them, but that is not an independent oracle for nested activation start/depth/paint order. The fixture does not cover delayed creation/deletion, parallel operands, nested calls, cross-operand semantic moves, hidden views, copy/delete/reidentify lifecycle, or large models. Coordinate any later anchor contract with #16/#21 owners and retain these gaps in published evidence.
+
+Root should publish this directory and the exact wired code/test result together for remote peer review. Independent machines cannot consume workspace-local links.
+
+## Root source review before execution
+
+The panic-restoration evaluator originally accepted any panic inside its scope, so an earlier failed geometry/thread assertion could have looked like successful deliberate unwinding. Root corrected it to require the exact deliberate panic payload. Moved message polylines now also require equal point counts before zipped endpoint comparisons. These are evaluator corrections; execution remains pending.
+
+Independent bounded review confirmed hook placement, fixture assumptions and the hand-derived coordinates without executing them. Its coverage caveat prompted adding box marker metadata and insertion-slot labels to equality comparisons. Transient selection, camera and interaction state are not part of this geometry comparison. No material source finding remains from that review; compiler/runtime evidence is still required.
+
+## Peer activation integration boundary
+
+A read-only check of peer source `8112dea7a371755c7373f4ecc09a6488a73ac136` found that the pre-row hook remains upstream of typed activation construction and final message anchoring. That anchoring preserves generated y coordinates. Its column-zero self-call changes x from the old lane/lane+75/lane+75/lane path to lane/lane+66/lane+66/lane+6; receive y remains660 in this fixture, and the activation begins there rather than at send y636.
+
+The peer branch and this branch have different lifetime integration states. This branch has production lifetime rendering, message alignment, self-lifecycle clearance and alive_spans clipping. In the peer checkpoint, scenario_lifecycle is cfg(test)-only and typed activation_segment emits an unclipped span. A future union must retain the lifetime behavior and reconcile duplicate activation methods; copying either whole Scene implementation is insufficient. Compare both lifecycle geometry and typed segment identity/rectangle/column/finish, and verify delayed Create/Delete inside and outside operands. Do not remove the existing lifecycle comparison to make the peer version compile. A segment clipped before its semantic reply must not falsely claim a visible reply termination. No peer code has been merged by this experiment.
+
+[Shared integration finding](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/21#issuecomment-698) and [peer activation source](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/src/commit/8112dea7a371755c7373f4ecc09a6488a73ac136/crates/oa-desktop/src/behavior/scenario_activation.rs). This is source compatibility evidence, not runtime acceptance.

harness/experiments/behavior-layout-scene-20260912/fixture.arcadia

@@ -0,0 +1,60 @@
+arcadia 7;
+project layout_probe "Behavior layout Scene probe" id "10000000-0000-4000-8000-000000000001" {
+    oa_entity sender "Sender" id "10000000-0000-4000-8000-000000000002" {}
+    oa_entity receiver "Receiver" id "10000000-0000-4000-8000-000000000003" {}
+    oa_activity inspect "Inspect" id "10000000-0000-4000-8000-000000000004" {}
+    allocation inspect_assignment "Receiver performs inspection" id "10000000-0000-4000-8000-000000000005" {
+        source @receiver; target @inspect;
+    }
+    communication_mean channel "Shared channel" id "10000000-0000-4000-8000-000000000006" {
+        source @sender; target @receiver; oriented false;
+    }
+    oa_scenario conversation "Conversation" id "10000000-0000-4000-8000-000000000007" {
+        viewpoint ParticipantInteraction;
+        steps [@first, @second, @fragment, @self_call, @self_reply];
+    }
+    oa_lifeline left "Sender role" id "10000000-0000-4000-8000-000000000008" { parent @conversation; represented @sender; }
+    oa_lifeline right "Receiver role" id "10000000-0000-4000-8000-000000000009" { parent @conversation; represented @receiver; }
+    oa_occurrence first "First delivery" id "10000000-0000-4000-8000-00000000000a" {
+        parent @conversation;
+        body { Exchange {
+            exchange @channel; sender @left; receiver @right;
+            message_kind Asynchronous;
+        }; };
+    }
+    oa_occurrence second "Second delivery" id "10000000-0000-4000-8000-00000000000b" {
+        parent @conversation;
+        body { Exchange {
+            exchange @channel; sender @left; receiver @right;
+            message_kind Asynchronous;
+        }; };
+    }
+    oa_occurrence fragment "Optional inspection" id "10000000-0000-4000-8000-00000000000c" {
+        parent @conversation;
+        body { Fragment { operator Optional; branches [@operand]; }; };
+    }
+    oa_occurrence operand "When requested" id "10000000-0000-4000-8000-00000000000d" {
+        parent @fragment;
+        body { Branch { guard "requested"; occurrences [@nested]; }; };
+    }
+    oa_occurrence nested "Inspection occurrence" id "10000000-0000-4000-8000-00000000000e" {
+        parent @operand;
+        body { Action { action @inspect; lifeline @right; }; };
+    }
+    // Self calls intentionally have no global self-edge: such a relation is
+    // invalid in the current metamodel. Their unassigned exchange is a known
+    // incomplete-model warning, while explicit lifelines make Scene drawable.
+    oa_occurrence self_call "Local call" id "10000000-0000-4000-8000-00000000000f" {
+        parent @conversation;
+        body { Exchange {
+            exchange none; sender @right; receiver @right; message_kind Call;
+        }; };
+    }
+    oa_occurrence self_reply "Local reply" id "10000000-0000-4000-8000-000000000010" {
+        parent @conversation;
+        body { Exchange {
+            exchange none; sender @right; receiver @right;
+            message_kind Reply; reply_to @self_call;
+        }; };
+    }
+}

harness/experiments/behavior-layout-scene-20260912/lifetime.arcadia

@@ -0,0 +1,45 @@
+arcadia 7;
+// Separate lifetime probe: preserve this authored note and all stable IDs.
+project lifetime_probe "Delayed receiver lifetime" id "20000000-0000-4000-8000-000000000001" {
+    oa_activity prepare "Prepare request" id "20000000-0000-4000-8000-000000000002" {}
+    oa_activity serve "Serve request" id "20000000-0000-4000-8000-000000000003" {}
+    interaction service "Service request" id "20000000-0000-4000-8000-000000000004" {
+        source @prepare; target @serve;
+    }
+    oa_scenario lifetime_conversation "Receiver created on demand" id "20000000-0000-4000-8000-000000000005" {
+        viewpoint OperationalActivity;
+        steps [@before_birth, @create_receiver, @service_call, @delete_receiver];
+    }
+    oa_lifeline requester "Requester" id "20000000-0000-4000-8000-000000000006" {
+        parent @lifetime_conversation; represented @prepare;
+    }
+    oa_lifeline provider "Provider" id "20000000-0000-4000-8000-000000000007" {
+        parent @lifetime_conversation; represented @serve;
+    }
+    oa_occurrence before_birth "Prepare before receiver exists" id "20000000-0000-4000-8000-000000000008" {
+        parent @lifetime_conversation;
+        body { Action { action @prepare; lifeline @requester; }; };
+    }
+    oa_occurrence create_receiver "Create receiver" id "20000000-0000-4000-8000-000000000009" {
+        parent @lifetime_conversation;
+        body { Exchange {
+            exchange @service; sender @requester; receiver @provider;
+            message_kind Create;
+        }; };
+    }
+    oa_occurrence service_call "Call receiver" id "20000000-0000-4000-8000-00000000000a" {
+        parent @lifetime_conversation;
+        body { Exchange {
+            exchange @service; sender @requester; receiver @provider;
+            message_kind Call;
+        }; };
+    }
+    // Death ends the visible activation but deliberately does not invent a Reply.
+    oa_occurrence delete_receiver "Delete receiver" id "20000000-0000-4000-8000-00000000000b" {
+        parent @lifetime_conversation;
+        body { Exchange {
+            exchange @service; sender @requester; receiver @provider;
+            message_kind Delete;
+        }; };
+    }
+}

harness/experiments/behavior-layout-scene-20260912/lifetime.md

@@ -0,0 +1,93 @@
+# Lifetime extension of the actual Scene experiment — not executed
+
+Prepared 2026-09-12 in `codex/behavior-layout-scene-ytr83r-20260912`, inspected
+HEAD `911f63e`. This extension owns only `lifetime.arcadia`, `lifetime.rs`, this
+note, and the `mod lifetime;` declaration in the existing experiment module.
+The original fixture and its seven baseline tests are unchanged. Root owns the
+README compatibility note, compiler resource, source integration and publication.
+No production renderer, parser or model code was edited here.
+
+## Question and method
+
+Does the current test-only row-anchor hook propagate a changed Create/Delete
+position into the actual Scene's local lifetime, marker hit identity, aligned
+message endpoints and activation clipping, while leaving semantic/source state
+and occurrence IDs intact?
+
+The separate source fixture declares stable UUIDs, a sender action before receiver
+birth, then Create, Call and receiver Delete. All three messages reference one
+valid Interaction; explicit sender/receiver lifelines represent its Activity
+endpoints. A Reply is deliberately absent: receiver death must not manufacture a
+reply or erase the unanswered-call presentation cue. The test requires real
+language parsing, no semantic errors, ordinary `Document::from_bundle` admission,
+canonical format/reparse Project equality and exact original source retention.
+Warnings are allowed and are not promoted into semantic acceptance requirements.
+
+The evaluator calls the existing `Scene::sequence` and scoped `render`/`drag`
+helpers. It reads `Rendering::alive_spans` and `marker_at`, real Scene line
+polylines and actual activation `BoxItem` records. It does not construct an
+alternative activation/lifetime implementation or edit final geometry afterward.
+
+## Independent expectations
+
+Current Scene metrics give sender action148, Create243, Call335 and Delete427:
+the action consumes95 and each following message92. The scene height is564 and
+its root insertion bounds are106–477. These numbers are regression oracles for
+the inspected implementation, not permanent product spacing requirements.
+
+The receiver is alive exactly243–427; the sender remains alive throughout the
+visible root span. Create ends at the 140px birth capsule's near edge, 70px before
+the receiver lane, while Delete ends at the death cross's center. Marker and
+Scene hit queries return the original Create/Delete occurrence IDs. The actual
+8px activation starts at Call335 and ends at death427, with no minimum-height tail
+after death. The unresolved-call cue stays at receiver-x+12, death-y−16.
+
+Three tests establish these expectations if they pass:
+
+1. Baseline parsed Scene has those independent rows, line endpoints, lifetime
+   extents, hit identities, activation bounds and unanswered-call cue. Its real
+   geometry remains equal after source round trip and an empty hook scope.
+2. Moving Create down60 changes its row to303 and propagates Call395/Delete487;
+   the actual receiver lifetime, birth/death markers and activation follow. The
+   preceding action's box stays fixed, line/row UUIDs stay stable, and the old
+   birth point is no longer a lifecycle marker.
+3. Moving only Delete down48 changes death to475 and extends the same real
+   activation to475, while Create and Call polylines stay fixed. Moving Create
+   with an authored Delete request still at427 forces displayed death487; either
+   signed-zero pointer delta preserves the entire latent map and Scene. Moving
+   Create back restores baseline geometry and the original authored map.
+
+Every test compares the entire accepted Project and source bundle against the
+original snapshot, and requires no dirty state or undo/redo history. No test
+weakens equality to just the occurrence list.
+
+## Contract reused and limits
+
+The inspected implementation builds lifecycle geometry after recording occurrence
+rows (`behavior.rs:1332–1344`), aligns Create/Delete messages through
+`scenario_lifecycle::render::Rendering::align_messages`, and constructs actual
+activation boxes through `activation_sequence`/`activation_segment`
+(`behavior.rs:1663–1734`). The latter intersects segments with `alive_spans` and
+keeps a cue when Delete terminates an unanswered call. Existing
+`scenario_lifecycle/render_tests.rs` tests real root birth/death alignment and
+branch-local activation clipping. This extension exercises those current
+contracts through the layout hook; it does not replace them.
+
+The peer `8112dea` typed activation correction has a different future integration
+boundary and, as reported to this task, has no production lifecycle clipping yet.
+These tests are not evidence that that unmerged source is compatible. A future
+typed activation union needs its own tests for clipping, typed call/segment IDs,
+self/nested activation receive geometry, branch behavior, depth and paint order.
+Do not preserve a legacy width/classification assertion blindly when deliberately
+changing the activation representation; retain independent lifetime endpoints,
+identity and no-after-death expectations on the new actual records.
+
+This extension remains uncompiled and unexecuted. It does not establish persisted
+layout syntax, a production drag transaction, undoable geometry edits, native
+pointer behavior, GPU painting, performance, or general upward/free positioning.
+The existing hook still applies a next-row floor. Root should run the existing
+`cargo test -p oa-desktop behavior_layout_scene_experiment -- --nocapture` gate
+on the exact identified wired source, then publish fixture, evaluator and result
+together. Remote peer machines cannot use workspace-local links.
+
+Independent bounded source review confirmed the fixture ownership/endpoint contract and the numerical expectations above. Formatting and whitespace checks passed. Compilation and execution remain pending; these findings do not establish an editing transaction or native behavior.

harness/experiments/behavior-layout-scene-20260912/lifetime.rs

@@ -0,0 +1,259 @@
+//! Real current Scene/lifecycle evaluator, independent of the original fixture.
+//! No replacement activation geometry or future peer implementation is used.
+use super::*;
+use crate::document::Document;
+use oa_core::source_project::{ProjectLimits, SourceBundle};
+
+fn lifetime_document() -> (Document, Id) {
+    let source = include_str!("lifetime.arcadia");
+    let parsed = language::parse(source).expect("separate lifetime source parses");
+    let errors: Vec<_> = validation::validate(&parsed)
+        .into_iter()
+        .filter(|issue| issue.severity == validation::Severity::Error)
+        .collect();
+    assert!(
+        errors.is_empty(),
+        "lifetime fixture semantic errors: {errors:?}"
+    );
+    let owner = id(&parsed, "lifetime_conversation");
+    let bundle = SourceBundle {
+        entry: "lifetime.arcadia".into(),
+        files: BTreeMap::from([("lifetime.arcadia".into(), source.into())]),
+    };
+    let document = Document::from_bundle(bundle.clone(), ProjectLimits::default())
+        .expect("lifetime fixture is ordinarily admitted");
+    assert_eq!(document.project(), &parsed);
+    assert_eq!(document.bundle(), &bundle);
+    assert_eq!(language::parse(&language::format(&parsed)).unwrap(), parsed);
+    (document, owner)
+}
+
+/// Numeric expectations are hand-derived current-Scene metrics, not proposed
+/// permanent spacing rules: Action95, message92, initial occurrence148.
+fn assert_lifetime_geometry(
+    scene: &Scene,
+    project: &Project,
+    owner: Id,
+    birth: f32,
+    call_y: f32,
+    death: f32,
+) {
+    let requester = id(project, "requester");
+    let provider = id(project, "provider");
+    let create = id(project, "create_receiver");
+    let call = id(project, "service_call");
+    let delete = id(project, "delete_receiver");
+    let left = scene.lanes[&requester];
+    let right = scene.lanes[&provider];
+    assert_eq!((left, right), (160., 400.));
+    assert_eq!(row(scene, id(project, "before_birth")), 148.);
+    assert_eq!(row(scene, create), birth);
+    assert_eq!(row(scene, call), call_y);
+    assert_eq!(row(scene, delete), death);
+    assert!(
+        birth > 148.,
+        "receiver creation is delayed beyond the opening action"
+    );
+    assert_eq!(scene.rows[&create].0, owner);
+    assert_eq!(scene.rows[&delete].0, owner);
+
+    // Exercise the actual Rendering bridge, including marker hit identity and
+    // its clipping contract, rather than rebuilding lifetimes from our rows.
+    let alive = scene
+        .lifecycle
+        .alive_spans(provider, owner, 85., scene.size.height - 20.);
+    assert_eq!(
+        alive
+            .iter()
+            .map(|span| (span.start, span.end))
+            .collect::<Vec<_>>(),
+        vec![(birth, death)]
+    );
+    assert!(
+        scene
+            .lifecycle
+            .alive_spans(provider, owner, 85., birth)
+            .is_empty()
+    );
+    assert!(
+        scene
+            .lifecycle
+            .alive_spans(provider, owner, death, scene.size.height - 20.)
+            .is_empty()
+    );
+    let sender_alive = scene
+        .lifecycle
+        .alive_spans(requester, owner, 85., scene.size.height - 20.);
+    assert_eq!(
+        sender_alive
+            .iter()
+            .map(|span| (span.start, span.end))
+            .collect::<Vec<_>>(),
+        vec![(85., scene.size.height - 20.)]
+    );
+    assert_eq!(
+        scene.lifecycle.marker_at(Point::new(right, birth)),
+        Some(create)
+    );
+    assert_eq!(
+        scene.lifecycle.marker_at(Point::new(right, death)),
+        Some(delete)
+    );
+    assert_eq!(scene.hit(Point::new(right, birth)), Some(create));
+    assert_eq!(scene.hit(Point::new(right, death)), Some(delete));
+    assert_eq!(
+        line(scene, create).points,
+        vec![Point::new(left, birth), Point::new(right - 70., birth)]
+    );
+    assert_eq!(
+        line(scene, call).points,
+        vec![Point::new(left, call_y), Point::new(right, call_y)]
+    );
+    assert_eq!(
+        line(scene, delete).points,
+        vec![Point::new(left, death), Point::new(right, death)]
+    );
+    assert!(line(scene, create).label_at.y + 22. < birth - 14.);
+
+    // Inspect actual activation boxes produced by Scene::activation_sequence.
+    // A correlated Reply is absent, so death must clip the bar, not close the
+    // semantic call. Do not accept a new generic minimum-height tail after death.
+    let bars: Vec<_> = scene
+        .boxes
+        .iter()
+        .filter(|item| item.id == call && item.title.is_empty())
+        .collect();
+    assert_eq!(bars.len(), 1);
+    assert_eq!(
+        bars[0].rect,
+        Rectangle::new(
+            Point::new(right - 4., call_y),
+            Size::new(8., death - call_y)
+        )
+    );
+    assert_eq!(bars[0].rect.y + bars[0].rect.height, death);
+    assert!(
+        bars.iter()
+            .all(|item| item.rect.y >= birth && item.rect.y + item.rect.height <= death)
+    );
+    assert_eq!(scene.open_calls, vec![Point::new(right + 12., death - 16.)]);
+    assert!(!project.elements.values().any(|element| matches!(
+        element.shared(),
+        Some(SharedBody::Occurrence {
+            body: OccurrenceBody::Exchange {
+                message_kind: MessageKind::Reply,
+                ..
+            },
+            ..
+        })
+    )));
+}
+
+#[test]
+fn delayed_create_call_and_delete_have_real_lifetime_markers_and_exact_clipped_activation() {
+    let (document, owner) = lifetime_document();
+    let before = document.snapshot();
+    let source = document.bundle().clone();
+    let scene = Scene::sequence(document.project(), owner, owner);
+    assert_lifetime_geometry(&scene, document.project(), owner, 243., 335., 427.);
+    assert_eq!(scene.size.height, 564.);
+    assert_eq!(scene.sequence_bounds[&owner], (106., 477.));
+    same_geometry(&scene, &render(document.project(), owner, &Layout::new()));
+    let reparsed = language::parse(&language::format(document.project())).unwrap();
+    same_geometry(&scene, &Scene::sequence(&reparsed, owner, owner));
+    assert_eq!(document.project(), &before.decoded.project);
+    assert_eq!(document.bundle(), &source);
+    assert!(!document.dirty() && !document.can_undo() && !document.can_redo());
+}
+
+#[test]
+fn moving_create_moves_real_lifetime_and_followers_without_changing_semantics_or_source() {
+    let (document, owner) = lifetime_document();
+    let before = document.snapshot();
+    let source = document.bundle().clone();
+    let p = document.project();
+    let create = id(p, "create_receiver");
+    let provider = id(p, "provider");
+    let baseline = Scene::sequence(p, owner, owner);
+    let layout = drag(&Layout::new(), &baseline, create, 60.);
+    assert_eq!(layout, Layout::from([(create, 303.)]));
+    let moved = render(p, owner, &layout);
+    assert_lifetime_geometry(&moved, p, owner, 303., 395., 487.);
+    assert_eq!(moved.size.height, 624.);
+    assert_eq!(
+        moved
+            .lifecycle
+            .marker_at(Point::new(moved.lanes[&provider], 243.)),
+        None
+    );
+    assert_eq!(
+        named_box(&moved, id(p, "before_birth")).rect,
+        named_box(&baseline, id(p, "before_birth")).rect
+    );
+    assert_eq!(
+        moved.rows.keys().collect::<Vec<_>>(),
+        baseline.rows.keys().collect::<Vec<_>>()
+    );
+    assert_eq!(
+        moved.lines.iter().map(|line| line.id).collect::<Vec<_>>(),
+        baseline
+            .lines
+            .iter()
+            .map(|line| line.id)
+            .collect::<Vec<_>>()
+    );
+    let reparsed = language::parse(&language::format(p)).unwrap();
+    same_geometry(&moved, &render(&reparsed, owner, &layout));
+    assert_eq!(p, &before.decoded.project);
+    assert_eq!(document.bundle(), &source);
+    assert!(!document.dirty() && !document.can_undo() && !document.can_redo());
+}
+
+#[test]
+fn moving_delete_extends_only_to_actual_death_and_zero_motion_preserves_latent_lifetime_intent() {
+    let (document, owner) = lifetime_document();
+    let before = document.snapshot();
+    let source = document.bundle().clone();
+    let p = document.project();
+    let create = id(p, "create_receiver");
+    let delete = id(p, "delete_receiver");
+    let provider = id(p, "provider");
+    let baseline = Scene::sequence(p, owner, owner);
+    let later_delete = drag(&Layout::new(), &baseline, delete, 48.);
+    let extended = render(p, owner, &later_delete);
+    assert_lifetime_geometry(&extended, p, owner, 243., 335., 475.);
+    assert_eq!(extended.size.height, 612.);
+    assert_eq!(
+        extended
+            .lifecycle
+            .marker_at(Point::new(extended.lanes[&provider], 427.)),
+        None
+    );
+    assert_eq!(
+        line(&extended, create).points,
+        line(&baseline, create).points
+    );
+    assert_eq!(
+        line(&extended, id(p, "service_call")).points,
+        line(&baseline, id(p, "service_call")).points
+    );
+
+    // Create displacement forces the displayed death to487 while its authored
+    // request stays427. Both signed zero deltas must preserve that latent value.
+    let original = Layout::from([(create, 243.), (delete, 427.)]);
+    let displaced = drag(&original, &baseline, create, 60.);
+    let frame = render(p, owner, &displaced);
+    assert_lifetime_geometry(&frame, p, owner, 303., 395., 487.);
+    assert_eq!(displaced[&delete], 427.);
+    for delta in [0., -0.] {
+        let untouched = drag(&displaced, &frame, delete, delta);
+        assert_eq!(untouched, displaced);
+        same_geometry(&frame, &render(p, owner, &untouched));
+        let restored = drag(&untouched, &frame, create, -60.);
+        assert_eq!(restored, original);
+        same_geometry(&baseline, &render(p, owner, &restored));
+    }
+    assert_eq!(p, &before.decoded.project);
+    assert_eq!(document.bundle(), &source);
+    assert!(!document.dirty() && !document.can_undo() && !document.can_redo());
+}

harness/experiments/behavior-layout-scene-20260912/mod.rs

@@ -0,0 +1,345 @@
+//! Isolated test-only adapter. See README.md and wiring.patch before running.
+//! It drives the actual parent Scene; it contains no replacement geometry model.
+use super::*;
+use oa_core::{language, validation};
+use std::cell::RefCell;
+
+mod lifetime;
+
+type Layout = BTreeMap<Id, f32>;
+
+thread_local! {
+    static ANCHORS: RefCell<Option<Layout>> = const { RefCell::new(None) };
+}
+
+struct AnchorScope(Option<Layout>);
+impl AnchorScope {
+    fn install(layout: &Layout) -> Self {
+        Self(ANCHORS.with(|slot| slot.replace(Some(layout.clone()))))
+    }
+}
+impl Drop for AnchorScope {
+    fn drop(&mut self) {
+        ANCHORS.with(|slot| {
+            slot.replace(self.0.take());
+        });
+    }
+}
+
+/// Called only by the proposed cfg(test) row hook, before Scene records rows.
+/// Retains the CURRENT renderer's next-row floor; this is not general free y.
+pub(super) fn resolve_row_anchor(id: Id, y: &mut f32) {
+    ANCHORS.with(|slot| {
+        if let Some(desired) = slot.borrow().as_ref().and_then(|map| map.get(&id)) {
+            assert!(desired.is_finite());
+            *y = (*y).max(*desired);
+        }
+    });
+}
+
+fn render(project: &Project, owner: Id, layout: &Layout) -> Scene {
+    let _scope = AnchorScope::install(layout);
+    Scene::sequence(project, owner, owner)
+}
+
+/// Pointer intent differs from explicit SetDesiredY: zero displacement preserves
+/// the complete original authored candidate even when desired != displayed.
+fn drag(original: &Layout, frame: &Scene, target: Id, delta_y: f32) -> Layout {
+    assert!(delta_y.is_finite());
+    if delta_y == 0. {
+        return original.clone();
+    }
+    let mut next = original.clone();
+    next.insert(target, frame.rows[&target].1 + delta_y);
+    next
+}
+
+fn id(p: &Project, alias: &str) -> Id {
+    p.identities()
+        .into_iter()
+        .find(|(_, name)| *name == alias)
+        .unwrap()
+        .0
+}
+
+fn fixture() -> (Project, Id) {
+    let p = language::parse(include_str!("fixture.arcadia")).expect("real Arcadia fixture parses");
+    let errors: Vec<_> = validation::validate(&p)
+        .into_iter()
+        .filter(|issue| issue.severity == validation::Severity::Error)
+        .collect();
+    assert!(errors.is_empty(), "fixture semantic errors: {errors:?}");
+    let owner = id(&p, "conversation");
+    (p, owner)
+}
+
+fn row(scene: &Scene, id: Id) -> f32 {
+    scene.rows[&id].1
+}
+fn line(scene: &Scene, id: Id) -> &Line {
+    assert_eq!(scene.lines.iter().filter(|line| line.id == id).count(), 1);
+    scene.lines.iter().find(|line| line.id == id).unwrap()
+}
+fn named_box(scene: &Scene, id: Id) -> &BoxItem {
+    scene
+        .boxes
+        .iter()
+        .find(|item| item.id == id && !item.title.is_empty())
+        .unwrap()
+}
+fn same_geometry(a: &Scene, b: &Scene) {
+    assert_eq!(a.rows, b.rows);
+    assert_eq!(a.sequence_bounds, b.sequence_bounds);
+    assert_eq!(a.size, b.size);
+    assert_eq!(a.lanes, b.lanes);
+    assert_eq!(a.lifecycle, b.lifecycle);
+    assert_eq!(a.open_calls, b.open_calls);
+    let lines = |s: &Scene| {
+        s.lines
+            .iter()
+            .map(|l| {
+                (
+                    l.id,
+                    l.points.clone(),
+                    l.label_at,
+                    l.label.clone(),
+                    l.dashed,
+                )
+            })
+            .collect::<Vec<_>>()
+    };
+    let boxes = |s: &Scene| {
+        s.boxes
+            .iter()
+            .map(|b| (b.id, b.rect, b.title.clone(), b.detail.clone(), b.marker))
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(lines(a), lines(b));
+    assert_eq!(boxes(a), boxes(b));
+    let slots = |s: &Scene| {
+        s.slots
+            .iter()
+            .map(|s| (s.slot.parent, s.slot.before, s.y, s.label.clone()))
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(slots(a), slots(b));
+}
+
+#[test]
+fn real_parser_roundtrip_and_baseline_scene_have_independent_expected_anchors() {
+    let (p, owner) = fixture();
+    let before = p.clone();
+    let source = language::format(&p);
+    let reparsed = language::parse(&source).unwrap();
+    assert_eq!(reparsed, p);
+    let baseline = Scene::sequence(&p, owner, owner);
+    same_geometry(&baseline, &render(&p, owner, &Layout::new()));
+    same_geometry(&baseline, &Scene::sequence(&reparsed, owner, owner));
+    let first = id(&p, "first");
+    let second = id(&p, "second");
+    assert_ne!(first, second);
+    for occurrence in [first, second] {
+        assert!(matches!(p.elements[&occurrence].shared(),
+            Some(SharedBody::Occurrence { body: OccurrenceBody::Exchange { exchange: Some(edge), .. }, .. })
+            if *edge == id(&p, "channel")));
+    }
+    // Hand-derived current metrics: start148, each message92, fragment55,
+    // operand90, action95, fragment trailing64. These are regression oracles,
+    // NOT a claim that those fixed spacings should remain product constraints.
+    for (alias, expected) in [
+        ("first", 148.),
+        ("second", 240.),
+        ("fragment", 332.),
+        ("nested", 477.),
+        ("self_call", 636.),
+        ("self_reply", 728.),
+    ] {
+        assert_eq!(row(&baseline, id(&p, alias)), expected, "{alias}");
+    }
+    assert_eq!(baseline.rows[&id(&p, "nested")].0, id(&p, "operand"));
+    assert_eq!(named_box(&baseline, id(&p, "nested")).rect.y, 457.);
+    let frame = named_box(&baseline, id(&p, "fragment")).rect;
+    assert_eq!((frame.y, frame.height), (332., 240.));
+    let left = baseline.lanes[&id(&p, "left")];
+    let right = baseline.lanes[&id(&p, "right")];
+    assert_eq!(
+        line(&baseline, first).points,
+        vec![Point::new(left, 148.), Point::new(right, 148.)]
+    );
+    assert_eq!(
+        line(&baseline, second).points,
+        vec![Point::new(left, 240.), Point::new(right, 240.)]
+    );
+    let local = line(&baseline, id(&p, "self_call"));
+    assert_eq!(
+        local.points,
+        vec![
+            Point::new(right, 636.),
+            Point::new(right + 75., 636.),
+            Point::new(right + 75., 660.),
+            Point::new(right, 660.)
+        ]
+    );
+    assert_eq!(p, before);
+    assert_eq!(language::format(&p), source);
+}
+
+#[test]
+fn moved_repeat_drives_actual_scene_followers_frames_and_self_message_without_semantic_edits() {
+    let (p, owner) = fixture();
+    let before = p.clone();
+    let source = language::format(&p);
+    let baseline = Scene::sequence(&p, owner, owner);
+    let second = id(&p, "second");
+    let candidate = drag(&Layout::new(), &baseline, second, 40.);
+    assert_eq!(candidate, Layout::from([(second, 280.)]));
+    let moved = render(&p, owner, &candidate);
+    assert_eq!(row(&moved, id(&p, "first")), 148.);
+    assert_eq!(row(&moved, second), 280.);
+    assert_eq!(row(&moved, id(&p, "nested")), 517.);
+    assert_eq!(row(&moved, id(&p, "self_call")), 676.);
+    assert_eq!(row(&moved, id(&p, "self_reply")), 768.);
+    assert_eq!(
+        line(&moved, id(&p, "first")).points,
+        line(&baseline, id(&p, "first")).points
+    );
+    for alias in ["second", "self_call", "self_reply"] {
+        assert_eq!(
+            line(&moved, id(&p, alias)).points.len(),
+            line(&baseline, id(&p, alias)).points.len()
+        );
+        for (old, new) in line(&baseline, id(&p, alias))
+            .points
+            .iter()
+            .zip(&line(&moved, id(&p, alias)).points)
+        {
+            assert_eq!(new.x, old.x);
+            assert_eq!(new.y - old.y, 40.);
+        }
+    }
+    let frame = named_box(&moved, id(&p, "fragment")).rect;
+    assert_eq!((frame.y, frame.height), (372., 240.));
+    assert_eq!(named_box(&moved, id(&p, "nested")).rect.y, 497.);
+    same_geometry(&moved, &render(&p, owner, &candidate));
+    same_geometry(
+        &moved,
+        &render(&language::parse(&source).unwrap(), owner, &candidate),
+    );
+    assert_eq!(p, before); // Entire Project, not only the steps vector.
+    assert_eq!(language::format(&p), source);
+}
+
+#[test]
+fn nested_anchor_grows_actual_fragment_and_self_call_keeps_its_receive_offset() {
+    let (p, owner) = fixture();
+    let before = p.clone();
+    let baseline = Scene::sequence(&p, owner, owner);
+    let nested = id(&p, "nested");
+    let candidate = drag(&Layout::new(), &baseline, nested, 30.);
+    let moved = render(&p, owner, &candidate);
+    let frame = named_box(&moved, id(&p, "fragment")).rect;
+    assert_eq!((frame.y, frame.height), (332., 270.));
+    assert_eq!(named_box(&moved, nested).rect.y, 487.);
+    assert_eq!(row(&moved, id(&p, "self_call")), 666.);
+    let call = id(&p, "self_call");
+    let next = drag(&candidate, &moved, call, 18.);
+    let local = render(&p, owner, &next);
+    assert_eq!(row(&local, call), 684.);
+    assert_eq!(line(&local, call).points.first().unwrap().y, 684.);
+    assert_eq!(line(&local, call).points.last().unwrap().y, 708.);
+    assert_eq!(row(&local, id(&p, "self_reply")), 776.);
+    assert_eq!(
+        named_box(&local, nested).rect,
+        named_box(&moved, nested).rect
+    );
+    assert_eq!(p, before);
+}
+
+#[test]
+fn zero_pointer_delta_preserves_latent_authored_intent_but_explicit_assignment_can_change_it() {
+    let (p, owner) = fixture();
+    let baseline = Scene::sequence(&p, owner, owner);
+    let first = id(&p, "first");
+    let second = id(&p, "second");
+    let original = Layout::from([(first, 148.), (second, 240.)]);
+    let displaced = drag(&original, &baseline, first, 200.);
+    let frame = render(&p, owner, &displaced);
+    assert_eq!(row(&frame, second), 440.);
+    assert_eq!(displaced[&second], 240.);
+    let untouched = drag(&displaced, &frame, second, 0.);
+    assert_eq!(untouched, displaced);
+    let back = drag(&untouched, &frame, first, -200.);
+    assert_eq!(back, original);
+    assert_eq!(row(&render(&p, owner, &back), second), 240.);
+    let mut explicit = displaced.clone();
+    explicit.insert(second, 440.); // Explicit SetDesiredY, not a pointer gesture.
+    let explicit_back = drag(&explicit, &frame, first, -200.);
+    assert_eq!(row(&render(&p, owner, &explicit_back), second), 440.);
+}
+
+#[test]
+fn source_reorder_keeps_override_bound_to_occurrence_identity_and_does_not_write_back_projection() {
+    let (p, owner) = fixture();
+    let input = include_str!("fixture.arcadia");
+    let reordered_source =
+        input.replace("[@first, @second, @fragment", "[@second, @first, @fragment");
+    assert_ne!(input, reordered_source);
+    let reordered = language::parse(&reordered_source).unwrap();
+    let before = reordered.clone();
+    let second = id(&p, "second");
+    let first = id(&p, "first");
+    assert_eq!(id(&reordered, "second"), second);
+    let scene = render(&reordered, owner, &Layout::from([(second, 280.)]));
+    assert_eq!(row(&scene, second), 280.);
+    assert_eq!(row(&scene, first), 372.);
+    assert_eq!(
+        &reordered.elements[&owner].steps().unwrap()[..2],
+        &[second, first]
+    );
+    assert_eq!(reordered, before);
+    assert_eq!(
+        language::parse(&language::format(&reordered)).unwrap(),
+        before
+    );
+}
+
+#[test]
+fn current_floor_is_an_explicit_counterexample_to_general_free_positioning() {
+    let (p, owner) = fixture();
+    let baseline = Scene::sequence(&p, owner, owner);
+    let second = id(&p, "second");
+    let requested = drag(&Layout::new(), &baseline, second, -40.);
+    assert_eq!(requested[&second], 200.);
+    assert_eq!(row(&render(&p, owner, &requested), second), 240.);
+    // This expected mismatch records a limitation; it is not acceptance of
+    // silently clamped product gestures or proof that y200 is semantically bad.
+}
+
+#[test]
+fn scoped_hook_is_inactive_by_default_thread_local_and_restored_after_panic() {
+    let (p, owner) = fixture();
+    let first = id(&p, "first");
+    let baseline = Scene::sequence(&p, owner, owner);
+    let caught = std::panic::catch_unwind(|| {
+        let _scope = AnchorScope::install(&Layout::from([(first, 900.)]));
+        assert_eq!(row(&Scene::sequence(&p, owner, owner), first), 900.);
+        // Another test thread has no access to this thread's temporary anchors.
+        std::thread::spawn(|| {
+            let (p, owner) = fixture();
+            assert_eq!(
+                row(&Scene::sequence(&p, owner, owner), id(&p, "first")),
+                148.
+            );
+        })
+        .join()
+        .unwrap();
+        panic!("exercise scoped restoration");
+    });
+    let payload = caught.expect_err("the deliberate scope-restoration panic must occur");
+    assert_eq!(
+        payload.downcast_ref::<&str>().copied(),
+        Some("exercise scoped restoration"),
+        "an earlier failed assertion must not masquerade as the expected panic"
+    );
+    same_geometry(&baseline, &Scene::sequence(&p, owner, owner));
+}

harness/experiments/behavior-layout-scene-20260912/wiring.patch

@@ -0,0 +1,14 @@
+diff --git a/crates/oa-desktop/src/behavior.rs b/crates/oa-desktop/src/behavior.rs
+--- a/crates/oa-desktop/src/behavior.rs
++++ b/crates/oa-desktop/src/behavior.rs
+@@ -1120,1 +1120,5 @@
++#[cfg(test)]
++#[path = "../../../harness/experiments/behavior-layout-scene-20260912/mod.rs"]
++mod behavior_layout_scene_experiment;
++
+ struct BoxItem {
+@@ -1446,2 +1450,4 @@
++            #[cfg(test)]
++            behavior_layout_scene_experiment::resolve_row_anchor(*id, y);
+             if ordered {
+                 let slot = scenario::Slot {

harness/experiments/diagram-navigation-gates-20260912/.gitattributes

@@ -1,8 +0,0 @@
-correction-tests.log -text
-correction-tests-receipt.json -text
-core-outline-misfiltered.log -text
-core-outline-misfiltered-receipt.json -text
-core-outline-interruption.json -text
-core-outline-lib.log -text -whitespace
-core-outline-lib-receipt.json -text whitespace=cr-at-eol
-core-outline-inputs-after.json -text whitespace=cr-at-eol

harness/experiments/diagram-navigation-gates-20260912/core-outline-check.md

@@ -1,13 +0,0 @@
-# Core outline gate: corrected test selection
-
-The original command `cargo test -p oa-core language_outline_tests --locked --offline` used the source filename as its filter. Source `crates/oa-core/src/language.rs:2184–2186` instead declares `#[path = "language_outline_tests.rs"] mod outline_tests`; the intended twelve tests are in `language::outline_tests`. The original filter would select none of those tests, while Cargo still builds unrelated integration targets.
-
-Root interrupted only the verified owned Cargo process tree after discovering the selection error. The run began at 2026-09-12T22:29:21.4944572Z and closed at 2026-09-12T23:19:37.6119510Z with exitCode -1. This is an interrupted invalid gate, neither a passing result nor a product test failure. Its [raw output](core-outline-misfiltered.log), [terminal receipt](core-outline-misfiltered-receipt.json) and [interruption record](core-outline-interruption.json) are preserved with text conversion disabled.
-
-The replacement is `cargo test -p oa-core --lib language::outline_tests:: --locked --offline`. Its runner requires the result to contain twelve passed tests, zero failures and zero ignored cases in addition to Cargo exit0, preventing empty test selection from being accepted. Corrected execution passed: **12 passed, 0 failed, 0 ignored**, Cargo exit 0. The [raw output](core-outline-lib.log) and [terminal receipt](core-outline-lib-receipt.json) identify the command and timestamps. The runner captured evidence base `4db1ef543ced916179194272bf0e65dce73cb107`; later evidence-only commit `2568c70455ba8f6099b0ed92dd8321d50841a984` was present at closure. Production source remains `46b4f3c0d0f04050ad6d705051ee0199138e47a2`.
-
-The run started 2026-09-12T23:20:37.3391898Z and closed 2026-09-13T00:13:35.4441019Z. Cargo reported 52m07s compilation and 3.25s test execution. The heavily delayed host makes this unsuitable as comparative performance evidence. This focused library result does not cover all core tests, strict lint, the later rename union or native GUI acceptance. Raw trailing blank lines are preserved as output evidence.
-
-All 562 captured inputs and their membership remained unchanged from the original pre-gate capture through this corrected core result. The [post-core input manifest](core-outline-inputs-after.json) matches the same path/byte/SHA-256 entries in the [published desktop manifest](correction-all-inputs.json); evidence-only report changes and the unwired draft were not compiler inputs.
-
-The receipt and post-core manifest retain original CRLF bytes with `whitespace=cr-at-eol`; the raw log also retains its terminal blank line. These exact-path attributes avoid treating original evidence line endings as source-format defects.

harness/experiments/diagram-navigation-gates-20260912/core-outline-lib-receipt.json

@@ -1,9 +0,0 @@
-{
-  "command": "cargo test -p oa-core --lib language::outline_tests:: --locked --offline",
-  "startUtc": "2026-09-12T23:20:37.3391898Z",
-  "endUtc": "2026-09-13T00:13:35.4441019Z",
-  "base": "4db1ef543ced916179194272bf0e65dce73cb107",
-  "cargoExitCode": 0,
-  "expectedTests": 12,
-  "expectedTestsPassed": true
-}

harness/experiments/diagram-navigation-gates-20260912/core-outline-lib.log

@@ -1,20 +0,0 @@
-   Compiling oa-core v0.2.0 (C:\Users\User\Documents\Git\ARCADIA-Studio\.local\diagram-coverage-fixes-ytr83r-20260912\crates\oa-core)
-    Finished `test` profile [unoptimized] target(s) in 52m 07s
-     Running unittests src\lib.rs (C:\Users\User\Documents\Git\ARCADIA-Studio\target\debug\deps\oa_core-38898034cc715c78.exe)
-
-running 12 tests
-test language::outline_tests::closed_id_at_eof_is_inside_the_declaration_extent ... ok
-test language::outline_tests::bounds_refuse_before_returning_a_partial_outline ... ok
-test language::outline_tests::header_shape_still_requires_valid_hexadecimal_uuid_data ... ok
-test language::outline_tests::invalid_full_scan_keeps_closed_children_and_reports_lexical_body_facts ... ok
-test language::outline_tests::deeply_nested_bounds_use_the_same_iterative_walk_and_declaration_budget ... ok
-test language::outline_tests::keyword_alias_and_collisions_keep_every_source_ordered_header ... ok
-test language::outline_tests::missing_bad_and_historical_ids_never_allocate_authored_identity ... ok
-test language::outline_tests::noncanonical_uuid_spellings_have_no_outline_or_analysis_identity ... ok
-test language::outline_tests::missing_body_syntax_is_unchecked_even_when_known_error_flags_are_clear ... ok
-test language::outline_tests::outline_roles_preserve_unicode_crlf_and_exact_escaped_uuid_literal ... ok
-test language::outline_tests::outline_ranges_follow_current_bytes_without_identity_stabilization ... ok
-test language::outline_tests::uppercase_and_json_escaped_header_ids_survive_both_parsers_and_outline ... ok
-
-test result: ok. 12 passed; 0 failed; 0 ignored; 0 measured; 42 filtered out; finished in 3.25s
-

harness/experiments/diagram-navigation-gates-20260912/core-outline-misfiltered-receipt.json

@@ -1,8 +0,0 @@
-{
-  "command": "cargo test -p oa-core language_outline_tests --locked --offline",
-  "startUtc": "2026-09-12T22:29:21.4944572Z",
-  "endUtc": "2026-09-12T23:19:37.6119510Z",
-  "base": "46b4f3c0d0f04050ad6d705051ee0199138e47a2",
-  "uncommittedChanges": true,
-  "exitCode": -1
-}

harness/experiments/diagram-navigation-gates-20260912/core-outline-misfiltered.log

@@ -1 +0,0 @@
-   Compiling oa-core v0.2.0 (C:\Users\User\Documents\Git\ARCADIA-Studio\.local\diagram-coverage-fixes-ytr83r-20260912\crates\oa-core)

harness/experiments/diagram-navigation-gates-20260912/correction-handoff.md

@@ -1,7 +1,5 @@
 # Diagram navigation coverage corrections — handoff, 2026-09-12
 
-**Root verification update:** Windows desktop execution passed: 894 passed, 0 failed, 1 ignored on source46b4f3c. See the [complete result and input evidence](correction-tests.md). Core-specific checks, strict lint, matching GUI and native acceptance remain separate.
-
 ## Candidate and ownership
 
 Implemented on branch `codex/diagram-coverage-fixes-ytr83r-20260912`. Production base is `fdf756e6a41b1879760e45c2c263bd671b562fe3`; the root's subsequent docs-only commit does not change that production base. Candidate HEAD when this pre-format manifest was captured: `f23615ffebdc3ca6872f98b6889ec49bb4e8abda`.

harness/experiments/diagram-navigation-gates-20260912/correction-tests-receipt.json

@@ -1,8 +0,0 @@
-{
-  "command": "cargo test -p oa-desktop --all-targets --locked --offline",
-  "startUtc": "2026-09-12T22:10:52.9461475Z",
-  "endUtc": "2026-09-12T22:42:39.0355299Z",
-  "base": "46b4f3c0d0f04050ad6d705051ee0199138e47a2",
-  "uncommittedChanges": true,
-  "exitCode": 0
-}

harness/experiments/diagram-navigation-gates-20260912/correction-tests.log

@@ -1,910 +0,0 @@
-   Compiling oa-core v0.2.0 (C:\Users\User\Documents\Git\ARCADIA-Studio\.local\diagram-coverage-fixes-ytr83r-20260912\crates\oa-core)
-   Compiling oa-server v0.2.0 (C:\Users\User\Documents\Git\ARCADIA-Studio\.local\diagram-coverage-fixes-ytr83r-20260912\crates\oa-server)
-   Compiling oa-desktop v0.2.0 (C:\Users\User\Documents\Git\ARCADIA-Studio\.local\diagram-coverage-fixes-ytr83r-20260912\crates\oa-desktop)
-    Finished `test` profile [unoptimized] target(s) in 12m 44s
-     Running unittests src\main.rs (C:\Users\User\Documents\Git\ARCADIA-Studio\target\debug\deps\arcadia_studio-27db9628b266bf39.exe)
-
-running 895 tests
-test app::architecture_authoring::tests::architecture_blank_names_and_escape_never_accept_placeholder_or_rename ... ok
-test app::architecture_authoring::tests::architecture_captured_escape_does_not_cancel_other_controls_or_placement ... ok
-test app::architecture_authoring::tests::architecture_f2_routes_selected_node_to_inline_rename_and_exact_undo ... ok
-test app::architecture_authoring::tests::architecture_allocated_work_is_root_owned_and_one_exact_history_change ... ok
-test app::architecture_authoring::tests::architecture_invalid_click_cannot_poison_inline_or_checkpoint_geometry ... ok
-test app::architecture_authoring::tests::architecture_first_focused_input_escape_cancels_create_and_rename ... ok
-test app::architecture_authoring_tests::architecture_cancelled_gesture_cannot_commit_a_later_named_draft ... ok
-test app::architecture_authoring::tests::architecture_stale_submit_keeps_create_and_rename_visible_and_exact ... ok
-test app::architecture_authoring_tests::architecture_canvas_left_click_uses_world_coordinate_once_at_zoom_and_pan ... ok
-test app::architecture_authoring_tests::architecture_checkpoint_retains_exact_name_point_and_fresh_binding_without_commands ... ok
-test app::architecture_authoring_tests::architecture_context_choices_are_small_and_system_is_singleton ... ok
-test app::architecture_authoring_tests::architecture_creation_names_before_commit_preserves_camera_and_undoes_once ... ok
-test app::architecture_authoring_tests::architecture_contextual_allocation_creates_work_relation_and_node_in_one_undo ... ok
-test app::architecture_authoring_tests::architecture_existing_inventory_is_contextual_and_placement_never_implies_allocation ... ok
-test app::architecture_authoring_tests::architecture_name_survives_rejected_click_resize_navigation_and_escape_is_explicit ... ok
-test app::architecture_authoring_tests::architecture_f2_rename_preserves_identity_placement_and_atomic_history ... ok
-test app::architecture_authoring_tests::basic_transition_explicit_overview_focus_wins_over_an_already_populated_architecture ... ok
-test app::architecture_authoring_tests::architecture_rejected_submission_keeps_inline_name_visible_and_invalid_click_is_ignored ... ok
-test app::behavior_lifecycle_tests::passive_behavior_canvas_events_do_not_apply_property_drafts ... ok
-test app::behavior_lifecycle_tests::incomplete_behavior_form_is_dirty_close_save_retains_it_and_cancel_allows_switching ... ok
-test app::behavior_lifecycle_tests::pending_behavior_blocks_navigation_property_edits_and_model_history ... ok
-test app::behavior_lifecycle_tests::pending_behavior_blocks_source_creation_and_source_history_replay ... ok
-test app::behavior_lifecycle_tests::save_prepares_behavior_before_opening_destination_and_cancel_keeps_one_undo ... ok
-test app::behavior_lifecycle_tests::source_writeback_failure_keeps_typed_behavior_form_for_repair_and_one_undo ... ok
-test app::checkpoints::tests::checkpoint_completion_releases_the_writer_while_a_context_menu_is_open ... ok
-test app::checkpoints::tests::checkpoint_inline_create_and_rename_restore_focus_without_changing_drafts_or_history ... ok
-test app::checkpoints::tests::checkpoint_noninline_contexts_keep_other_focus_and_still_lint ... ok
-test app::checkpoints::tests::discard_and_close_waits_for_the_late_checkpoint_then_retires_it ... ok
-test app::checkpoints::tests::home_resume_keeps_state_view_while_explicit_architecture_remains_reachable ... ok
-test app::checkpoints::tests::home_resume_returns_to_each_actual_workspace_without_model_edits ... ok
-test app::checkpoints::tests::home_resume_retains_invalid_source_and_property_drafts ... ok
-test app::checkpoints::tests::malformed_checkpoint_does_not_replace_the_current_model ... ok
-test app::checkpoints::tests::recent_and_recovery_navigation_respect_unsaved_decision ... ok
-test app::checkpoints::tests::restored_copy_keeps_raw_property_and_requires_save_without_local_or_hosted_binding ... ok
-test app::checkpoints::tests::stale_write_completion_cannot_recover_a_discarded_document ... ok
-test app::checkpoints::tests::walkthrough_request_keeps_unfinished_source_behind_the_normal_pending_guard ... ok
-test app::data_paging_lifecycle_tests::paging_preserves_same_context_and_resets_on_layer_or_document_replacement ... ok
-test app::diagram_reveal::tests::actual_window_resize_before_first_measurement_retains_focus_for_the_new_context ... ok
-test app::diagram_reveal::tests::all_reveal_surfaces_recenter_once_after_the_real_viewport_and_preserve_authored_state ... ok
-test app::checkpoints::tests::saving_an_older_snapshot_keeps_recovery_for_newer_unsaved_work ... ok
-test app::diagram_reveal::tests::malformed_or_wrong_stamp_measurements_cannot_poison_a_pending_reveal ... ok
-test app::diagram_selection_tests::changing_visible_view_follows_its_clean_inspector_without_a_model_edit ... ok
-test app::diagram_reveal::tests::user_camera_edit_and_navigation_cancel_deferred_focus_without_late_snapping ... ok
-test app::diagram_selection_tests::diagram_switch_preserves_an_independent_semantic_inspection ... ok
-test app::diagram_selection_tests::diagram_uuid_edit_follows_the_same_view_or_a_different_picker_target ... ok
-test app::diagram_selection_tests::invalid_view_draft_blocks_the_switch_and_retains_raw_input ... ok
-test app::diagram_selection_tests::stale_diagram_choice_never_applies_an_unrelated_valid_draft ... ok
-test app::diagram_selection_tests::valid_pending_view_edit_applies_to_old_view_then_inspects_the_new_view ... ok
-test app::diagram_usages::tests::accepted_new_chooser_retires_old_measurement_without_blocking_future_viewports ... ok
-test app::diagram_usages::tests::allocation_navigation_keeps_relation_selection_and_exact_visual_work_lifetime ... ok
-test app::diagram_usages::tests::asynchronous_lookup_is_loading_inert_and_retains_filter_until_completion ... ok
-test app::diagram_usages::tests::closed_lookup_keeps_slot_and_replacement_waits_for_exact_old_completion ... ok
-test app::diagram_usages::tests::caret_uses_exact_verified_alias_identity_and_preserves_source_cursor ... ok
-test app::diagram_usages::tests::completion_releases_worker_behind_busy_modal_without_navigation ... ok
-test app::diagram_usages::tests::completion_after_cancel_releases_slot_without_reopening_or_moving ... ok
-test app::diagram_usages::tests::forged_completion_cannot_release_another_slot_or_admit_wrong_context ... ok
-test app::diagram_usages::tests::dirty_or_comment_caret_has_no_selected_object_fallback ... ok
-test app::diagram_usages::tests::old_panel_tokens_and_forged_targets_cannot_redirect_selection ... ok
-test app::diagram_usages::tests::oversized_node_focus_stays_on_label_and_single_surface_query_excludes_other_views ... ok
-test app::diagram_usages::tests::port_navigation_selects_port_and_exact_visible_owner_without_editing_geometry ... ok
-test app::diagram_usages::tests::query_presentation_snapshot_keeps_expansion_without_retaining_live_state ... ok
-test app::diagram_usages::tests::pending_source_behavior_and_modal_inputs_block_open_and_choose_without_loss ... ok
-test app::diagram_usages::tests::repeated_preview_arrows_select_the_relation_and_highlight_the_exact_caller_link ... ok
-test app::diagram_usages::tests::repeated_scenario_messages_select_the_exact_occurrence_and_move_camera ... ok
-test app::diagram_usages::tests::repeated_process_calls_reveal_the_chosen_caller_and_distinct_tile_camera ... ok
-test app::diagram_usages::tests::revision_retarget_and_document_change_make_old_destinations_inert ... ok
-test app::diagram_usages::tests::reset_keeps_old_worker_slot_and_only_new_document_results_are_admitted ... ok
-test app::diagram_usages::tests::saved_node_and_edge_navigation_preserve_whole_sources_and_actual_history ... ok
-test app::diagram_usages::tests::stale_caret_completion_never_opens_diagrams_for_current_selection ... ok
-test app::diagram_usages::tests::stale_open_context_cannot_replace_a_panel ... ok
-test app::diagram_usages::tests::stale_revision_completion_refreshes_asynchronously_without_activating ... ok
-test app::diagram_usages::tests::state_row_navigation_has_exact_visual_row_without_retargeting_the_selected_relation ... ok
-test app::diagram_usages::tests::tree_origin_captures_subject_and_never_falls_back_to_current_selection_or_name ... ok
-test app::diagram_usages::tests::whole_surface_camera_fits_huge_extent_while_target_camera_remains_readable ... ok
-test app::diagram_usages::tests::worker_failure_finishes_loading_and_can_be_retried_without_losing_sources ... ok
-test app::direct_scenario_tests::direct_scenario_camera_details_and_real_resize_invalidate_only_pointer_context ... ok
-test app::direct_scenario_tests::direct_scenario_rejects_every_stale_context_and_preserves_property_drafts ... ok
-test app::direct_scenario_tests::direct_scenario_creation_and_reorder_preserve_selection_and_each_undo_once ... ok
-test app::direct_scenario_tests::direct_scenario_source_failure_and_navigation_keep_form_until_success ... ok
-test app::hosted::tests::hosted_catalog_invalidation_follows_service_writes_and_observed_revision_changes ... ok
-test app::hosted::tests::hosted_catalog_search_credentials_and_failed_refresh_never_mix_result_scopes ... ok
-test app::hosted::tests::hosted_changed_bound_head_does_not_invalidate_another_services_empty_filter ... ok
-test app::hosted::tests::hosted_conflict_fetches_review_without_adoption_and_reload_is_undoable ... ok
-test app::hosted::tests::hosted_detached_drafts_and_recovery_remain_available_after_rejected_publish ... ok
-test app::hosted::tests::hosted_failed_cross_service_publication_checks_and_reloads_its_own_resource ... ok
-test app::hosted::tests::hosted_failed_or_cancelled_local_open_keeps_the_existing_document_and_destination ... ok
-test app::hosted::tests::hosted_invalid_and_detached_source_drafts_never_start_network_writes ... ok
-test app::hosted::tests::hosted_actual_app_tasks_publish_edit_conflict_correct_credentials_reload_and_open ... ok
-test app::hosted::tests::hosted_modal_blocks_underlying_edits_and_credentials_are_redacted ... ok
-test app::hosted::tests::hosted_new_revision_invalidates_filtered_catalog_even_without_a_displayed_row ... ok
-test app::hosted::tests::hosted_only_successful_source_save_as_changes_the_active_destination ... ok
-test app::hosted::tests::hosted_open_waits_for_unsaved_guard_and_failed_open_preserves_current_document ... ok
-test app::hosted::tests::hosted_publish_acknowledges_only_the_sent_snapshot_and_retains_undo ... ok
-test app::hosted::tests::hosted_invalid_local_open_repair_saves_locally_and_never_replaces_old_resource ... ok
-test app::hosted::tests::hosted_stale_completions_do_not_clear_current_busy_or_adopt_another_document ... ok
-test app::hosted::tests::hosted_unknown_save_is_acknowledged_by_exact_readback_without_retry ... ok
-test app::lint_tests::committed_check_cache_follows_edit_and_undo_while_drafts_stay_separate ... ok
-test app::lint_tests::lint_coalesces_work_and_rejects_obsolete_results ... ok
-test app::lint_tests::prior_document_lint_cannot_enter_reopened_model_or_block_next_checks ... ok
-test app::port_view_tests::catalog_creation_follows_the_new_port_and_keeps_group_browsing_explicit ... ok
-test app::port_view_tests::filtered_active_view_cannot_hide_a_created_port_when_eligible_owner_view_is_folded ... ok
-test app::process_canvas::direct_process_dirty_source_blocks_canvas_creation_without_losing_text ... ok
-test app::process_canvas::tests::direct_process_app_open_source_and_back_preserve_local_reference_identity ... ok
-test app::process_canvas::tests::direct_process_app_same_owner_selection_preserves_tool_but_owner_change_resets_it ... ok
-test app::process_canvas::tests::direct_process_app_save_details_resize_and_passive_geometry_keep_drafts_and_camera ... ok
-test app::process_canvas::tests::direct_process_app_source_failure_retains_form_then_commits_once_and_selects_occurrence ... ok
-test app::process_canvas::tests::direct_process_app_stale_context_dirty_source_and_properties_never_mutate ... ok
-test app::process_canvas::tests::process_focus_retains_rejected_draft_and_guards_selection_until_panels_restore ... ok
-test app::process_canvas::tests::direct_process_append_empty_first_second_exchange_has_exact_source_history ... ok
-test app::reference_authoring::tests::inspector_reference_browse_is_read_only_then_one_scoped_value_applies_with_exact_undo_redo ... ok
-test app::reference_authoring::tests::inspector_reference_retains_invalid_missing_and_incompatible_current_until_explicit_clear ... ok
-test app::reference_authoring::tests::chooser_rejects_old_results_after_context_recovery_reload_or_modal_and_keeps_history_text_out ... ok
-test app::reference_authoring::tests::mounted::mounted_form_tab_enters_in_both_directions_and_cycles_boundaries_without_losing_focus ... ok
-test app::reference_authoring::tests::mounted::mounted_delayed_return_cannot_focus_under_review_and_fresh_modal_tab_owns_its_form ... ok
-test app::reference_authoring::tests::mounted::mounted_reference_choice_stages_literal_identity_and_delayed_focus_cannot_hit_replacement_field ... ok
-test app::reference_authoring::tests::mounted::mounted_fresh_tab_reveals_offscreen_reference_and_return_reveals_it_again ... ok
-test app::reference_authoring::tests::mounted::mounted_reverse_review_required_rationale_remains_editable_beside_candidate_reference_form ... ok
-test app::reference_authoring::tests::mounted::mounted_reference_trigger_tabs_to_root_popup_search_escape_and_exact_adjacent_fields ... ok
-test app::reference_authoring::tests::mounted::mounted_scrolled_reference_anchor_uses_window_geometry_for_pointer_and_keyboard ... ok
-test app::reference_authoring::tests::reference_array_row_reorder_and_constructor_switch_invalidate_exact_old_field ... ok
-test app::reference_authoring::tests::review_reference_cannot_reopen_or_write_a_banked_row_after_another_row_takes_focus ... ok
-test app::reference_authoring::tests::review_reference_facets_groups_and_attachment_hosts_browse_without_replanning_and_reject_old_facet ... ok
-test app::repair_save_state_tests::recovering_applied_repair_rebinds_rolled_back_disk_bytes_without_changing_model ... ok
-test app::repair_save_state_tests::recovery_missing_entry_or_failed_reload_preserves_current_destination_save_authority ... ok
-test app::repair_save_state_tests::repair_history_compares_to_new_disk_baseline_and_then_successful_save ... ok
-test app::repair_save_state_tests::repair_to_previous_saved_bytes_requires_save_at_new_destination_and_guards_close ... ok
-test app::repair_save_state_tests::valid_equal_content_at_distinct_destinations_stays_clean ... ok
-test app::review_navigation_tests::rejected_semantic_source_writeback_retains_review_camera_and_original_navigation ... ok
-test app::review_navigation_tests::review_already_showing_the_target_keeps_its_camera_and_query ... ok
-test app::review_navigation_tests::semantic_name_take_selects_the_counterpart_view_in_both_directions_with_one_exact_history_entry ... ok
-test app::review_navigation_tests::semantic_review_without_a_destination_view_clears_the_old_layer_canvas_without_creating_a_view ... ok
-test app::save_as_tests::save_as_late_receipt_preserves_newer_raw_source_draft_and_destination ... ok
-test app::save_as_tests::save_as_preflight_rejects_historical_collision_before_starting_io ... ok
-test app::save_as_tests::save_as_receipt_then_one_undo_restores_meaning_and_saving_preserves_redo ... ok
-test app::source_project_tests::closed_detached_file_keeps_first_save_conflict_then_can_be_reloaded_fresh ... ok
-test app::source_project_tests::inactive_invalid_draft_blocks_graphical_changes_and_diagnostic_switches_files ... ok
-test app::source_project_tests::json_export_and_rejected_save_as_preserve_source_location_history_and_bytes ... ok
-test app::source_project_tests::missing_include_open_keeps_old_model_and_can_be_repaired_and_saved ... ok
-test app::source_project_tests::recovery_after_first_save_failure_retains_target_then_retries_without_reentering_path ... ok
-test app::source_project_tests::recovery_of_previous_save_as_target_does_not_redirect_current_project ... ok
-test app::source_project_tests::recovery_open_finds_first_save_journal_without_an_entry_file ... ok
-test app::source_project_tests::recovery_target_survives_edit_lint_apply_and_rejected_recovery_until_success ... ok
-test app::source_project_tests::source3_native_open_preserves_report_comments_nesting_and_save_reopen ... ok
-test app::source_project_tests::two_file_apply_graphical_edit_exact_undo_save_as_and_reopen ... ok
-test app::source_symbols::tests::back_after_origin_edit_uses_its_current_cursor_instead_of_the_old_range ... ok
-test app::source_symbols::tests::back_keeps_the_latest_64_actual_locations_without_reusing_dropped_history ... ok
-test app::source_symbols::tests::back_restores_exact_reversed_utf8_selection_and_crlf_source ... ok
-test app::source_symbols::tests::captured_find_and_modal_escape_use_one_actual_subscription_and_preserve_pending_work ... ok
-test app::source_symbols::tests::captured_subscription_does_not_duplicate_existing_behavior_or_architecture_routes ... ok
-test app::source_symbols::tests::close_during_busy_hides_panel_and_completion_does_not_reopen_it ... ok
-test app::source_symbols::tests::closed_results_stay_closed_on_exact_back_and_reopen_only_for_a_return_notice ... ok
-test app::source_symbols::tests::combined_modal_completion_releases_worker_without_navigation_or_model_changes ... ok
-test app::source_symbols::tests::combined_reference_chooser_blocks_navigation_and_completion_precedes_reconciliation ... ok
-test app::source_symbols::tests::completion_rejects_file_edit_session_cursor_interaction_and_raw_input_changes ... ok
-test app::source_symbols::tests::detached_duplicate_requires_an_explicit_choice_even_when_included_source_is_validated ... ok
-test app::source_symbols::tests::escape_dismisses_modal_before_underlying_source_results ... ok
-test app::source_symbols::tests::escape_dismisses_results_and_cancels_busy_navigation_without_changing_sources ... ok
-test app::source_symbols::tests::find_close_releases_removed_input_and_guarded_focus_respects_later_input ... ok
-test app::source_symbols::tests::find_only_captured_escape_closes_once_and_preserves_raw_query_and_selection ... ok
-test app::source_symbols::tests::invalid_unapplied_drafts_navigate_without_apply_or_losing_either_history ... ok
-test app::source_symbols::tests::matching_reveal_ticket_is_required_and_raw_input_invalidates_pending_reveal ... ok
-test app::source_symbols::tests::old_find_close_cannot_cancel_a_new_file_session_or_reopened_find_intent ... ok
-test app::source_symbols::tests::old_symbol_widget_envelopes_after_file_switch_preserve_same_session_intent ... ok
-test app::source_symbols::tests::old_symbol_widget_envelopes_after_reset_preserve_new_same_path_intent ... ok
-test app::source_symbols::tests::reset_retains_worker_slot_until_old_completion_then_admits_new_session_query ... ok
-test app::source_symbols::tests::saturated_raw_clock_never_authorizes_completion_or_reveal ... ok
-test app::source_symbols::tests::source_symbols_100_modules_1000_definitions_10000_uses ... ignored, manual 100-module latency/process-memory trial; run alone with --ignored --nocapture --test-threads=1
-test app::source_symbols::tests::unknown_job_cannot_release_current_worker_and_old_duplicate_cannot_replace_new_results ... ok
-test app::source_symbols::tests::valid_definition_and_reference_choice_keep_whole_model_and_source_unchanged ... ok
-test app::state_diagram_tests::all_context_dimensions_reject_stale_selection_camera_and_model_messages ... ok
-test app::state_diagram_tests::create_view_places_only_its_machine_and_restores_exact_source_in_one_undo ... ok
-test app::state_diagram_tests::direct_create_connect_select_and_move_keep_semantic_identity_and_atomic_history ... ok
-test app::state_diagram_tests::fallback_owner_first_selection_keeps_the_captured_context_for_its_first_move ... ok
-test app::state_diagram_tests::pending_drafts_block_every_direct_mutation_and_passive_camera_preserves_inputs ... ok
-test app::reference_authoring::tests::mounted::mounted_review_pointer_open_and_outside_dismissal_keep_background_input_inactive ... ok
-test app::state_diagram_tests::rejected_creation_keeps_source_and_selection_then_valid_owner_can_retry ... ok
-test app::state_diagram_tests::real_view_tool_and_history_changes_invalidate_old_release_events ... ok
-test app::state_diagram_tests::same_size_viewport_after_revision_or_tool_epoch_does_not_refit_the_camera ... ok
-test app::state_diagram_tests::shared_semantic_states_keep_architecture_and_behavior_placements_independent ... ok
-test app::state_diagram_tests::state_diagram_routes_constructor_and_source_open_to_the_existing_workspace_without_edits ... ok
-test app::state_diagram_tests::state_diagram_routes_picker_and_reveal_but_explicit_architecture_does_not_bounce ... ok
-test app::state_diagram_tests::state_navigation_catalog_selection_across_layers_resets_camera_and_tool ... ok
-test app::state_diagram_tests::state_diagram_routes_preserve_selected_raw_properties_and_pending_behavior_guards ... ok
-test app::state_diagram_tests::state_navigation_layer_change_resets_the_new_machine_at_the_same_viewport_size ... ok
-test app::state_diagram_tests::state_navigation_catalog_selection_of_another_machine_resets_camera_and_tool ... ok
-test app::state_diagram_tests::state_navigation_root_event_and_same_layer_keep_the_current_camera_and_tool ... ok
-test app::state_diagram_tests::state_navigation_return_to_the_same_view_preserves_camera_tool_and_fit_mode ... ok
-test app::transition_context_tests::explicit_destination_is_honored_and_ordinary_work_transition_still_places_in_architecture ... ok
-test app::transition_context_tests::explicit_behavior_internal_and_process_roots_keep_their_workspace_without_creating_a_view ... ok
-test app::transition_context_tests::rejected_source_writeback_keeps_review_and_navigation_and_invalid_draft_still_blocks_start ... ok
-test app::transition_context_tests::machine_and_typed_action_transitions_resolve_the_owner_and_reusing_that_context_retains_camera ... ok
-test app::view_copy_tests::copying_architecture_keeps_architecture_even_with_a_retained_state_view ... ok
-test app::transition_context_tests::scenario_transition_focuses_requested_counterpart_and_preserves_unrelated_views_in_both_directions ... ok
-test app::view_copy_tests::copying_the_current_state_view_uses_its_own_identity_and_is_one_source_undo ... ok
-test app::view_copy_tests::duplicate_rejection_preserves_an_incomplete_source_buffer ... ok
-test app::view_copy_tests::stale_copy_does_not_apply_an_unrelated_valid_property_draft ... ok
-test app::view_copy_tests::duplicate_rejection_preserves_invalid_property_and_pending_behavior_drafts ... ok
-test behavior::canvas_workspace::tests::relative_camera_zoom_keeps_the_cursor_world_point_and_rejects_nonfinite_inputs ... ok
-test behavior::canvas_workspace::tests::viewport_ordered_batch_uses_each_event_position_and_cancels_before_camera_motion ... ok
-test behavior::contextual_source_tests::contextual_source_app_checkpoint_restores_inner_raw_draft_without_model_adoption ... ok
-test behavior::contextual_source_tests::contextual_source_app_empty_actions_and_child_open_refuse_other_raw_editors ... ok
-test behavior::contextual_source_tests::contextual_source_app_modal_escape_then_child_back_then_parent_cancel_preserve_accepted_source ... ok
-test behavior::contextual_source_tests::contextual_source_back_retains_parent_and_rejects_late_child_event ... ok
-test behavior::contextual_source_tests::contextual_source_back_remains_available_after_owner_deletion_and_with_dirty_editors ... ok
-test behavior::contextual_source_tests::contextual_source_default_consumer_name_has_stable_alias_and_correlated_selection ... ok
-test behavior::contextual_source_tests::contextual_source_deleted_owner_view_retains_draft_instead_of_panicking_or_using_fallback ... ok
-test behavior::contextual_source_tests::contextual_source_empty_palette_lifeline_cannot_open_a_previous_owner_or_layer ... ok
-test behavior::contextual_source_tests::contextual_source_empty_history_reports_no_change_and_success_requires_a_real_history_step ... ok
-test behavior::contextual_source_tests::contextual_source_existing_choice_prunes_staged_dependency ... ok
-test behavior::contextual_source_tests::contextual_source_failed_source_budget_preserves_both_drafts_and_accepted_bytes ... ok
-test behavior::contextual_source_tests::contextual_source_incomplete_recovered_kind_reports_error_without_panicking ... ok
-test behavior::contextual_source_tests::contextual_source_inserts_work_on_the_exact_guarded_link_and_refuses_exchange_identity_conflict ... ok
-test behavior::contextual_source_tests::contextual_source_machine_before_any_owner_creates_optional_view_atomically ... ok
-test behavior::contextual_source_tests::contextual_source_lifelines_stage_exact_separate_records_and_one_history_entry ... ok
-test behavior::contextual_source_tests::contextual_source_mounted_small_editor_keeps_back_and_use_outside_field_scroll ... ok
-test behavior::contextual_source_tests::contextual_source_nested_semantic_parent_is_explicit_and_revalidated ... ok
-test behavior::contextual_source_tests::contextual_source_new_callee_lifeline_preserves_caller_bindings_as_an_explicit_warning ... ok
-test behavior::contextual_source_tests::contextual_source_original_document_remains_bound_after_back_or_choosing_existing ... ok
-test behavior::contextual_source_tests::contextual_source_owner_first_can_return_to_an_unnamed_machine_without_losing_source ... ok
-test behavior::contextual_source_tests::contextual_source_recovery_keeps_inner_raw_fields_and_refuses_deleted_or_changed_owner ... ok
-test behavior::contextual_source_tests::contextual_source_second_system_and_role_machine_owner_refuse_without_fallback ... ok
-test behavior::creation::app_tests::app_choosing_another_behavior_or_layer_cannot_commit_a_creation_draft ... ok
-test behavior::contextual_source_tests::contextual_source_work_uses_reserved_contribution_and_link_ids_and_one_undo ... ok
-test behavior::creation::app_tests::app_creation_opens_the_actual_new_owner_instead_of_first_or_previously_active_behavior ... ok
-test behavior::creation::app_tests::app_first_captured_escape_dismisses_file_or_pending_overlay_before_creation ... ok
-test behavior::creation::app_tests::app_lesson_request_cancel_retains_creation_then_escape_discards_only_the_draft ... ok
-test behavior::creation::app_tests::app_machine_behavior_submit_opens_its_opted_in_view_as_one_undoable_transaction ... ok
-test behavior::creation::app_tests::app_new_never_auto_applies_valid_or_invalid_property_and_source_drafts ... ok
-test behavior::creation::app_tests::app_recovered_rootless_sa_creation_retains_layer_ids_and_other_raw_drafts ... ok
-test behavior::creation::app_tests::app_stale_layer_open_never_starts_or_replaces_a_draft ... ok
-test behavior::creation::tests::all_four_viewpoints_are_explicit_and_survive_source_history_reopen ... ok
-test behavior::creation::tests::cancel_and_illegal_family_layer_switches_never_create_model_objects ... ok
-test behavior::creation::tests::corrupted_recovery_and_reserved_identity_collision_refuse_without_repairing_raw_values ... ok
-test behavior::creation::tests::creation_selection_rejects_changed_scenario_body_and_post_creation_operations ... ok
-test behavior::creation::tests::machine_requires_valid_owner_and_first_view_adds_no_region_or_state ... ok
-test behavior::creation::tests::mounted_creation_keeps_actions_visible_and_renders_only_six_owner_candidates ... ok
-test behavior::creation::tests::oa_process_and_sa_chain_keep_exact_names_root_ownership_and_one_history_entry ... ok
-test behavior::creation::tests::optional_context_collapses_without_losing_authored_reference_or_raw_search ... ok
-test behavior::creation::tests::owner_search_is_name_ordered_filtered_and_page_sized_not_a_catalog ... ok
-test behavior::creation::tests::post_commit_selection_is_correlated_with_exact_created_behavior_and_view ... ok
-test behavior::creation::tests::rejected_source_transaction_keeps_draft_and_every_accepted_source_byte ... ok
-test behavior::creation::tests::recovery_preserves_exact_raw_inputs_reserved_ids_and_revalidates_stale_owner ... ok
-test behavior::creation::tests::repeated_owner_names_remain_distinguishable_by_searchable_parent_context_and_alias ... ok
-test behavior::direct_canvas_tests::direct_alt_execution_stops_each_operand_at_its_reply_and_marks_open_operand ... ok
-test behavior::direct_canvas_tests::direct_bounds_change_during_held_drag_never_commits_old_slot ... ok
-test behavior::direct_canvas_tests::direct_context_escape_unfocus_and_pending_form_cancel_gestures ... ok
-test behavior::direct_canvas_tests::direct_clicked_occurrence_capture_cancels_on_view_and_context_changes ... ok
-test behavior::direct_canvas_tests::direct_drag_and_click_click_use_ordered_sources_and_publish_once ... ok
-test behavior::direct_canvas_tests::direct_execution_span_ends_at_its_correlated_reply_and_marks_an_open_call ... ok
-test behavior::direct_canvas_tests::direct_scroll_resize_and_bounds_changes_cancel_captured_slots ... ok
-test behavior::direct_canvas_tests::direct_panned_canvas_maps_ordered_pointer_events_to_the_visible_slot ... ok
-test behavior::direct_canvas_tests::direct_selected_handle_reorders_and_hits_keep_semantic_identity ... ok
-test behavior::direct_canvas_tests::reused_exchange_messages_display_their_distinct_occurrence_names ... ok
-test behavior::scenario::data_contract_tests::recursive_browsing_up_and_root_keep_values_and_report_the_depth_limit ... ok
-test behavior::scenario::data_contract_tests::recursive_value_focus_exposes_authored_leaf_and_phase_changes_retain_surviving_keys ... ok
-test behavior::scenario::data_contract_tests::large_payload_has_one_editor_with_reachable_field_and_authored_pages ... ok
-test behavior::scenario::data_contract_tests::reply_call_picker_previews_the_same_value_reset_as_selecting_another_exchange ... ok
-test behavior::scenario::direct_tests::direct_busy_save_keeps_details_current_and_camera_for_the_next_pointer_gesture ... ok
-test behavior::scenario::data_contract_tests::scenario_form_commits_two_reused_record_values_and_correlated_reply_atomically ... ok
-test behavior::scenario::direct_tests::direct_clicked_occurrence_rejects_stale_slots_and_retains_recoverable_drafts ... ok
-test behavior::scenario::direct_tests::direct_exchange_compatibility_browsing_preserves_final_slot_validation ... ok
-test behavior::scenario::direct_tests::direct_exchange_picker_is_bounded_and_browsing_keeps_pending_values ... ok
-test behavior::scenario::direct_tests::direct_five_hundred_exchange_choice_render_probe ... ok
-test behavior::scenario::direct_tests::direct_form_keeps_the_same_canvas_in_the_widget_tree ... ok
-test behavior::scenario::direct_tests::direct_middle_pair_insertion_is_one_exact_source_and_model_undo ... ok
-test behavior::scenario::direct_tests::direct_operand_pair_keeps_parent_sequence_and_cannot_reorder_across_operands ... ok
-test behavior::scenario::direct_tests::direct_clicked_occurrences_use_root_and_operand_slots_with_exact_source_history ... ok
-test behavior::scenario::direct_tests::direct_reply_choices_validate_the_actual_slot_and_reorder_rejects_reverse_order ... ok
-test behavior::scenario::direct_tests::direct_scenario_reference_navigation_blocks_pending_drafts_and_stale_contexts ... ok
-test behavior::scenario::direct_tests::direct_scenario_reference_navigation_retains_each_exact_caller_without_history ... ok
-test behavior::scenario::direct_tests::direct_scenario_reference_return_survives_rename_and_rejects_deleted_or_changed_use ... ok
-test behavior::scenario::operation_tests::operation_gui_async_picker_uses_request_root_and_nested_directions_without_erasing_rejected_values ... ok
-test behavior::scenario::operation_tests::operation_gui_selects_two_parameterless_allocations_without_inventing_refinement_and_reply_derives_call ... ok
-test behavior::scenario::operation_tests::operation_gui_unresolved_and_disabled_selection_recovery_preserves_rejected_raw_values ... ok
-test behavior::scenario::tests::fragment_operands_accept_paired_messages_through_normal_destination_picker ... ok
-test behavior::scenario::tests::graphical_call_reply_is_atomic_correlated_and_source_equivalent ... ok
-test behavior::scenario::tests::invalid_lifecycle_edit_keeps_draft_and_timer_has_no_global_exchange ... ok
-test behavior::scenario::tests::lifeline_picker_uses_core_viewpoint_contract ... ok
-test behavior::scenario::tests::reverse_communication_canvas_choices_and_correlated_reply_share_core_direction ... ok
-test behavior::scenario::tests::scenario_reuse_requires_explicit_compatible_bindings ... ok
-test behavior::scenario::tests::tagged_scenario_commit_is_not_redirected_by_other_editor_events ... ok
-test behavior::scenario::usage::tests::scenario_operation_label_membership_excludes_ellipsis_only_and_normalizes_whitespace ... ok
-test behavior::scenario::usage::tests::scenario_usage_counts_nested_occurrences_and_lifelines_but_keeps_reuse_opaque ... ok
-test behavior::scenario::usage::tests::scenario_usage_keeps_repeated_messages_and_reveal_is_read_only_and_revalidated ... ok
-test behavior::scenario::usage::tests::scenario_usage_only_reports_the_resolved_operation_fields_actually_in_the_label ... ok
-test behavior::scenario::workspace::tests::new_scenario_form_resets_only_its_scroll_and_recovery_gets_a_fresh_session ... ok
-test behavior::scenario::workspace::tests::production_empty_scenario_lifeline_tool_keeps_staged_source_inside_stable_canvas ... ok
-test behavior::scenario::workspace::tests::production_scenario_camera_external_controls_bounds_and_retained_deltas_cancel_old_drags ... ok
-test behavior::scenario::workspace::tests::production_scenario_canvas_keeps_bounds_draft_identity_and_camera_through_editing ... ok
-test behavior::scenario::workspace::tests::production_scenario_canvas_pan_invalidates_a_pressed_creation_and_caller_restores_once ... ok
-test behavior::scenario::direct_tests::direct_reply_choices_cache_keeps_typing_fast_and_revalidates_changed_contexts ... ok
-test behavior::scenario::workspace::tests::production_scenario_keyboard_reveals_and_activates_initially_offscreen_last_tool ... ok
-test behavior::scenario::workspace::tests::production_scenario_keyboard_enters_activates_draws_focus_and_returns_to_inspector ... ok
-test behavior::scenario::workspace::tests::production_scenario_retained_toolbar_intents_reject_chooser_dirty_and_picker_lifetimes ... ok
-test behavior::scenario::workspace::tests::production_scenario_whole_glyph_drag_moves_one_occurrence_and_rejects_other_operand ... ok
-test behavior::scenario::workspace::tests::scenario_form_focus_missing_exact_target_leaves_other_inputs_untouched ... ok
-test behavior::scenario::workspace::tests::scenario_form_focus_chained_apply_rechecks_live_review_owner ... ok
-test behavior::scenario::workspace::tests::scenario_form_focus_returns_from_back_use_and_escape_after_initial_focus_is_consumed ... ok
-test behavior::scenario::workspace::tests::scenario_form_focus_targets_the_name_and_rejects_stale_sessions_or_modals ... ok
-test behavior::scenario::workspace::tests::scenario_workspace_choosing_tools_preserves_valid_and_invalid_pending_editors ... ok
-test behavior::scenario::workspace::tests::scenario_workspace_fit_uses_measured_inner_viewport_and_rejects_nonfinite_inputs ... ok
-test behavior::scenario::workspace::tests::scenario_workspace_open_and_back_restore_owner_and_mounted_camera_after_preselection ... ok
-test behavior::scenario::workspace::tests::scenario_workspace_same_size_owner_and_document_changes_remeasure_fit_viewport ... ok
-test behavior::scenario::workspace::tests::scenario_workspace_scaled_and_panned_scene_keeps_clicked_slots_and_message_endpoints ... ok
-test behavior::scenario::workspace::tests::scenario_workspace_scaled_nested_occurrences_and_reorder_keep_exact_sequence_identity ... ok
-test behavior::scenario::workspace::tests::scenario_workspace_viewport_events_are_passive_guarded_and_do_not_apply_raw_forms ... ok
-test behavior::scenario_lifecycle::render::tests::birth_label_clip_keeps_padded_world_bounds_at_each_scene_scale ... ok
-test behavior::scenario_lifecycle::render::tests::birth_label_clip_preserves_parent_viewport_bounds ... ok
-test behavior::scenario_lifecycle::render::tests::box_text_clip_intersects_parent_viewport_and_rejects_empty_interiors ... ok
-test behavior::scenario_lifecycle::render::tests::panned_header_and_create_clips_use_screen_translation_and_actual_viewport ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_birth_death_markers_align_endpoints_and_win_selection_without_mutating_source ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_branch_delete_clips_only_its_activation_and_keeps_unanswered_call_visible ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_conditional_repeated_and_parallel_scopes_do_not_claim_definite_continuation ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_empty_and_create_only_use_visible_root_extents_not_insertion_bounds ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_lifecycle_edit_undo_redo_restores_exact_source_and_changed_geometry ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_long_header_title_and_detail_keep_names_and_have_bounded_clips ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_minimum_zoom_marker_halos_do_not_steal_adjacent_capsule_or_header_hits ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_minimum_zoom_near_ordinary_message_wins_over_lifecycle_halos ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_panned_zoomed_program_keeps_header_birth_and_death_hit_identity ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_self_delete_caption_clears_the_preceding_action_box ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_self_lifecycle_elbows_end_on_recorded_marker_rows ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_unassigned_lanes_and_explicit_incomplete_receiver_keep_real_marker_identity ... ok
-test behavior::scenario_lifecycle::render::tests::real_scene_wide_latin_header_exceeds_old_character_budget ... ok
-test behavior::scenario_lifecycle::tests::alternative_death_does_not_kill_its_displayed_sibling ... ok
-test behavior::scenario_lifecycle::tests::conditional_birth_does_not_infer_absence_in_siblings_or_ancestors ... ok
-test behavior::scenario_lifecycle::tests::explicit_receiver_is_authoritative_even_with_missing_exchange ... ok
-test behavior::scenario_lifecycle::tests::lifecycle_free_fragments_do_not_poison_other_lanes ... ok
-test behavior::scenario_lifecycle::tests::loop_lifetime_is_local_and_warning_bearing_loops_remain_drawable ... ok
-test behavior::scenario::workspace::tests::scenario_form_focus_saved_action_is_inert_on_replacement_child_review_and_changed_context ... ok
-test behavior::scenario_lifecycle::tests::missing_geometry_is_reported_without_nonfinite_or_guessed_markers ... ok
-test behavior::scenario_lifecycle::tests::projection_retains_exact_authored_source_and_does_not_enter_history ... ok
-test behavior::scenario_lifecycle::tests::optional_cleanup_inside_loop_does_not_claim_balanced_or_definite_exit ... ok
-test behavior::scenario_lifecycle::tests::root_lifetime_has_exact_birth_death_boundaries_without_source_mutation ... ok
-test behavior::scenario_lifecycle::tests::scenario_use_is_opaque_and_never_imports_callee_lifecycle_events ... ok
-test behavior::scenario_scroll::tests::direct_scenario_caller_restores_mounted_scroll_once_with_clamping_and_app_receipt ... ok
-test behavior::scenario_scroll::tests::direct_scroll_mounted_identity_resets_navigation_but_preserves_edits_before_first_report ... ok
-test behavior::scenario_scroll::tests::direct_scenario_restore_cannot_scroll_another_document_owner_or_process_view ... ok
-test behavior::scenario_scroll::tests::independent_process_owner_change_resets_actual_scroll_offsets ... ok
-test behavior::scenario_scroll::tests::direct_scroll_observer_reports_actual_initial_clamped_and_remounted_offsets_once ... ok
-test behavior::source_draft::layout_tests::contextual_source_layout_long_parent_wraps_after_visible_name_without_losing_raw_data ... ok
-test behavior::source_draft::layout_tests::contextual_source_layout_visible_kind_click_keeps_choice_explicit_and_name_input_works ... ok
-test behavior::state_canvas::tests::context_menu_keeps_window_anchor_and_explicit_placement_identity ... ok
-test behavior::state_canvas::tests::context_tool_and_pending_form_changes_cancel_mutating_gestures ... ok
-test behavior::source_draft::layout_tests::contextual_source_layout_initial_essentials_fit_short_composed_host_with_real_paragraphs ... ok
-test behavior::state_canvas::tests::creation_uses_the_explicit_deepest_owner_and_never_a_fallback_ancestor ... ok
-test behavior::state_canvas::tests::diagram_usage_external_labels_obey_routing_cutoff_while_internal_rows_retain_full_summary ... ok
-test behavior::state_canvas::tests::diagram_usage_state_rows_and_label_references_follow_actual_projection ... ok
-test behavior::state_canvas::tests::diagram_usage_transition_labels_do_not_match_prose_or_fields_beyond_cutoff ... ok
-test behavior::state_canvas::tests::escape_and_view_switch_discard_the_armed_transition_source ... ok
-test behavior::state_canvas::tests::internal_rows_and_pseudostate_hits_use_shared_persisted_geometry ... ok
-test behavior::state_canvas::tests::drag_uses_ordered_release_at_each_zoom_and_moves_descendants_in_one_undo ... ok
-test behavior::state_canvas::tests::ordered_stationary_click_does_not_move_on_later_motion_in_the_same_batch ... ok
-test behavior::state_canvas::tests::pan_is_button_scoped_read_only_and_hover_does_not_reproject_the_scene ... ok
-test behavior::state_canvas::tests::relayout_does_not_turn_a_transition_click_into_a_drag_or_pan ... ok
-test behavior::state_canvas::tests::pseudostate_names_avoid_rightward_and_downward_routes_and_share_hit_bounds ... ok
-test behavior::state_canvas::tests::selected_endpoint_reconnect_preserves_identity_and_requires_handle_motion ... ok
-test behavior::state_canvas::tests::stacked_symbol_names_avoid_each_other_and_are_independent_of_input_order ... ok
-test behavior::state_canvas::tests::selection_relayout_does_not_move_nodes_or_change_drag_distance ... ok
-test behavior::state_canvas::tests::transition_supports_click_click_and_drag_without_coalesced_accidental_edges ... ok
-test behavior::state_canvas::tests::typed_state_actions_are_named_selectable_rows_before_internal_transitions_and_regions ... ok
-test behavior::state_edit::tests::an_empty_machine_has_an_explicit_visible_owner_for_first_region_creation ... ok
-test behavior::state_canvas::tests::viewport_uses_full_canvas_coordinates_and_republishes_for_a_new_context ... ok
-test behavior::state_edit::tests::connect_preserves_self_loops_and_rejects_hidden_or_incompatible_vertices ... ok
-test behavior::state_edit::tests::creation_places_missing_ancestry_and_unfolds_existing_owners_atomically ... ok
-test behavior::state_edit::tests::placing_existing_content_and_moving_a_folded_group_preserve_other_views_and_semantics ... ok
-test behavior::state_edit::tests::every_context_component_and_invalid_ownership_are_checked_before_planning ... ok
-test behavior::state_edit::tests::view_initializes_only_its_machine_in_one_source_and_model_history_entry ... ok
-test behavior::state_edit::tests::reconnect_preserves_the_complete_record_and_replaces_cardinality_in_place ... ok
-test behavior::states::tests::internal_choice_targets_self_and_edit_preserves_identity_and_description ... ok
-test behavior::states::tests::invalid_pseudo_trigger_keeps_draft_and_does_not_create_orphan_event ... ok
-test behavior::states::tests::timeout_and_work_trigger_commit_together_roundtrip_and_undo ... ok
-test behavior::states::tests::selected_composite_owns_new_region_and_history_uses_selected_region ... ok
-test behavior::tests::failed_document_commit_retains_typed_transition_and_time_event_for_repair ... ok
-test behavior::tests::legacy_process_and_chain_keep_their_ordered_exchange_scene ... ok
-test behavior::tests::recovery_preserves_distinct_qualified_value_paths_and_rejects_invalid_payload_atomically ... ok
-test behavior::tests::recovery_retains_each_incomplete_behavior_form_without_executing_it ... ok
-test behavior::tests::selecting_state_transition_keeps_its_behavior_context ... ok
-test behavior::topology::contextual::tests::qualified_link_gui_deleted_transient_selection_does_not_seed_or_hide_retained_authored_endpoint ... ok
-test behavior::topology::contextual::tests::qualified_link_gui_nested_preview_folds_only_the_exact_reference_instance ... ok
-test behavior::topology::contextual::tests::qualified_link_gui_rejected_endpoint_keeps_exact_raw_intent_after_recovery ... ok
-test behavior::topology::contextual::tests::qualified_link_gui_repeated_sources_remain_distinct_and_apply_has_exact_source_history ... ok
-test behavior::tests::one_behavior_form_survives_start_edit_and_unrelated_cancel_until_commit ... ok
-test behavior::topology::contextual_routing::tests::contextual_route_native_x_to_first_b_keeps_visible_arrow_above_background_and_clear_of_other_references ... ok
-test behavior::topology::contextual_routing::tests::contextual_route_nested_visible_hidden_and_parallel_paths_keep_exact_addresses_and_legacy_routes ... ok
-test behavior::topology::contextual_routing::tests::contextual_route_shared_anchor_preserves_selected_direct_reconnect_at_fit_and_full_scale ... ok
-test behavior::topology::direct_tests::direct_process_append_preserves_existing_order_and_rejects_incompatible_exchange ... ok
-test behavior::topology::direct_tests::direct_process_controls_allow_incomplete_work_and_preserve_branch_semantics ... ok
-test behavior::topology::direct_tests::direct_process_empty_first_and_second_exchange_keep_the_same_interactive_renderer ... ok
-test behavior::topology::direct_tests::direct_process_imported_order_is_projected_without_mutation_and_first_canvas_edit_is_atomic ... ok
-test behavior::topology::direct_tests::direct_process_incompatible_imported_order_rejects_conversion_without_losing_draft ... ok
-test behavior::topology::direct_tests::direct_process_nested_source_reopen_and_api_command_use_one_transaction ... ok
-test behavior::topology::direct_tests::direct_process_oa_sa_repeated_occurrences_share_sources_and_split_one_guarded_link ... ok
-test behavior::topology::direct_tests::direct_process_palette_preserves_fit_and_manual_camera ... ok
-test behavior::topology::direct_tests::direct_process_production_click_click_drag_insert_and_camera_coordinates ... ok
-test behavior::topology::direct_tests::direct_process_production_endpoint_and_peer_reorder_handles_publish_exact_identity ... ok
-test behavior::topology::direct_tests::direct_process_production_stale_focus_scroll_bounds_and_pending_cancel ... ok
-test behavior::topology::direct_tests::direct_process_readable_default_fit_expansion_and_bounded_choices ... ok
-test behavior::topology::direct_tests::direct_process_real_picker_stays_bounded_and_search_keeps_selection ... ok
-test behavior::topology::contextual::tests::qualified_link_gui_scope_paging_and_search_reach_tail_beyond_512_without_losing_endpoints ... ok
-test behavior::topology::direct_tests::direct_process_reuse_preview_is_local_expandable_and_recursive_sources_are_rejected ... ok
-test behavior::topology::direct_tests::direct_process_reconnect_delete_and_reorder_preserve_other_paths_and_sources ... ok
-test behavior::topology::direct_tests::direct_process_specific_parallel_link_and_incompatible_adjacency ... ok
-test behavior::topology::direct_tests::direct_process_scaled_control_and_link_gestures_use_visible_positions ... ok
-test behavior::topology::tests::cycle_projection_terminates_and_retains_actual_links ... ok
-test behavior::topology::tests::empty_process_can_start_through_normal_authoring_events ... ok
-test behavior::topology::direct_tests::direct_process_three_ordered_exchanges_preserve_outer_paths_on_insertion ... ok
-test behavior::topology::tests::fitting_a_branch_keeps_all_nodes_visible_and_selection_uses_scaled_coordinates ... ok
-test behavior::topology::tests::guarded_branch_is_one_transaction_with_distinct_source_identities ... ok
-test behavior::topology::tests::insertion_picker_only_offers_work_matching_adjacent_exchanges ... ok
-test behavior::topology::tests::legacy_branch_insertion_replaces_only_the_selected_implied_link ... ok
-test behavior::topology::tests::long_engineering_identifiers_stay_inside_label_width ... ok
-test behavior::topology::tests::process_camera_selection_ignores_independent_details_scroll ... ok
-test behavior::topology::tests::legacy_edit_preserves_order_and_new_work_in_one_undo ... ok
-test behavior::topology::tests::process_fit_uses_measured_height_and_reports_minimum_without_changing_manual_zoom ... ok
-test behavior::topology::tests::reusable_preview_preserves_identity_and_filters_recursive_sources ... ok
-test behavior::topology::tests::process_fit_disclosures_and_focus_preserve_rejected_raw_draft_and_accepted_source ... ok
-test behavior::topology::tests::unlinked_contributions_do_not_gain_fictional_edges ... ok
-test behavior::topology::tests::stale_or_invalid_submit_preserves_inputs_and_creates_nothing ... ok
-test behavior::topology::usages::tests::expanded_nested_tiles_do_not_invent_links_the_preview_painter_does_not_emit ... ok
-test behavior::topology::usages::tests::preview_arrow_focus_is_in_the_painted_gap_and_hidden_endpoints_never_fallback ... ok
-test behavior::topology::usages::tests::process_contextual_purpose_and_painted_preview_links_keep_distinct_identities ... ok
-test behavior::topology::usages::tests::process_usage_reveal_validates_before_state_changes_and_centers_the_exact_tile ... ok
-test behavior::topology::usages::tests::process_usages_keep_caller_paths_and_exclude_unshown_fifth_preview ... ok
-test behavior::topology::usages::tests::process_usages_exclude_endpoint_coincidence_and_keep_actual_occurrences_and_links ... ok
-test behavior::topology::usages::tests::visible_preview_segment_excludes_all_opaque_tiles_for_reverse_and_cross_row_arrows ... ok
-test behavior::topology::view::layout_tests::production_process_caller_return_rejects_its_previous_camera_lifetime ... ok
-test behavior::topology::view::layout_tests::production_canvas_keyboard_and_delayed_tasks_respect_real_chooser_and_review_owners ... ok
-test behavior::topology::view::layout_tests::production_process_camera_external_controls_bounds_and_retained_deltas_cancel_old_drags ... ok
-test behavior::topology::view::layout_tests::production_process_canvas_focus_wheel_fit_and_stale_camera_are_presentation_only ... ok
-test behavior::topology::view::layout_tests::production_process_form_replacement_resets_scroll_without_a_closed_render ... ok
-test behavior::topology::view::layout_tests::production_process_canvas_scaled_path_creation_preserves_source_and_editor_bounds ... ok
-test behavior::topology::view::layout_tests::production_process_keyboard_enters_activates_draws_focus_and_returns_to_inspector ... ok
-test behavior::topology::view::layout_tests::production_process_keyboard_reveals_and_activates_initially_offscreen_last_tool ... ok
-test connection_edit::tests::cancel_navigation_revision_and_dirty_drafts_cannot_commit_a_stale_connection ... ok
-test connection_edit::tests::visible_endpoint_drawing_commits_ports_and_exchange_once_with_exact_history ... ok
-test connection_tool::tests::boundary_candidates_match_core_orientation_and_reject_same_owner_or_mixed_kind ... ok
-test connection_tool::tests::boundary_feasibility_keeps_interface_warnings_and_final_carried_item_checks ... ok
-test connection_tool::tests::boundary_feasibility_rejects_dangling_identity_in_a_malformed_element_map ... ok
-test connection_tool::tests::direct_connections_share_exact_source_history_and_model_parity ... ok
-test connection_tool::tests::explicit_function_ports_keep_owners_contracts_and_do_not_invent_carried_items ... ok
-test connection_tool::tests::final_command_validation_rejects_invalid_models_without_mutation ... ok
-test connection_tool::tests::function_cards_use_unique_reuse_and_atomic_generation_when_ambiguous ... ok
-test connection_tool::tests::mismatched_port_owners_layers_and_contract_kinds_are_not_candidates ... ok
-test connection_tool::tests::operational_communication_uses_participants_without_creating_ports ... ok
-test connection_tool::tests::operational_interaction_targets_only_distinct_oa_activities ... ok
-test context_menu::tests::a_new_context_token_cannot_reuse_the_previous_mouse_press_or_scroll ... ok
-test context_menu::tests::actions_area_does_not_swallow_first_independent_click_after_overlay_consumed_its_release ... ok
-test context_menu::tests::anchors_outside_the_window_and_nonfinite_input_stay_bounded ... ok
-test context_menu::tests::clicking_disabled_or_dragging_off_an_action_never_executes_it ... ok
-test context_menu::tests::coalesced_dismissal_release_does_not_swallow_the_next_independent_click ... ok
-test context_menu::tests::empty_and_disabled_only_menus_still_capture_keys_and_escape_closes ... ok
-test behavior::topology::view::layout_tests::production_process_retained_toolbar_intents_reject_chooser_dirty_and_picker_lifetimes ... ok
-test context_menu::tests::keyboard_skips_headers_separators_and_disabled_actions_and_invokes_once ... ok
-test context_menu::tests::reconstructed_overlay_uses_retained_layout_for_rows_and_hit_testing ... ok
-test context_menu::tests::outside_dismissal_consumes_press_and_release_across_controlled_close ... ok
-test context_menu::tests::tall_menu_clamps_to_viewport_and_keyboard_wheel_and_scrollbar_reach_the_end ... ok
-test data_values::tests::phase_choices_keep_reused_record_addresses_distinct ... ok
-test data_values::tests::recursive_picker_starts_with_distinct_leaf_names_and_sorts_them ... ok
-test context_menu::tests::retained_overlay_layout_keeps_measured_width_and_scrollbar_after_reconstruction ... ok
-test data_values::tests::reference_parameter_stops_descent_and_unspecified_direction_remains_visible ... ok
-test data_values::tests::recursive_records_can_be_drilled_into_and_valid_imported_paths_resolve ... ok
-test data_view::tests::allocation_rows_edit_relationship_identity_and_remove_only_that_allocation ... ok
-test data_view::tests::association_creation_is_a_separate_relation_with_editable_end_contracts ... ok
-test data_view::tests::browsing_pages_preserves_invalid_numeric_draft_and_inherited_allocation_identity ... ok
-test data_view::tests::contextual_data_actions_use_typed_defaults_and_one_undo ... ok
-test data_values::tests::roots_and_one_hop_children_do_not_expand_unrelated_payload_branches ... ok
-test diagram::lifecycle_tests::menu_reset_and_draw_use_fresh_open_context ... ok
-test diagram::lifecycle_tests::middle_and_arrow_panning_preserve_source_and_history ... ok
-test diagram::lifecycle_tests::motion_after_release_must_not_move_clicked_port ... ok
-test diagram::lifecycle_tests::motion_after_source_click_release_must_not_create_connection ... ok
-test diagram::pointer_tests::coalesced_fe_ports_commit_once_through_app_and_source_history ... ok
-test diagram::pointer_tests::coalesced_port_drag_commits_once_through_app_and_source_history ... ok
-test diagram::pointer_tests::drag_from_already_selected_stationary_port_keeps_source_between_batches ... ok
-test diagram::pointer_tests::menu_captured_motion_must_not_turn_following_click_into_old_port_drag ... ok
-test diagram::pointer_tests::modal_and_stale_epoch_block_queued_connection_and_port_commits ... ok
-test diagram::port_hit_tests::coincident_ports_keep_selection_then_use_stable_identity ... ok
-test diagram::port_hit_tests::nearest_port_center_wins_on_all_borders_and_zoom_levels ... ok
-test diagram::port_hit_tests::nested_owner_palette_selection_drag_and_context_menu_pick_the_same_port ... ok
-test diagram::port_labels::tests::leaving_and_reentering_keeps_suppression_until_each_held_button_releases ... ok
-test diagram::port_labels::tests::menu_epoch_clears_suppression_when_the_overlay_consumes_release ... ok
-test diagram::port_labels::tests::outside_presses_do_not_suppress_and_cancel_or_focus_loss_clear_held_buttons ... ok
-test diagram::port_labels::tests::passive_layer_leaves_port_drag_selection_and_commit_with_the_interactive_canvas ... ok
-test diagram::tests::association_end_contracts_share_svg_geometry_and_select_without_moving_name_label ... ok
-test diagram::tests::bend_gestures_use_screen_hit_radius_and_commit_one_undo_at_three_zooms ... ok
-test diagram::tests::coincident_line_hit_retains_the_selected_connection ... ok
-test diagram::tests::connection_gestures_pick_real_ports_and_commit_coalesced_drag_at_every_zoom ... ok
-test diagram::tests::detached_label_selects_connection_and_occluding_card_owns_its_hit ... ok
-test diagram::tests::dragging_a_child_previews_the_same_enclosure_and_ports_as_commit ... ok
-test diagram::tests::fast_drags_commit_the_release_cursor_without_a_final_motion_event ... ok
-test diagram::tests::implicit_port_click_selects_semantics_and_drag_preview_svg_share_anchors ... ok
-test diagram::tests::route_cache_ignores_pan_zoom_and_cancelled_drag_cannot_commit ... ok
-test diagram::tests::routed_svg_has_same_polyline_label_and_bounds_as_canvas_scene ... ok
-test diagram::tests::svg_distinguishes_inferred_work_allocation_from_direct_allocation ... ok
-test diagram::tests::svg_preserves_visible_exchange_labels_and_capability_stereotypes ... ok
-test diagram::tests::typed_function_glyphs_and_unoriented_standard_connections_have_distinct_svg ... ok
-test diagram::view_options_tests::communication_svg_uses_saved_visibility_labels_and_direction ... ok
-test diagram_usage::coverage_tests::absent_endpoint_placements_and_hidden_performer_do_not_create_grouping_targets ... ok
-test diagram_usage::coverage_tests::allocation_grouping_has_exact_relation_placements_and_readable_work_geometry ... ok
-test diagram_usage::coverage_tests::allocation_grouping_walks_two_visible_summary_levels_without_inventing_allocations ... ok
-test diagram_usage::coverage_tests::collapsed_leaf_and_edge_filter_still_leave_the_actual_nesting_visible ... ok
-test diagram_usage::coverage_tests::folded_summary_or_performer_does_not_substitute_a_visible_ancestor_for_the_leaf ... ok
-test diagram_usage::coverage_tests::other_projections_do_not_report_allocation_nesting_when_only_an_arrow_or_nothing_is_drawn ... ok
-test diagram_usage::coverage_tests::repeated_saved_views_keep_allocation_placement_identity_and_geometry_independent ... ok
-test diagram_usage::coverage_tests::role_derived_nesting_without_a_direct_allocation_does_not_invent_one ... ok
-test diagram_usage::tests::folded_child_is_not_a_visible_node_and_placement_identity_stays_exact ... ok
-test diagram_usage::tests::oversized_container_reveal_targets_its_labelled_header ... ok
-test diagram_usage::tests::ports_are_found_at_the_visible_owner_and_unplaced_elements_do_not_match_names ... ok
-test diagram_usage::tests::reveal_camera_centers_target_without_whole_view_shrink ... ok
-test diagram_usage::tests::saved_membership_respects_filters_and_does_not_change_project ... ok
-test diagram_usage::tests::state_machine_owner_finds_its_view_without_a_machine_placement ... ok
-test diagram_usage::tests::whole_diagram_camera_fits_large_bounds_instead_of_individual_object_scale ... ok
-test document::save_as_tests::save_as_preserves_explicit_source_entry_changes_in_history ... ok
-test document::save_as_tests::save_as_rebases_uniform_history_without_an_undo_step_or_lost_redo ... ok
-test document::save_as_tests::save_as_rejects_included_filename_collisions_in_past_and_future_without_mutation ... ok
-test document::save_as_tests::save_as_rejects_stale_or_content_changing_receipt_atomically ... ok
-test document::tests::accepted_history_keeps_the_latest_hundred_complete_snapshots ... ok
-test document::tests::altered_compiled_model_or_index_is_rejected_without_mutation ... ok
-test document::tests::asynchronous_save_marks_its_snapshot_without_cleaning_later_edits ... ok
-test document::tests::byte_budget_trims_oldest_history_without_discarding_a_large_current ... ok
-test document::tests::cached_view_index_tracks_accepted_creation_undo_and_redo ... ok
-test document::tests::comment_and_semantic_history_restore_exact_bytes_and_branch_together ... ok
-test document::tests::creation_selects_the_single_uuid_persisted_in_source ... ok
-test document::tests::invalid_project_is_rejected_before_format_can_normalize_it ... ok
-test document::tests::nested_cross_file_reparent_and_source_edit_share_exact_history ... ok
-test document::tests::no_op_command_or_source_apply_preserves_history_revision_and_redo ... ok
-test document::tests::omitted_id_stabilization_remains_dirty_until_exact_source_is_saved ... ok
-test document::tests::recreated_equal_record_does_not_inherit_deleted_source_ownership ... ok
-test document::tests::rejected_compile_command_and_writeback_preserve_state_and_redo ... ok
-test explorer::tests::collapse_and_search_retain_context_without_changing_collapse_state ... ok
-test explorer::tests::deep_containment_and_search_keep_the_full_path_without_recursion ... ok
-test explorer::tests::equal_names_have_stable_alias_and_identity_tie_breakers ... ok
-test explorer::tests::perspective_isolation_and_allocations_do_not_change_containment ... ok
-test explorer::tests::prefix_names_cannot_separate_a_parent_from_its_children ... ok
-test forms::data_fields::tests::defaults_distinguish_absent_empty_and_typed_literals_with_escaped_unicode ... ok
-test forms::data_fields::tests::field_browser_pages_every_direct_field_without_flattening_other_records ... ok
-test forms::data_fields::tests::independent_review_combined_take_type_informs_actual_default_form_in_both_directions ... ok
-test forms::data_fields::tests::numeric_bound_drafts_keep_partial_and_full_precision_values_out_of_accepted_state ... ok
-test forms::data_fields::tests::selecting_qualified_path_preserves_expression_typed_before_the_next_render ... ok
-test forms::data_fields::tests::semantic_reference_choices_follow_selected_mechanism_and_revert_on_keep ... ok
-test forms::data_fields::tests::supertype_picker_excludes_descendants_and_keeps_original_inherited_field_identity ... ok
-test forms::history_fields::tests::history_absent_baseline_and_empty_history_use_explicit_facts_and_exact_document_history ... ok
-test forms::history_fields::tests::history_clear_discards_inactive_invalid_constructors_before_reusing_the_same_row ... ok
-test forms::history_fields::tests::history_compound_value_and_constructor_variants_are_editable_without_live_context ... ok
-test forms::history_fields::tests::history_deleted_keys_and_observation_uuids_remain_exact_and_duplicate_history_rejects ... ok
-test forms::history_fields::tests::history_every_descriptor_fact_choice_matches_actual_closed_types_and_source_contract ... ok
-test forms::history_fields::tests::history_exact_strings_do_not_confuse_uuid_shaped_prose_or_literal_keys_with_references ... ok
-test forms::history_fields::tests::history_invalid_numbers_survive_constructor_switch_reorder_removal_and_recovery ... ok
-test forms::history_fields::tests::history_missing_semantic_field_can_be_added_and_removed_without_touching_prose_or_live_objects ... ok
-test forms::history_fields::tests::history_nested_optional_number_events_switch_absent_present_and_recover_invalid_raw ... ok
-test forms::history_fields::tests::history_nested_uuid_and_list_events_preserve_present_values_and_tagged_item_branches ... ok
-test forms::history_fields::tests::history_optional_uuid_and_text_seed_absence_without_inventing_observations ... ok
-test forms::history_fields::tests::history_primitive_type_choices_remain_visible_inside_the_tagged_union ... ok
-test forms::history_fields::tests::history_retained_text_constructors_follow_exact_mode_without_changing_the_observation ... ok
-test forms::port_fields::tests::all_demo_records_roundtrip_through_graphical_and_escaped_string_drafts ... ok
-test forms::port_fields::tests::boundary_choices_honor_draft_direction_same_kind_and_direct_interface_items ... ok
-test forms::port_fields::tests::contract_choices_follow_owner_and_never_offer_legacy_or_oa_typed_ports ... ok
-test forms::port_fields::tests::failed_shape_keeps_incomplete_text_and_saved_contract_payloads ... ok
-test forms::port_fields::tests::functional_endpoints_require_owner_direction_and_items_but_retain_bad_current_choice ... ok
-test forms::port_fields::tests::interface_roles_offer_participants_and_component_ports_independent_of_orientation ... ok
-test forms::port_fields::tests::port_allocation_choices_use_actual_owner_direction_and_ignore_edited_relation ... ok
-test forms::port_fields::tests::standard_switch_retains_incompatible_orientation_until_explicit_repair ... ok
-test forms::port_fields::tests::switching_function_direction_preserves_invalid_items_and_each_authored_payload ... ok
-test forms::reference_chooser::tests::captured_choice_cannot_cross_document_revision_draft_record_or_array_path ... ok
-test forms::reference_chooser::tests::catalog_search_disambiguates_repeated_names_containment_alias_and_exact_placement_identity ... ok
-test forms::reference_chooser::tests::dismissal_swallows_matching_release_across_closed_rebuild_but_next_click_reaches_parent ... ok
-test forms::reference_chooser::tests::empty_search_escape_tab_and_optional_clear_do_not_silently_choose_nil ... ok
-test forms::reference_chooser::tests::historical_paths_never_open_and_only_explicit_choice_or_clear_is_a_write ... ok
-test forms::reference_chooser::tests::mounted_clipboard_paste_and_ime_commit_preserve_whole_strings_without_selecting ... ok
-test forms::reference_chooser::tests::mounted_filtered_row_click_uses_the_displayed_identity_and_scoped_write_intent ... ok
-test forms::reference_chooser::tests::mounted_input_preserves_rapid_same_batch_typing_and_cursor_across_controlled_rebuilds ... ok
-test forms::reference_chooser::tests::mounted_keyboard_pages_and_selects_only_the_highlighted_visible_candidate_once ... ok
-test forms::reference_chooser::tests::mounted_overlay_clamps_at_three_field_positions_and_keeps_results_and_query_bounded ... ok
-test forms::reference_chooser::tests::mounted_query_change_rejects_old_release_and_old_result_events_without_locking_popup ... ok
-test forms::reference_chooser::tests::mounted_query_then_escape_in_one_batch_closes_and_relative_keys_keep_input_order ... ok
-test forms::reference_chooser::tests::out_of_order_query_serials_cannot_restore_obsolete_results ... ok
-test forms::tests::data_and_port_choices_are_typed_but_retain_invalid_current_values ... ok
-test forms::tests::editing_allocation_offers_other_performers_without_counting_itself_twice ... ok
-test forms::tests::moving_placement_and_changing_identity_is_one_lossless_undoable_edit ... ok
-test forms::tests::parent_choices_reject_cycles_without_removing_clear_or_current_choice ... ok
-test forms::tests::reply_and_reuse_forms_offer_semantically_compatible_references ... ok
-test forms::tests::scenario_choices_respect_owner_and_exchange_layer ... ok
-test forms::tests::semantic_port_group_choices_use_combined_owner_and_retain_invalid_transferred_items ... ok
-test forms::tests::shared_perspective_change_keeps_payload_and_rejects_incompatible_dependencies ... ok
-test forms::tests::state_observation_picker_keeps_work_lifelines_allocated_to_machine_owner ... ok
-test forms::tests::state_placement_form_uses_draft_destination_membership_without_changing_other_views ... ok
-test forms::tests::state_projection_form_keeps_string_variants_and_requires_a_typed_context ... ok
-test forms::view_fields::tests::category_family_change_retains_members_until_explicit_correction ... ok
-test forms::view_fields::tests::selective_view_property_apply_recovery_and_undo_preserve_semantics_and_empty_choices ... ok
-test guide::tests::filtering_and_related_navigation_keep_selection_visible ... ok
-test guide::tests::guide_topic_navigation_resets_only_article_and_same_topic_search_keeps_scroll ... ok
-test guide::tests::search_finds_concepts_in_walkthroughs_and_api_reference ... ok
-test home::tests::corrupt_future_and_oversized_history_are_preserved_with_usable_session_history ... ok
-test home::tests::failed_metadata_replace_keeps_previous_history_and_reports_memory_only_entry ... ok
-test home::tests::first_and_replaced_metadata_are_parseable_and_contain_no_model_bytes ... ok
-test home::tests::forgotten_and_missing_files_never_change_the_model_or_other_entries ... ok
-test home::tests::loading_missing_history_does_not_create_files_or_directories ... ok
-test home::tests::malformed_entries_and_unknown_fields_never_become_open_requests ... ok
-test home::tests::successful_local_history_is_bounded_ordered_deduplicated_and_durable ... ok
-test home::tests::unavailable_location_can_reappear_on_refresh_without_losing_identity ... ok
-test home::tests::walkthrough_uses_packaged_bundle_before_development_and_reports_missing_assets ... ok
-test hosted::client::tests::hosted_endpoint_validation_redacts_secrets_and_preserves_proxy_paths ... ok
-test hosted::client::tests::hosted_lost_publication_response_is_uncertain_without_retry ... ok
-test hosted::client::tests::hosted_open_rejects_incoherent_envelopes_missing_etags_and_unstable_ids ... ok
-test hosted::client::tests::hosted_oversized_local_bundle_is_rejected_before_network_admission ... ok
-test hosted::client::tests::hosted_production_auth_proxy_prefix_and_located_rejection ... ok
-test hosted::client::tests::hosted_production_roundtrip_preserves_comments_noops_and_conflicts ... ok
-test data_view::tests::large_inherited_dictionary_has_bounded_widgets_and_every_original_field_is_reachable has been running for over 60 seconds
-test hosted::client::tests::hosted_publication_race_keeps_receipt_identity_for_review ... ok
-test hosted::client::tests::hosted_publication_retains_known_resource_after_failed_followup ... ok
-test hosted::client::tests::hosted_put_preserves_an_opaque_etag_and_compiles_the_accepted_bundle ... ok
-test hosted::client::tests::hosted_redirect_is_not_followed_or_retried_and_problem_tokens_are_redacted ... ok
-test hosted::client::tests::hosted_response_limits_cover_declared_and_chunked_bodies ... ok
-test hosted::client::tests::hosted_structured_mutation_failures_distinguish_precommit_rejections ... ok
-test hosted::client::tests::hosted_timeout_and_disconnect_leave_mutation_outcomes_explicit ... ok
-test model_menu::tests::add_bend_here_uses_context_point_and_one_source_aware_history_change ... ok
-test model_menu::tests::late_menu_actions_do_not_dismiss_new_menu_or_cross_view_context ... ok
-test model_menu::tests::menu_preserves_pending_properties_and_rejects_delayed_mutations ... ok
-test model_menu::tests::pending_source_allows_file_navigation_but_disables_model_actions ... ok
-test model_menu::tests::right_click_targets_actor_without_changing_selection_until_action ... ok
-test model_menu::tests::show_from_explorer_places_unfolds_and_keeps_semantic_selection ... ok
-test model_menu::tests::state_menu_folds_and_hides_only_its_captured_placement_and_rejects_stale_views ... ok
-test model_menu::tests::state_menu_keeps_typed_creation_reachable_and_preserves_pending_properties ... ok
-test navigation::tests::semantic_browser_finds_behavior_users_without_confusing_containment ... ok
-test port_edit::tests::all_border_drags_commit_exact_preview_and_restore_automatic_anchors_in_history ... ok
-test port_edit::tests::graphical_port_reparent_clears_old_anchors_in_the_same_history_operation ... ok
-test port_preview::tests::functional_creation_identifies_new_and_reused_endpoints_and_owners ... ok
-test port_preview::tests::legacy_split_discloses_endpoint_routing_item_origins_and_retained_evidence ... ok
-test port_preview::tests::reused_boundary_shows_item_union_and_existing_allocating_facts ... ok
-test port_preview::tests::synchronization_preview_exposes_contract_shrinkage_and_current_declaration_origin ... ok
-test port_workflow::recovery_tests::port_recovery_retains_authored_contract_and_identity_but_rebuilds_preview ... ok
-test port_workflow::tests::creating_typed_port_and_rejecting_stale_preview_preserve_drafts_and_identity ... ok
-test port_workflow::tests::graphical_function_exchange_and_component_generation_commit_and_undo_whole_contracts ... ok
-test port_workflow::tests::legacy_resolution_preserves_original_record_and_applies_as_one_undo ... ok
-test port_workflow::tests::port_creation_keeps_owner_diagram_and_unfolds_in_the_same_undo ... ok
-test port_workflow::tests::synchronization_uses_active_contract_instead_of_preserved_direction ... ok
-test recovery::source5::tests::source5_fingerprint_preserves_historical_field_order_and_diagram_shape ... ok
-test recovery::source5_tests::source4_checkpoint_remains_explicitly_unsupported_without_touching_disk ... ok
-test recovery::source5_tests::source5_checkpoint_does_not_refresh_unrelated_clean_buffer_baseline ... ok
-test recovery::source5_tests::source5_checkpoint_missing_identity_is_not_a_lossless_upgrade ... ok
-test recovery::source5_tests::source5_checkpoint_old_diagram_property_shape_remains_editable ... ok
-test recovery::source5_tests::source5_checkpoint_port_draft_replans_and_rejects_stale_base ... ok
-test recovery::source5_tests::source5_checkpoint_preserves_dirty_invalid_text_and_baseline_exactly ... ok
-test recovery::source5_tests::source5_checkpoint_preserves_distinct_unapplied_open_workspace ... ok
-test recovery::source5_tests::source5_checkpoint_property_preserves_invalid_raw_input ... ok
-test recovery::source5_tests::source5_checkpoint_upgrade_never_rewrites_checkpoint_or_origin ... ok
-test recovery::source5_tests::source5_checkpoint_upgrades_only_header_and_clean_editor_baseline ... ok
-test recovery::source5_tests::source5_checkpoint_workflow_rebinds_only_the_proven_old_revision ... ok
-test recovery::source7_tests::source7_current_combined_contextual_and_operation_drafts_survive_without_execution ... ok
-test recovery::source7_tests::source7_explicit_new_fields_cannot_enter_frozen_old_model_profiles ... ok
-test recovery::source7_tests::source7_legacy_inactive_constructor_path_is_structural_but_raw_prose_is_not ... ok
-test data_view::tests::large_inherited_dictionary_has_bounded_widgets_and_every_original_field_is_reachable ... ok
-test recovery::source7_tests::source7_legacy_profiles_preserve_dirty_source_property_and_behavior_raw_fields ... ok
-test recovery::source7_tests::source7_legacy_structural_intent_rejects_even_null_but_never_scans_raw_strings ... ok
-test recovery::source7_tests::source7_legacy_view_selector_refuses_new_relation_kind_without_rewriting_checkpoint ... ok
-test recovery::source7_tests::source7_legacy_profile_workflow_and_semantic_drafts_replan_with_exact_base ... ok
-test recovery::tests::altered_accepted_identity_and_unrecognized_raw_property_fields_reject ... ok
-test recovery::tests::exact_source_and_unfinished_invalid_buffers_restore_without_model_overwrite ... ok
-test recovery::source7_tests::source7_recovers_nonempty_frozen_5_and_6_profiles_with_exact_historical_binding ... ok
-test recovery::tests::excess_retained_buffers_cannot_replace_the_last_recoverable_checkpoint ... ok
-test recovery::tests::invalid_open_retains_distinct_accepted_model_and_repair_workspace ... ok
-test recovery::tests::missing_includes_remain_reachable_repair_targets_without_fabricated_buffers ... ok
-test recovery::tests::raw_invalid_property_number_survives_and_stays_rejected_until_repaired ... ok
-test recovery::tests::multiple_sessions_replace_only_their_own_checkpoint_and_corruption_is_retained ... ok
-test semantic_review::artifacts_recovery_falsifier_tests::forged_artifact_draft_cannot_target_an_unreserved_or_non_artifact_identity ... ok
-test semantic_review::artifacts_recovery_falsifier_tests::forged_artifact_raw_variants_duplicate_addresses_and_unknown_fields_are_refused ... ok
-test semantic_review::artifacts_recovery_falsifier_tests::forged_artifact_reservations_cannot_duplicate_or_claim_an_existing_identity_or_another_owner ... ok
-test semantic_review::artifacts_tests::artifact_candidate_is_a_complete_record_not_a_tombstone_or_unattached_creation_shortcut ... ok
-test semantic_review::artifacts_tests::artifact_creation_and_identified_source_deletion_follow_core_metadata_and_history_boundary_both_directions ... ok
-test semantic_review::artifacts_recovery_falsifier_tests::legitimate_invalid_artifact_checkpoint_round_trips_and_prepares_only_after_explicit_repair ... ok
-test semantic_review::artifacts_tests::artifact_metadata_apply_and_exact_history_reset_are_one_source_preserving_undo_redo ... ok
-test semantic_review::artifacts_tests::artifact_gui_reserves_recovers_and_creates_only_after_all_seven_metadata_reviews_both_directions ... ok
-test semantic_review::artifacts_tests::artifact_move_metadata_none_empty_and_invalid_raw_recovery_are_independent_both_directions ... ok
-test semantic_review::attachments::tests::absent_attachment_payloads_migrate_v1_and_v2_and_source5_upgrade_requires_exact_legacy_base ... ok
-test semantic_review::artifacts_tests::artifact_moved_source_absence_deletes_but_destination_only_take_retains_both_directions ... ok
-test semantic_review::attachments::tests::attachment_apply_is_one_exact_source_and_history_undo_redo ... ok
-test semantic_review::attachments::tests::addressed_attachment_candidates_equal_direct_core_oracle_both_directions ... ok
-test semantic_review::attachments::tests::attachment_pair_drafts_survive_family_switch_and_restore_without_mutating_model ... ok
-test semantic_review::attachments::tests::functional_incident_source_requires_explicit_matching_port_review_in_one_atomic_candidate ... ok
-test semantic_review::attachments::tests::parent_and_each_endpoint_candidate_preserve_other_fields_and_match_core_both_directions ... ok
-test semantic_review::attachments::tests::raw_rejected_attachment_reference_survives_recovery_and_wrong_scope_is_rejected ... ok
-test semantic_review::attachments::tests::source_only_absence_and_explicit_absent_endpoint_are_different ... ok
-test semantic_review::attachments::tests::attachment_candidate_and_direct_record_keep_conflict_on_actual_slot_without_losing_drafts ... ok
-test semantic_review::attachments::tests::two_incident_endpoint_candidates_form_one_complete_record_and_recover_invalid_excluded_draft ... ok
-test semantic_review::batch_tests::batch_apply_is_one_exact_source_and_history_undo_redo_roundtrip ... ok
-test semantic_review::batch_tests::batch_candidate_conflict_keeps_both_raw_values_and_keep_is_a_real_constraint ... ok
-test semantic_review::batch_tests::batch_complete_constructor_cannot_erase_another_rows_new_literal ... ok
-test semantic_review::batch_tests::batch_constructor_retirement_conflicts_with_another_rows_kept_bound_in_both_orders ... ok
-test semantic_review::batch_tests::batch_delayed_text_targets_its_original_row_and_facet_without_switching_focus ... ok
-test semantic_review::batch_tests::batch_excluded_invalid_row_survives_focus_reopen_and_v2_recovery ... ok
-test semantic_review::batch_tests::batch_first_equal_constructor_acknowledgement_allows_an_independent_bound ... ok
-test semantic_review::batch_tests::batch_joint_bounds_use_one_candidate_and_match_an_independent_atomic_core_oracle ... ok
-test semantic_review::batch_tests::batch_reverse_distinct_targets_work_and_reverse_convergence_is_explicit ... ok
-test semantic_review::batch_tests::batch_v2_rejects_duplicate_included_sources_bad_addresses_and_stale_model ... ok
-test semantic_review::batch_tests::recovered_trace_picker_names_existing_trace_instead_of_deleted_reference ... ok
-test semantic_review::batch_tests::category_family_and_members_are_independent_core_checked_facets_both_directions ... ok
-test semantic_review::compose::diagnostic_tests::distinct_review_conflict_keeps_trace_aliases_even_when_names_are_equal ... ok
-test semantic_review::compose::diagnostic_tests::reserved_creation_conflict_uses_its_rows_seed_instead_of_a_deleted_reference ... ok
-test semantic_review::compose::diagnostic_tests::same_review_presence_and_owner_conflict_names_both_facets_and_owners_and_retains_drafts ... ok
-test semantic_review::compose::diagnostic_tests::typed_owner_display_does_not_reinterpret_uuid_shaped_artifact_text ... ok
-test semantic_review::batch_tests::rejected_direction_switch_at_row_limit_preserves_every_recoverable_draft has been running for over 60 seconds
-test semantic_review::constructor_tests::closed_data_and_event_take_composition_matches_core_across_every_kind_pair_and_direction has been running for over 60 seconds
-test semantic_review::constructor_tests::closed_data_and_event_take_composition_matches_core_across_every_kind_pair_and_direction ... ok
-test semantic_review::constructor_tests::data_group_candidates_cover_every_definition_and_companion_default_both_directions ... ok
-test semantic_review::constructor_tests::data_group_retains_invalid_sibling_drafts_companion_default_and_variant_editor_buffers ... ok
-test semantic_review::constructor_tests::exchange_constructor_takes_qualified_annotation_addresses_without_remapping_expression_text ... ok
-test semantic_review::constructor_tests::existing_fragment_and_branch_group_candidates_edit_complete_owned_order_without_deletion ... ok
-test semantic_review::constructor_tests::group_take_reference_payload_and_scalar_candidate_match_core_and_one_document_batch ... ok
-test semantic_review::constructor_tests::historical_event_keep_retires_only_obsolete_branch_and_unchanged_kind_acknowledges_no_payload ... ok
-test semantic_review::batch_tests::rejected_direction_switch_at_row_limit_preserves_every_recoverable_draft ... ok
-test semantic_review::constructor_tests::historical_same_kind_take_preserves_target_only_literals_when_composed_with_candidate ... ok
-test semantic_review::constructor_tests::outer_and_nested_constructor_candidates_require_explicit_resolution_and_retain_both_drafts ... ok
-test semantic_review::constructor_tests::port_group_companions_typed_owner_context_and_direction_restrictions_are_explicit ... ok
-test semantic_review::constructor_tests::reverse_existing_typed_port_reviews_keep_or_candidate_legacy_without_permitting_typed_oa_write ... ok
-test semantic_review::constructor_tests::scenario_use_group_takes_typed_binding_references_and_preserves_source_text_both_directions ... ok
-test semantic_review::keyed_rows_tests::annotation_address_browser_descends_qualified_fields_without_changing_rows ... ok
-test semantic_review::keyed_rows_tests::annotation_observations_keep_uuid_shaped_expression_text_in_both_sides_and_history ... ok
-test semantic_review::constructor_tests::occurrence_and_event_candidate_variants_cover_closed_families_without_touching_headers ... ok
-test semantic_review::keyed_rows_tests::binding_choices_separate_reused_keys_from_local_lifelines ... ok
-test semantic_review::keyed_rows_tests::binding_local_picker_follows_a_candidate_parent_before_the_review_is_valid ... ok
-test semantic_review::keyed_rows_tests::binding_take_requires_local_correspondence_and_candidate_rejects_wrong_scenario ... ok
-test semantic_review::keyed_rows_tests::batch_keyed_rows_compare_exact_target_slots_and_retain_independent_values ... ok
-test semantic_review::keyed_rows_tests::independent_rows_keep_take_candidate_match_core_and_preserve_siblings_both_directions has been running for over 60 seconds
-test semantic_review::keyed_rows_tests::keyed_recovery_retains_raw_rows_and_staged_pairs_both_directions_without_applying ... ok
-test semantic_review::keyed_rows_tests::keyed_row_drafts_retain_expression_local_and_presence_across_decisions_and_staging ... ok
-test semantic_review::keyed_rows_tests::independent_rows_keep_take_candidate_match_core_and_preserve_siblings_both_directions ... ok
-test semantic_review::keyed_rows_tests::keyed_rows_distinguish_unpaired_source_from_explicit_absence_and_require_exact_reset ... ok
-test semantic_review::keyed_rows_tests::row_review_apply_preserves_exact_source_and_semantic_history_through_undo_redo ... ok
-test semantic_review::keyed_tests::deleted_member_source_observation_removes_only_mapped_membership_both_directions ... ok
-test semantic_review::keyed_rows_tests::multiple_new_rows_compose_in_empty_collections_using_destination_key_order ... ok
-test semantic_review::keyed_tests::exact_reset_only_is_one_history_source_transaction_and_undo_redo_both_directions ... ok
-test semantic_review::keyed_tests::exact_literal_new_rows_and_removals_commit_both_directions_without_default_loss ... ok
-test semantic_review::keyed_tests::function_port_members_use_existing_typed_choices_and_preserve_oa_legacy ... ok
-test semantic_review::keyed_tests::historical_one_sided_pair_migration_requires_exact_reset_and_explicit_overlap_resolution ... ok
-test semantic_review::keyed_tests::member_identity_labels_and_new_tabs_preserve_exact_names_and_deleted_keys ... ok
-test semantic_review::keyed_tests::invalid_literal_removal_and_unselected_scalar_buffers_are_retained_and_repairable ... ok
-test semantic_review::keyed_tests::staging_removal_and_obsolete_reset_recovery_keep_other_decisions_and_raw_presence ... ok
-test semantic_review::keyed_tests::reset_precedes_equal_constructor_candidate_and_preserves_independent_literal_draft ... ok
-test semantic_review::keyed_tests::stale_or_source_failed_reset_and_membership_apply_retain_exact_choices ... ok
-test semantic_review::keyed_tests::unsupported_independent_families_and_missing_identities_do_not_gain_edit_authority ... ok
-test semantic_review::message_kind_tests::message_group_candidate_closed_kinds_are_core_validated_in_both_directions ... ok
-test semantic_review::message_kind_tests::message_group_candidate_timer_switches_preserve_both_drafts_and_overlap_is_explicit ... ok
-test semantic_review::message_kind_tests::message_group_initial_equal_take_acknowledges_only_kind_and_checks_authored_timer_agreement ... ok
-test semantic_review::keyed_tests::unordered_members_keep_take_candidate_preserve_other_rows_both_directions has been running for over 60 seconds
-test semantic_review::message_kind_tests::message_group_keep_historical_switch_retires_timer_and_completed_no_switch_rejects ... ok
-test semantic_review::message_kind_tests::message_group_rejects_protected_edits_stale_plan_and_source_failure_without_losing_timer ... ok
-test semantic_review::message_kind_tests::message_group_reply_and_reference_take_require_explicit_call_mapping_both_directions ... ok
-test semantic_review::message_kind_tests::message_group_take_full_timer_and_scalar_candidate_are_one_source_history_change_both_directions ... ok
-test semantic_review::message_kind_tests::message_group_timer_does_not_erase_exchange_without_its_own_selected_decision ... ok
-test semantic_review::keyed_tests::unordered_members_keep_take_candidate_preserve_other_rows_both_directions ... ok
-test semantic_review::ordered_tests::historical_pair_restore_uses_exact_member_keys_and_never_zips_order_observations ... ok
-test semantic_review::ordered_tests::order_take_preserves_destination_only_positions_and_order_alone_cannot_add_members ... ok
-test semantic_review::ordered_tests::ambiguous_order_preserves_local_member_and_requires_explicit_candidate_positions ... ok
-test semantic_review::ordered_tests::ordered_membership_choices_stage_exact_pairs_in_all_owner_shapes ... ok
-test semantic_review::ordered_tests::ordered_review_apply_is_exact_source_history_transaction_with_reopen_and_undo_redo ... ok
-test semantic_review::ordered_tests::ordered_presence_keep_take_candidate_remove_only_selected_entry_and_order_take_reorders_only ... ok
-test semantic_review::ordered_tests::raw_order_survives_membership_changes_decisions_and_recovery_until_explicit_reconcile ... ok
-test semantic_review::ordered_tests::ordered_take_uses_unique_anchors_and_matches_core_with_unrelated_candidate_both_directions ... ok
-test semantic_review::recovery::tests::raw_scalar_and_closed_constructor_drafts_recover_against_exact_model_only ... ok
-test semantic_review::recovery::tests::version_one_without_orders_restores_raw_intent_and_replans_without_execution ... ok
-test semantic_review::source7_tests::contextual_incident_leaf_keep_allows_path_change_but_conflicts_with_changed_leaf_both_directions ... ok
-test semantic_review::source7_tests::reverse_operation_omission_gui_requires_raw_rationale_and_matches_one_core_batch_after_recovery ... ok
-test semantic_review::source7_tests::semantic_operation_virtual_none_candidate_uses_exact_allocation_and_preserves_accepted_bytes ... ok
-test semantic_review::ordered_tests::several_incoming_members_follow_source_order_despite_independent_identity_sorting ... ok
-test semantic_review::tests::candidate_mixed_with_reference_take_uses_typed_correspondence_not_text_guessing ... ok
-test semantic_review::tests::deselected_invalid_candidate_is_retained_but_does_not_poison_another_selected_scalar ... ok
-test semantic_review::tests::explicit_trace_selection_updates_only_that_history ... ok
-test semantic_review::tests::independent_review_clear_bound_ignores_retained_invalid_other_facet ... ok
-test semantic_review::tests::independent_review_keyed_fact_titles_keep_live_deleted_and_qualified_identity ... ok
-test semantic_review::tests::first_equal_constructor_acknowledges_only_kind_and_allows_independent_leaves ... ok
-test semantic_review::tests::inherited_annotation_impact_requires_exact_acceptance_and_edits_clear_approval ... ok
-test semantic_review::tests::invalid_numeric_draft_and_protected_edits_retain_workflow_and_source ... ok
-test semantic_review::tests::read_only_structured_facts_and_partial_rollup_are_honest ... ok
-test semantic_review::tests::relation_candidates_preserve_endpoints_and_combine_selected_roles_and_bounds ... ok
-test semantic_review::tests::scoped_literal_list_edits_preserve_unfinished_values_and_other_facet_buffers ... ok
-test semantic_review::tests::scalar_keep_take_candidate_commit_exact_source_and_history_in_both_directions ... ok
-test semantic_review::tests::state_kind_scalar_uses_typed_candidate_and_core_validation ... ok
-test semantic_review::tests::stale_plan_and_source_writeback_failure_do_not_lose_decisions_or_history ... ok
-test source_navigation::interaction::tests::captured_find_click_invalidates_without_app_message_and_preserves_focus ... ok
-test source_navigation::interaction::tests::focus_rechecks_clock_between_inspection_and_application_and_missing_target_is_inert ... ok
-test source_navigation::interaction::tests::raw_navigation_inputs_advance_but_passive_geometry_does_not_and_exhaustion_refuses ... ok
-test source_navigation::query::tests::comments_strings_and_comment_gap_are_not_navigation_hits ... ok
-test source_navigation::query::tests::detached_alias_and_identity_collisions_never_auto_select ... ok
-test source_navigation::query::tests::dirty_but_parseable_text_has_current_names_and_no_validated_fallback ... ok
-test source_navigation::query::tests::exact_multifile_unicode_crlf_definition_and_repeated_lexical_references ... ok
-test semantic_review::view::reserved_artifact_tests::reserved_artifact_facet_and_reference_labels_survive_recovery_without_calling_it_deleted ... ok
-test source_navigation::query::tests::exact_snapshot_readback_rejects_same_key_byte_membership_and_evidence_changes ... ok
-test source_navigation::query::tests::invalid_include_syntax_never_borrows_the_old_reachable_file_set ... ok
-test source_navigation::query::tests::include_cycle_depth_and_aggregate_edges_are_explicit_partial_outcomes ... ok
-test source_navigation::query::tests::large_display_name_cannot_escape_the_owned_row_string_budget ... ok
-test source_navigation::query::tests::keyword_alias_and_loaded_path_case_collisions_use_reviewed_index_rules ... ok
-test source_navigation::query::tests::missing_include_partial_scope_does_not_resurrect_witness_text ... ok
-test source_navigation::query::tests::omitted_rows_are_counted_before_result_allocation_and_never_confer_uniqueness ... ok
-test source_navigation::query::tests::missing_and_noncanonical_authored_ids_remain_draft_spans_without_generated_anchors ... ok
-test source_navigation::query::tests::owned_request_checks_raw_limits_immediately_and_extracts_only_on_worker ... ok
-test source_navigation::query::tests::owned_request_moves_exact_text_into_worker_snapshot_and_matches_sync_results ... ok
-test source_navigation::query::tests::owned_validation_proof_preserves_full_witness_count_and_partial_scope ... ok
-test source_navigation::query::tests::raw_aggregate_limits_refuse_before_outline_or_copied_snapshot ... ok
-test source_navigation::query::tests::sole_detached_candidate_and_unapplied_equal_bytes_require_choice ... ok
-test source_navigation::query::tests::token_declaration_and_live_reference_limits_are_aggregate_not_per_file ... ok
-test source_navigation::symbols::tests::admitted_unicode_path_budget_keeps_original_policy_after_single_fold ... ok
-test source_navigation::query::tests::validation_witness_must_match_entry_and_complete_included_file_set ... ok
-test source_navigation::symbols::tests::comment_separated_reference_keeps_crlf_unicode_and_disjoint_hit_spans ... ok
-test source_navigation::symbols::tests::detached_uuid_clone_disables_anchor_even_for_included_query ... ok
-test source_navigation::symbols::tests::declaration_order_and_duplicate_roles_refuse_instead_of_corrupting_hit_search ... ok
-test source_navigation::symbols::tests::every_budget_admits_boundary_and_returns_no_index_one_below ... ok
-test source_navigation::symbols::tests::duplicate_aliases_are_candidates_without_false_reference_attribution ... ok
-test source_navigation::symbols::tests::incomplete_draft_is_lexical_and_error_token_does_not_leak_references ... ok
-test source_navigation::symbols::tests::header_metadata_must_match_current_token_boundaries_and_authored_id ... ok
-test source_navigation::symbols::tests::legal_keyword_classified_alias_is_not_discarded ... ok
-test source_navigation::symbols::tests::missing_ids_produce_only_current_snapshot_locations_without_stabilization ... ok
-test source_navigation::symbols::tests::noncanonical_header_identity_cannot_enter_through_query_metadata ... ok
-test source_navigation::symbols::tests::nested_declaration_extents_do_not_turn_body_text_into_definition_hits ... ok
-test source_navigation::symbols::tests::path_identity_rejects_normalization_and_case_collisions ... ok
-test source_navigation::symbols::tests::query_header_admission_preserves_uppercase_and_json_escape_bytes ... ok
-test source_navigation::symbols::tests::repeated_live_uses_are_distinct_and_strings_comments_history_are_excluded ... ok
-test source_navigation::symbols::tests::reused_alias_cannot_steal_old_identity_and_old_locations_are_stale ... ok
-test source_navigation::symbols::tests::stopped_outline_is_not_a_successful_empty_query ... ok
-test source_navigation::symbols::tests::scope_provenance_and_detached_alias_collision_are_explicit ... ok
-test source_navigation::symbols::tests::truncated_or_gapped_tokens_refuse_even_when_project_scope_is_partial ... ok
-test source_navigation::symbols::tests::unicode_path_collisions_match_core_lowercase_policy ... ok
-test source_navigation::tests::search_uses_utf8_columns_wraps_and_refreshes_after_edits ... ok
-test source_tree::tests::active_scroll_offset_uses_the_visible_order_and_retains_ancestor_context ... ok
-test source_tree::tests::collapsed_folders_retain_active_dirty_and_diagnostic_markers ... ok
-test source_tree::tests::detached_buffers_keep_paths_and_only_clean_buffers_are_closable ... ok
-test source_tree::tests::exact_unicode_spaces_and_file_folder_name_collisions_are_not_normalized ... ok
-test source_tree::tests::deep_paths_build_expand_and_drop_on_a_small_stack ... ok
-test source_tree::tests::folders_are_compact_and_sorted_before_files_without_losing_duplicate_basenames ... ok
-test source_workspace::tests::draft_history_budget_covers_inactive_files_without_discarding_drafts ... ok
-test source_workspace::tests::fresh_session_cannot_reuse_a_retained_buffer_generation ... ok
-test source_workspace::tests::navigation_revision_wrap_cannot_reuse_an_old_workspace_key ... ok
-test source_workspace::tests::navigation_scope_changes_invalidate_without_changing_unchanged_positions ... ok
-test source_workspace::tests::navigation_versions_distinguish_reopened_recovered_and_changed_drafts ... ok
-test tests::actor_port_creation_updates_containment_and_locate_reveals_its_owner ... ok
-test tests::adding_bend_between_close_ports_stays_outside_owner_clearance ... ok
-test source_workspace::tests::switching_retains_invalid_drafts_and_independent_history ... ok
-test tests::bidirectional_transition_ui_commits_once_and_preserves_other_diagrams ... ok
-test tests::child_work_does_not_invent_unallocated_or_mixed_performers ... ok
-test tests::child_work_preserves_allocated_context_and_atomic_history ... ok
-test tests::behavior_and_data_authoring_do_not_place_nodes_in_unrelated_architecture_views ... ok
-test tests::counterpart_creation_focuses_visible_target_and_reuse_keeps_views ... ok
-test tests::child_work_transfers_leaf_roles_without_fabricating_responsibilities ... ok
-test tests::dragging_keeps_semantic_selection_and_same_node_remains_editable ... ok
-test tests::escaped_string_mode_preserves_exact_control_characters ... ok
-test tests::creation_from_capabilities_routes_work_to_architecture_and_folded_allocation_inserts_below_existing_work ... ok
-test tests::explicit_relationship_builder_never_mutates_on_preview ... ok
-test tests::explorer_and_creation_selection_follow_their_own_placement ... ok
-test tests::fit_adapts_to_canvas_returning_after_help_but_preserves_manual_navigation ... ok
-test tests::fit_uses_measured_canvas_bounds_and_preserves_them_on_open ... ok
-test tests::focused_explorer_follows_reparenting_without_changing_identity ... ok
-test tests::graphical_rename_keeps_aliases_and_references_and_undo ... ok
-test tests::identity_property_change_is_atomic_and_rewrites_all_live_references ... ok
-test tests::invalid_numeric_draft_survives_navigation_save_and_help ... ok
-test tests::invalid_save_and_continue_returns_to_repairable_draft ... ok
-test tests::every_demo_record_has_a_lossless_graphical_draft ... ok
-test tests::malformed_source_preserves_model_and_is_recoverable ... ok
-test tests::mission_capability_authoring_is_contextual_atomic_and_text_equivalent ... ok
-test tests::modal_owns_background_commands_and_shortcuts ... ok
-test tests::manual_trace_requires_target_and_selection_normalizes_creation_kind ... ok
-test tests::nested_allocation_insertion_reflows_sibling_subtrees_and_preserves_fold_state ... ok
-test tests::opening_and_creating_models_preserve_the_actual_window_size_for_fit ... ok
-test tests::opening_legacy_source_surfaces_report_without_modifying_original_bytes ... ok
-test tests::pending_source_prevents_property_draft_collision_and_preserves_both_if_present ... ok
-test tests::placement_relocation_follows_cross_layer_traceability_view ... ok
-test tests::placement_identity_edit_then_drag_and_diagram_identity_then_arrange ... ok
-test tests::property_enum_and_optional_reference_roundtrip ... ok
-test tests::reopening_canvas_for_a_modal_preserves_viewport_after_route_edits ... ok
-test tests::routing_actions_are_atomic_guarded_and_fit_the_authored_detour ... ok
-test tests::revealing_an_implicit_function_port_unfolds_its_visible_architecture_owner ... ok
-test tests::source_find_navigates_an_invalid_draft_without_applying_or_losing_it ... ok
-test tests::source_navigation_waits_for_editor_layout_and_cancels_on_edit ... ok
-test tests::system_only_models_open_the_populated_perspective ... ok
-test tests::transition_resolutions_belong_to_the_effective_target_and_kind ... ok
-test tests::selecting_current_constructors_preserves_payloads ... ok
-test view_copy::tests::duplicate_state_view_preserves_machine_nesting_and_collapse_with_unique_aliases ... ok
-test view_copy::tests::duplicate_retains_ports_routes_options_and_artifact_claims_with_exact_undo_redo ... ok
-test view_copy::tests::missing_view_does_not_propose_an_empty_replacement ... ok
-test views::source_tests::source_editor_windows_menu_payload_is_inert_but_space_and_altgr_still_edit ... ok
-test views::source_tests::source_header_remains_scrollable_and_preserves_offset_across_diagnostic_refresh ... ok
-test views::source_tests::source_header_keeps_editor_bounds_stable_through_lint_and_find_rebuilds ... ok
-test views::tests::short_preserves_ascii_cjk_and_whitespace_policy ... ok
-test views::tests::short_never_splits_retained_extended_graphemes ... ok
-test views::tests::short_preserves_native_lifeline_clusters_at_cutoff ... ok
-test views::tests::short_preserves_empty_and_small_limit_policy ... ok
-test views::traceability::tests::traceability_filter_reaches_artifacts_after_68_traces_and_searches_all_metadata ... ok
-test workflow::communication::tests::communication_requires_two_explicit_ports_and_recovers_the_partial_choice ... ok
-test views::traceability::tests::traceability_browsing_retains_invalid_property_draft_and_existing_select_guard ... ok
-test workflow::port_authoring_tests::boundary_picker_recomputes_for_unoriented_reverse_endpoints_without_relaxing_contracts ... ok
-test workflow::port_authoring_tests::duplicate_port_names_show_owner_contract_and_unique_alias ... ok
-test workflow::port_authoring_tests::fresh_functions_are_actual_picker_targets_and_plan_enables_apply ... ok
-test workflow::port_authoring_tests::generic_component_port_connection_keeps_its_endpoint_and_direction ... ok
-test workflow::port_authoring_tests::ordinary_standard_connections_default_unoriented_and_new_roles_exclude_legacy ... ok
-test workflow::recovery::tests::incomplete_relationship_and_trace_recover_raw_fields_and_reject_changed_model ... ok
-test workflow::recovery::tests::transition_recovery_replans_typed_request_without_persisted_commands ... ok
-test workflow::transition_tests::basic_transition_boundary_choice_is_required_without_an_inferred_system ... ok
-test workflow::transition_tests::basic_transition_creates_overview_when_existing_views_cannot_show_result ... ok
-test workflow::transition_tests::basic_transition_explicit_destination_appends_below_existing_bounds_and_is_one_source_edit ... ok
-test workflow::transition_tests::basic_transition_invalid_explicit_destination_retains_choice_and_refuses ... ok
-test workflow::transition_tests::basic_transition_reconcile_keeps_existing_selected_view_placement_and_route_exact ... ok
-test workflow::transition_tests::basic_transition_skips_lowest_uuid_state_view_and_preserves_oa ... ok
-test workflow::port_authoring_tests::boundary_picker_matches_exact_commands_across_contracts_and_ownership ... ok
-
-test result: ok. 894 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 1137.48s
-

harness/experiments/diagram-navigation-gates-20260912/correction-tests.md

@@ -1,15 +0,0 @@
-# Corrected navigation: Windows desktop test result
-
-Tested source: `46b4f3c0d0f04050ad6d705051ee0199138e47a2` on `codex/diagram-coverage-fixes-ytr83r-20260912`.
-
-`cargo test -p oa-desktop --all-targets --locked --offline` completed with **894 passed, 0 failed, 1 ignored**, exit 0. Compilation reported 12m44s; execution reported 1137.48 seconds. [Raw output](correction-tests.log), [receipt](correction-tests-receipt.json), and [all 562 verified compiler inputs](correction-all-inputs.json) are preserved. Each input matched its pre-check hash and byte length after the desktop run. The receipt conservatively records uncommitted work: the checkout also contained an unwired, untracked experiment directory, which was not included by this build. The compiled correction source matches the published commit.
-
-All three failures of the [older source](README.md) now pass. The passing run includes the new exact qualified-preview link checks, independent Allocation grouping fixtures, port/state semantic-selection and visual-focus checks, stale chooser/deferred viewport cases, camera persistence, and existing desktop/source/history regressions.
-
-The one ignored case is `app::source_symbols::tests::source_symbols_100_modules_1000_definitions_10000_uses`, explicitly a manual latency/process-memory trial intended to run alone. This result does not establish its performance threshold or large-model native responsiveness. The host also ran an independent core compilation and Capella startup during portions of execution; elapsed time here is not a comparative performance benchmark.
-
-Core-specific outline tests and strict lint are separate gates. A matching GUI build and native acceptance of the corrected source remain pending. The process/scenario free-editing requirements are still unfinished, and Linux/WSL remains paused by the user.
-
-## Raw-log preservation
-
-Post-push blob verification detected that Git normalized CRLF line endings in the initially published raw log and receipt at `0eca66f`. A follow-up commit disables text conversion for these two exact evidence paths and restores their original bytes, including the terminal blank line. Historical commits are unchanged. The unrestricted Git whitespace check reports that blank line at `correction-tests.log:910`; it is an intentional raw-evidence exception. The same check excluding this exact raw log passes for the report, receipt and manifest changes. This does not change the successful source whitespace check recorded in the correction handoff.