Sync agent instructions from main

2026-09-13 11:38:37 +03:00 · 2026-09-12 13:43:14 +03:00 · 2026-09-12 13:39:57 +03:00 · 2026-09-12 13:15:27 +03:00 · 2026-09-11 11:14:23 -07:00 · 2026-09-11 10:34:29 -07:00
1464 changed files with 46272 additions and 235295 deletions
@@ -15,76 +15,40 @@

 # Exact source/recovery oracles and archived ledgers retain their measured bytes.
 # Keep ordinary text diffs; only disable checkout/check-in newline conversion.
+PROJECT_GOAL.md -text whitespace=cr-at-eol
 harness/fixtures/release1-native/** -text
 harness/fixtures/interface-operation-probe/** -text
 harness/history/2026-09-06-ledgers-before-consolidation/** -text
+harness/history/2026-09-10-ledgers-before-continuation-refresh/** -text
 harness/history/2026-09-10-ledgers-before-second-consolidation/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
 harness/experiments/textual-authoring-20260911-local/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
-harness/experiments/constructor-defaults-20260911/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
-harness/experiments/constructor-defaults-20260911/results/*.arcadia whitespace=-blank-at-eol,cr-at-eol
-harness/experiments/behavior-creation-native-20260911/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
-harness/experiments/analysis-context-20260911/** -text whitespace=cr-at-eol
-harness/experiments/textual-authoring-20260911/** -text whitespace=cr-at-eol
-harness/experiments/textual-authoring-20260911/observed/split-entry.arcadia whitespace=-blank-at-eol,cr-at-eol
-harness/fixtures/scenario-authoring/base/** -text whitespace=cr-at-eol
 crates/oa-desktop/src/recovery/fixtures/*.json -text
+crates/oa-core/src/analysis_numeric/fixtures/** -text whitespace=cr-at-eol
 harness/fixtures/source7-native/** -text
 harness/fixtures/basic-editing/** -text
+harness/fixtures/scenario-authoring/base/** -text whitespace=cr-at-eol
+harness/experiments/textual-authoring-20260911/** -text whitespace=cr-at-eol
+harness/experiments/textual-authoring-20260911/observed/split-entry.arcadia whitespace=-blank-at-eol,cr-at-eol
+harness/experiments/analysis-context-20260911/** -text whitespace=cr-at-eol
+harness/experiments/analysis-baseline-20260911/** -text whitespace=cr-at-eol
+harness/experiments/library-compatibility-20260911/** -text whitespace=cr-at-eol
+harness/experiments/refined-contracts-review-20260911/** -text whitespace=cr-at-eol
 harness/behavior-creation-contract.rs -text whitespace=cr-at-eol
 harness/experiments/source-cli-independent-20260911/** -text whitespace=cr-at-eol
 harness/experiments/authoring-prerelease-20260911/** -text whitespace=cr-at-eol
 harness/experiments/cli-packaging-20260911/** -text whitespace=cr-at-eol
 harness/experiments/cli-prerelease-20260911/** -text whitespace=cr-at-eol
 harness/experiments/contextual-source-20260911/** -text whitespace=cr-at-eol
-harness/experiments/contextual-source-native-20260911/** -text whitespace=cr-at-eol
-harness/experiments/contextual-source-reopen-20260911/** -text whitespace=cr-at-eol
-harness/experiments/contextual-source-native-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-layout-reboot-20260911/** -text whitespace=cr-at-eol
-harness/experiments/contextual-source-layout-reboot-20260911/run-gates2.ps1 whitespace=-blank-at-eof,cr-at-eol
 harness/experiments/contextual-source-20260911/**/*.log whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/scenario-native-local-20260911/** -text whitespace=cr-at-eol
-harness/experiments/scenario-native-local-20260911/**/*.log whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/scenario-native-local-20260911/**/*.arcadia whitespace=-blank-at-eol,cr-at-eol
 harness/fixtures/staged-source-authoring/** -text whitespace=cr-at-eol
 harness/staged-source-authoring-contract.rs -text whitespace=cr-at-eol

 # Preserve checksum-bound font notices verbatim through Git round trips.
-harness/experiments/wsl-capacity-20260911/** -text whitespace=cr-at-eol
-harness/experiments/wsl-postboot-9e8r6t-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-layout-postboot-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-layout-verified-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-layout-full-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
 scripts/windows-notices/GNOME-Cantarell-61362600e104-COPYING -text
 scripts/windows-notices/Fira-OFL.txt -text
 scripts/windows-notices/FiraSans-Regular-NOTICE.txt -text
-harness/experiments/contextual-source-recovery-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-machine-v2-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-lifeline-v2-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-lifeline-v2-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-machine-v2-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/contextual-source-reopen-20260911/launch-method.ps1 whitespace=-blank-at-eof,cr-at-eol
-# Raw compact.exe output includes CR-CR-LF and incidental trailing spaces.
-harness/experiments/wsl-capacity-20260911/*.log -whitespace
-harness/experiments/contextual-prerelease-20260911/** -text whitespace=cr-at-eol
-harness/experiments/contextual-prerelease-publication-20260911/** -text whitespace=cr-at-eol
-harness/history/2026-09-11-state-before-gitea-migration/** -text whitespace=cr-at-eol
-harness/experiments/contextual-prerelease-20260911/native/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/contextual-prerelease-20260911/producer/package*.log whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/contextual-prerelease-20260911/producer/source-push.log -whitespace
-
-# Exact frozen navigation GUI input bytes; historical server source is separate.
-crates/oa-desktop/src/behavior/creation.rs -text
-crates/oa-desktop/src/behavior/scenario/workspace.rs -text
-crates/oa-desktop/src/behavior/topology/contextual.rs -text
-crates/oa-desktop/src/guide.rs -text
-crates/oa-desktop/src/semantic_review/artifacts_view.rs -text
-crates/oa-desktop/src/semantic_review/attachments_view.rs -text
-crates/oa-desktop/src/semantic_review/keyed.rs -text
-crates/oa-desktop/src/semantic_review/keyed_rows.rs -text
-crates/oa-desktop/src/semantic_review/keyed_tests.rs -text
-crates/oa-desktop/src/semantic_review/ordered.rs -text
-docs/api.html -text
-docs/api.rst -text
-docs/language.html -text
-docs/openapi.json -text
-harness/fixtures/rest-coverage/coverage-probe.json -text
+harness/experiments/behavior-creation-native-20260911/** -text whitespace=cr-at-eol
+harness/experiments/constructor-defaults-20260911/** -text whitespace=cr-at-eol
+harness/experiments/constructor-defaults-20260911/results/*.arcadia whitespace=-blank-at-eol,cr-at-eol
+harness/release-scenario-native-9e8r6t-20260911.md -text whitespace=cr-at-eol
+harness/experiments/analysis-numeric-gate-20260911/** -text
@@ -35,20 +35,28 @@ Use Gitea for live coordination and the relevant code version for implementation

 ## Coordination and integration

+All independent agents coordinating through Gitea run on completely separate machines, each with its own clone, filesystem, tools, processes, and runtime. Gitea and pushed Git history are the shared communication and delivery channels. Local files (including `harness`), unpushed commits, worktrees, test results, and localhost services are not accessible to peers. Matching branch names or paths do not imply synchronized contents.
+
 1. On starting or resuming, including after compaction, inspect the working branch, local changes, applicable instructions, relevant shared records, and existing implementation. Recover context from authoritative records. Check for newer shared instructions on the actual remote default branch without overwriting local work. Read what is relevant; avoid repeated full-history scans and constant polling.
-2. Search before creating tasks. Claim a meaningful outcome in its Gitea issue with a stable session identity, scope, branch/worktree, and acceptance criteria. Keep small steps within that task. Recheck after claiming; comments are not atomic locks. Respect existing ownership and resolve overlapping claims before overlapping work.
-3. Independent sessions are peers. Each owns its contribution and delegated work. Record one integration/release owner when a milestone needs shared coordination. Use separate worktrees or checkouts, partition files/interfaces, and coordinate changes to shared specifications and documents.
-4. At meaningful checkpoints or handoffs, record changed results, commit/PR links, verification commands and environment, blockers, and next actions. Identify the tested code version and uncommitted or unpublished work; make required artifacts accessible to other sessions. Do not assume another agent is running or has read a message; silence alone does not establish abandonment. Record evidence and preserve existing work when reassigning a task.
-5. Follow project review and merge conventions. Inspect upstream changes, resolve conflicts while preserving others' edits, and verify the combined result. Do not overwrite others' work or force-push shared history to resolve coordination problems.
+2. Search before creating tasks. Claim a meaningful outcome in its Gitea issue with a stable session identity, scope, remote repository/branch, and acceptance criteria. Keep small steps within that task. Recheck after claiming; comments are not atomic locks. Respect existing ownership and resolve overlapping claims before overlapping work.
+3. Independent sessions are peers. Each owns its contribution and delegated work on its own machine. Record one integration/release owner when a milestone needs shared coordination. Use distinct remote work branches, partition files/interfaces, and coordinate changes to shared specifications and documents. Worktrees provide local isolation only; they do not share work between machines.
+4. At meaningful checkpoints or handoffs, record changed results, commit/PR links, verification commands and environment, blockers, and next actions. Identify the tested code version and label uncommitted or unpublished work as local-only. Before asking peers to consume results, push the required code and versioned documentation, including relevant `harness` updates; publish other required artifacts in Gitea and link them. Use repository-relative paths with commit references, reproducible commands, and necessary environment details; local paths and localhost URLs alone are not handoffs. Do not assume another agent is running or has read a message; silence alone does not establish abandonment. Record evidence and preserve existing work when reassigning a task.
+5. Follow project review and merge conventions. Fetch the relevant remote branches and inspect the identified commits before reviewing or integrating another machine's work. Resolve conflicts while preserving others' edits, and verify the combined result locally; report material environment differences. Local instruction-file edits reach peers only after publication and retrieval. Do not overwrite others' work or force-push shared history to resolve coordination problems.
 6. Close work when its acceptance criteria are met and the result is integrated or delivered as appropriate. Mark duplicates and superseded tasks explicitly with replacement links. Then choose further useful unowned work while the requested objective remains incomplete.

 Use Gitea MCP for shared coordination. If unavailable, report the failure, buffer necessary handoff information locally, and continue already-owned or clearly non-overlapping work. Reconcile with current Gitea state when access returns; do not claim an ownership update, review, or publication succeeded without confirmation.

 ## Delegation and reasoning

-Use GPT-6 Astra exclusively. Delegate bounded independent research, design, implementation, or review when it improves progress, judgment, or preserves the parent's context. Give subagents the relevant context, ownership boundaries, result format, and evidence requirements. Use fresh critics when practical. The parent owns synthesis and integration and normally consolidates results into Gitea. Choose concurrency according to useful independent work and available resources, including other sessions; there is no agent-count quota.
+Use GPT-6 Astra exclusively. Gitea peers are independent remote sessions, not subagents controlled by this session. Spawned subagents use the execution environment actually provided by the agent tools; do not assume they share files, and publish their results before Gitea peers need them. Delegate bounded independent research, design, implementation, or review when it improves progress, judgment, or preserves the parent's context. Give subagents the relevant context, ownership boundaries, result format, and evidence requirements. Use fresh critics when practical. The parent owns synthesis and integration and normally consolidates results into Gitea. Choose concurrency according to useful independent work and available resources, including other sessions; there is no agent-count quota.

-Use the highest available reasoning effort for orchestration and foundational semantic, methodological, formal, or cross-domain decisions. For subagents, use extra-high for difficult design, adversarial review, or unusually hard implementation; high for normal implementation, targeted research, correctness review, debugging, and runtime evaluation; medium for routine exploration, mechanical changes, builds, and tests; and lower for trivial work. Allocate by difficulty, not length, using supported controls; do not claim an unapplied change or alter global configuration merely to enforce these preferences.
+Optimize reasoning effort for verified outcomes per cost, including review, retries, and repair:
+
+- Main agent: default to high for planning, synthesis, integration, and acceptance decisions; medium for dispatching a settled plan and routine coordination.
+- Subagents: default to medium for bounded implementation and targeted research; low for straightforward retrieval, mechanical edits, and running established checks; high for complex debugging, correctness review, adversarial analysis, or ambiguous design.
+- Use extra-high selectively for difficult foundational semantic, methodological, formal, or cross-domain decisions. Reserve max for exceptional unresolved problems where additional reasoning is likely to justify its cost. Retain higher settings when evidence supports their value.
+
+Allocate by task difficulty and consequences, not role or length alone. Start higher when a clearly difficult decision has expensive downstream consequences. Escalate for concrete reasoning difficulties; resolve missing evidence or unclear requirements at their source. Set subagent effort explicitly through supported controls to avoid unintended inheritance. Do not claim an unapplied change or alter global configuration merely to enforce these preferences.

 ## Memory and maintenance

@@ -2107,6 +2107,25 @@ dependencies = [
 "jni-sys 0.3.1",
 ]

+[[package]]
+name = "num-bigint"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2153,6 +2172,9 @@ name = "oa-core"
 version = "0.2.0"
 dependencies = [
 "libc",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
 "same-file",
 "serde",
 "serde_json",
@@ -12,6 +12,9 @@ uuid.workspace = true
 thiserror.workspace = true
 tempfile = "3"
 same-file = "1"
+num-bigint = "0.5.1"
+num-integer = "0.1.47"
+num-traits = "0.2.19"

 [target.'cfg(target_os = "linux")'.dependencies]
 libc = "0.2"
@@ -0,0 +1,103 @@
+//! Exact numeric foundation for analysis; no model, expression, or package resolver.
+//!
+//! Values use reduced rational coordinates. All nontrivial arithmetic takes one
+//! request-local [WorkMeter]. The future evaluator must also charge *expanded*
+//! expression/call/property/list/target visits and retain the same logical walk on
+//! cache hits. Stored AST size is not a dynamic execution limit.
+//!
+//! Approximate engineering functions/irrational unit scales require a subsequent
+//! explicit numeric profile; rationals do not implement degree/radian conversion
+//! or transcendental mathematics.
+
+mod dimension;
+mod exact;
+mod meter;
+mod quantity;
+
+pub use dimension::{Dimension, DimensionAxis};
+pub use exact::{Exact, ExactWire};
+pub use meter::{
+    EvaluationStep, NumericOperation, WorkExhaustion, WorkLimits, WorkMeter, WorkResource,
+    WorkSite, WorkUsage,
+};
+pub use quantity::{NumericType, NumericValue, ResolvedKind, Unit};
+
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+/// Profile identity includes the accounting rules, not crate-internal timing.
+pub const WORK_PROFILE: &str = "Q1-logical-work-1";
+pub const MAX_COMPONENT_BITS: u64 = 4096;
+/// Cross products require 8192 bits; their sum can require one additional bit.
+pub const MAX_INTERMEDIATE_BITS: u64 = 8193;
+pub const MAX_COMPONENT_DIGITS: usize = 1234;
+pub const MAX_DECIMAL_EXPONENT: i32 = 128;
+pub const MAX_INTEGER_POWER: i8 = 16;
+/// Includes ratio punctuation/whitespace without permitting unbounded scanning.
+pub const MAX_LITERAL_BYTES: usize = 2 * MAX_COMPONENT_DIGITS + 32;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum NumberComponent {
+    Numerator,
+    Denominator,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Error, Serialize, Deserialize)]
+pub enum NumericLimit {
+    #[error("request work exhausted: {0}")]
+    Work(WorkExhaustion),
+    #[error("{component:?} uses {bits} bits, above the {limit}-bit {stage} limit")]
+    Bits {
+        component: NumberComponent,
+        bits: u64,
+        limit: u64,
+        stage: String,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Error, Serialize, Deserialize)]
+pub enum NumericError {
+    #[error("numeric limit: {0}")]
+    Limit(NumericLimit),
+    #[error("invalid numeric literal")]
+    InvalidLiteral,
+    #[error("numeric literal exceeds its digit or byte limit")]
+    LiteralTooLong,
+    #[error("decimal exponent is outside -128 through 128")]
+    DecimalExponent,
+    #[error("wire rational is not in canonical reduced form")]
+    NonCanonicalWire,
+    #[error("rational denominator is zero")]
+    ZeroDenominator,
+    #[error("division by zero")]
+    DivisionByZero,
+    #[error("zero to the power zero is undefined in this profile")]
+    ZeroPowerZero,
+    #[error("integer power is outside -16 through 16")]
+    IntegerPower,
+    #[error("dimension exponent at {axis:?} is outside -32 through 32: {value}")]
+    DimensionExponent { axis: DimensionAxis, value: i32 },
+    #[error("unit scale must be strictly positive")]
+    UnitScale,
+    #[error("a linear unit must have zero offset")]
+    LinearOffset,
+    #[error("an affine point must have a distinct linear difference kind")]
+    DifferenceKind,
+    #[error("numeric kinds or dimensions are incompatible")]
+    IncompatibleTypes,
+    #[error("operation is not defined for affine points")]
+    AffineOperation,
+    #[error("AsKind requires an anonymous matching dimension and a linear target")]
+    KindAssertion,
+    #[error("request work limits exceed the provisional reference ceilings")]
+    InvalidWorkLimits,
+}
+
+impl NumericError {
+    pub fn is_terminal_work_exhaustion(&self) -> bool {
+        matches!(self, Self::Limit(NumericLimit::Work(_)))
+    }
+}
+
+#[cfg(test)]
+mod tests;
@@ -0,0 +1,107 @@
+use super::NumericError;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum DimensionAxis {
+    Length,
+    Mass,
+    Time,
+    ElectricCurrent,
+    Temperature,
+    Amount,
+    LuminousIntensity,
+}
+
+impl DimensionAxis {
+    pub const ALL: [Self; 7] = [
+        Self::Length,
+        Self::Mass,
+        Self::Time,
+        Self::ElectricCurrent,
+        Self::Temperature,
+        Self::Amount,
+        Self::LuminousIntensity,
+    ];
+}
+
+/// SI base-dimension vector in DimensionAxis::ALL order, each entry -32..=32.
+/// This is a dimension, never a nominal quantity-kind compatibility proof.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(try_from = "[i16; 7]", into = "[i16; 7]")]
+pub struct Dimension([i16; 7]);
+
+impl Dimension {
+    pub const ZERO: Self = Self([0; 7]);
+
+    pub fn new(exponents: [i16; 7]) -> Result<Self, NumericError> {
+        for (index, value) in exponents.iter().copied().enumerate() {
+            if !(-32..=32).contains(&value) {
+                return Err(NumericError::DimensionExponent {
+                    axis: DimensionAxis::ALL[index],
+                    value: i32::from(value),
+                });
+            }
+        }
+        Ok(Self(exponents))
+    }
+
+    pub fn exponents(self) -> [i16; 7] {
+        self.0
+    }
+
+    pub fn is_dimensionless(self) -> bool {
+        self == Self::ZERO
+    }
+
+    pub fn checked_product(self, rhs: Self) -> Result<Self, NumericError> {
+        self.combine(rhs, 1)
+    }
+
+    pub fn checked_quotient(self, rhs: Self) -> Result<Self, NumericError> {
+        self.combine(rhs, -1)
+    }
+
+    pub fn checked_power(self, exponent: i8) -> Result<Self, NumericError> {
+        if !(-super::MAX_INTEGER_POWER..=super::MAX_INTEGER_POWER).contains(&exponent) {
+            return Err(NumericError::IntegerPower);
+        }
+        let mut output = [0; 7];
+        for (index, value) in self.0.iter().enumerate() {
+            output[index] = Self::checked_exponent(index, i32::from(*value) * i32::from(exponent))?;
+        }
+        Ok(Self(output))
+    }
+
+    fn combine(self, rhs: Self, sign: i32) -> Result<Self, NumericError> {
+        let mut output = [0; 7];
+        for (index, value) in self.0.iter().enumerate() {
+            output[index] =
+                Self::checked_exponent(index, i32::from(*value) + sign * i32::from(rhs.0[index]))?;
+        }
+        Ok(Self(output))
+    }
+
+    fn checked_exponent(index: usize, value: i32) -> Result<i16, NumericError> {
+        if !(-32..=32).contains(&value) {
+            return Err(NumericError::DimensionExponent {
+                axis: DimensionAxis::ALL[index],
+                value,
+            });
+        }
+        Ok(value as i16)
+    }
+}
+
+impl TryFrom<[i16; 7]> for Dimension {
+    type Error = NumericError;
+
+    fn try_from(value: [i16; 7]) -> Result<Self, Self::Error> {
+        Self::new(value)
+    }
+}
+
+impl From<Dimension> for [i16; 7] {
+    fn from(value: Dimension) -> Self {
+        value.0
+    }
+}
@@ -0,0 +1,469 @@
+use super::meter::{normalization_cost, parse_cost, product_cost, sum_cost, words};
+use super::{
+    MAX_COMPONENT_BITS, MAX_COMPONENT_DIGITS, MAX_DECIMAL_EXPONENT, MAX_INTEGER_POWER,
+    MAX_INTERMEDIATE_BITS, MAX_LITERAL_BYTES, NumberComponent, NumericError, NumericLimit,
+    NumericOperation, WorkLimits, WorkMeter,
+};
+use num_bigint::BigInt;
+use num_integer::Integer;
+use num_traits::{One, Signed, Zero};
+use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
+
+/// The interchange representation deliberately does not use num-bigint's serde
+/// format or JSON numeric values. Duplicate/missing/unknown fields reject.
+/// Its derived decoder allocates String fields before numeric validation; a
+/// transport/document adapter must bound the encoded envelope and decoded text.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ExactWire {
+    pub numerator: String,
+    pub denominator: String,
+}
+
+/// Reduced rational with positive denominator and <=4096-bit components.
+///
+/// There are no unmetered arithmetic/ordering traits. Eq is structural equality
+/// of already normalized bounded values, not an expression comparison API.
+/// Standalone serde admission bounds the subsequent BigInt validation, not the
+/// preceding String decoding. Document adapters must bound encoded/decoded input
+/// and aggregate admission work. Evaluation uses one explicit WorkMeter.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(try_from = "ExactWire", into = "ExactWire")]
+pub struct Exact {
+    numerator: BigInt,
+    denominator: BigInt,
+}
+
+impl Exact {
+    pub fn from_integer(value: i64) -> Self {
+        Self {
+            numerator: BigInt::from(value),
+            denominator: BigInt::one(),
+        }
+    }
+
+    pub fn is_zero(&self) -> bool {
+        self.numerator.is_zero()
+    }
+
+    pub fn is_positive(&self) -> bool {
+        self.numerator.is_positive()
+    }
+
+    pub fn component_bits(&self) -> (u64, u64) {
+        (self.numerator.bits(), self.denominator.bits())
+    }
+
+    pub fn to_wire(&self) -> ExactWire {
+        ExactWire {
+            numerator: self.numerator.to_string(),
+            denominator: self.denominator.to_string(),
+        }
+    }
+
+    /// Canonical *literal* spelling, not a generic expression formatter.
+    /// Negative literal nodes use ratio(-n,d), even when d=1. A leading minus
+    /// belongs to the future expression parser's UnaryNegate node instead.
+    pub fn canonical_literal(&self) -> String {
+        if self.denominator.is_one() && !self.numerator.is_negative() {
+            self.numerator.to_string()
+        } else {
+            format!("ratio({}, {})", self.numerator, self.denominator)
+        }
+    }
+
+    pub fn from_wire(wire: &ExactWire, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        let n_digits = wire_digits(&wire.numerator, true)?;
+        let d_digits = wire_digits(&wire.denominator, false)?;
+        let n_bound = decimal_bits(n_digits.len());
+        let d_bound = decimal_bits(d_digits.len());
+        meter.numeric(
+            NumericOperation::ParseWire,
+            parse_cost(n_digits.len(), n_bound)
+                + parse_cost(d_digits.len(), d_bound)
+                + normalization_cost(n_bound, d_bound),
+        )?;
+        let numerator = parse_integer(&wire.numerator)?;
+        let denominator = parse_integer(&wire.denominator)?;
+        Self::check_bits(&numerator, &denominator, MAX_COMPONENT_BITS, "wire")?;
+        if denominator.is_zero() {
+            return Err(NumericError::ZeroDenominator);
+        }
+        if !numerator.gcd(&denominator).is_one() {
+            return Err(NumericError::NonCanonicalWire);
+        }
+        Ok(Self {
+            numerator,
+            denominator,
+        })
+    }
+
+    /// Reads one unsigned decimal/integer atom or a ratio(n,d) literal only.
+    /// It does not parse expressions, unary operators, units, calls or names.
+    /// Source ratios/decimals may reduce; wire values must already be canonical.
+    pub fn parse_literal(source: &str, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        if source.len() > MAX_LITERAL_BYTES {
+            return Err(NumericError::LiteralTooLong);
+        }
+        let source = trim_ascii(source);
+        if let Some(body) = source.strip_prefix("ratio(") {
+            let body = body.strip_suffix(')').ok_or(NumericError::InvalidLiteral)?;
+            let (n, d) = body.split_once(',').ok_or(NumericError::InvalidLiteral)?;
+            return Self::parse_ratio(trim_ascii(n), trim_ascii(d), meter);
+        }
+        Self::parse_decimal(source, meter)
+    }
+
+    fn parse_ratio(n: &str, d: &str, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        let n_digits = source_integer_digits(n, true)?;
+        let d_digits = source_integer_digits(d, false)?;
+        let n_bound = decimal_bits(n_digits.len());
+        let d_bound = decimal_bits(d_digits.len());
+        Self::check_estimates(n_bound, d_bound)?;
+        meter.numeric(
+            NumericOperation::ParseLiteral,
+            parse_cost(n_digits.len(), n_bound)
+                + parse_cost(d_digits.len(), d_bound)
+                + normalization_cost(n_bound, d_bound),
+        )?;
+        Self::normalize_precharged(parse_integer(n)?, parse_integer(d)?)
+    }
+
+    fn parse_decimal(source: &str, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        let mut parts = source.split(['e', 'E']);
+        let mantissa = parts.next().ok_or(NumericError::InvalidLiteral)?;
+        let exponent = match parts.next() {
+            Some(text) => parse_exponent(text)?,
+            None => 0,
+        };
+        if parts.next().is_some() {
+            return Err(NumericError::InvalidLiteral);
+        }
+        let (whole, fraction) = match mantissa.split_once('.') {
+            Some((whole, fraction)) if !fraction.is_empty() => (whole, fraction),
+            Some(_) => return Err(NumericError::InvalidLiteral),
+            None => (mantissa, ""),
+        };
+        source_integer_digits(whole, false)?;
+        if !fraction.bytes().all(|byte| byte.is_ascii_digit()) {
+            return Err(NumericError::InvalidLiteral);
+        }
+        let digit_count = whole.len() + fraction.len();
+        if digit_count > MAX_COMPONENT_DIGITS {
+            return Err(NumericError::LiteralTooLong);
+        }
+        let adjustment = exponent - fraction.len() as i32;
+        let power = adjustment.unsigned_abs();
+        let mantissa_bound = decimal_bits(digit_count);
+        let scale_bound = decimal_bits(power as usize + 1);
+        let (n_bound, d_bound) = if adjustment >= 0 {
+            (mantissa_bound + scale_bound, 1)
+        } else {
+            (mantissa_bound, scale_bound)
+        };
+        Self::check_estimates(n_bound, d_bound)?;
+        // Fixed logical allowance for constructing 10^power; independent of
+        // num-bigint's selected multiplication/exponentiation implementation.
+        let power_steps = 1 + 2 * u64::from(u32::BITS - power.leading_zeros());
+        meter.numeric(
+            NumericOperation::ParseLiteral,
+            parse_cost(digit_count, mantissa_bound)
+                + power_steps * product_cost(scale_bound, scale_bound)
+                + product_cost(mantissa_bound, scale_bound)
+                + normalization_cost(n_bound, d_bound),
+        )?;
+        let digits = format!("{whole}{fraction}");
+        let mut numerator = parse_integer(&digits)?;
+        let scale = BigInt::from(10_u8).pow(power);
+        let denominator = if adjustment >= 0 {
+            numerator *= scale;
+            BigInt::one()
+        } else {
+            scale
+        };
+        Self::normalize_precharged(numerator, denominator)
+    }
+
+    pub fn add(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        self.add_or_subtract(rhs, false, meter)
+    }
+
+    pub fn subtract(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        self.add_or_subtract(rhs, true, meter)
+    }
+
+    fn add_or_subtract(
+        &self,
+        rhs: &Self,
+        subtract: bool,
+        meter: &mut WorkMeter,
+    ) -> Result<Self, NumericError> {
+        let (a, b) = self.component_bits();
+        let (c, d) = rhs.component_bits();
+        let left_bound = a + d;
+        let right_bound = c + b;
+        let n_bound = left_bound.max(right_bound) + 1;
+        let d_bound = b + d;
+        Self::check_estimates(n_bound, d_bound)?;
+        meter.numeric(
+            if subtract {
+                NumericOperation::Subtract
+            } else {
+                NumericOperation::Add
+            },
+            product_cost(a, d)
+                + product_cost(c, b)
+                + sum_cost(left_bound, right_bound)
+                + product_cost(b, d)
+                + normalization_cost(n_bound, d_bound),
+        )?;
+        let left = &self.numerator * &rhs.denominator;
+        let right = &rhs.numerator * &self.denominator;
+        let numerator = if subtract { left - right } else { left + right };
+        let denominator = &self.denominator * &rhs.denominator;
+        Self::normalize_precharged(numerator, denominator)
+    }
+
+    pub fn multiply(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        let (a, b) = self.component_bits();
+        let (c, d) = rhs.component_bits();
+        Self::check_estimates(a + c, b + d)?;
+        meter.numeric(
+            NumericOperation::Multiply,
+            product_cost(a, c) + product_cost(b, d) + normalization_cost(a + c, b + d),
+        )?;
+        Self::normalize_precharged(
+            &self.numerator * &rhs.numerator,
+            &self.denominator * &rhs.denominator,
+        )
+    }
+
+    pub fn divide(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        let (a, b) = self.component_bits();
+        let (c, d) = rhs.component_bits();
+        Self::check_estimates(a + d, b + c)?;
+        meter.numeric(
+            NumericOperation::Divide,
+            product_cost(a, d) + product_cost(b, c) + normalization_cost(a + d, b + c),
+        )?;
+        if rhs.is_zero() {
+            return Err(NumericError::DivisionByZero);
+        }
+        Self::normalize_precharged(
+            &self.numerator * &rhs.denominator,
+            &self.denominator * &rhs.numerator,
+        )
+    }
+
+    pub fn compare(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Ordering, NumericError> {
+        let (a, b) = self.component_bits();
+        let (c, d) = rhs.component_bits();
+        Self::check_estimates((a + d).max(c + b), 1)?;
+        meter.numeric(
+            NumericOperation::Compare,
+            product_cost(a, d) + product_cost(c, b) + sum_cost(a + d, c + b),
+        )?;
+        Ok((&self.numerator * &rhs.denominator).cmp(&(&rhs.numerator * &self.denominator)))
+    }
+
+    pub fn negated(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.numeric(NumericOperation::Negate, self.copy_cost())?;
+        Ok(Self {
+            numerator: -&self.numerator,
+            denominator: self.denominator.clone(),
+        })
+    }
+
+    pub fn absolute(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.numeric(NumericOperation::Absolute, self.copy_cost())?;
+        Ok(Self {
+            numerator: self.numerator.abs(),
+            denominator: self.denominator.clone(),
+        })
+    }
+
+    pub fn reciprocal(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.numeric(NumericOperation::Reciprocal, self.copy_cost())?;
+        if self.is_zero() {
+            return Err(NumericError::DivisionByZero);
+        }
+        Ok(Self {
+            numerator: if self.numerator.is_negative() {
+                -&self.denominator
+            } else {
+                self.denominator.clone()
+            },
+            denominator: self.numerator.abs(),
+        })
+    }
+
+    /// Fixed left-to-right repeated multiplication, at most 16 multiplications.
+    /// Each reduced stage obeys the same component bound; no large power is
+    /// allocated and subsequently discarded after discovering it is oversized.
+    pub fn power(&self, exponent: i8, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.numeric(NumericOperation::Power, self.copy_cost())?;
+        if !(-MAX_INTEGER_POWER..=MAX_INTEGER_POWER).contains(&exponent) {
+            return Err(NumericError::IntegerPower);
+        }
+        if self.is_zero() && exponent == 0 {
+            return Err(NumericError::ZeroPowerZero);
+        }
+        let factor = if exponent < 0 {
+            self.reciprocal(meter)?
+        } else {
+            self.clone()
+        };
+        let mut value = Self::from_integer(1);
+        for _ in 0..exponent.unsigned_abs() {
+            value = value.multiply(&factor, meter)?;
+        }
+        Ok(value)
+    }
+
+    pub(super) fn copy_cost(&self) -> u64 {
+        let (n, d) = self.component_bits();
+        1 + words(n) + words(d)
+    }
+
+    fn normalize_precharged(
+        mut numerator: BigInt,
+        mut denominator: BigInt,
+    ) -> Result<Self, NumericError> {
+        Self::check_bits(
+            &numerator,
+            &denominator,
+            MAX_INTERMEDIATE_BITS,
+            "intermediate",
+        )?;
+        if denominator.is_zero() {
+            return Err(NumericError::ZeroDenominator);
+        }
+        if denominator.is_negative() {
+            numerator = -numerator;
+            denominator = -denominator;
+        }
+        let gcd = numerator.gcd(&denominator);
+        numerator /= &gcd;
+        denominator /= gcd;
+        Self::check_bits(&numerator, &denominator, MAX_COMPONENT_BITS, "reduced")?;
+        Ok(Self {
+            numerator,
+            denominator,
+        })
+    }
+
+    fn check_estimates(n: u64, d: u64) -> Result<(), NumericError> {
+        Self::check_bit_count(
+            n,
+            NumberComponent::Numerator,
+            MAX_INTERMEDIATE_BITS,
+            "predicted",
+        )?;
+        Self::check_bit_count(
+            d,
+            NumberComponent::Denominator,
+            MAX_INTERMEDIATE_BITS,
+            "predicted",
+        )
+    }
+
+    fn check_bits(n: &BigInt, d: &BigInt, limit: u64, stage: &str) -> Result<(), NumericError> {
+        Self::check_bit_count(n.bits(), NumberComponent::Numerator, limit, stage)?;
+        Self::check_bit_count(d.bits(), NumberComponent::Denominator, limit, stage)
+    }
+
+    fn check_bit_count(
+        bits: u64,
+        component: NumberComponent,
+        limit: u64,
+        stage: &str,
+    ) -> Result<(), NumericError> {
+        if bits > limit {
+            return Err(NumericError::Limit(NumericLimit::Bits {
+                component,
+                bits,
+                limit,
+                stage: stage.to_owned(),
+            }));
+        }
+        Ok(())
+    }
+}
+
+impl TryFrom<ExactWire> for Exact {
+    type Error = NumericError;
+
+    fn try_from(value: ExactWire) -> Result<Self, Self::Error> {
+        // BigInt validation is bounded after ExactWire strings have decoded.
+        // The adapter owns envelope/text/aggregate admission bounds and must not
+        // reset evaluation meters.
+        Self::from_wire(&value, &mut WorkMeter::new(WorkLimits::REFERENCE))
+    }
+}
+
+impl From<Exact> for ExactWire {
+    fn from(value: Exact) -> Self {
+        value.to_wire()
+    }
+}
+
+fn trim_ascii(text: &str) -> &str {
+    text.trim_matches(|ch: char| ch.is_ascii_whitespace())
+}
+
+fn source_integer_digits(text: &str, signed: bool) -> Result<&str, NumericError> {
+    let digits = if signed {
+        text.strip_prefix('-').unwrap_or(text)
+    } else {
+        text
+    };
+    if digits.len() > MAX_COMPONENT_DIGITS {
+        return Err(NumericError::LiteralTooLong);
+    }
+    if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
+        return Err(NumericError::InvalidLiteral);
+    }
+    Ok(digits)
+}
+
+fn wire_digits(text: &str, signed: bool) -> Result<&str, NumericError> {
+    let digits = source_integer_digits(text, signed).map_err(|error| match error {
+        NumericError::LiteralTooLong => error,
+        _ => NumericError::NonCanonicalWire,
+    })?;
+    if (digits.len() > 1 && digits.starts_with('0')) || (text.starts_with('-') && digits == "0") {
+        return Err(NumericError::NonCanonicalWire);
+    }
+    Ok(digits)
+}
+
+fn parse_integer(text: &str) -> Result<BigInt, NumericError> {
+    BigInt::parse_bytes(text.as_bytes(), 10).ok_or(NumericError::InvalidLiteral)
+}
+
+fn parse_exponent(text: &str) -> Result<i32, NumericError> {
+    let (negative, digits) = if let Some(digits) = text.strip_prefix('-') {
+        (true, digits)
+    } else {
+        (false, text.strip_prefix('+').unwrap_or(text))
+    };
+    if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
+        return Err(NumericError::InvalidLiteral);
+    }
+    let mut value = 0_i32;
+    for digit in digits.bytes() {
+        value = value * 10 + i32::from(digit - b'0');
+        if value > MAX_DECIMAL_EXPONENT {
+            return Err(NumericError::DecimalExponent);
+        }
+    }
+    Ok(if negative { -value } else { value })
+}
+
+fn decimal_bits(digits: usize) -> u64 {
+    // 3.322 exceeds log2(10); dimensions are bounded before this conversion.
+    (digits as u64 * 3322).div_ceil(1000).max(1)
+}
@@ -0,0 +1,32 @@
+[
+  {
+    "canonical_source": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "expression": {
+      "Number": {
+        "denominator": "1",
+        "numerator": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+      }
+    },
+    "name": "ten_to_300"
+  },
+  {
+    "canonical_source": "ratio(1, 522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168)",
+    "expression": {
+      "Number": {
+        "denominator": "522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168",
+        "numerator": "1"
+      }
+    },
+    "name": "one_over_two_to_4095"
+  },
+  {
+    "canonical_source": "ratio(-1044388881413152506691752710716624382579964249047383780384233483283953907971557456848826811934997558340890106714439262837987573438185793607263236087851365277945956976543709998340361590134383718314428070011855946226376318839397712745672334684344586617496807908705803704071284048740118609114467977783598029006686938976881787785946905630190260940599579453432823469303026696443059025015972399867714215541693835559885291486318237914434496734087811872639496475100189041349008417061675093668333850551032972088269550769983616369411933015213796825837188091833656751221318492846368125550225998300412344784862595674492194617023806505913245610825731835380087608622102834270197698202313169017678006675195485079921636419370285375124784014907159135459982790513399611551794271106831134090584272884279791554849782954323534517065223269061394905987693002122963395687782878948440616007412945674919823050571642377154816321380631045902916136926708342856440730447899971901781465763473223850267253059899795996090799469201774624817718449867455659250178329070473119433165550807568221846571746373296884912819520317457002440926616910874148385078411929804522981857338977648103126085903001302413467189726673216491511131602920781738033436090243804708340403154190335, 1)",
+    "expression": {
+      "Number": {
+        "denominator": "1",
+        "numerator": "-1044388881413152506691752710716624382579964249047383780384233483283953907971557456848826811934997558340890106714439262837987573438185793607263236087851365277945956976543709998340361590134383718314428070011855946226376318839397712745672334684344586617496807908705803704071284048740118609114467977783598029006686938976881787785946905630190260940599579453432823469303026696443059025015972399867714215541693835559885291486318237914434496734087811872639496475100189041349008417061675093668333850551032972088269550769983616369411933015213796825837188091833656751221318492846368125550225998300412344784862595674492194617023806505913245610825731835380087608622102834270197698202313169017678006675195485079921636419370285375124784014907159135459982790513399611551794271106831134090584272884279791554849782954323534517065223269061394905987693002122963395687782878948440616007412945674919823050571642377154816321380631045902916136926708342856440730447899971901781465763473223850267253059899795996090799469201774624817718449867455659250178329070473119433165550807568221846571746373296884912819520317457002440926616910874148385078411929804522981857338977648103126085903001302413467189726673216491511131602920781738033436090243804708340403154190335"
+      }
+    },
+    "name": "negative_4096_bit_bound"
+  }
+]
@@ -0,0 +1,240 @@
+use super::{NumericError, NumericLimit};
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+/// Every event is charged once per dynamic occurrence, before entering it.
+///
+/// A Call expression therefore charges Expression and CalculationEntry; a
+/// Property read charges Expression and PropertyBinding. List element visits
+/// are additional to evaluation of their expressions. Only executed branches
+/// are charged. Targets are sorted by category (properties, then checks), then
+/// stable UUID bytes, by the integrating evaluator.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum EvaluationStep {
+    Target,
+    Expression,
+    CalculationEntry,
+    PropertyBinding,
+    ListElement,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum NumericOperation {
+    ParseWire,
+    ParseLiteral,
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Compare,
+    Negate,
+    Absolute,
+    Reciprocal,
+    Power,
+    KindAssertion,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum WorkResource {
+    DynamicEvents,
+    NumericUnits,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum WorkSite {
+    Evaluation(EvaluationStep),
+    Numeric(NumericOperation),
+}
+
+/// Failed reservations consume no partial charge. The first failure is latched.
+#[derive(Debug, Clone, PartialEq, Eq, Error, Serialize, Deserialize)]
+#[error("{resource:?}: used {used}, requested {requested}, limit {limit}, at {site:?}")]
+pub struct WorkExhaustion {
+    pub resource: WorkResource,
+    pub used: u64,
+    pub requested: u64,
+    pub limit: u64,
+    pub site: WorkSite,
+}
+
+/// Provisional calibration ceilings, not measured execution-time guarantees.
+///
+/// Effective limits, profile identity, capture, targets and context must all be
+/// recorded in request/result/frozen identity. A caller may lower these ceilings.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(try_from = "WorkLimitsWire", into = "WorkLimitsWire")]
+pub struct WorkLimits {
+    dynamic_events: u64,
+    numeric_units: u64,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct WorkLimitsWire {
+    dynamic_events: u64,
+    numeric_units: u64,
+}
+
+impl WorkLimits {
+    pub const REFERENCE: Self = Self {
+        dynamic_events: 1_000_000,
+        numeric_units: 50_000_000,
+    };
+
+    pub fn new(dynamic_events: u64, numeric_units: u64) -> Result<Self, NumericError> {
+        if dynamic_events > Self::REFERENCE.dynamic_events
+            || numeric_units > Self::REFERENCE.numeric_units
+        {
+            return Err(NumericError::InvalidWorkLimits);
+        }
+        Ok(Self {
+            dynamic_events,
+            numeric_units,
+        })
+    }
+
+    pub fn dynamic_events(self) -> u64 {
+        self.dynamic_events
+    }
+
+    pub fn numeric_units(self) -> u64 {
+        self.numeric_units
+    }
+}
+
+impl TryFrom<WorkLimitsWire> for WorkLimits {
+    type Error = NumericError;
+
+    fn try_from(value: WorkLimitsWire) -> Result<Self, Self::Error> {
+        Self::new(value.dynamic_events, value.numeric_units)
+    }
+}
+
+impl From<WorkLimits> for WorkLimitsWire {
+    fn from(value: WorkLimits) -> Self {
+        Self {
+            dynamic_events: value.dynamic_events,
+            numeric_units: value.numeric_units,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct WorkUsage {
+    pub dynamic_events: u64,
+    pub numeric_units: u64,
+}
+
+/// Intentionally neither Clone nor Default: pass the same mutable meter through
+/// every target, numeric operation and expanded call in one evaluation request.
+///
+/// Exhaustion is terminal. Integrators must stop traversing siblings/targets and
+/// mark already collected causes as incomplete. Replaying an aggregate cache
+/// cost is insufficient if it changes the exact exhaustion location; initially
+/// retain logical traversal even when numerical values come from a cache.
+#[derive(Debug)]
+pub struct WorkMeter {
+    limits: WorkLimits,
+    usage: WorkUsage,
+    exhausted: Option<WorkExhaustion>,
+}
+
+impl WorkMeter {
+    pub fn new(limits: WorkLimits) -> Self {
+        Self {
+            limits,
+            usage: WorkUsage::default(),
+            exhausted: None,
+        }
+    }
+
+    pub fn limits(&self) -> WorkLimits {
+        self.limits
+    }
+
+    pub fn usage(&self) -> WorkUsage {
+        self.usage
+    }
+
+    pub fn exhaustion(&self) -> Option<&WorkExhaustion> {
+        self.exhausted.as_ref()
+    }
+
+    pub fn ensure_active(&self) -> Result<(), NumericError> {
+        match &self.exhausted {
+            Some(failure) => Err(NumericError::Limit(NumericLimit::Work(failure.clone()))),
+            None => Ok(()),
+        }
+    }
+
+    pub fn visit(&mut self, step: EvaluationStep) -> Result<(), NumericError> {
+        self.reserve(WorkResource::DynamicEvents, 1, WorkSite::Evaluation(step))
+    }
+
+    pub(super) fn numeric(
+        &mut self,
+        operation: NumericOperation,
+        units: u64,
+    ) -> Result<(), NumericError> {
+        self.reserve(
+            WorkResource::NumericUnits,
+            units,
+            WorkSite::Numeric(operation),
+        )
+    }
+
+    fn reserve(
+        &mut self,
+        resource: WorkResource,
+        requested: u64,
+        site: WorkSite,
+    ) -> Result<(), NumericError> {
+        self.ensure_active()?;
+        let (used, limit) = match resource {
+            WorkResource::DynamicEvents => (self.usage.dynamic_events, self.limits.dynamic_events),
+            WorkResource::NumericUnits => (self.usage.numeric_units, self.limits.numeric_units),
+        };
+        // Subtraction is safe: only successful reservations update usage.
+        if requested > limit - used {
+            let failure = WorkExhaustion {
+                resource,
+                used,
+                requested,
+                limit,
+                site,
+            };
+            self.exhausted = Some(failure.clone());
+            return Err(NumericError::Limit(NumericLimit::Work(failure)));
+        }
+        match resource {
+            WorkResource::DynamicEvents => self.usage.dynamic_events += requested,
+            WorkResource::NumericUnits => self.usage.numeric_units += requested,
+        }
+        Ok(())
+    }
+}
+
+// Logical 64-bit words are platform independent. These are deterministic
+// accounting weights, not a claim about num-bigint's internal algorithm/timing.
+pub(super) fn words(bits: u64) -> u64 {
+    bits.max(1).div_ceil(64)
+}
+
+pub(super) fn product_cost(a_bits: u64, b_bits: u64) -> u64 {
+    1 + words(a_bits) * words(b_bits)
+}
+
+pub(super) fn sum_cost(a_bits: u64, b_bits: u64) -> u64 {
+    1 + words(a_bits.max(b_bits))
+}
+
+pub(super) fn normalization_cost(n_bits: u64, d_bits: u64) -> u64 {
+    let width = words(n_bits.max(d_bits));
+    // 64*w² for GCD plus 2*w² for the two quotient operations.
+    1 + 66 * width * width
+}
+
+pub(super) fn parse_cost(digits: usize, estimated_bits: u64) -> u64 {
+    1 + digits as u64 * words(estimated_bits)
+}
@@ -0,0 +1,378 @@
+use super::{Dimension, Exact, MAX_INTEGER_POWER, NumericError, NumericOperation, WorkMeter};
+use std::cmp::Ordering;
+
+/// K is supplied by the common resolver's verified nominal compatibility
+/// relation. It is not inferred from dimension/name/symbol/archive bytes here.
+/// Coordinate basis/algebra/difference-kind closure must be part of that proof.
+/// Exact definition references and pins remain the caller's provenance.
+/// K must be a bounded, cheap-to-clone/compare verified handle. Constructing or
+/// comparing an unbounded rooted contract graph is resolver admission work and
+/// must not be hidden inside K's Clone/Eq implementations. Rust trait bounds do
+/// not enforce this resource contract.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResolvedKind<K> {
+    key: K,
+    dimension: Dimension,
+    difference: Option<K>,
+}
+
+impl<K> ResolvedKind<K> {
+    pub fn linear(key: K, dimension: Dimension) -> Self {
+        Self {
+            key,
+            dimension,
+            difference: None,
+        }
+    }
+
+    pub fn key(&self) -> &K {
+        &self.key
+    }
+
+    pub fn dimension(&self) -> Dimension {
+        self.dimension
+    }
+
+    pub fn is_affine(&self) -> bool {
+        self.difference.is_some()
+    }
+}
+
+impl<K: Clone + Eq> ResolvedKind<K> {
+    pub fn affine(key: K, difference: &Self) -> Result<Self, NumericError> {
+        if difference.is_affine() || key == difference.key {
+            return Err(NumericError::DifferenceKind);
+        }
+        Ok(Self {
+            key,
+            dimension: difference.dimension,
+            difference: Some(difference.key.clone()),
+        })
+    }
+
+    pub fn difference_kind(&self) -> Option<Self> {
+        self.difference
+            .as_ref()
+            .map(|key| Self::linear(key.clone(), self.dimension))
+    }
+}
+
+/// Canonical coordinate = magnitude * scale + offset.
+/// Unit symbols and display preferences are outside this numeric representation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Unit<K> {
+    kind: ResolvedKind<K>,
+    scale: Exact,
+    offset: Exact,
+}
+
+impl<K: Clone + Eq> Unit<K> {
+    pub fn new(kind: ResolvedKind<K>, scale: Exact, offset: Exact) -> Result<Self, NumericError> {
+        if !scale.is_positive() {
+            return Err(NumericError::UnitScale);
+        }
+        if !kind.is_affine() && !offset.is_zero() {
+            return Err(NumericError::LinearOffset);
+        }
+        Ok(Self {
+            kind,
+            scale,
+            offset,
+        })
+    }
+
+    pub fn kind(&self) -> &ResolvedKind<K> {
+        &self.kind
+    }
+
+    pub fn scale(&self) -> &Exact {
+        &self.scale
+    }
+
+    pub fn offset(&self) -> &Exact {
+        &self.offset
+    }
+
+    /// Fixed multiply-then-add path. Each reduced arithmetic stage is bounded.
+    /// A mathematically cancelling wider intermediate still reports NumericLimit;
+    /// replacing this path with a fused operation requires a new work profile.
+    pub fn to_canonical(
+        &self,
+        magnitude: &Exact,
+        meter: &mut WorkMeter,
+    ) -> Result<Exact, NumericError> {
+        magnitude
+            .multiply(&self.scale, meter)?
+            .add(&self.offset, meter)
+    }
+
+    /// Fixed subtract-then-divide path; never rounds a coordinate.
+    pub fn from_canonical(
+        &self,
+        coordinate: &Exact,
+        meter: &mut WorkMeter,
+    ) -> Result<Exact, NumericError> {
+        coordinate
+            .subtract(&self.offset, meter)?
+            .divide(&self.scale, meter)
+    }
+
+    pub fn convert(
+        &self,
+        magnitude: &Exact,
+        target: &Self,
+        meter: &mut WorkMeter,
+    ) -> Result<Exact, NumericError> {
+        meter.ensure_active()?;
+        if self.kind != target.kind {
+            return Err(NumericError::IncompatibleTypes);
+        }
+        target.from_canonical(&self.to_canonical(magnitude, meter)?, meter)
+    }
+}
+
+/// Internal numerical types. Boolean/list/check semantics belong to the common
+/// expression evaluator. Anonymous zero dimension normalizes to Number.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NumericType<K> {
+    Number,
+    Named(ResolvedKind<K>),
+    Anonymous(Dimension),
+}
+
+impl<K> NumericType<K> {
+    pub fn dimension(&self) -> Dimension {
+        match self {
+            Self::Number => Dimension::ZERO,
+            Self::Named(kind) => kind.dimension,
+            Self::Anonymous(dimension) => *dimension,
+        }
+    }
+
+    pub fn is_affine(&self) -> bool {
+        matches!(self, Self::Named(kind) if kind.is_affine())
+    }
+
+    fn anonymous(dimension: Dimension) -> Self {
+        if dimension.is_dimensionless() {
+            Self::Number
+        } else {
+            Self::Anonymous(dimension)
+        }
+    }
+
+    fn normalized(self) -> Self {
+        match self {
+            Self::Anonymous(dimension) => Self::anonymous(dimension),
+            other => other,
+        }
+    }
+}
+
+/// A canonical rational coordinate with an internal numerical type.
+///
+/// Derived Eq compares stored representation. Formal equality/ordering must call
+/// compare(), which rejects mismatched nominal kinds instead of treating them
+/// as a false predicate. Public property output must still check its declared
+/// type and anchor the result to that declaration's exact definition reference.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NumericValue<K> {
+    value_type: NumericType<K>,
+    coordinate: Exact,
+}
+
+impl<K: Clone + Eq> NumericValue<K> {
+    pub fn new(value_type: NumericType<K>, coordinate: Exact) -> Self {
+        Self {
+            value_type: value_type.normalized(),
+            coordinate,
+        }
+    }
+
+    pub fn number(coordinate: Exact) -> Self {
+        Self::new(NumericType::Number, coordinate)
+    }
+
+    pub fn from_unit(
+        magnitude: &Exact,
+        unit: &Unit<K>,
+        meter: &mut WorkMeter,
+    ) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        Ok(Self::new(
+            NumericType::Named(unit.kind.clone()),
+            unit.to_canonical(magnitude, meter)?,
+        ))
+    }
+
+    pub fn value_type(&self) -> &NumericType<K> {
+        &self.value_type
+    }
+
+    pub fn coordinate(&self) -> &Exact {
+        &self.coordinate
+    }
+
+    pub fn display_in(&self, unit: &Unit<K>, meter: &mut WorkMeter) -> Result<Exact, NumericError> {
+        meter.ensure_active()?;
+        if !matches!(&self.value_type, NumericType::Named(kind) if kind == &unit.kind) {
+            return Err(NumericError::IncompatibleTypes);
+        }
+        unit.from_canonical(&self.coordinate, meter)
+    }
+
+    pub fn add(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        let output = self.additive_type(rhs, false)?;
+        Ok(Self::new(
+            output,
+            self.coordinate.add(&rhs.coordinate, meter)?,
+        ))
+    }
+
+    pub fn subtract(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        let output = self.additive_type(rhs, true)?;
+        Ok(Self::new(
+            output,
+            self.coordinate.subtract(&rhs.coordinate, meter)?,
+        ))
+    }
+
+    fn additive_type(&self, rhs: &Self, subtract: bool) -> Result<NumericType<K>, NumericError> {
+        use NumericType::{Anonymous, Named, Number};
+        match (&self.value_type, &rhs.value_type) {
+            (Number, Number) => Ok(Number),
+            (Anonymous(left), Anonymous(right)) if left == right => Ok(Anonymous(*left)),
+            (Named(left), Named(right)) => match (&left.difference, &right.difference) {
+                (None, None) if left == right => Ok(Named(left.clone())),
+                (Some(difference), Some(_)) if subtract && left == right => Ok(Named(
+                    ResolvedKind::linear(difference.clone(), left.dimension),
+                )),
+                (Some(difference), None)
+                    if difference == &right.key && left.dimension == right.dimension =>
+                {
+                    Ok(Named(left.clone()))
+                }
+                (None, Some(difference))
+                    if !subtract
+                        && difference == &left.key
+                        && left.dimension == right.dimension =>
+                {
+                    Ok(Named(right.clone()))
+                }
+                _ => Err(NumericError::IncompatibleTypes),
+            },
+            _ => Err(NumericError::IncompatibleTypes),
+        }
+    }
+
+    pub fn multiply(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        let output = self.multiplicative_type(rhs, false)?;
+        Ok(Self::new(
+            output,
+            self.coordinate.multiply(&rhs.coordinate, meter)?,
+        ))
+    }
+
+    pub fn divide(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        let output = self.multiplicative_type(rhs, true)?;
+        Ok(Self::new(
+            output,
+            self.coordinate.divide(&rhs.coordinate, meter)?,
+        ))
+    }
+
+    fn multiplicative_type(
+        &self,
+        rhs: &Self,
+        divide: bool,
+    ) -> Result<NumericType<K>, NumericError> {
+        use NumericType::Number;
+        if self.value_type.is_affine() || rhs.value_type.is_affine() {
+            return Err(NumericError::AffineOperation);
+        }
+        match (&self.value_type, &rhs.value_type) {
+            (Number, Number) => Ok(Number),
+            (_, Number) => Ok(self.value_type.clone()),
+            (Number, _) if !divide => Ok(rhs.value_type.clone()),
+            _ => {
+                let left = self.value_type.dimension();
+                let right = rhs.value_type.dimension();
+                let dimension = if divide {
+                    left.checked_quotient(right)?
+                } else {
+                    left.checked_product(right)?
+                };
+                Ok(NumericType::anonymous(dimension))
+            }
+        }
+    }
+
+    pub fn negated(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        if self.value_type.is_affine() {
+            return Err(NumericError::AffineOperation);
+        }
+        Ok(Self::new(
+            self.value_type.clone(),
+            self.coordinate.negated(meter)?,
+        ))
+    }
+
+    pub fn absolute(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        if self.value_type.is_affine() {
+            return Err(NumericError::AffineOperation);
+        }
+        Ok(Self::new(
+            self.value_type.clone(),
+            self.coordinate.absolute(meter)?,
+        ))
+    }
+
+    pub fn power(&self, exponent: i8, meter: &mut WorkMeter) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        if !(-MAX_INTEGER_POWER..=MAX_INTEGER_POWER).contains(&exponent) {
+            return Err(NumericError::IntegerPower);
+        }
+        if self.value_type.is_affine() {
+            return Err(NumericError::AffineOperation);
+        }
+        let output = match exponent {
+            0 => NumericType::Number,
+            1 => self.value_type.clone(),
+            _ => NumericType::anonymous(self.value_type.dimension().checked_power(exponent)?),
+        };
+        Ok(Self::new(output, self.coordinate.power(exponent, meter)?))
+    }
+
+    pub fn compare(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Ordering, NumericError> {
+        meter.ensure_active()?;
+        if self.value_type != rhs.value_type {
+            return Err(NumericError::IncompatibleTypes);
+        }
+        self.coordinate.compare(&rhs.coordinate, meter)
+    }
+
+    pub fn as_kind(
+        &self,
+        target: &ResolvedKind<K>,
+        meter: &mut WorkMeter,
+    ) -> Result<Self, NumericError> {
+        meter.ensure_active()?;
+        if target.is_affine()
+            || matches!(self.value_type, NumericType::Named(_))
+            || self.value_type.dimension() != target.dimension
+        {
+            return Err(NumericError::KindAssertion);
+        }
+        meter.numeric(NumericOperation::KindAssertion, self.coordinate.copy_cost())?;
+        Ok(Self::new(
+            NumericType::Named(target.clone()),
+            self.coordinate.clone(),
+        ))
+    }
+}
@@ -0,0 +1,804 @@
+use super::*;
+use num_bigint::BigInt;
+use num_traits::One;
+use std::cmp::Ordering;
+
+fn meter() -> WorkMeter {
+    WorkMeter::new(WorkLimits::REFERENCE)
+}
+
+fn exact(n: impl ToString, d: impl ToString) -> Exact {
+    Exact::from_wire(
+        &ExactWire {
+            numerator: n.to_string(),
+            denominator: d.to_string(),
+        },
+        &mut meter(),
+    )
+    .unwrap()
+}
+
+fn source(text: &str) -> Exact {
+    Exact::parse_literal(text, &mut meter()).unwrap()
+}
+
+fn assert_fraction(value: &Exact, n: impl ToString, d: impl ToString) {
+    assert_eq!(
+        value.to_wire(),
+        ExactWire {
+            numerator: n.to_string(),
+            denominator: d.to_string(),
+        }
+    );
+}
+
+// Independent bounded i128 oracle. It does not call the production Exact/GCD
+// implementation when deriving expected arithmetic or ordering.
+fn small_fraction(mut n: i128, mut d: i128) -> (i128, i128) {
+    assert_ne!(d, 0);
+    if d < 0 {
+        n = -n;
+        d = -d;
+    }
+    let (mut a, mut b) = (n.abs(), d);
+    while b != 0 {
+        (a, b) = (b, a % b);
+    }
+    (n / a, d / a)
+}
+
+#[test]
+fn arithmetic_matches_independent_small_integer_oracle() {
+    for a in [-5_i128, -2, 0, 1, 4] {
+        for b in [1_i128, 2, 3, 7] {
+            for c in [-5_i128, -2, 0, 1, 4] {
+                for d in [1_i128, 2, 3, 7] {
+                    let (an, ad) = small_fraction(a, b);
+                    let (bn, bd) = small_fraction(c, d);
+                    let left = exact(an, ad);
+                    let right = exact(bn, bd);
+                    let mut work = meter();
+                    let (n, den) = small_fraction(a * d + c * b, b * d);
+                    assert_fraction(&left.add(&right, &mut work).unwrap(), n, den);
+                    let (n, den) = small_fraction(a * d - c * b, b * d);
+                    assert_fraction(&left.subtract(&right, &mut work).unwrap(), n, den);
+                    let (n, den) = small_fraction(a * c, b * d);
+                    assert_fraction(&left.multiply(&right, &mut work).unwrap(), n, den);
+                    if c != 0 {
+                        let (n, den) = small_fraction(a * d, b * c);
+                        assert_fraction(&left.divide(&right, &mut work).unwrap(), n, den);
+                    } else {
+                        assert_eq!(
+                            left.divide(&right, &mut work),
+                            Err(NumericError::DivisionByZero)
+                        );
+                    }
+                    assert_eq!(
+                        left.compare(&right, &mut work).unwrap(),
+                        (a * d).cmp(&(c * b))
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn decimals_are_exact_and_source_ratios_reduce() {
+    assert_fraction(
+        &source("0.1").add(&source("0.2"), &mut meter()).unwrap(),
+        3,
+        10,
+    );
+    assert_fraction(&source("0.50"), 1, 2);
+    assert_fraction(&source("12.50e-2"), 1, 8);
+    assert_fraction(&source("1e+3"), 1000, 1);
+    assert_fraction(&source("0001.2500"), 5, 4);
+    assert_fraction(&source(" ratio( -6, 8 ) "), -3, 4);
+    assert_fraction(&source("ratio(-0, 27)"), 0, 1);
+    assert_eq!(source("0.5").canonical_literal(), "ratio(1, 2)");
+    assert_eq!(source("42").canonical_literal(), "42");
+}
+
+#[test]
+fn powers_and_signs_have_explicit_domains() {
+    let x = exact(-2, 3);
+    assert_fraction(&x.power(3, &mut meter()).unwrap(), -8, 27);
+    assert_fraction(&x.power(-3, &mut meter()).unwrap(), -27, 8);
+    assert_fraction(&x.power(0, &mut meter()).unwrap(), 1, 1);
+    assert_fraction(&x.absolute(&mut meter()).unwrap(), 2, 3);
+    assert_fraction(&x.negated(&mut meter()).unwrap(), 2, 3);
+    assert_fraction(&x.reciprocal(&mut meter()).unwrap(), -3, 2);
+    let zero = Exact::from_integer(0);
+    assert_eq!(
+        zero.power(0, &mut meter()),
+        Err(NumericError::ZeroPowerZero)
+    );
+    assert_eq!(
+        zero.power(-1, &mut meter()),
+        Err(NumericError::DivisionByZero)
+    );
+    assert_eq!(x.power(17, &mut meter()), Err(NumericError::IntegerPower));
+    assert_eq!(
+        x.power(i8::MIN, &mut meter()),
+        Err(NumericError::IntegerPower)
+    );
+}
+
+#[test]
+fn canonical_wire_rejects_both_component_noncanonical_forms() {
+    for (n, d) in [
+        ("+1", "1"),
+        ("01", "1"),
+        ("-0", "1"),
+        ("1", "+1"),
+        ("1", "-1"),
+        ("1", "01"),
+        ("2", "4"),
+        ("0", "3"),
+        ("", "1"),
+        ("1", ""),
+        ("1.0", "1"),
+        ("1", "1.0"),
+        ("1e1", "1"),
+        ("1", "1e1"),
+        (" 1", "1"),
+        ("1", "1 "),
+    ] {
+        assert!(
+            Exact::from_wire(
+                &ExactWire {
+                    numerator: n.into(),
+                    denominator: d.into()
+                },
+                &mut meter(),
+            )
+            .is_err(),
+            "accepted {n}/{d}"
+        );
+    }
+    assert_eq!(
+        Exact::from_wire(
+            &ExactWire {
+                numerator: "1".into(),
+                denominator: "0".into()
+            },
+            &mut meter()
+        ),
+        Err(NumericError::ZeroDenominator)
+    );
+    assert_fraction(&exact(0, 1), 0, 1);
+    assert_fraction(&exact(-1, 2), -1, 2);
+}
+
+#[test]
+fn serde_uses_closed_canonical_string_wire() {
+    let value = exact(-3, 7);
+    let encoded = serde_json::to_value(&value).unwrap();
+    assert_eq!(
+        encoded,
+        serde_json::json!({"numerator":"-3","denominator":"7"})
+    );
+    assert_eq!(serde_json::from_value::<Exact>(encoded).unwrap(), value);
+    for invalid in [
+        r#"{"numerator":1,"denominator":"2"}"#,
+        r#"{"numerator":"1","denominator":2}"#,
+        r#"{"numerator":"1","denominator":"2","other":0}"#,
+        r#"{"numerator":"1","numerator":"2","denominator":"3"}"#,
+        r#"{"numerator":"1"}"#,
+        r#"{"numerator":"2","denominator":"4"}"#,
+    ] {
+        assert!(serde_json::from_str::<Exact>(invalid).is_err(), "{invalid}");
+    }
+}
+
+#[test]
+fn literal_reader_does_not_fold_expression_unary_minus() {
+    assert_eq!(
+        Exact::parse_literal("-2", &mut meter()),
+        Err(NumericError::InvalidLiteral)
+    );
+    let negative_literal = source("ratio(-2, 1)");
+    assert_eq!(negative_literal.canonical_literal(), "ratio(-2, 1)");
+    assert_eq!(source("2").negated(&mut meter()).unwrap(), negative_literal);
+    // Equality of coordinates does not claim AST equality. The expression
+    // parser must preserve UnaryNegate independently of its operand literal.
+    assert_eq!(source("2").canonical_literal(), "2");
+}
+
+#[test]
+fn literal_syntax_and_decimal_exponent_are_bounded() {
+    for invalid in [
+        "",
+        "-",
+        "+1",
+        ".5",
+        "1.",
+        "1.2.3",
+        "1e",
+        "1ee2",
+        "1e+-2",
+        "1_000",
+        "NaN",
+        "Infinity",
+        "1/2",
+        "ratio(1)",
+        "ratio(1,2,3)",
+        "ratio(1,-2)",
+        "ratio(+1,2)",
+        "ratio(1,2) + 1",
+        "１２",
+    ] {
+        assert!(
+            Exact::parse_literal(invalid, &mut meter()).is_err(),
+            "{invalid}"
+        );
+    }
+    for invalid in ["1e129", "1e-129", "1e9999999999999999999999"] {
+        assert_eq!(
+            Exact::parse_literal(invalid, &mut meter()),
+            Err(NumericError::DecimalExponent)
+        );
+    }
+    assert!(Exact::parse_literal("1e128", &mut meter()).is_ok());
+    assert!(Exact::parse_literal("1e-128", &mut meter()).is_ok());
+    assert_eq!(
+        Exact::parse_literal(&"1".repeat(MAX_COMPONENT_DIGITS + 1), &mut meter()),
+        Err(NumericError::LiteralTooLong)
+    );
+    assert_eq!(
+        Exact::parse_literal(&" ".repeat(MAX_LITERAL_BYTES + 1), &mut meter()),
+        Err(NumericError::LiteralTooLong)
+    );
+}
+
+#[test]
+fn full_independent_r7_packets_round_trip_as_literals_and_wire() {
+    let packets: serde_json::Value =
+        serde_json::from_str(include_str!("fixtures/r7-literal-boundaries.json")).unwrap();
+    for packet in packets.as_array().unwrap() {
+        let wire: ExactWire =
+            serde_json::from_value(packet["expression"]["Number"].clone()).unwrap();
+        let expected = Exact::from_wire(&wire, &mut meter()).unwrap();
+        let spelling = packet["canonical_source"].as_str().unwrap();
+        assert_eq!(expected.canonical_literal(), spelling);
+        assert_eq!(
+            Exact::parse_literal(spelling, &mut meter()).unwrap(),
+            expected
+        );
+        let serialized = serde_json::to_string(&expected).unwrap();
+        assert_eq!(
+            serde_json::from_str::<Exact>(&serialized).unwrap(),
+            expected
+        );
+        assert_eq!(expected.to_wire(), wire);
+    }
+}
+
+#[test]
+fn full_8193_bit_sum_intermediate_can_reduce_to_admitted_value() {
+    // N=(2^4096)-1, D=N-1. gcd(N,D)=1 and D is even.
+    // N/D + N/D = N/(D/2), although its un-reduced numerator needs 8193 bits.
+    let n = (BigInt::one() << 4096_usize) - 1_u8;
+    let d = &n - 1_u8;
+    let value = exact(&n, &d);
+    let result = value.add(&value, &mut meter()).unwrap();
+    assert_fraction(&result, &n, &d / 2_u8);
+}
+
+#[test]
+fn cross_products_cancel_before_reduced_component_limit() {
+    let n = BigInt::one() << 4095_usize;
+    let d = &n - 1_u8;
+    let left = exact(&n, &d);
+    let right = exact(&d, &n);
+    assert_fraction(&left.multiply(&right, &mut meter()).unwrap(), 1, 1);
+    assert_fraction(
+        &left
+            .add(&left.negated(&mut meter()).unwrap(), &mut meter())
+            .unwrap(),
+        0,
+        1,
+    );
+}
+
+#[test]
+fn both_reduced_component_overflows_are_reported() {
+    let n = BigInt::one() << 4095_usize;
+    let mut work = meter();
+    let failure = exact(&n, 1)
+        .multiply(&Exact::from_integer(2), &mut work)
+        .unwrap_err();
+    assert!(matches!(
+        failure,
+        NumericError::Limit(NumericLimit::Bits {
+            component: NumberComponent::Numerator,
+            bits: 4097,
+            ..
+        })
+    ));
+    assert!(work.exhaustion().is_none());
+    let failure = exact(1, &n)
+        .divide(&Exact::from_integer(2), &mut work)
+        .unwrap_err();
+    assert!(matches!(
+        failure,
+        NumericError::Limit(NumericLimit::Bits {
+            component: NumberComponent::Denominator,
+            bits: 4097,
+            ..
+        })
+    ));
+    // Value overflow is a nonterminal supported-operation failure; fuel
+    // exhaustion, in contrast, terminates the entire request.
+    assert_fraction(&source("1").add(&source("1"), &mut work).unwrap(), 2, 1);
+}
+
+#[test]
+fn wire_rejects_4097_bits_before_gcd_can_reduce_them() {
+    let oversized = (BigInt::one() << 4096_usize).to_string();
+    for wire in [
+        ExactWire {
+            numerator: oversized.clone(),
+            denominator: "1".into(),
+        },
+        ExactWire {
+            numerator: "1".into(),
+            denominator: oversized.clone(),
+        },
+        ExactWire {
+            numerator: oversized.clone(),
+            denominator: oversized,
+        },
+    ] {
+        assert!(matches!(
+            Exact::from_wire(&wire, &mut meter()),
+            Err(NumericError::Limit(NumericLimit::Bits { stage, .. })) if stage == "wire"
+        ));
+    }
+}
+
+#[test]
+fn numeric_precharge_precedes_big_integer_result_allocation() {
+    let n = BigInt::one() << 4095_usize;
+    let left = exact(&n, 1);
+    let mut work = WorkMeter::new(WorkLimits::new(10, 0).unwrap());
+    let failure = left
+        .multiply(&Exact::from_integer(2), &mut work)
+        .unwrap_err();
+    assert!(failure.is_terminal_work_exhaustion());
+    assert_eq!(work.usage().numeric_units, 0);
+    assert!(matches!(
+        work.exhaustion().unwrap().site,
+        WorkSite::Numeric(NumericOperation::Multiply)
+    ));
+    // With available fuel the same operation reaches the 4097-bit result check.
+    assert!(matches!(
+        left.multiply(&Exact::from_integer(2), &mut meter()),
+        Err(NumericError::Limit(NumericLimit::Bits { .. }))
+    ));
+    let too_wide_wire = ExactWire {
+        numerator: (BigInt::one() << 4096_usize).to_string(),
+        denominator: "1".into(),
+    };
+    let mut parse_work = WorkMeter::new(WorkLimits::new(0, 0).unwrap());
+    assert!(
+        Exact::from_wire(&too_wide_wire, &mut parse_work)
+            .unwrap_err()
+            .is_terminal_work_exhaustion()
+    );
+}
+
+#[test]
+fn provisional_limits_and_effective_limits_round_trip() {
+    let limits = WorkLimits::new(500, 2000).unwrap();
+    let encoded = serde_json::to_value(limits).unwrap();
+    assert_eq!(
+        encoded,
+        serde_json::json!({"dynamic_events":500,"numeric_units":2000})
+    );
+    assert_eq!(
+        serde_json::from_value::<WorkLimits>(encoded).unwrap(),
+        limits
+    );
+    assert_eq!(
+        WorkLimits::new(1_000_001, 0),
+        Err(NumericError::InvalidWorkLimits)
+    );
+    assert_eq!(
+        WorkLimits::new(0, 50_000_001),
+        Err(NumericError::InvalidWorkLimits)
+    );
+    assert!(
+        serde_json::from_str::<WorkLimits>(r#"{"dynamic_events":1000001,"numeric_units":0}"#)
+            .is_err()
+    );
+}
+
+#[test]
+fn exact_accounting_boundary_and_terminal_failure_are_stable() {
+    // One-word addition: three products at 2, one sum at 2,
+    // normalization at 67 => 75 logical numeric units.
+    let mut work = WorkMeter::new(WorkLimits::new(4, 75).unwrap());
+    assert_fraction(&exact(1, 2).add(&exact(1, 3), &mut work).unwrap(), 5, 6);
+    assert_eq!(work.usage().numeric_units, 75);
+    assert!(work.exhaustion().is_none());
+    let first = Exact::from_integer(1).negated(&mut work).unwrap_err();
+    let at_failure = work.usage();
+    assert_eq!(
+        work.exhaustion().unwrap(),
+        &WorkExhaustion {
+            resource: WorkResource::NumericUnits,
+            used: 75,
+            requested: 3,
+            limit: 75,
+            site: WorkSite::Numeric(NumericOperation::Negate),
+        }
+    );
+    assert_eq!(work.visit(EvaluationStep::Target).unwrap_err(), first);
+    assert_eq!(
+        Exact::from_integer(1)
+            .divide(&Exact::from_integer(0), &mut work)
+            .unwrap_err(),
+        first
+    );
+    assert_eq!(
+        work.numeric(NumericOperation::Compare, 0).unwrap_err(),
+        first
+    );
+    assert_eq!(work.usage(), at_failure);
+}
+
+#[test]
+fn zero_cost_and_maximum_reservation_do_not_underflow_or_reactivate() {
+    let mut work = WorkMeter::new(WorkLimits::new(0, 0).unwrap());
+    work.numeric(NumericOperation::Compare, 0).unwrap();
+    let failure = work
+        .numeric(NumericOperation::Multiply, u64::MAX)
+        .unwrap_err();
+    assert!(failure.is_terminal_work_exhaustion());
+    assert_eq!(work.usage(), WorkUsage::default());
+    assert_eq!(
+        work.numeric(NumericOperation::Compare, 0).unwrap_err(),
+        failure
+    );
+    let mut dynamic = WorkMeter::new(WorkLimits::new(0, 5).unwrap());
+    assert!(dynamic.visit(EvaluationStep::Target).is_err());
+    assert_eq!(dynamic.usage(), WorkUsage::default());
+}
+
+#[test]
+fn multiple_targets_share_one_aggregate_meter() {
+    let mut work = WorkMeter::new(WorkLimits::new(3, 50).unwrap());
+    work.visit(EvaluationStep::Target).unwrap();
+    work.visit(EvaluationStep::Expression).unwrap();
+    work.visit(EvaluationStep::Target).unwrap();
+    let failure = work.visit(EvaluationStep::Expression).unwrap_err();
+    assert!(failure.is_terminal_work_exhaustion());
+    assert_eq!(work.usage().dynamic_events, 3);
+}
+
+// A direct bounded call-tree workload, not an expression interpreter/dialect.
+fn expanded_calls(
+    depth: u8,
+    x: u64,
+    work: &mut WorkMeter,
+    entered: &mut u64,
+) -> Result<u64, NumericError> {
+    work.visit(EvaluationStep::CalculationEntry)?;
+    *entered += 1;
+    if depth == 0 {
+        return Ok(x);
+    }
+    let left = expanded_calls(depth - 1, 2 * x, work, entered)?;
+    let right = expanded_calls(depth - 1, 2 * x + 1, work, entered)?;
+    Ok(left + right)
+}
+
+#[test]
+fn c1_expanded_call_witness_terminates_at_dynamic_limit() {
+    let mut work = WorkMeter::new(WorkLimits::new(10_000, 0).unwrap());
+    let mut entered = 0;
+    let failure = expanded_calls(30, 0, &mut work, &mut entered).unwrap_err();
+    assert!(failure.is_terminal_work_exhaustion());
+    assert_eq!(entered, 10_000);
+    assert_eq!(work.usage().dynamic_events, 10_000);
+    assert_eq!(
+        work.exhaustion().unwrap().site,
+        WorkSite::Evaluation(EvaluationStep::CalculationEntry)
+    );
+    // Nearby finite control: 63 invocations, leaves 0..31, sum 496.
+    let mut bounded = WorkMeter::new(WorkLimits::new(63, 0).unwrap());
+    let mut entered = 0;
+    assert_eq!(
+        expanded_calls(5, 0, &mut bounded, &mut entered).unwrap(),
+        496
+    );
+    assert_eq!(entered, 63);
+    assert!(bounded.exhaustion().is_none());
+}
+
+fn dim(value: [i16; 7]) -> Dimension {
+    Dimension::new(value).unwrap()
+}
+
+fn linear(key: &str, dimension: Dimension) -> ResolvedKind<String> {
+    ResolvedKind::linear(key.to_owned(), dimension)
+}
+
+fn named(n: i64, kind: &ResolvedKind<String>) -> NumericValue<String> {
+    NumericValue::new(NumericType::Named(kind.clone()), Exact::from_integer(n))
+}
+
+#[test]
+fn dimensions_use_checked_seven_axis_integer_algebra() {
+    let length = dim([1, 0, 0, 0, 0, 0, 0]);
+    let mass = dim([0, 1, 0, 0, 0, 0, 0]);
+    let time = dim([0, 0, 1, 0, 0, 0, 0]);
+    assert_eq!(
+        mass.checked_product(length)
+            .unwrap()
+            .checked_quotient(time.checked_power(2).unwrap())
+            .unwrap(),
+        dim([1, 1, -2, 0, 0, 0, 0])
+    );
+    assert!(time.checked_quotient(time).unwrap().is_dimensionless());
+    assert!(matches!(
+        dim([32, 0, 0, 0, 0, 0, 0]).checked_product(length),
+        Err(NumericError::DimensionExponent {
+            axis: DimensionAxis::Length,
+            value: 33
+        })
+    ));
+    assert!(dim([0, 0, -32, 0, 0, 0, 0]).checked_quotient(time).is_err());
+    assert!(length.checked_power(i8::MIN).is_err());
+    assert!(Dimension::new([33, 0, 0, 0, 0, 0, 0]).is_err());
+    assert_eq!(
+        serde_json::to_value(time).unwrap(),
+        serde_json::json!([0, 0, 1, 0, 0, 0, 0])
+    );
+    for invalid in ["[0,0,33,0,0,0,0]", "[0,0,1]", "[0,0,1,0,0,0,0,0]"] {
+        assert!(serde_json::from_str::<Dimension>(invalid).is_err());
+    }
+}
+
+#[test]
+fn duration_unit_coordinates_are_exact_and_nominal() {
+    let duration = linear("duration", dim([0, 0, 1, 0, 0, 0, 0]));
+    let s = Unit::new(duration.clone(), source("1"), source("0")).unwrap();
+    let ms = Unit::new(duration.clone(), source("0.001"), source("0")).unwrap();
+    assert_fraction(&ms.convert(&source("750"), &s, &mut meter()).unwrap(), 3, 4);
+    let receive = NumericValue::from_unit(&source("750"), &ms, &mut meter()).unwrap();
+    let dispatch = NumericValue::from_unit(&source("1"), &s, &mut meter()).unwrap();
+    let total = receive.add(&dispatch, &mut meter()).unwrap();
+    assert_fraction(total.coordinate(), 7, 4);
+    assert_fraction(&total.display_in(&ms, &mut meter()).unwrap(), 1750, 1);
+    let different = Unit::new(
+        linear("different-kind", duration.dimension()),
+        source("1"),
+        source("0"),
+    )
+    .unwrap();
+    assert_eq!(
+        ms.convert(&source("750"), &different, &mut meter()),
+        Err(NumericError::IncompatibleTypes)
+    );
+    let inconsistent = Unit::new(
+        linear("duration", dim([1, 0, 0, 0, 0, 0, 0])),
+        source("1"),
+        source("0"),
+    )
+    .unwrap();
+    assert!(
+        ms.convert(&source("1"), &inconsistent, &mut meter())
+            .is_err()
+    );
+    assert!(Unit::new(duration.clone(), source("0"), source("0")).is_err());
+    assert!(Unit::new(duration.clone(), source("ratio(-1,1)"), source("0")).is_err());
+    assert_eq!(
+        Unit::new(duration, source("1"), source("1")).unwrap_err(),
+        NumericError::LinearOffset
+    );
+}
+
+#[test]
+fn affine_point_and_difference_arithmetic_has_distinct_kinds() {
+    let interval = linear("temperature-difference", dim([0, 0, 0, 0, 1, 0, 0]));
+    let point = ResolvedKind::affine("temperature-point".to_owned(), &interval).unwrap();
+    let celsius = Unit::new(point.clone(), source("1"), source("273.15")).unwrap();
+    let fahrenheit = Unit::new(
+        point.clone(),
+        source("ratio(5,9)"),
+        source("ratio(45967,180)"),
+    )
+    .unwrap();
+    let kelvin_interval = Unit::new(interval.clone(), source("1"), source("0")).unwrap();
+    assert_fraction(
+        &celsius
+            .convert(&source("0"), &fahrenheit, &mut meter())
+            .unwrap(),
+        32,
+        1,
+    );
+    assert_fraction(
+        &fahrenheit
+            .convert(&source("70"), &celsius, &mut meter())
+            .unwrap(),
+        190,
+        9,
+    );
+    let p20 = NumericValue::from_unit(&source("20"), &celsius, &mut meter()).unwrap();
+    let p10 = NumericValue::from_unit(&source("10"), &celsius, &mut meter()).unwrap();
+    let difference = p20.subtract(&p10, &mut meter()).unwrap();
+    assert_eq!(
+        difference.value_type(),
+        &NumericType::Named(interval.clone())
+    );
+    assert_fraction(
+        &difference
+            .display_in(&kelvin_interval, &mut meter())
+            .unwrap(),
+        10,
+        1,
+    );
+    let delta5 = named(5, &interval);
+    let p25 = p20.add(&delta5, &mut meter()).unwrap();
+    assert_fraction(&p25.display_in(&celsius, &mut meter()).unwrap(), 25, 1);
+    assert_eq!(delta5.add(&p20, &mut meter()).unwrap(), p25);
+    assert!(p20.add(&p10, &mut meter()).is_err());
+    assert!(delta5.subtract(&p20, &mut meter()).is_err());
+    assert_eq!(
+        p20.power(1, &mut meter()),
+        Err(NumericError::AffineOperation)
+    );
+    assert_eq!(
+        p20.negated(&mut meter()),
+        Err(NumericError::AffineOperation)
+    );
+    assert_eq!(p20.compare(&p10, &mut meter()).unwrap(), Ordering::Greater);
+    assert!(p20.display_in(&kelvin_interval, &mut meter()).is_err());
+    assert!(ResolvedKind::affine(interval.key().clone(), &interval).is_err());
+    assert!(ResolvedKind::affine("other".to_owned(), &point).is_err());
+}
+
+#[test]
+fn affine_conversion_rejects_a_wider_stage_even_when_the_final_value_would_fit() {
+    // A fused coordinate calculation 2*m-m equals m, where m=2^4095 fits.
+    // The fixed multiply stage produces 2^4096, so it must fail before offset
+    // cancellation. The inverse path likewise rejects (m-(-m))/2 at subtraction.
+    let large = BigInt::one() << 4095_usize;
+    let magnitude = exact(&large, 1);
+    let interval = linear("temperature-interval", dim([0, 0, 0, 0, 1, 0, 0]));
+    let point = ResolvedKind::affine("temperature-point".to_owned(), &interval).unwrap();
+    let unit = Unit::new(point, Exact::from_integer(2), exact(-&large, 1)).unwrap();
+    let mut work = meter();
+    for outcome in [
+        unit.to_canonical(&magnitude, &mut work),
+        unit.from_canonical(&magnitude, &mut work),
+    ] {
+        assert!(matches!(
+            outcome,
+            Err(NumericError::Limit(NumericLimit::Bits {
+                component: NumberComponent::Numerator,
+                bits: 4097,
+                limit: MAX_COMPONENT_BITS,
+                ..
+            }))
+        ));
+    }
+    assert!(work.exhaustion().is_none());
+    let half = exact(&large >> 1_usize, 1);
+    assert_fraction(&unit.to_canonical(&half, &mut work).unwrap(), 0, 1);
+    assert_eq!(
+        unit.from_canonical(&Exact::from_integer(0), &mut work)
+            .unwrap(),
+        half
+    );
+}
+
+#[test]
+fn r6_anonymous_compound_energy_needs_one_outer_assertion() {
+    let force = linear("force", dim([1, 1, -2, 0, 0, 0, 0]));
+    let length = linear("length", dim([1, 0, 0, 0, 0, 0, 0]));
+    let energy = linear("energy", dim([2, 1, -2, 0, 0, 0, 0]));
+    let a = named(3, &force)
+        .multiply(&named(4, &length), &mut meter())
+        .unwrap();
+    let b = named(2, &force)
+        .multiply(&named(7, &length), &mut meter())
+        .unwrap();
+    assert_eq!(a.value_type(), &NumericType::Anonymous(energy.dimension()));
+    let sum = a.add(&b, &mut meter()).unwrap();
+    let result = sum.as_kind(&energy, &mut meter()).unwrap();
+    assert_fraction(result.coordinate(), 26, 1);
+    assert_eq!(result.value_type(), &NumericType::Named(energy.clone()));
+    assert_eq!(a.compare(&b, &mut meter()).unwrap(), Ordering::Less);
+    assert!(result.add(&sum, &mut meter()).is_err());
+    assert_eq!(
+        result.as_kind(&energy, &mut meter()),
+        Err(NumericError::KindAssertion)
+    );
+}
+
+#[test]
+fn anonymous_product_then_quotient_closes_and_preserves_scaling() {
+    let mass = linear("mass", dim([0, 1, 0, 0, 0, 0, 0]));
+    let length = linear("length", dim([1, 0, 0, 0, 0, 0, 0]));
+    let time = linear("duration", dim([0, 0, 1, 0, 0, 0, 0]));
+    let momentum = linear("momentum", dim([1, 1, -1, 0, 0, 0, 0]));
+    let result = named(2, &mass)
+        .multiply(&named(3, &length), &mut meter())
+        .unwrap()
+        .divide(&named(2, &time), &mut meter())
+        .unwrap()
+        .as_kind(&momentum, &mut meter())
+        .unwrap();
+    assert_fraction(result.coordinate(), 3, 1);
+    let scalar = NumericValue::number(source("2"));
+    let scaled = scalar.multiply(&named(3, &time), &mut meter()).unwrap();
+    assert_eq!(scaled.value_type(), &NumericType::Named(time.clone()));
+    assert_fraction(scaled.coordinate(), 6, 1);
+    assert_eq!(
+        named(3, &time)
+            .divide(&scalar, &mut meter())
+            .unwrap()
+            .value_type(),
+        &NumericType::Named(time.clone())
+    );
+    assert_eq!(
+        scalar
+            .divide(&named(3, &time), &mut meter())
+            .unwrap()
+            .value_type(),
+        &NumericType::Anonymous(dim([0, 0, -1, 0, 0, 0, 0]))
+    );
+}
+
+#[test]
+fn nominal_kinds_survive_comparison_but_explicit_quotients_can_erase_dimension() {
+    let energy = linear("energy", dim([2, 1, -2, 0, 0, 0, 0]));
+    let torque = linear("torque", energy.dimension());
+    let left = named(7, &energy);
+    let right = named(7, &torque);
+    assert!(left.add(&right, &mut meter()).is_err());
+    assert!(left.compare(&right, &mut meter()).is_err());
+    let ratio = left.divide(&right, &mut meter()).unwrap();
+    assert_eq!(ratio.value_type(), &NumericType::Number);
+    assert_fraction(ratio.coordinate(), 1, 1);
+    let named_ratio = linear("chosen-ratio", Dimension::ZERO);
+    let asserted = ratio.as_kind(&named_ratio, &mut meter()).unwrap();
+    assert_eq!(
+        asserted.value_type(),
+        &NumericType::Named(named_ratio.clone())
+    );
+    assert!(asserted.add(&ratio, &mut meter()).is_err());
+    assert_eq!(
+        NumericValue::<String>::new(NumericType::Anonymous(Dimension::ZERO), source("1")),
+        NumericValue::number(source("1"))
+    );
+}
+
+#[test]
+fn numerical_power_types_and_dimension_overflow_are_checked() {
+    let length = linear("length", dim([1, 0, 0, 0, 0, 0, 0]));
+    let value = named(2, &length);
+    assert_eq!(
+        value.power(0, &mut meter()).unwrap().value_type(),
+        &NumericType::Number
+    );
+    assert_eq!(
+        value.power(1, &mut meter()).unwrap().value_type(),
+        value.value_type()
+    );
+    assert_eq!(
+        value.power(-2, &mut meter()).unwrap().value_type(),
+        &NumericType::Anonymous(dim([-2, 0, 0, 0, 0, 0, 0]))
+    );
+    let large_dimension = linear("large-dimension", dim([32, 0, 0, 0, 0, 0, 0]));
+    assert!(
+        named(1, &large_dimension)
+            .multiply(&value, &mut meter())
+            .is_err()
+    );
+    assert!(named(1, &large_dimension).power(2, &mut meter()).is_err());
+}
@@ -142,87 +142,12 @@ pub struct Analysis {
    pub declarations: Vec<DeclarationSpan>,
 }

-/// Check the decoded spelling required by declaration-header UUID clauses.
-/// This is the shared 36-byte/hyphen shape rule, not a hexadecimal parser:
-/// callers must additionally parse the UUID. Uppercase hex and JSON escapes
-/// that decode to this spelling remain accepted. URN/braced/compact forms do not.
-pub fn has_uuid_header_shape(decoded: &str) -> bool {
-    decoded.len() == 36
-        && [8, 13, 18, 23]
-            .into_iter()
-            .all(|index| decoded.as_bytes()[index] == b'-')
-}
-
-/// Budgets for one original source buffer. Policy is caller-owned; these
-/// limits do not change the grammar or perform model admission.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct OutlineLimits {
-    pub max_source_bytes: usize,
-    pub max_tokens: usize,
-    pub max_declarations: usize,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum OutlineResource {
-    SourceBytes,
-    Tokens,
-    Declarations,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct OutlineLimit {
-    pub resource: OutlineResource,
-    pub limit: usize,
-    pub observed_at_least: usize,
-    /// Original byte offset where admission stopped; never a rewritten offset.
-    pub offset: usize,
-}
-
-/// Roles discovered by the existing tolerant declaration walk. Keeping the
-/// wrapper preserves DeclarationSpan and Analysis as existing public APIs.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct OutlineDeclaration {
-    pub declaration: DeclarationSpan,
-    pub kind_span: Span,
-    pub alias_span: Span,
-    /// Whole quoted header ID token, even if it is not a valid UUID. In that
-    /// case declaration.id is None. Missing/non-string ID values have no span.
-    pub id_literal_span: Option<Span>,
-}
-
-/// A full-file tolerant scan, not a successful parse or validated model. Invalid
-/// text remains available. Lexical errors and unmatched braces are facts only:
-/// their absence does not establish syntactic or semantic validity.
-///
-/// A budget failure returns Err and no partial Outline. Include reachability,
-/// project completeness and editor revision are intentionally not inferred here.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Outline<'a> {
-    pub source: &'a str,
-    pub tokens: Vec<TokenSpan>,
-    pub declarations: Vec<OutlineDeclaration>,
-    pub has_lexical_errors: bool,
-    pub has_unmatched_braces: bool,
-}
-
 /// Tolerant highlighting tokens cover the whole input, including incomplete
 /// strings and unexpected characters. No model is created or modified.
 pub fn tokenize(source: &str) -> Vec<TokenSpan> {
-    tokenize_with_limit(source, usize::MAX).expect("unlimited token scan")
-}
-
-fn tokenize_with_limit(source: &str, max_tokens: usize) -> Result<Vec<TokenSpan>, OutlineLimit> {
    let mut tokens = Vec::new();
    let mut cursor = 0;
    while cursor < source.len() {
-        if tokens.len() == max_tokens {
-            return Err(OutlineLimit {
-                resource: OutlineResource::Tokens,
-                limit: max_tokens,
-                observed_at_least: tokens.len().saturating_add(1),
-                offset: cursor,
-            });
-        }
        let start = cursor;
        let ch = source[cursor..].chars().next().expect("in bounds");
        let class = if matches!(ch, ' ' | '\t' | '\r' | '\n') {
@@ -299,7 +224,7 @@ fn tokenize_with_limit(source: &str, max_tokens: usize) -> Result<Vec<TokenSpan>
            span: Span { start, end: cursor },
        });
    }
-    Ok(tokens)
+    tokens
 }

 pub fn lint(source: &str) -> Vec<Diagnostic> {
@@ -1305,7 +1230,11 @@ impl Parser<'_> {
        self.cursor += 1;
        let offset = self.current().span.start;
        let value = self.quoted()?;
-        if !has_uuid_header_shape(&value) {
+        if value.len() != 36
+            || ![8, 13, 18, 23]
+                .into_iter()
+                .all(|i| value.as_bytes()[i] == b'-')
+        {
            return Err(Error {
                code: "invalid_source",
                offset,
@@ -2033,49 +1962,8 @@ fn take_required_id(fields: &mut Map<String, Value>, key: &str) -> Result<Id, St

 /// Analyze an incomplete source buffer without adopting a candidate. Declaration
 /// spans remain available even when a later declaration contains errors.
-/// Invalid compact/braced/URN header IDs retain no authored identity, matching
-/// the declaration parser rather than the UUID crate's broader accepted forms.
 pub fn analyze(source: &str) -> Analysis {
    let tokens = tokenize(source);
-    let (declarations, _) =
-        declaration_outline(source, &tokens, usize::MAX).expect("unlimited declaration walk");
-    Analysis {
-        tokens,
-        diagnostics: lint(source),
-        declarations: declarations.into_iter().map(|d| d.declaration).collect(),
-    }
-}
-
-/// Read exact current text without lint, parsing a model, stabilization or I/O.
-/// Source bytes are admitted before token allocation; token/declaration limits
-/// are checked before lexing the next token or materializing the next record.
-pub fn outline(source: &str, limits: OutlineLimits) -> Result<Outline<'_>, OutlineLimit> {
-    if source.len() > limits.max_source_bytes {
-        return Err(OutlineLimit {
-            resource: OutlineResource::SourceBytes,
-            limit: limits.max_source_bytes,
-            observed_at_least: source.len(),
-            offset: 0,
-        });
-    }
-    let tokens = tokenize_with_limit(source, limits.max_tokens)?;
-    let has_lexical_errors = tokens.iter().any(|token| token.class == TokenClass::Error);
-    let (declarations, has_unmatched_braces) =
-        declaration_outline(source, &tokens, limits.max_declarations)?;
-    Ok(Outline {
-        source,
-        tokens,
-        declarations,
-        has_lexical_errors,
-        has_unmatched_braces,
-    })
-}
-
-fn declaration_outline(
-    source: &str,
-    tokens: &[TokenSpan],
-    max_declarations: usize,
-) -> Result<(Vec<OutlineDeclaration>, bool), OutlineLimit> {
    let significant = tokens
        .iter()
        .filter(|t| !matches!(t.class, TokenClass::Whitespace | TokenClass::Comment))
@@ -2084,21 +1972,17 @@ fn declaration_outline(
    // again would make tolerant navigation quadratic on deeply nested drafts.
    let mut body_ends = vec![None; significant.len()];
    let mut bodies = Vec::new();
-    let mut unmatched_close = false;
    for (index, token) in significant.iter().enumerate() {
        match &source[token.span.start..token.span.end] {
            "{" => bodies.push(index),
            "}" => {
                if let Some(open) = bodies.pop() {
                    body_ends[open] = Some(token.span.end);
-                } else {
-                    unmatched_close = true;
                }
            }
            _ => {}
        }
    }
-    let has_unmatched_braces = unmatched_close || !bodies.is_empty();
    let mut declarations = Vec::new();
    for (i, t) in significant.iter().enumerate() {
        let word = &source[t.span.start..t.span.end];
@@ -2123,16 +2007,7 @@ fn declaration_outline(
            }
            j += 1;
        }
-        if declarations.len() == max_declarations {
-            return Err(OutlineLimit {
-                resource: OutlineResource::Declarations,
-                limit: max_declarations,
-                observed_at_least: declarations.len().saturating_add(1),
-                offset: t.span.start,
-            });
-        }
        let mut id = None;
-        let mut id_literal_span = None;
        if significant
            .get(j)
            .is_some_and(|t| &source[t.span.start..t.span.end] == "id")
@@ -2140,51 +2015,39 @@ fn declaration_outline(
            if let Some(value) = significant.get(j + 1)
                && value.class == TokenClass::String
            {
-                id_literal_span = Some(value.span);
                let text =
                    serde_json::from_str::<String>(&source[value.span.start..value.span.end])
                        .unwrap();
-                if has_uuid_header_shape(&text) {
-                    id = Id::parse_str(&text).ok();
-                }
+                id = Id::parse_str(&text).ok();
            }
            j += 2;
        }
-        // A recognized header ID at EOF must remain inside the whole span.
-        // Keep the old next-token/body behavior; only the EOF fallback changes.
-        let header_end = significant
-            .get(j.saturating_sub(1))
-            .or_else(|| significant.last())
-            .map_or(alias_token.span.end, |token| token.span.end);
-        let mut end = significant.get(j).map_or(header_end, |t| t.span.end);
+        let mut end = significant
+            .get(j)
+            .map_or(alias_token.span.end, |t| t.span.end);
        if significant
            .get(j)
            .is_some_and(|t| &source[t.span.start..t.span.end] == "{")
        {
            end = body_ends[j].unwrap_or(source.len());
        }
-        declarations.push(OutlineDeclaration {
-            declaration: DeclarationSpan {
-                alias: alias.into(),
-                id,
-                kind: word.into(),
-                span: Span {
-                    start: t.span.start,
-                    end,
-                },
+        declarations.push(DeclarationSpan {
+            alias: alias.into(),
+            id,
+            kind: word.into(),
+            span: Span {
+                start: t.span.start,
+                end,
            },
-            kind_span: t.span,
-            alias_span: alias_token.span,
-            id_literal_span,
        });
    }
-    Ok((declarations, has_unmatched_braces))
+    Analysis {
+        tokens,
+        diagnostics: lint(source),
+        declarations,
+    }
 }

-#[cfg(test)]
-#[path = "language_outline_tests.rs"]
-mod outline_tests;
-
 #[cfg(test)]
 #[path = "language_nesting_tests.rs"]
 mod nesting_tests;
@@ -2579,7 +2442,11 @@ pub(crate) mod legacy {
            let value = self.quoted()?;
            // Require the portable 8-4-4-4-12 spelling, not the UUID crate's URN,
            // braces, or compact alternatives. Uppercase hexadecimal is accepted.
-            if !super::has_uuid_header_shape(&value) {
+            if value.len() != 36
+                || ![8, 13, 18, 23]
+                    .into_iter()
+                    .all(|index| value.as_bytes()[index] == b'-')
+            {
                return Err(Error {
                    code: "invalid_source",
                    offset,
@@ -1,386 +0,0 @@
-//! Prepared outline tests. Explicit compatibility tests additionally exercise
-//! the existing parsers/analyze; the outline entry itself never calls them.
-use super::*;
-
-fn limits() -> OutlineLimits {
-    OutlineLimits {
-        max_source_bytes: 1024 * 1024,
-        max_tokens: 100_000,
-        max_declarations: 1_000,
-    }
-}
-
-fn declaration<'a>(result: &'a Outline<'_>, alias: &str) -> &'a OutlineDeclaration {
-    result
-        .declarations
-        .iter()
-        .find(|d| d.declaration.alias == alias)
-        .unwrap()
-}
-
-fn text(source: &str, span: Span) -> &str {
-    &source[span.start..span.end]
-}
-
-#[test]
-fn outline_roles_preserve_unicode_crlf_and_exact_escaped_uuid_literal() {
-    let source = "// 検査 🚒\r\noa_actor responder \"救助\" id \"\\u00300000000-0000-0000-0000-000000000001\" {}\r\nsource @ // 使用\r\n responder;";
-    let before = source.as_bytes().to_vec();
-    let result = outline(source, limits()).unwrap();
-    assert_eq!(result.source.as_bytes(), before);
-    assert_eq!(result.source.as_ptr(), source.as_ptr());
-    let d = declaration(&result, "responder");
-    assert_eq!(text(source, d.kind_span), "oa_actor");
-    assert_eq!(text(source, d.alias_span), "responder");
-    assert_eq!(
-        text(source, d.id_literal_span.unwrap()),
-        "\"\\u00300000000-0000-0000-0000-000000000001\""
-    );
-    assert_eq!(d.declaration.id, Some(Id::from_u128(1)));
-    assert_eq!(d.declaration.span.start, source.find("oa_actor").unwrap());
-    assert_eq!(d.declaration.span.end, source.find("{}\r\n").unwrap() + 2);
-    let mut end = 0;
-    for token in &result.tokens {
-        assert_eq!(token.span.start, end);
-        assert!(token.span.start < token.span.end);
-        assert!(source.is_char_boundary(token.span.start));
-        assert!(source.is_char_boundary(token.span.end));
-        end = token.span.end;
-    }
-    assert_eq!(end, source.len());
-    assert!(!result.has_lexical_errors);
-    assert!(!result.has_unmatched_braces);
-}
-
-#[test]
-fn closed_id_at_eof_is_inside_the_declaration_extent() {
-    for source in [
-        "oa_actor a \"Actor\" id \"00000000-0000-0000-0000-000000000001\"",
-        "node placed id \"00000000-0000-0000-0000-000000000001\"",
-    ] {
-        let result = outline(source, limits()).unwrap();
-        let d = &result.declarations[0];
-        let literal = d.id_literal_span.unwrap();
-        assert_eq!(d.declaration.id, Some(Id::from_u128(1)));
-        assert_eq!(d.declaration.span.end, source.len());
-        assert!(d.declaration.span.start <= literal.start);
-        assert!(literal.end <= d.declaration.span.end);
-    }
-    for source in ["oa_actor a \"Actor\"", "oa_actor a \"Actor\" id"] {
-        let result = outline(source, limits()).unwrap();
-        let d = &result.declarations[0];
-        assert_eq!(d.declaration.span.end, source.len());
-        assert_eq!(d.declaration.id, None);
-        assert_eq!(d.id_literal_span, None);
-    }
-}
-
-#[test]
-fn missing_bad_and_historical_ids_never_allocate_authored_identity() {
-    let source = "oa_actor missing \"No ID\" {}\noa_actor bad \"Bad ID\" id \"not-a-uuid\" {}\noa_actor historical \"00000000-0000-0000-0000-000000000001\" { history uuid \"00000000-0000-0000-0000-000000000001\"; }";
-    let first = outline(source, limits()).unwrap();
-    let second = outline(source, limits()).unwrap();
-    assert_eq!(first, second);
-    assert!(
-        first
-            .declarations
-            .iter()
-            .all(|d| d.declaration.id.is_none())
-    );
-    assert_eq!(declaration(&first, "missing").id_literal_span, None);
-    assert_eq!(declaration(&first, "historical").id_literal_span, None);
-    assert_eq!(
-        text(source, declaration(&first, "bad").id_literal_span.unwrap()),
-        "\"not-a-uuid\""
-    );
-    // Balanced tokens are not a successful syntax/semantic validation claim.
-    assert!(!first.has_lexical_errors);
-    assert!(!first.has_unmatched_braces);
-}
-
-#[test]
-fn invalid_full_scan_keeps_closed_children_and_reports_lexical_body_facts() {
-    let source = "oa_entity outer \"Outer\" {\n oa_actor ready \"Ready\" { description \"} stays text\"; }\n oa_actor pending \"Pending\" { description \"unfinished 🌊";
-    let result = outline(source, limits()).unwrap();
-    assert_eq!(result.source, source);
-    assert_eq!(result.tokens.last().unwrap().span.end, source.len());
-    assert!(result.has_lexical_errors);
-    assert!(result.has_unmatched_braces);
-    let ready = declaration(&result, "ready");
-    assert_eq!(
-        text(source, ready.declaration.span),
-        "oa_actor ready \"Ready\" { description \"} stays text\"; }"
-    );
-    assert_eq!(
-        declaration(&result, "outer").declaration.span.end,
-        source.len()
-    );
-    assert_eq!(
-        declaration(&result, "pending").declaration.span.end,
-        source.len()
-    );
-    let unmatched_close = outline("}\n// brace in comment {\n", limits()).unwrap();
-    assert!(unmatched_close.has_unmatched_braces);
-    assert!(!unmatched_close.has_lexical_errors);
-}
-
-#[test]
-fn missing_body_syntax_is_unchecked_even_when_known_error_flags_are_clear() {
-    let source = "oa_actor a \"A\" id \"00000000-0000-0000-0000-000000000001\"";
-    let result = outline(source, limits()).unwrap();
-    assert_eq!(result.declarations.len(), 1);
-    assert!(!result.has_lexical_errors);
-    assert!(!result.has_unmatched_braces);
-    // There is deliberately no `valid` flag: the known-complete fact is scanning
-    // these bytes, not the missing body becoming legal or the draft being applied.
-    assert_eq!(result.source, source);
-}
-
-#[test]
-fn keyword_alias_and_collisions_keep_every_source_ordered_header() {
-    let source = "project root_model \"Model\" {\n oa_actor oa_activity \"First\" id \"00000000-0000-0000-0000-000000000001\" {}\n oa_actor oa_activity \"Second\" id \"00000000-0000-0000-0000-000000000001\" {}\n diagram view_one \"View\" {}\n node placement { diagram @view_one; }\n}";
-    let result = outline(source, limits()).unwrap();
-    assert_eq!(result.declarations.len(), 5);
-    let duplicates: Vec<_> = result
-        .declarations
-        .iter()
-        .filter(|d| d.declaration.alias == "oa_activity")
-        .collect();
-    assert_eq!(duplicates.len(), 2);
-    assert!(duplicates[0].alias_span.start < duplicates[1].alias_span.start);
-    assert_eq!(duplicates[0].declaration.id, duplicates[1].declaration.id);
-    assert!(
-        result
-            .tokens
-            .iter()
-            .any(|t| t.span == duplicates[0].alias_span && t.class == TokenClass::Keyword)
-    );
-    assert_eq!(
-        text(source, declaration(&result, "placement").kind_span),
-        "node"
-    );
-    assert_eq!(declaration(&result, "placement").declaration.id, None);
-}
-
-#[test]
-fn bounds_refuse_before_returning_a_partial_outline() {
-    let source = "oa_actor a \"A\" {}\noa_actor b \"B\" {}";
-    let admitted = outline(source, limits()).unwrap();
-    let exact = OutlineLimits {
-        max_source_bytes: source.len(),
-        max_tokens: admitted.tokens.len(),
-        max_declarations: 2,
-    };
-    assert_eq!(outline(source, exact).unwrap(), admitted);
-    for resource in [
-        OutlineResource::SourceBytes,
-        OutlineResource::Tokens,
-        OutlineResource::Declarations,
-    ] {
-        let mut lower = exact;
-        match resource {
-            OutlineResource::SourceBytes => lower.max_source_bytes -= 1,
-            OutlineResource::Tokens => lower.max_tokens -= 1,
-            OutlineResource::Declarations => lower.max_declarations -= 1,
-        }
-        let error = outline(source, lower).unwrap_err();
-        assert_eq!(error.resource, resource);
-        assert!(error.observed_at_least > error.limit);
-        assert!(source.is_char_boundary(error.offset));
-        if resource == OutlineResource::Declarations {
-            assert_eq!(error.offset, source.find("oa_actor b").unwrap());
-        }
-    }
-    let empty = outline(
-        "",
-        OutlineLimits {
-            max_source_bytes: 0,
-            max_tokens: 0,
-            max_declarations: 0,
-        },
-    )
-    .unwrap();
-    assert!(empty.tokens.is_empty() && empty.declarations.is_empty());
-    let unicode = "// 🌊\r\noa_actor a \"A\" {}";
-    let error = outline(
-        unicode,
-        OutlineLimits {
-            max_source_bytes: 4,
-            ..limits()
-        },
-    )
-    .unwrap_err();
-    assert_eq!(error.resource, OutlineResource::SourceBytes);
-    assert_eq!(error.offset, 0);
-    let error = outline(
-        unicode,
-        OutlineLimits {
-            max_tokens: 1,
-            ..limits()
-        },
-    )
-    .unwrap_err();
-    assert_eq!(error.resource, OutlineResource::Tokens);
-    assert_eq!(error.offset, unicode.find('\n').unwrap());
-}
-
-#[test]
-fn outline_ranges_follow_current_bytes_without_identity_stabilization() {
-    let old = "oa_actor a \"A\" {}\nsource @a;";
-    let current = format!("// 航海 🚒\r\n{old}");
-    let old_outline = outline(old, limits()).unwrap();
-    let current_outline = outline(&current, limits()).unwrap();
-    let shift = current.len() - old.len();
-    let old_role = &old_outline.declarations[0];
-    let current_role = &current_outline.declarations[0];
-    assert_eq!(
-        current_role.alias_span.start,
-        old_role.alias_span.start + shift
-    );
-    assert_eq!(
-        current_role.kind_span.start,
-        old_role.kind_span.start + shift
-    );
-    assert_eq!(
-        current_role.declaration.span.end,
-        old_role.declaration.span.end + shift
-    );
-    assert_eq!(current_outline.source, current);
-    assert_eq!(old_outline.source, old);
-    assert_eq!(current_role.declaration.id, None);
-    assert!(!current_outline.source.contains(" id "));
-    // Workspace revision/stale-handle rejection belongs to the query/adapter,
-    // not a claim that an old owned span can be applied to any other string.
-}
-
-#[test]
-fn deeply_nested_bounds_use_the_same_iterative_walk_and_declaration_budget() {
-    let mut source = String::new();
-    for index in 0..600 {
-        source.push_str(&format!("oa_activity work_{index} \"Work\" {{\n"));
-    }
-    source.push_str(&"}\n".repeat(600));
-    let result = outline(&source, limits()).unwrap();
-    assert_eq!(result.declarations.len(), 600);
-    assert!(!result.has_unmatched_braces);
-    assert_eq!(
-        result.declarations[0].declaration.span.end,
-        source.len() - 1
-    );
-    let error = outline(
-        &source,
-        OutlineLimits {
-            max_declarations: 599,
-            ..limits()
-        },
-    )
-    .unwrap_err();
-    assert_eq!(error.resource, OutlineResource::Declarations);
-    assert_eq!(error.observed_at_least, 600);
-    assert_eq!(error.offset, source.find("oa_activity work_599").unwrap());
-}
-
-#[test]
-fn noncanonical_uuid_spellings_have_no_outline_or_analysis_identity() {
-    for raw in [
-        "00000000000000000000000000000001",
-        "{00000000-0000-0000-0000-000000000001}",
-        "urn:uuid:00000000-0000-0000-0000-000000000001",
-    ] {
-        assert!(
-            Id::parse_str(raw).is_ok(),
-            "The UUID crate alone is too permissive"
-        );
-        assert!(!has_uuid_header_shape(raw));
-        let literal = format!("\"{raw}\"");
-        let modern = format!("arcadia 7; project model \"Model\" id {literal} {{}}");
-        let before = modern.clone();
-        let result = outline(&modern, limits()).unwrap();
-        let d = declaration(&result, "model");
-        assert_eq!(d.declaration.id, None);
-        assert_eq!(text(&modern, d.id_literal_span.unwrap()), literal);
-        assert_eq!(modern, before);
-        let errors = parse(&modern).unwrap_err();
-        assert!(
-            errors
-                .iter()
-                .any(|error| error.message.contains("8-4-4-4-12")
-                    && error.span.start == modern.find(&literal).unwrap())
-        );
-        // Intentional compatibility correction: old analyze yielded Some(Id(1))
-        // here despite lint rejecting the header. It now shares outline's None.
-        let analysis = analyze(&modern);
-        assert_eq!(
-            analysis
-                .declarations
-                .iter()
-                .find(|d| d.alias == "model")
-                .unwrap()
-                .id,
-            None
-        );
-        assert!(
-            analysis
-                .diagnostics
-                .iter()
-                .any(|error| error.message.contains("8-4-4-4-12"))
-        );
-        let legacy_source = format!("arcadia 1; project \"Legacy\" id {literal} {{}}");
-        let legacy_errors = legacy::parse(&legacy_source).unwrap_err();
-        assert!(
-            legacy_errors
-                .iter()
-                .any(|error| error.message.contains("8-4-4-4-12"))
-        );
-    }
-}
-
-#[test]
-fn uppercase_and_json_escaped_header_ids_survive_both_parsers_and_outline() {
-    let expected = Id::from_u128(0xabcdef);
-    let canonical = expected.to_string();
-    let uppercase = canonical.to_uppercase();
-    assert_ne!(uppercase, canonical);
-    for raw in [uppercase.clone(), format!("\\u0030{}", &uppercase[1..])] {
-        let literal = format!("\"{raw}\"");
-        let decoded: String = serde_json::from_str(&literal).unwrap();
-        assert!(has_uuid_header_shape(&decoded));
-        let modern = format!("arcadia 7; project model \"Model\" id {literal} {{}}");
-        let result = outline(&modern, limits()).unwrap();
-        let d = declaration(&result, "model");
-        assert_eq!(d.declaration.id, Some(expected));
-        assert_eq!(text(&modern, d.id_literal_span.unwrap()), literal);
-        assert_eq!(result.source.as_bytes(), modern.as_bytes());
-        assert_eq!(parse(&modern).unwrap().id, expected);
-        let analysis = analyze(&modern);
-        assert_eq!(analysis.declarations[0].id, Some(expected));
-        assert!(
-            !analysis
-                .diagnostics
-                .iter()
-                .any(|error| error.severity == crate::validation::Severity::Error)
-        );
-        let legacy_source = format!("arcadia 1; project \"Legacy\" id {literal} {{}}");
-        assert_eq!(legacy::parse(&legacy_source).unwrap().id, expected);
-    }
-}
-
-#[test]
-fn header_shape_still_requires_valid_hexadecimal_uuid_data() {
-    let raw = "00000000-0000-0000-0000-00000000000Z";
-    assert!(has_uuid_header_shape(raw));
-    assert!(Id::parse_str(raw).is_err());
-    let literal = format!("\"{raw}\"");
-    let source = format!("arcadia 7; project model \"Model\" id {literal} {{}}");
-    let result = outline(&source, limits()).unwrap();
-    let d = declaration(&result, "model");
-    assert_eq!(d.declaration.id, None);
-    assert_eq!(text(&source, d.id_literal_span.unwrap()), literal);
-    assert!(
-        parse(&source)
-            .unwrap_err()
-            .iter()
-            .any(|error| error.message == "Invalid UUID identity.")
-    );
-    assert_eq!(analyze(&source).declarations[0].id, None);
-}
@@ -1,4 +1,5 @@
 //! Framework-independent OA/SA model, transactional commands and editing services.
+pub mod analysis_numeric;
 pub mod data;
 pub mod language;
 pub mod model;
@@ -5,9 +5,9 @@ mod checkpoints;
 #[cfg(test)]
 mod diagram_selection_tests;
 mod hosted;
+mod reference_authoring;
 #[cfg(test)]
 mod review_navigation_tests;
-mod source_symbols;
 #[cfg(test)]
 mod transition_context_tests;
 #[cfg(test)]
@@ -319,6 +319,7 @@ pub struct FilePrompt {

 #[derive(Debug, Clone)]
 pub enum Message {
+    BehaviorControl(behavior::canvas_workspace::Intent),
    Architecture(architecture_authoring::Event),
    Home(crate::home::Event),
    CheckpointTick,
@@ -372,6 +373,8 @@ pub enum Message {
    FieldValuePath(String, crate::data_values::FieldPathKey),
    FieldValueBrowse(String, Option<crate::data_values::FieldPathKey>, usize),
    FieldReferenceBrowse(String, String, usize),
+    FieldReferenceOpen(crate::forms::reference_chooser::adapter::Open),
+    FieldReferenceEvent(crate::forms::reference_chooser::Event),
    FieldVariant(String, Value),
    FieldArray(String, Option<usize>, i32),
    Apply,
@@ -416,15 +419,9 @@ pub enum Message {
    Linted(u64, Result<Vec<SourceDiagnostic>, String>),
    SourceDiagnostic(usize),
    SourceRelated(SourceLocation),
-    SourceViewport(Option<Id>),
-    SourceSymbols(
-        crate::source_navigation::SymbolContext,
-        crate::source_navigation::SymbolEvent,
-    ),
-    SourceSymbolsReady(crate::source_navigation::Completion),
+    SourceViewport,
    SourceForSelection,
    SourceNavigation(crate::source_navigation::Event),
-    SourceFindClose(crate::source_navigation::SymbolContext, Id),
    Save(bool),
    SavePath(Option<PathBuf>),
    Saved(Result<Option<FileSnapshot>, SaveFailure>),
@@ -452,10 +449,14 @@ pub struct App {
    pub hosted: crate::hosted::State,
    pub connection: Option<crate::connection_edit::Session>,
    pub model_menu: Option<crate::model_menu::Opened>,
+    reference_authoring: reference_authoring::State,
    pub source_tree: crate::source_tree::State,
    menu_sequence: u64,
    pub canvas_document: Id,
    pub canvas_epoch: u64,
+    /// Camera batches survive their own updates, never external presentation changes.
+    pub camera_epoch: u64,
+    camera_boundary_epoch: u64,
    pub selected_bend: Option<(Id, usize)>,
    pub exact_strings: bool,
    pub document: Document,
@@ -498,8 +499,6 @@ pub struct App {
    pub source_jump: Option<text_editor::Cursor>,
    source_select_line: bool,
    pub source_navigation: crate::source_navigation::State,
-    source_find_instance: Id,
-    pub source_symbols: crate::source_navigation::SymbolState,
    pub model_issues: Vec<validation::Issue>,
    pub migration: Option<persistence::MigrationReport>,
    source_version: u64,
@@ -556,10 +555,13 @@ impl App {
            checkpoint_close: None,
            connection: None,
            model_menu: None,
+            reference_authoring: Default::default(),
            source_tree: Default::default(),
            menu_sequence: 0,
            canvas_document: Id::new_v4(),
            canvas_epoch: 0,
+            camera_epoch: 0,
+            camera_boundary_epoch: 0,
            selected_bend: None,
            exact_strings: false,
            document,
@@ -605,8 +607,6 @@ impl App {
            source_jump: None,
            source_select_line: false,
            source_navigation: crate::source_navigation::State::default(),
-            source_find_instance: Id::new_v4(),
-            source_symbols: crate::source_navigation::SymbolState::default(),
            model_issues,
            migration: None,
            source_version: 0,
@@ -660,7 +660,6 @@ impl App {
        self.lint_requested = None;
    }
    fn show_source_file(&mut self, restore_cursor: bool) {
-        self.source_symbols.reveal = None;
        self.source_tree.reveal(&self.source_workspace.active);
        self.source_select_line = false;
        let source = self.source_workspace.text().to_owned();
@@ -675,9 +674,6 @@ impl App {
                    .map(|b| b.cursor)
            })
            .flatten();
-        if let Some(cursor) = self.source_jump {
-            self.queue_source_reveal(cursor, false);
-        }
    }
    fn selected_architecture_placement(&self) -> Option<Id> {
        self.active_diagram
@@ -931,7 +927,6 @@ impl App {
        let canvas_size = self.canvas_size;
        let source_version = self.source_version + 1;
        let lint_running = self.lint_running;
-        let navigation_in_flight = self.source_symbols.in_flight;
        let guide = std::mem::take(&mut self.guide);
        let mut hosted = std::mem::take(&mut self.hosted);
        hosted.leave_document();
@@ -943,7 +938,6 @@ impl App {
        self.canvas_size = canvas_size;
        self.source_version = source_version;
        self.lint_running = lint_running;
-        self.source_symbols.in_flight = navigation_in_flight;
        self.guide = guide;
        self.path = path;
        self.status = "Project ready".into();
@@ -1044,9 +1038,9 @@ impl App {
            crate::model_menu::popup(self),
        )
        .into();
-        crate::source_navigation::interaction::observe(
-            crate::hosted::view::overlay(self, base),
-            self.source_symbols.raw_interaction.clone(),
+        behavior::canvas_workspace::focus_root(
+            crate::hosted::view::overlay(self, self.reference_overlay(base)),
+            behavior::canvas_workspace::Scope::input_owner(self),
        )
    }
    pub fn subscription(&self) -> Subscription<Message> {
@@ -1055,14 +1049,8 @@ impl App {
            window::close_requests().map(|id| Message::Request(Pending::Close(id))),
            window::resize_events().map(|(_, size)| Message::WindowResized(size)),
            architecture_authoring::subscription(self),
-            // Use one captured-Escape bridge: a focused Find input consumes
-            // Escape, while modal priority remains in the ordinary handler.
            behavior::creation::subscription(
-                self.behavior.creation.has_pending()
-                    || self.behavior.source_active()
-                    || (self.page == Page::Text
-                        && (self.source_symbols.open || self.source_navigation.open)
-                        && self.architecture.is_none()),
+                self.behavior.creation.has_pending() || self.behavior.source_active(),
            )
            .map(|()| Message::Escape),
            iced::event::listen_with(|event, status, _| {
@@ -1109,46 +1097,107 @@ impl App {
        ])
    }
    pub fn update(&mut self, message: Message) -> Task<Message> {
-        let message = match message {
-            Message::SourceFindClose(context, instance) => {
-                if context != self.source_symbol_context()
-                    || instance != self.source_find_instance
-                    || !self.source_navigation.open
-                    || !self.source_navigation_available()
-                {
-                    return Task::none();
-                }
-                // Only the checked envelope may enter the legacy Close handler.
-                Message::SourceNavigation(crate::source_navigation::Event::Close)
-            }
-            Message::SourceNavigation(crate::source_navigation::Event::Close) => {
-                return Task::none();
-            }
-            message => message,
-        };
-        if let Message::SourceSymbols(context, _) = &message
-            && (context.session != self.source_workspace.session()
-                || context.path != self.source_workspace.active)
-        {
+        if let Message::BehaviorControl(intent) = message {
+            return self.behavior_control(intent);
+        }
+        let camera = matches!(
+            &message,
+            Message::ScenarioCanvas(crate::behavior::scenario::CanvasEvent::Camera(..))
+                | Message::TopologyCanvas(crate::behavior::topology::CanvasEvent::Camera(..))
+        );
+        let before = self.camera_boundary();
+        let task = self.update_inner(message);
+        if !camera && self.camera_boundary() != before {
+            self.camera_epoch = self.camera_epoch.wrapping_add(1);
+            self.camera_boundary_epoch = self.canvas_epoch;
+        }
+        task
+    }
+    fn behavior_control(&mut self, intent: behavior::canvas_workspace::Intent) -> Task<Message> {
+        use behavior::canvas_workspace::{self, Event as Camera, Scope};
+        use behavior::scenario::CanvasEvent as Scenario;
+        use behavior::topology::CanvasEvent as Process;
+        if Scope::input_owner(self) != Some(intent.scope) {
            return Task::none();
        }
-        // Internal results and geometry do not constitute a new user intent.
-        // Process query completion even behind a modal to release its worker slot;
-        // its handler independently refuses navigation outside the live editor.
-        if let Message::SourceSymbolsReady(completion) = message {
-            return self.source_symbols_ready(completion);
+        let mut message = *intent.message;
+        let scope = intent.scope;
+        let valid_scenario = |c: behavior::scenario::Context| {
+            c.document == scope.document
+                && c.scenario == scope.owner
+                && c.revision == scope.revision
+                && self.camera_toolbar_epoch(c.epoch)
+        };
+        let valid_process = |c: behavior::topology::Context| {
+            c.document == scope.document
+                && c.owner == scope.owner
+                && c.revision == scope.revision
+                && self.camera_toolbar_epoch(c.epoch)
+        };
+        // This whitelist contains only the production presentation controls.
+        // A stamped toolbar cannot smuggle an arbitrary authoring command.
+        match &mut message {
+            Message::ScenarioCanvas(Scenario::Camera(c, lifetime, Camera::Focus))
+                if valid_scenario(*c) && *lifetime == scope.epoch =>
+            {
+                return canvas_workspace::focus_task(scope, Camera::Focus);
+            }
+            Message::TopologyCanvas(Process::Camera(c, lifetime, Camera::Focus))
+                if valid_process(*c) && *lifetime == scope.epoch =>
+            {
+                return canvas_workspace::focus_task(scope, Camera::Focus);
+            }
+            Message::ScenarioCanvas(
+                Scenario::Zoom(c, _)
+                | Scenario::Choose(c, _)
+                | Scenario::Focus(c)
+                | Scenario::Shelf(c, _),
+            ) if valid_scenario(*c) => {
+                c.epoch = self.canvas_epoch;
+            }
+            Message::TopologyCanvas(
+                Process::Zoom(c, _) | Process::Choose(c, _) | Process::Focus(c),
+            ) if valid_process(*c) => {
+                c.epoch = self.canvas_epoch;
+            }
+            Message::Behavior(behavior::Event::Topology(behavior::topology::Event::Shelf(_)))
+                if self.topology_context().is_some() => {}
+            _ => return Task::none(),
        }
-        if !matches!(
-            &message,
-            Message::CheckpointTick
-                | Message::CheckpointWritten(..)
-                | Message::Lint(_)
-                | Message::Linted(..)
-                | Message::SourceViewport(_)
-                | Message::WindowResized(_)
-                | Message::CanvasResized(_)
-        ) {
-            self.source_interaction();
+        let task = self.update(message);
+        // Reapplying Fit or a tool also ends a held gesture. Focus is stamped
+        // after the action, for Iced's final-view ordering.
+        if self.camera_epoch == scope.epoch {
+            self.camera_epoch = self.camera_epoch.wrapping_add(1);
+            self.camera_boundary_epoch = self.canvas_epoch;
+        }
+        let focus = Scope::input_owner(self).map_or_else(Task::none, |scope| {
+            canvas_workspace::focus_task(scope, Camera::ControlFocus(intent.name))
+        });
+        Task::batch([task, focus])
+    }
+    fn camera_toolbar_epoch(&self, epoch: u64) -> bool {
+        epoch >= self.camera_boundary_epoch && epoch <= self.canvas_epoch
+    }
+    fn camera_boundary(&self) -> impl PartialEq + use<> {
+        (
+            self.canvas_epoch,
+            self.canvas_document,
+            self.document.revision(),
+            crate::behavior::selected_owner(self),
+            self.page,
+            self.window_size,
+            crate::behavior::canvas_workspace::keyboard_enabled(self),
+            self.behavior.has_pending(),
+            self.draft_dirty(),
+            self.source_dirty(),
+            self.behavior.topology.camera_boundary(),
+            self.behavior.scenario.camera_boundary(),
+        )
+    }
+    fn update_inner(&mut self, message: Message) -> Task<Message> {
+        if let Some(task) = self.reference_message(&message) {
+            return task;
        }
        if matches!(&message, Message::Connection(_))
            && self
@@ -1214,7 +1263,7 @@ impl App {
                    | Message::CanvasResized(_)
                    | Message::Lint(_)
                    | Message::Linted(_, _)
-                    | Message::SourceViewport(_)
+                    | Message::SourceViewport
                    | Message::Request(Pending::Close(_))
            )
        {
@@ -1260,7 +1309,7 @@ impl App {
                    | Message::Exported(_)
                    | Message::WindowResized(_)
                    | Message::CanvasResized(_)
-                    | Message::SourceViewport(_)
+                    | Message::SourceViewport
            )
        {
            return Task::none();
@@ -1298,7 +1347,7 @@ impl App {
                | Message::CheckpointLoaded(..)
                | Message::WindowResized(_)
                | Message::CanvasResized(_)
-                | Message::SourceViewport(_)
+                | Message::SourceViewport
                | Message::Lint(_)
                | Message::Linted(_, _)
                | Message::Saved(_)
@@ -1372,6 +1421,7 @@ impl App {
            self.last_workspace_page = self.page;
        }
        let mut task = self.handle(message);
+        self.reconcile_reference_chooser();
        self.route_state_diagram_workspace();
        if self.page != Page::Home {
            self.last_workspace_page = self.page;
@@ -1441,6 +1491,7 @@ impl App {
    }
    fn handle(&mut self, message: Message) -> Task<Message> {
        match message {
+            Message::BehaviorControl(intent) => return self.behavior_control(intent),
            Message::Architecture(event) => return self.architecture_event(event),
            Message::Home(event) => return self.home_event(event),
            Message::CheckpointTick => return self.checkpoint_tick(),
@@ -1456,6 +1507,17 @@ impl App {
            Message::ScenarioCanvas(event) => {
                use crate::behavior::scenario::{self, CanvasEvent};
                let context = event.context();
+                if let CanvasEvent::FormShown(_, session) = event {
+                    if self.scenario_context().is_some_and(|current| {
+                        current.document == context.document
+                            && current.scenario == context.scenario
+                            && current.revision == context.revision
+                    }) && self.behavior.scenario.take_form_focus(session)
+                    {
+                        return iced::widget::operation::focus(scenario::NAME_INPUT);
+                    }
+                    return Task::none();
+                }
                if let CanvasEvent::Viewport(_, size) = event {
                    if self.scenario_context().is_some_and(|current| {
                        current.document == context.document
@@ -1493,6 +1555,49 @@ impl App {
                    }
                    return Task::none();
                }
+                if let CanvasEvent::Camera(_, lifetime, input) = event {
+                    use crate::behavior::canvas_workspace::{self, Event};
+                    if lifetime != self.camera_epoch
+                        || !self.scenario_context().is_some_and(|c| {
+                            c.document == context.document
+                                && c.scenario == context.scenario
+                                && c.revision == context.revision
+                        })
+                    {
+                        return Task::none();
+                    }
+                    let scope = canvas_workspace::Scope {
+                        document: context.document,
+                        owner: context.scenario,
+                        revision: context.revision,
+                        epoch: lifetime,
+                    };
+                    if self.behavior.has_pending()
+                        || self.draft_dirty()
+                        || self.source_dirty()
+                        || !canvas_workspace::keyboard_enabled(self)
+                    {
+                        return Task::none();
+                    }
+                    match input {
+                        Event::Focus
+                        | Event::Traverse(_)
+                        | Event::ControlFocus(_)
+                        | Event::ToggleFocus
+                        | Event::Leave => {
+                            return canvas_workspace::focus_task(scope, input);
+                        }
+                        Event::CancelGesture => {
+                            self.canvas_epoch = self.canvas_epoch.wrapping_add(1)
+                        }
+                        input => {
+                            if self.behavior.scenario.camera(input) {
+                                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
+                            }
+                        }
+                    }
+                    return Task::none();
+                }
                if self.scenario_context() != Some(context) {
                    return Task::none();
                }
@@ -1506,9 +1611,11 @@ impl App {
                        self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
                    }
                    CanvasEvent::Zoom(_, scale) => {
-                        if self.behavior.scenario.zoom(scale) {
+                        let mut state = std::mem::take(&mut self.behavior.scenario);
+                        if state.camera_zoom(self.project(), context.scenario, scale) {
                            self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
                        }
+                        self.behavior.scenario = state;
                    }
                    CanvasEvent::OpenUse(_, occurrence) => {
                        if self.behavior.has_pending() || self.draft_dirty() || self.source_dirty()
@@ -1630,13 +1737,22 @@ impl App {
                                ..
                            } => {
                                let mut state = std::mem::take(&mut self.behavior.scenario);
-                                let result = state.begin_occurrence(
-                                    self.project(),
-                                    context,
-                                    tool,
-                                    slot,
-                                    lifeline,
-                                );
+                                let result = if tool == scenario::Tool::Lifeline {
+                                    state
+                                        .update(
+                                            self.project(),
+                                            scenario::Event::Start(context.scenario, tool),
+                                        )
+                                        .map(|_| ())
+                                } else {
+                                    state.begin_occurrence(
+                                        self.project(),
+                                        context,
+                                        tool,
+                                        slot,
+                                        lifeline,
+                                    )
+                                };
                                self.behavior.scenario = state;
                                match result {
                                    Ok(()) => {
@@ -1858,8 +1974,6 @@ impl App {
                return self.update(Message::Add(child));
            }
            Message::Escape => {
-                let restore_source_focus = self.source_navigation_available()
-                    && (self.source_navigation.open || self.source_symbols.open);
                if self.behavior.source_back() {
                    self.status =
                        "Returned to the unchanged parent form; no source was created.".into();
@@ -1876,12 +1990,6 @@ impl App {
                    self.status = "Drawing cancelled · Select / move is active".into();
                }
                self.source_navigation.open = false;
-                self.source_symbols.open = false;
-                self.source_symbols.results = None;
-                self.source_symbols.notice = None;
-                if restore_source_focus {
-                    self.restore_source_editor_focus();
-                }
                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
                self.selected_bend = None;
            }
@@ -1937,6 +2045,9 @@ impl App {
                        .insert(path, crate::forms::ValueBrowser { scope, page });
                }
            }
+            Message::FieldReferenceOpen(_) | Message::FieldReferenceEvent(_) => {
+                return Task::none();
+            }
            Message::FieldReferenceBrowse(path, query, page) => {
                if let Some(draft) = &mut self.draft {
                    let page = if draft
@@ -2930,21 +3041,12 @@ impl App {
                                if self.path.is_none()
                                    || self.path.as_ref() == Some(&receipt.target)
                                {
-                                    if self.path.as_ref() != Some(&receipt.target) {
-                                        self.source_workspace.reset_navigation_session();
-                                    }
                                    self.path = Some(receipt.target);
-                                    self.document.bind_repair_baseline(disk.reachable_bundle());
                                    self.disk_project = Some(disk);
                                }
                                self.status = "Interrupted disk save recovered. Current model and drafts are retained; Save all can be retried.".into();
                            }
                            Err(error) => {
-                                if self.path.is_none()
-                                    || self.path.as_ref() == Some(&receipt.target)
-                                {
-                                    self.document.invalidate_saved_baseline();
-                                }
                                self.status = format!(
                                    "Disk recovery completed; files could not be reloaded: {error}"
                                )
@@ -3001,11 +3103,14 @@ impl App {
                }
            }
            Message::SourceRelated(location) => self.jump_to_source(location),
-            Message::SourceViewport(ticket) => return self.source_viewport(ticket),
-            Message::SourceFindClose(..) => return Task::none(), // update checks and unwraps it
-            Message::SourceSymbols(_, event) => return self.source_symbol_event(event),
-            Message::SourceSymbolsReady(completion) => {
-                return self.source_symbols_ready(completion);
+            Message::SourceViewport => {
+                if let Some(cursor) = self.source_jump.take() {
+                    self.source_editor.move_to(cursor);
+                    if self.source_select_line && cursor.selection.is_none() {
+                        self.source_editor.perform(text_editor::Action::SelectLine);
+                    }
+                    return iced::widget::operation::focus("source-editor");
+                }
            }
            Message::ApplySource => {
                self.apply_source();
@@ -3051,7 +3156,6 @@ impl App {
                            return Task::none();
                        }
                        self.page = Page::Text;
-                        self.source_find_instance = Id::new_v4();
                        self.source_navigation.open = true;
                        self.source_navigation.refresh(&self.source_editor.text());
                        return iced::widget::operation::focus(if go_to_line {
@@ -3060,22 +3164,13 @@ impl App {
                            "source-find"
                        });
                    }
-                    Event::Close => {
-                        let was_open = self.source_navigation.open;
-                        self.source_navigation.open = false;
-                        if was_open {
-                            self.restore_source_editor_focus();
-                        }
-                    }
+                    Event::Close => self.source_navigation.open = false,
                    Event::Query(query) => {
                        self.source_navigation.query = query;
                        self.source_navigation.refresh(&self.source_editor.text());
                    }
                    Event::Next(backwards) if self.page == Page::Text => {
                        self.source_jump = self.source_navigation.next(backwards);
-                        if let Some(cursor) = self.source_jump {
-                            self.queue_source_reveal(cursor, false);
-                        }
                        if self.source_jump.is_none() {
                            self.status = "No matching source text.".into();
                        }
@@ -3086,7 +3181,8 @@ impl App {
                        .destination(self.source_editor.line_count())
                    {
                        Ok(cursor) => {
-                            self.queue_source_reveal(cursor, true);
+                            self.source_jump = Some(cursor);
+                            self.source_select_line = true;
                        }
                        Err(error) => self.status = error,
                    },
@@ -3169,9 +3265,6 @@ impl App {
                                }
                                self.sync_source();
                            }
-                            if self.path.as_ref() != Some(&receipt.path) {
-                                self.source_workspace.reset_navigation_session();
-                            }
                            self.disk_project = Some(disk);
                            self.path = Some(receipt.path);
                            self.hosted.session = None;
@@ -3730,9 +3823,8 @@ impl App {
                self.canvas_document = Id::new_v4();
                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
                self.path = Some(path);
-                self.document.bind_repair_baseline(disk.reachable_bundle());
                self.source_workspace = Workspace::new(&disk.bundle, false);
-                self.source_workspace.set_reachable(disk.reachable.clone());
+                self.source_workspace.reachable = disk.reachable.clone();
                self.show_source_file(false);
                self.source_diagnostics = error.diagnostics().to_vec();
                self.source_version += 1;
@@ -3784,13 +3876,11 @@ impl App {
        let column = prefix
            .rfind('\n')
            .map_or(offset, |start| offset - start - 1);
-        self.queue_source_reveal(
-            text_editor::Cursor {
-                position: text_editor::Position { line, column },
-                selection: None,
-            },
-            true,
-        );
+        self.source_jump = Some(text_editor::Cursor {
+            position: text_editor::Position { line, column },
+            selection: None,
+        });
+        self.source_select_line = true;
    }

    fn create_source_file(&mut self) -> Result<(), String> {
@@ -4400,10 +4490,6 @@ fn read_snapshot(path: PathBuf) -> Result<LoadedSnapshot, String> {
 #[path = "app/save_as_tests.rs"]
 mod save_as_tests;

-#[cfg(test)]
-#[path = "app/repair_save_state_tests.rs"]
-mod repair_save_state_tests;
-
 #[cfg(test)]
 mod source_project_tests {
    use super::*;
@@ -213,14 +213,6 @@ impl App {
            self.pending = None;
            return Task::none();
        }
-        if self.path.is_some()
-            || self.hosted.session.as_ref().is_none_or(|session| {
-                session.resource_id != remote.resource_id
-                    || session.connection.base() != request.connection.base()
-            })
-        {
-            self.source_workspace.reset_navigation_session();
-        }
        self.hosted.session = Some(Session {
            connection: request.connection.clone(),
            resource_id: remote.resource_id,
@@ -353,14 +345,6 @@ impl App {
                        match self.document.apply_compiled((*remote.compiled).clone()) {
                            Ok(_) => {
                                self.document.mark_saved(remote.compiled.clone());
-                                if self.path.is_some()
-                                    || self.hosted.session.as_ref().is_none_or(|session| {
-                                        session.resource_id != remote.resource_id
-                                            || session.connection.base() != connection.base()
-                                    })
-                                {
-                                    self.source_workspace.reset_navigation_session();
-                                }
                                self.hosted.session = Some(Session {
                                    connection,
                                    resource_id: remote.resource_id,
@@ -15,18 +15,15 @@ impl App {
            epoch: self.canvas_epoch,
        })
    }
-    pub(super) fn reveal_process_selection(&self) -> Task<Message> {
-        let Some(context) = self.topology_context() else {
-            return Task::none();
-        };
-        let Some(offset) =
-            self.behavior
-                .topology
-                .selection_offset(self.project(), context.owner, self.selected)
-        else {
-            return Task::none();
-        };
-        iced::widget::operation::scroll_to("process-canvas", offset)
+    pub(super) fn reveal_process_selection(&mut self) -> Task<Message> {
+        if let Some(context) = self.topology_context() {
+            let mut state = std::mem::take(&mut self.behavior.topology);
+            if state.reveal_selection(self.project(), context.owner, self.selected) {
+                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
+            }
+            self.behavior.topology = state;
+        }
+        Task::none()
    }
    pub(super) fn edit_process_canvas(&mut self, event: CanvasEvent) -> Task<Message> {
        let context = event.context();
@@ -52,6 +49,47 @@ impl App {
            }
            return Task::none();
        }
+        if let CanvasEvent::Camera(_, lifetime, input) = event {
+            use crate::behavior::canvas_workspace::{self, Event};
+            if lifetime != self.camera_epoch
+                || !self.topology_context().is_some_and(|c| {
+                    c.document == context.document
+                        && c.owner == context.owner
+                        && c.revision == context.revision
+                })
+            {
+                return Task::none();
+            }
+            let scope = canvas_workspace::Scope {
+                document: context.document,
+                owner: context.owner,
+                revision: context.revision,
+                epoch: lifetime,
+            };
+            if self.behavior.has_pending()
+                || self.draft_dirty()
+                || self.source_dirty()
+                || !canvas_workspace::keyboard_enabled(self)
+            {
+                return Task::none();
+            }
+            match input {
+                Event::Focus
+                | Event::Traverse(_)
+                | Event::ControlFocus(_)
+                | Event::ToggleFocus
+                | Event::Leave => {
+                    return canvas_workspace::focus_task(scope, input);
+                }
+                Event::CancelGesture => self.canvas_epoch = self.canvas_epoch.wrapping_add(1),
+                input => {
+                    if self.behavior.topology.camera(input) {
+                        self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
+                    }
+                }
+            }
+            return Task::none();
+        }
        if self.topology_context() != Some(context) {
            return Task::none();
        }
@@ -81,6 +119,7 @@ impl App {
                            .first()
                            .copied()
                            .unwrap_or(endpoint.occurrence),
+                        resolved.defining_sequence,
                    );
                    self.behavior.active_owner = Some(resolved.defining_sequence);
                    self.select(endpoint.occurrence);
@@ -118,14 +157,18 @@ impl App {
                }
            }
            CanvasEvent::Choose(_, tool) => {
-                if self.behavior.has_pending() || !self.apply() {
+                if self.behavior.has_pending() || self.draft_dirty() || self.source_dirty() {
+                    self.status =
+                        "Apply or cancel pending edits before choosing a process tool.".into();
                    return Task::none();
                }
                self.behavior.topology.choose(tool);
                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
            }
            CanvasEvent::Zoom(_, zoom) => {
-                self.behavior.topology.zoom(zoom);
+                let mut state = std::mem::take(&mut self.behavior.topology);
+                state.camera_zoom(self.project(), context.owner, zoom);
+                self.behavior.topology = state;
                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
            }
            CanvasEvent::Expand(_, id) => {
@@ -149,7 +192,9 @@ impl App {
                        .get(&target)
                        .is_some_and(|e| matches!(e.kind(), Kind::Process | Kind::FunctionalChain))
                    {
-                        self.behavior.topology.remember(context.owner, occurrence);
+                        self.behavior
+                            .topology
+                            .remember(context.owner, occurrence, target);
                        self.behavior.active_owner = Some(target);
                    }
                    self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
@@ -0,0 +1,300 @@
+//! One transient chooser for the currently mounted Inspector or review field.
+//! Browsing never calls a draft setter or semantic planner.
+use super::{App, Message, Page, Pending};
+use crate::{
+    forms::{
+        Draft,
+        reference_chooser::{self as chooser, Action, Close, Outcome, adapter, trigger},
+    },
+    navigation::InspectorTab,
+    semantic_review::{self, RowAddress, RowEvent},
+    workflow,
+};
+use iced::{Element, Rectangle, Task};
+use oa_core::{FacetSelector, Id, Layer};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Host {
+    Inspector,
+    Review {
+        address: Option<RowAddress>,
+        facet: FacetSelector,
+    },
+}
+impl Host {
+    fn message(&self, event: chooser::Event) -> Message {
+        match self {
+            Self::Inspector => Message::FieldReferenceEvent(event),
+            Self::Review { address, facet } => {
+                Message::Workflow(workflow::Event::Semantic(semantic_review::Event::Row {
+                    address: *address,
+                    facet: Some(facet.clone()),
+                    event: RowEvent::ReferenceEvent(event),
+                }))
+            }
+        }
+    }
+}
+struct Opened {
+    host: Host,
+    request: adapter::Open,
+    document_session: Id,
+    page: Page,
+    layer: Layer,
+    chooser: chooser::State,
+}
+#[derive(Default)]
+pub(super) struct State {
+    opened: Option<Opened>,
+}
+
+impl App {
+    pub(crate) fn reference_input_active(&self) -> bool {
+        self.reference_authoring.opened.is_some()
+    }
+
+    fn reference_draft(&self, host: &Host, path: &str) -> Option<&Draft> {
+        match host {
+            Host::Inspector
+                if self.workflow.is_none() && self.inspector_tab == InspectorTab::Properties =>
+            {
+                self.draft.as_ref()
+            }
+            Host::Review { address, facet } => match self.workflow.as_ref()? {
+                workflow::Workflow::Semantic(state) => {
+                    state.reference_draft(self.project(), *address, facet, path)
+                }
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+    fn reference_available(&self) -> bool {
+        !self.busy
+            && !self.hosted.visible
+            && self.architecture.is_none()
+            && self.model_menu.is_none()
+            && self.file_prompt.is_none()
+            && !self.delete_pending
+            && self.pending.is_none()
+            && !self.source_dirty()
+            && !self.behavior.has_pending()
+            && !matches!(self.page, Page::Home | Page::Guide | Page::Text)
+    }
+    fn reference_valid(&self, opened: &Opened) -> bool {
+        self.reference_available()
+            && self.canvas_document == opened.document_session
+            && self.page == opened.page
+            && self.layer == opened.layer
+            && self.document.revision() == opened.chooser.stamp().context.revision
+            && self.project().id == opened.request.document
+            && self
+                .reference_draft(&opened.host, &opened.request.path)
+                .is_some_and(|draft| draft.reference_matches(&opened.request))
+    }
+    pub(super) fn reconcile_reference_chooser(&mut self) {
+        if self
+            .reference_authoring
+            .opened
+            .as_ref()
+            .is_some_and(|opened| !self.reference_valid(opened))
+        {
+            self.reference_authoring
+                .opened
+                .as_mut()
+                .unwrap()
+                .chooser
+                .invalidate();
+            self.reference_authoring.opened = None;
+        }
+    }
+    fn open_reference(&mut self, host: Host, request: adapter::Open) -> Task<Message> {
+        if !self.reference_available() {
+            return Task::none();
+        }
+        let Some(draft) = self.reference_draft(&host, &request.path) else {
+            return Task::none();
+        };
+        let Ok(chooser) =
+            draft.reference_catalog(self.project(), &request, self.document.revision())
+        else {
+            return Task::none();
+        };
+        self.reference_authoring.opened = Some(Opened {
+            host,
+            request,
+            document_session: self.canvas_document,
+            page: self.page,
+            layer: self.layer,
+            chooser,
+        });
+        Task::none()
+    }
+    fn reference_event(&mut self, host: Host, event: chooser::Event) -> Task<Message> {
+        let Some(mut opened) = self.reference_authoring.opened.take() else {
+            return Task::none();
+        };
+        if !self.reference_valid(&opened) {
+            return Task::none();
+        }
+        if opened.host != host {
+            self.reference_authoring.opened = Some(opened);
+            return Task::none();
+        }
+        match opened.chooser.update(event) {
+            Outcome::Ignored | Outcome::Browsed => {
+                self.reference_authoring.opened = Some(opened);
+                Task::none()
+            }
+            Outcome::Closed(reason) => self.reference_focus(
+                &opened,
+                match reason {
+                    Close::Escape => Some(0),
+                    Close::Tab { backwards } => Some(if backwards { -1 } else { 1 }),
+                    Close::Outside | Close::WindowChanged => None,
+                },
+            ),
+            Outcome::Write { context, value } => {
+                let intent = adapter::Set {
+                    context,
+                    generation: opened.request.generation,
+                    value,
+                };
+                let result = match &opened.host {
+                    Host::Inspector => self
+                        .draft
+                        .as_mut()
+                        .ok_or_else(|| "The property editor closed.".to_owned())
+                        .and_then(|draft| draft.reference_set(self.document.project(), &intent)),
+                    Host::Review { address, facet } => match self.workflow.as_mut() {
+                        Some(workflow::Workflow::Semantic(state)) => {
+                            state.set_reference(self.document.project(), *address, facet, intent)
+                        }
+                        _ => Err("The review editor closed.".into()),
+                    },
+                };
+                if let Err(error) = result {
+                    self.status = error;
+                }
+                // A scoped write rotates field generation. The task targets the
+                // newly rendered field, while a later structural edit makes it inert.
+                self.reference_focus(&opened, Some(0))
+            }
+        }
+    }
+    fn reference_focus(&self, opened: &Opened, step: Option<i32>) -> Task<Message> {
+        let Some(step) = step else {
+            return Task::none();
+        };
+        let Some(draft) = self.reference_draft(&opened.host, &opened.request.path) else {
+            return Task::none();
+        };
+        if draft.reference_session() != opened.request.session {
+            return Task::none();
+        }
+        trigger::focus(
+            draft.reference_session(),
+            draft.reference_generation(),
+            &opened.request.path,
+            step,
+        )
+    }
+    /// Called before generic modal dispatch: the review owns a modal, and this
+    /// chooser owns only its active field. All browser events stop here.
+    pub(super) fn reference_message(&mut self, message: &Message) -> Option<Task<Message>> {
+        self.reconcile_reference_chooser();
+        match message {
+            Message::FieldReferenceOpen(request) => {
+                Some(self.open_reference(Host::Inspector, request.clone()))
+            }
+            Message::FieldReferenceEvent(event) => {
+                Some(self.reference_event(Host::Inspector, event.clone()))
+            }
+            Message::Workflow(workflow::Event::Semantic(semantic_review::Event::Row {
+                address,
+                facet: Some(facet),
+                event,
+            })) => {
+                let host = Host::Review {
+                    address: *address,
+                    facet: facet.clone(),
+                };
+                match event {
+                    RowEvent::ReferenceOpen(request) => {
+                        Some(self.open_reference(host, request.clone()))
+                    }
+                    RowEvent::ReferenceEvent(event) => {
+                        Some(self.reference_event(host, event.clone()))
+                    }
+                    _ => None,
+                }
+            }
+            Message::Escape | Message::Request(Pending::Close(_))
+                if self.reference_authoring.opened.is_some() =>
+            {
+                let opened = self.reference_authoring.opened.as_ref().unwrap();
+                let host = opened.host.clone();
+                let event = opened.chooser.event(Action::Close(Close::Escape));
+                Some(self.reference_event(host, event))
+            }
+            // Global shortcuts are also emitted for keys captured by the search
+            // input. They must not apply drafts, navigate, or undo the model.
+            Message::Save(_)
+            | Message::ShortcutUndo(_)
+            | Message::Request(Pending::Open | Pending::New)
+            | Message::SourceNavigation(_)
+            | Message::Page(Page::Guide)
+                if self.reference_authoring.opened.is_some() =>
+            {
+                Some(Task::none())
+            }
+            _ => None,
+        }
+    }
+    pub(super) fn reference_overlay<
+        'a,
+        R: iced::advanced::text::Renderer<Font = iced::Font> + 'a,
+    >(
+        &'a self,
+        content: Element<'a, Message, iced::Theme, R>,
+    ) -> Element<'a, Message, iced::Theme, R> {
+        let opened = self
+            .reference_authoring
+            .opened
+            .as_ref()
+            .filter(|opened| self.reference_valid(opened));
+        let host = opened
+            .map(|opened| opened.host.clone())
+            .unwrap_or(Host::Inspector);
+        let focus_scope = if self.reference_available() {
+            match self.workflow.as_ref() {
+                None if self.inspector_tab == InspectorTab::Properties => {
+                    self.draft.as_ref().map(|draft| trigger::FormScope {
+                        session: draft.reference_session(),
+                        modal: false,
+                    })
+                }
+                Some(workflow::Workflow::Semantic(state)) => state
+                    .reference_form(self.project())
+                    .map(|draft| trigger::FormScope {
+                        session: draft.reference_session(),
+                        modal: true,
+                    }),
+                _ => None,
+            }
+        } else {
+            None
+        };
+        chooser::widget::Popup::new(
+            content,
+            opened.map(|opened| &opened.chooser),
+            opened.map_or(Rectangle::default(), |opened| opened.request.anchor),
+            move |event| host.message(event),
+        )
+        .focus_scope(focus_scope)
+        .into()
+    }
+}
+
+#[cfg(test)]
+mod tests;
@@ -0,0 +1,550 @@
+use super::*;
+use crate::forms::Draft;
+use oa_core::*;
+use serde_json::{Value, json};
+
+const OWNER: Id = Id::from_u128(100);
+const BASE: u128 = 10_000;
+const PATH: &str = "/body/Oa/Shared/DataType/definition/Record/supertype";
+
+fn element(p: &mut Project, id: Id, kind: Kind, layer: Layer, name: &str, parent: Option<Id>) {
+    let generated = p.add_element(kind, layer, name, parent).unwrap();
+    let mut element = p.elements.remove(&generated).unwrap();
+    element.id = id;
+    element.alias = format!("object_{}", id.as_u128());
+    if let Some(SharedBody::DataType { definition, .. }) = element.shared_mut() {
+        *definition = DataTypeDefinition::Record { supertype: None };
+    }
+    p.elements.insert(id, element);
+}
+fn catalog() -> Project {
+    let mut p = Project::empty();
+    p.id = Id::from_u128(1);
+    p.name = "Reference catalog".into();
+    element(
+        &mut p,
+        OWNER,
+        Kind::DataType,
+        Layer::Oa,
+        "Edited record",
+        None,
+    );
+    for n in (0..1_000).rev() {
+        let id = Id::from_u128(BASE + n);
+        element(&mut p, id, Kind::DataType, Layer::Oa, "Controller", None);
+        p.elements.get_mut(&id).unwrap().alias = format!("controller_{n:04}");
+    }
+    element(
+        &mut p,
+        Id::from_u128(200),
+        Kind::DataType,
+        Layer::Sa,
+        "Controller",
+        None,
+    );
+    element(
+        &mut p,
+        Id::from_u128(201),
+        Kind::Activity,
+        Layer::Oa,
+        "Controller",
+        None,
+    );
+    p
+}
+fn inspector(p: Project, selected: Id) -> App {
+    let mut app = App::with_project(p);
+    let _ = app.update(Message::Select(selected));
+    app
+}
+fn request(app: &App, host: &Host, path: &str) -> adapter::Open {
+    app.reference_draft(host, path).unwrap().reference_open(
+        app.project(),
+        path,
+        Rectangle {
+            x: 790.,
+            y: 640.,
+            width: 278.,
+            height: 32.,
+        },
+    )
+}
+fn open(app: &mut App, host: &Host, path: &str) {
+    let request = request(app, host, path);
+    let message = match host {
+        Host::Inspector => Message::FieldReferenceOpen(request),
+        Host::Review { address, facet } => {
+            Message::Workflow(workflow::Event::Semantic(semantic_review::Event::Row {
+                address: *address,
+                facet: Some(facet.clone()),
+                event: RowEvent::ReferenceOpen(request),
+            }))
+        }
+    };
+    let _ = app.update(message);
+    assert!(
+        app.reference_authoring.opened.is_some(),
+        "field must open: {}",
+        app.status
+    );
+}
+fn event(app: &App, action: Action) -> Message {
+    let opened = app.reference_authoring.opened.as_ref().unwrap();
+    opened.host.message(opened.chooser.event(action))
+}
+fn search(app: &mut App, query: &str) {
+    let serial = app
+        .reference_authoring
+        .opened
+        .as_ref()
+        .unwrap()
+        .chooser
+        .query_serial()
+        + 1;
+    let event = event(
+        app,
+        Action::Query {
+            text: query.into(),
+            serial,
+        },
+    );
+    let _ = app.update(event);
+}
+fn choose(app: &mut App, id: Id) {
+    let event = event(app, Action::Choose(id));
+    let _ = app.update(event);
+}
+fn raw(app: &App) -> Value {
+    serde_json::to_value(app.draft.as_ref().unwrap().recovery_snapshot()).unwrap()
+}
+fn review(app: &App) -> &semantic_review::State {
+    let Some(workflow::Workflow::Semantic(state)) = app.workflow.as_ref() else {
+        panic!("Review is open")
+    };
+    state
+}
+fn send_review(app: &mut App, event: RowEvent) {
+    let addressed = review(app).address_event(event);
+    let _ = app.update(Message::Workflow(workflow::Event::Semantic(addressed)));
+}
+fn review_host(app: &App) -> Host {
+    let semantic_review::Event::Row {
+        address,
+        facet: Some(facet),
+        ..
+    } = review(app).address_event(RowEvent::Preview)
+    else {
+        panic!("Active facet")
+    };
+    Host::Review { address, facet }
+}
+fn trace(p: &mut Project, id: Id, oa: Id, sa: Id) {
+    p.traces.insert(
+        id,
+        Trace {
+            id,
+            alias: format!("trace_{}", id.as_u128()),
+            name: "Rationale".into(),
+            description: String::new(),
+            oa,
+            sa,
+            kind: TraceKind::Manual,
+            baseline: None,
+        },
+    );
+}
+
+#[test]
+fn inspector_reference_browse_is_read_only_then_one_scoped_value_applies_with_exact_undo_redo() {
+    let p = catalog();
+    let mut app = inspector(p.clone(), OWNER);
+    let before = app.document.bundle().clone();
+    let revision = app.document.revision();
+    // Malformed escaped text is unrelated to the selected reference. Browsing
+    // and the scoped write must keep its exact spelling and inactive payload.
+    app.draft.as_mut().unwrap().set_exact(true).unwrap();
+    let _ = app.update(Message::Field("/name".into(), "\"unfinished".into()));
+    let raw_before = raw(&app);
+    open(&mut app, &Host::Inspector, PATH);
+    assert_eq!(
+        app.reference_authoring
+            .opened
+            .as_ref()
+            .unwrap()
+            .chooser
+            .count(),
+        1_000
+    );
+    search(&mut app, "controller @controller_0720 OA");
+    let picker = &app.reference_authoring.opened.as_ref().unwrap().chooser;
+    assert_eq!(picker.count(), 1);
+    assert_eq!(picker.highlighted().unwrap().id, Id::from_u128(BASE + 720));
+    assert_eq!(raw(&app), raw_before);
+    assert_eq!(app.document.bundle(), &before);
+    assert_eq!(app.document.revision(), revision);
+    assert!(!app.document.can_undo());
+    // Captured search shortcuts cannot accidentally save/apply or undo a model.
+    let _ = app.update(Message::Save(false));
+    let _ = app.update(Message::ShortcutUndo(false));
+    assert_eq!(raw(&app), raw_before);
+    assert_eq!(app.document.bundle(), &before);
+    choose(&mut app, Id::from_u128(BASE + 720));
+    let mut expected_raw = raw_before;
+    *expected_raw["value"].pointer_mut(PATH).unwrap() = json!(Id::from_u128(BASE + 720));
+    expected_raw["inputs"][PATH] = json!(Id::from_u128(BASE + 720).to_string());
+    assert_eq!(raw(&app), expected_raw);
+    assert_eq!(app.document.bundle(), &before);
+    assert!(!app.document.can_undo());
+    let _ = app.update(Message::Apply);
+    assert_eq!(
+        app.document.bundle(),
+        &before,
+        "Unrelated invalid text remains an Apply error"
+    );
+    let _ = app.update(Message::Field("/name".into(), "\"Edited record\"".into()));
+    let _ = app.update(Message::Apply);
+    let mut expected = p;
+    if let Some(SharedBody::DataType { definition, .. }) =
+        expected.elements.get_mut(&OWNER).unwrap().shared_mut()
+    {
+        *definition = DataTypeDefinition::Record {
+            supertype: Some(Id::from_u128(BASE + 720)),
+        };
+    }
+    assert_eq!(app.project(), &expected);
+    let accepted = app.document.bundle().clone();
+    assert_ne!(accepted, before);
+    let _ = app.update(Message::Undo);
+    assert_eq!(app.document.bundle(), &before);
+    let _ = app.update(Message::Redo);
+    assert_eq!(app.document.bundle(), &accepted);
+    assert_eq!(app.project(), &expected);
+}
+
+#[test]
+fn inspector_reference_retains_invalid_missing_and_incompatible_current_until_explicit_clear() {
+    for (raw_id, expected) in [
+        ("-".into(), "invalid"),
+        (Id::from_u128(999).to_string(), "missing"),
+        (Id::from_u128(200).to_string(), "incompatible"),
+    ] {
+        let mut app = inspector(catalog(), OWNER);
+        app.draft
+            .as_mut()
+            .unwrap()
+            .shape_scoped(PATH, json!(raw_id))
+            .unwrap();
+        let original = raw(&app);
+        let accepted = app.document.bundle().clone();
+        open(&mut app, &Host::Inspector, PATH);
+        let current = &app
+            .reference_authoring
+            .opened
+            .as_ref()
+            .unwrap()
+            .chooser
+            .current;
+        assert!(matches!(
+            (expected, current),
+            ("invalid", chooser::Current::InvalidRaw(_))
+                | ("missing", chooser::Current::Missing(_))
+                | ("incompatible", chooser::Current::Incompatible(_))
+        ));
+        let _ = app.update(Message::Escape);
+        assert_eq!(raw(&app), original);
+        open(&mut app, &Host::Inspector, PATH);
+        let clear = event(&app, Action::Clear);
+        let _ = app.update(clear);
+        assert!(
+            app.draft
+                .as_ref()
+                .unwrap()
+                .value
+                .pointer(PATH)
+                .unwrap()
+                .is_null()
+        );
+        assert_eq!(app.document.bundle(), &accepted);
+        assert!(!app.document.can_undo());
+    }
+}
+
+#[test]
+fn chooser_rejects_old_results_after_context_recovery_reload_or_modal_and_keeps_history_text_out() {
+    for change in 0..7 {
+        let mut app = inspector(catalog(), OWNER);
+        open(&mut app, &Host::Inspector, PATH);
+        let delayed = event(&app, Action::Choose(Id::from_u128(BASE + 1)));
+        match change {
+            0 => {
+                app.draft
+                    .as_mut()
+                    .unwrap()
+                    .shape_scoped(PATH, json!(Id::from_u128(BASE + 2)))
+                    .unwrap();
+            }
+            1 => {
+                let saved = app.draft.as_ref().unwrap().recovery_snapshot();
+                app.draft = Some(Draft::from_recovery(app.project(), saved).unwrap());
+            }
+            2 => {
+                app.canvas_document = Id::new_v4();
+            }
+            3 => {
+                app.hosted.visible = true;
+            }
+            4 => {
+                app.draft
+                    .as_mut()
+                    .unwrap()
+                    .set_context(Some(json!({"different":"scope"})));
+            }
+            5 => {
+                let _ = app.update(Message::Command(Command::Rename(
+                    Id::from_u128(BASE + 3),
+                    "Changed model".into(),
+                )));
+            }
+            _ => {
+                app.source_workspace
+                    .edit("unfinished source".into(), Default::default());
+            }
+        }
+        let expected = raw(&app);
+        let source = app.document.bundle().clone();
+        let _ = app.update(delayed);
+        assert!(app.reference_authoring.opened.is_none());
+        assert_eq!(raw(&app), expected);
+        assert_eq!(app.document.bundle(), &source);
+    }
+    let mut p = catalog();
+    trace(&mut p, Id::from_u128(300), OWNER, Id::from_u128(200));
+    let app = inspector(p, Id::from_u128(300));
+    let draft = app.draft.as_ref().unwrap();
+    let request = draft.reference_open(
+        app.project(),
+        "/baseline/semantic/facets/0/references/0/target",
+        Rectangle::default(),
+    );
+    assert!(draft.reference_catalog(app.project(), &request, 0).is_err());
+}
+
+#[test]
+fn reference_array_row_reorder_and_constructor_switch_invalidate_exact_old_field() {
+    let mut p = Project::empty();
+    for n in 0..3 {
+        element(
+            &mut p,
+            Id::from_u128(BASE + n),
+            Kind::ExchangeItem,
+            Layer::Oa,
+            "Signal item",
+            None,
+        );
+    }
+    element(&mut p, OWNER, Kind::Event, Layer::Oa, "Signal", None);
+    *p.elements.get_mut(&OWNER).unwrap().shared_mut().unwrap() = SharedBody::Event {
+        body: EventBody::Signal {
+            items: vec![Id::from_u128(BASE), Id::from_u128(BASE + 1)],
+        },
+    };
+    let mut app = inspector(p, OWNER);
+    let list = "/body/Oa/Shared/Event/body/Signal/items";
+    let path = format!("{list}/0");
+    open(&mut app, &Host::Inspector, &path);
+    let delayed = event(&app, Action::Choose(Id::from_u128(BASE + 2)));
+    let _ = app.update(Message::FieldArray(list.into(), Some(0), 1));
+    let expected = raw(&app);
+    assert_eq!(
+        app.draft.as_ref().unwrap().value.pointer(list),
+        Some(&json!([Id::from_u128(BASE + 1), Id::from_u128(BASE)]))
+    );
+    let _ = app.update(delayed);
+    assert_eq!(raw(&app), expected);
+    open(&mut app, &Host::Inspector, &path);
+    let delayed = event(&app, Action::Choose(Id::from_u128(BASE + 2)));
+    let _ = app.update(Message::FieldVariant(
+        "/body/Oa/Shared/Event/body".into(),
+        json!({"Change":{"expression":"unfinished"}}),
+    ));
+    let expected = raw(&app);
+    let _ = app.update(delayed);
+    assert_eq!(raw(&app), expected);
+    assert!(!app.document.can_undo());
+}
+
+#[test]
+fn review_reference_facets_groups_and_attachment_hosts_browse_without_replanning_and_reject_old_facet()
+ {
+    for mode in 0..3 {
+        let mut p = Project::empty();
+        p.id = Id::from_u128(1);
+        for (id, layer, parent) in [
+            (100, Layer::Oa, None),
+            (101, Layer::Sa, None),
+            (102, Layer::Sa, None),
+            (103, Layer::Oa, Some(Id::from_u128(100))),
+            (104, Layer::Sa, Some(Id::from_u128(101))),
+        ] {
+            element(
+                &mut p,
+                Id::from_u128(id),
+                if parent.is_some() {
+                    Kind::DataField
+                } else {
+                    Kind::DataType
+                },
+                layer,
+                "Record",
+                parent,
+            );
+        }
+        trace(
+            &mut p,
+            Id::from_u128(300),
+            Id::from_u128(100),
+            Id::from_u128(101),
+        );
+        let facet = match mode {
+            0 => FacetSelector::Data(DataFacet::RecordSupertype),
+            1 => FacetSelector::Data(DataFacet::Constructor),
+            _ => FacetSelector::Child(KeyPair {
+                oa: Some(Id::from_u128(103)),
+                sa: Some(Id::from_u128(104)),
+            }),
+        };
+        let path = if mode == 2 {
+            "/parent"
+        } else {
+            "/body/Sa/Shared/DataType/definition/Record/supertype"
+        };
+        let mut app = App::with_project(p.clone());
+        let _ = app.update(Message::StartSemanticReview(Id::from_u128(100)));
+        send_review(&mut app, RowEvent::Select(facet.clone()));
+        send_review(
+            &mut app,
+            RowEvent::Decide(facet.clone(), Some(SemanticDecision::Candidate)),
+        );
+        let host = review_host(&app);
+        let record = if mode == 2 {
+            Id::from_u128(104)
+        } else {
+            Id::from_u128(101)
+        };
+        assert_eq!(app.reference_draft(&host, path).unwrap().original, record);
+        let before = review(&app).recovery_snapshot().unwrap();
+        let plan = serde_json::to_value(&review(&app).plan).unwrap();
+        let proposed = review(&app).proposed.clone();
+        let source = app.document.bundle().clone();
+        open(&mut app, &host, path);
+        search(&mut app, "@object_102 SA");
+        assert_eq!(
+            app.reference_authoring
+                .opened
+                .as_ref()
+                .unwrap()
+                .chooser
+                .count(),
+            1
+        );
+        assert_eq!(review(&app).recovery_snapshot().unwrap(), before);
+        assert_eq!(serde_json::to_value(&review(&app).plan).unwrap(), plan);
+        assert_eq!(review(&app).proposed, proposed);
+        assert_eq!(app.document.bundle(), &source);
+        let old = event(&app, Action::Choose(Id::from_u128(102)));
+        send_review(
+            &mut app,
+            RowEvent::Select(FacetSelector::Header(HeaderFacet::Name)),
+        );
+        let switched = review(&app).recovery_snapshot().unwrap();
+        let _ = app.update(old);
+        assert_eq!(review(&app).recovery_snapshot().unwrap(), switched);
+        send_review(&mut app, RowEvent::Select(facet));
+        open(&mut app, &host, path);
+        choose(&mut app, Id::from_u128(102));
+        let draft = app.reference_draft(&host, path).unwrap();
+        let mut expected_record = serde_json::to_value(&p.elements[&record]).unwrap();
+        *expected_record.pointer_mut(path).unwrap() = json!(Id::from_u128(102));
+        assert_eq!(draft.materialize().unwrap(), expected_record);
+        assert_eq!(app.document.bundle(), &source);
+        assert!(
+            !app.document.can_undo(),
+            "A choice only stages the active review candidate"
+        );
+    }
+}
+
+mod mounted;
+
+#[test]
+fn review_reference_cannot_reopen_or_write_a_banked_row_after_another_row_takes_focus() {
+    let mut p = Project::empty();
+    for (id, layer) in [
+        (100, Layer::Oa),
+        (101, Layer::Sa),
+        (102, Layer::Sa),
+        (110, Layer::Oa),
+        (111, Layer::Sa),
+    ] {
+        element(
+            &mut p,
+            Id::from_u128(id),
+            Kind::DataType,
+            layer,
+            "Record",
+            None,
+        );
+    }
+    trace(
+        &mut p,
+        Id::from_u128(300),
+        Id::from_u128(100),
+        Id::from_u128(101),
+    );
+    trace(
+        &mut p,
+        Id::from_u128(310),
+        Id::from_u128(110),
+        Id::from_u128(111),
+    );
+    let mut app = App::with_project(p);
+    let _ = app.update(Message::StartSemanticReview(Id::from_u128(300)));
+    let facet = FacetSelector::Data(DataFacet::RecordSupertype);
+    send_review(&mut app, RowEvent::Select(facet.clone()));
+    send_review(
+        &mut app,
+        RowEvent::Decide(facet, Some(SemanticDecision::Candidate)),
+    );
+    let host = review_host(&app);
+    let path = "/body/Sa/Shared/DataType/definition/Record/supertype";
+    let old_open = request(&app, &host, path);
+    open(&mut app, &host, path);
+    let old_choice = event(&app, Action::Choose(Id::from_u128(102)));
+    for event in [
+        semantic_review::Event::ChooseTrace(crate::app::Choice {
+            id: Id::from_u128(310),
+            label: "Second exact trace".into(),
+        }),
+        semantic_review::Event::OpenTrace,
+    ] {
+        let _ = app.update(Message::Workflow(workflow::Event::Semantic(event)));
+    }
+    assert_eq!(review(&app).target(app.project()), Some(Id::from_u128(111)));
+    let expected = review(&app).recovery_snapshot().unwrap();
+    let source = app.document.bundle().clone();
+    let _ = app.update(old_choice);
+    let Host::Review { address, facet } = host else {
+        unreachable!()
+    };
+    let _ = app.update(Message::Workflow(workflow::Event::Semantic(
+        semantic_review::Event::Row {
+            address,
+            facet: Some(facet),
+            event: RowEvent::ReferenceOpen(old_open),
+        },
+    )));
+    assert!(app.reference_authoring.opened.is_none());
+    assert_eq!(review(&app).recovery_snapshot().unwrap(), expected);
+    assert_eq!(app.document.bundle(), &source);
+    assert!(!app.document.can_undo());
+}
@@ -0,0 +1,890 @@
+//! Real field + app-root overlay interaction. The null text renderer lets the
+//! same retained widget tree exercise focus and geometry without a GPU/window.
+use super::*;
+use iced::futures::StreamExt;
+use iced::{
+    Event as Input, Point, Size, Theme, Vector,
+    advanced::{
+        Layout, Shell, layout,
+        widget::{Id as WidgetId, Operation, Tree, operation},
+    },
+    keyboard, mouse,
+    widget::{Space, column, container, opaque, scrollable, stack, text_input},
+};
+
+#[derive(Default)]
+struct Clipboard;
+impl iced::advanced::Clipboard for Clipboard {
+    fn read(&self, _: iced::advanced::clipboard::Kind) -> Option<String> {
+        None
+    }
+    fn write(&mut self, _: iced::advanced::clipboard::Kind, _: String) {}
+}
+#[derive(Default)]
+struct Fields {
+    values: Vec<(WidgetId, Rectangle, bool)>,
+    scrolls: Vec<(Rectangle, Vector)>,
+}
+impl Operation for Fields {
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation)) {
+        visit(self);
+    }
+    fn focusable(
+        &mut self,
+        id: Option<&WidgetId>,
+        bounds: Rectangle,
+        state: &mut dyn operation::Focusable,
+    ) {
+        if let Some(id) = id {
+            self.values.push((id.clone(), bounds, state.is_focused()));
+        }
+    }
+    fn scrollable(
+        &mut self,
+        _: Option<&WidgetId>,
+        bounds: Rectangle,
+        _: Rectangle,
+        translation: Vector,
+        _: &mut dyn operation::Scrollable,
+    ) {
+        self.scrolls.push((bounds, translation));
+    }
+}
+impl Fields {
+    fn field(&self, id: &WidgetId) -> (Rectangle, bool) {
+        self.values
+            .iter()
+            .find(|(actual, _, _)| actual == id)
+            .map(|(_, bounds, focused)| (*bounds, *focused))
+            .expect("Mounted field identity")
+    }
+}
+fn view(
+    app: &App,
+    scrolled: bool,
+    nested: bool,
+    show_review: bool,
+) -> Element<'_, Message, Theme, ()> {
+    let draft = app.draft.as_ref().unwrap();
+    let form = column![
+        text_input("Name", &draft.inputs["/name"].raw)
+            .id("before-reference")
+            .on_input(|raw| Message::Field("/name".into(), raw)),
+        adapter::field(draft, app.project(), PATH),
+        text_input("Description", &draft.inputs["/description"].raw)
+            .id("after-reference")
+            .on_input(|raw| Message::Field("/description".into(), raw)),
+    ]
+    .spacing(9);
+    let form = trigger::scope(form, draft.reference_session());
+    let base: Element<'_, Message, Theme, ()> = if scrolled {
+        container(
+            scrollable(column![Space::new().height(500), form])
+                .id("reference-scroll")
+                .height(180),
+        )
+        .width(300)
+        .into()
+    } else {
+        container(form).width(300).height(iced::Fill).into()
+    };
+    let base: Element<'_, Message, Theme, ()> = if nested {
+        scrollable(column![Space::new().height(400), base])
+            .id("outer-reference-scroll")
+            .height(180)
+            .width(300)
+            .into()
+    } else {
+        base
+    };
+    let base = if show_review {
+        let review: Element<'_, Message, Theme, ()> = match app.workflow.as_ref() {
+            Some(workflow::Workflow::Semantic(state)) => {
+                match state.reference_form(app.project()) {
+                    Some(draft) => {
+                        let mut content = column![];
+                        if let Some(raw) = &state.operation_omission {
+                            content = content.push(
+                                text_input("Required engineering rationale", raw)
+                                    .id("review-rationale")
+                                    .on_input(|raw| {
+                                        Message::Workflow(workflow::Event::Semantic(
+                                            state.address_event(RowEvent::OperationRationale(raw)),
+                                        ))
+                                    }),
+                            );
+                        }
+                        content = content.push(trigger::scope(
+                            adapter::field(draft, app.project(), "/parent").map(|message| {
+                                match message {
+                                    Message::FieldReferenceOpen(request) => {
+                                        Message::Workflow(workflow::Event::Semantic(
+                                            state.address_event(RowEvent::ReferenceOpen(request)),
+                                        ))
+                                    }
+                                    other => other,
+                                }
+                            }),
+                            draft.reference_session(),
+                        ));
+                        opaque(container(trigger::modal(content)).width(300).height(180)).into()
+                    }
+                    None => Space::new().into(),
+                }
+            }
+            _ => Space::new().into(),
+        };
+        stack![base, review].into()
+    } else {
+        base
+    };
+    app.reference_overlay(base)
+}
+struct Mount {
+    tree: Option<Tree>,
+    size: Size,
+    scrolled: bool,
+    nested: bool,
+    show_review: bool,
+}
+impl Default for Mount {
+    fn default() -> Self {
+        Self {
+            tree: None,
+            size: Size::new(360., 320.),
+            scrolled: false,
+            nested: false,
+            show_review: false,
+        }
+    }
+}
+impl Mount {
+    fn frame(
+        &mut self,
+        app: &App,
+        events: &[(Input, Option<Point>)],
+    ) -> (Vec<Message>, Fields, Option<Rectangle>) {
+        let mut view = view(app, self.scrolled, self.nested, self.show_review);
+        let tree = self.tree.get_or_insert_with(|| Tree::new(view.as_widget()));
+        view.as_widget().diff(tree);
+        let node =
+            view.as_widget_mut()
+                .layout(tree, &(), &layout::Limits::new(Size::ZERO, self.size));
+        let viewport = Rectangle::with_size(self.size);
+        let overlay_node = view
+            .as_widget_mut()
+            .overlay(tree, Layout::new(&node), &(), &viewport, Vector::ZERO)
+            .map(|mut overlay| overlay.as_overlay_mut().layout(&(), self.size));
+        let mut messages = Vec::new();
+        for (input, point) in events {
+            let mut shell = Shell::new(&mut messages);
+            let cursor = point.map_or(mouse::Cursor::Unavailable, mouse::Cursor::Available);
+            if let Some(overlay_node) = &overlay_node {
+                let mut overlay = view
+                    .as_widget_mut()
+                    .overlay(tree, Layout::new(&node), &(), &viewport, Vector::ZERO)
+                    .unwrap();
+                overlay.as_overlay_mut().update(
+                    input,
+                    Layout::new(overlay_node),
+                    cursor,
+                    &(),
+                    &mut Clipboard,
+                    &mut shell,
+                );
+                assert!(shell.is_event_captured());
+            } else {
+                view.as_widget_mut().update(
+                    tree,
+                    input,
+                    Layout::new(&node),
+                    cursor,
+                    &(),
+                    &mut Clipboard,
+                    &mut shell,
+                    &viewport,
+                );
+            }
+        }
+        let mut fields = Fields::default();
+        view.as_widget_mut()
+            .operate(tree, Layout::new(&node), &(), &mut fields);
+        (
+            messages,
+            fields,
+            overlay_node.map(|node| node.children()[0].bounds()),
+        )
+    }
+    fn click(&mut self, app: &App, point: Point) -> Vec<Message> {
+        self.frame(
+            app,
+            &[
+                (
+                    Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+                    Some(point),
+                ),
+                (
+                    Input::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
+                    Some(point),
+                ),
+            ],
+        )
+        .0
+    }
+    async fn perform(&mut self, app: &App, task: Task<Message>) {
+        let Some(mut stream) = iced_runtime::task::into_stream(task) else {
+            return;
+        };
+        while let Some(action) = stream.next().await {
+            let iced_runtime::Action::Widget(mut operation) = action else {
+                panic!("Chooser only requests scoped widget focus")
+            };
+            let mut view = view(app, self.scrolled, self.nested, self.show_review);
+            let tree = self.tree.get_or_insert_with(|| Tree::new(view.as_widget()));
+            view.as_widget().diff(tree);
+            let node =
+                view.as_widget_mut()
+                    .layout(tree, &(), &layout::Limits::new(Size::ZERO, self.size));
+            loop {
+                view.as_widget_mut()
+                    .operate(tree, Layout::new(&node), &(), operation.as_mut());
+                match operation.finish() {
+                    operation::Outcome::Chain(next) => operation = next,
+                    _ => break,
+                }
+            }
+        }
+    }
+    async fn dispatch(&mut self, app: &mut App, messages: Vec<Message>) {
+        for message in messages {
+            let task = app.update(message);
+            self.perform(app, task).await;
+        }
+    }
+}
+fn key(key: keyboard::key::Named, shift: bool) -> Input {
+    Input::Keyboard(keyboard::Event::KeyPressed {
+        key: keyboard::Key::Named(key),
+        modified_key: keyboard::Key::Named(key),
+        physical_key: keyboard::key::Physical::Code(keyboard::key::Code::Space),
+        location: keyboard::Location::Standard,
+        modifiers: if shift {
+            keyboard::Modifiers::SHIFT
+        } else {
+            keyboard::Modifiers::empty()
+        },
+        text: None,
+        repeat: false,
+    })
+}
+fn typing(raw: &str) -> Vec<(Input, Option<Point>)> {
+    raw.chars()
+        .map(|character| {
+            let raw = character.to_string();
+            (
+                Input::Keyboard(keyboard::Event::KeyPressed {
+                    key: keyboard::Key::Character(raw.clone().into()),
+                    modified_key: keyboard::Key::Character(raw.clone().into()),
+                    physical_key: keyboard::key::Physical::Code(keyboard::key::Code::KeyA),
+                    location: keyboard::Location::Standard,
+                    modifiers: keyboard::Modifiers::empty(),
+                    text: Some(raw.into()),
+                    repeat: false,
+                }),
+                None,
+            )
+        })
+        .collect()
+}
+
+#[tokio::test]
+async fn mounted_reference_trigger_tabs_to_root_popup_search_escape_and_exact_adjacent_fields() {
+    let mut app = inspector(catalog(), OWNER);
+    let accepted = app.document.bundle().clone();
+    let original = raw(&app);
+    let mut mount = Mount::default();
+    let fields = mount.frame(&app, &[]).1;
+    let messages = mount.click(
+        &app,
+        fields.field(&WidgetId::new("before-reference")).0.center(),
+    );
+    mount.dispatch(&mut app, messages).await;
+    let (_, fields, _) = mount.frame(&app, &[(key(keyboard::key::Named::Tab, false), None)]);
+    let id = trigger::field_id(app.draft.as_ref().unwrap().reference_generation(), PATH);
+    assert!(
+        fields.field(&id).1,
+        "Tab reaches the real reference trigger"
+    );
+    let messages = mount
+        .frame(&app, &[(key(keyboard::key::Named::Enter, false), None)])
+        .0;
+    assert_eq!(messages.len(), 1, "One keyboard activation opens one field");
+    mount.dispatch(&mut app, messages).await;
+    let popup = mount
+        .frame(&app, &[])
+        .2
+        .expect("App root overlay is mounted");
+    assert!(
+        popup.x >= 0.
+            && popup.y >= 0.
+            && popup.x + popup.width <= 360.
+            && popup.y + popup.height <= 320.
+    );
+    let mut inputs = typing("@controller_0720");
+    inputs.push((key(keyboard::key::Named::Escape, false), None));
+    let messages = mount.frame(&app, &inputs).0;
+    mount.dispatch(&mut app, messages).await;
+    let (_, fields, popup) = mount.frame(&app, &[]);
+    assert!(popup.is_none());
+    assert!(
+        fields.field(&id).1,
+        "Escape returns to its exact reference field"
+    );
+    assert_eq!(raw(&app), original);
+    assert_eq!(app.document.bundle(), &accepted);
+    for (backwards, expected) in [(false, "after-reference"), (true, "before-reference")] {
+        let messages = mount.click(&app, fields.field(&id).0.center());
+        mount.dispatch(&mut app, messages).await;
+        let messages = mount
+            .frame(&app, &[(key(keyboard::key::Named::Tab, backwards), None)])
+            .0;
+        mount.dispatch(&mut app, messages).await;
+        let (_, fields, popup) = mount.frame(&app, &[]);
+        assert!(popup.is_none());
+        assert!(
+            fields.field(&WidgetId::new(expected)).1,
+            "Chooser Tab stays within the originating form"
+        );
+    }
+    assert_eq!(app.document.bundle(), &accepted);
+}
+
+#[tokio::test]
+async fn mounted_reference_choice_stages_literal_identity_and_delayed_focus_cannot_hit_replacement_field()
+ {
+    let mut app = inspector(catalog(), OWNER);
+    let accepted = app.document.bundle().clone();
+    let mut mount = Mount::default();
+    let id = trigger::field_id(app.draft.as_ref().unwrap().reference_generation(), PATH);
+    let fields = mount.frame(&app, &[]).1;
+    let messages = mount.click(&app, fields.field(&id).0.center());
+    mount.dispatch(&mut app, messages).await;
+    let messages = mount.frame(&app, &typing("@controller_0720")).0;
+    mount.dispatch(&mut app, messages).await;
+    assert_eq!(
+        app.reference_authoring
+            .opened
+            .as_ref()
+            .unwrap()
+            .chooser
+            .count(),
+        1
+    );
+    let messages = mount
+        .frame(&app, &[(key(keyboard::key::Named::Enter, false), None)])
+        .0;
+    assert_eq!(messages.len(), 1);
+    let delayed_focus = app.update(messages.into_iter().next().unwrap());
+    assert_eq!(
+        app.draft.as_ref().unwrap().value.pointer(PATH),
+        Some(&json!(Id::from_u128(BASE + 720)))
+    );
+    assert_eq!(app.document.bundle(), &accepted);
+    // A structural edit occurs after Choose but before its asynchronous focus.
+    app.draft
+        .as_mut()
+        .unwrap()
+        .shape_scoped(PATH, Value::Null)
+        .unwrap();
+    let fields = mount.frame(&app, &[]).1;
+    let messages = mount.click(
+        &app,
+        fields.field(&WidgetId::new("after-reference")).0.center(),
+    );
+    mount.dispatch(&mut app, messages).await;
+    mount.perform(&app, delayed_focus).await;
+    let fields = mount.frame(&app, &[]).1;
+    assert!(
+        fields.field(&WidgetId::new("after-reference")).1,
+        "A missing old field target makes no focus changes"
+    );
+    assert!(
+        !fields
+            .field(&trigger::field_id(
+                app.draft.as_ref().unwrap().reference_generation(),
+                PATH
+            ))
+            .1
+    );
+    assert_eq!(app.document.bundle(), &accepted);
+}
+
+#[tokio::test]
+async fn mounted_scrolled_reference_anchor_uses_window_geometry_for_pointer_and_keyboard() {
+    let mut app = inspector(catalog(), OWNER);
+    let mut mount = Mount {
+        scrolled: true,
+        ..Default::default()
+    };
+    mount.frame(&app, &[]);
+    mount
+        .perform(
+            &app,
+            iced::widget::operation::snap_to("reference-scroll", scrollable::RelativeOffset::END),
+        )
+        .await;
+    let fields = mount.frame(&app, &[]).1;
+    let id = trigger::field_id(app.draft.as_ref().unwrap().reference_generation(), PATH);
+    let content = fields.field(&id).0;
+    let (viewport, offset) = fields.scrolls[0];
+    assert!(offset.y > 400., "Fixture is genuinely scrolled");
+    let expected = Rectangle {
+        x: content.x - offset.x,
+        y: content.y - offset.y,
+        ..content
+    }
+    .intersection(&viewport)
+    .unwrap();
+    let messages = mount.click(&app, expected.center());
+    let [Message::FieldReferenceOpen(request)] = messages.as_slice() else {
+        panic!("Scrolled field should emit one actual Open")
+    };
+    assert_eq!(request.anchor, expected);
+    mount.dispatch(&mut app, messages).await;
+    let close = app.update(Message::Escape);
+    mount.perform(&app, close).await;
+    let messages = mount
+        .frame(&app, &[(key(keyboard::key::Named::Enter, false), None)])
+        .0;
+    let [Message::FieldReferenceOpen(request)] = messages.as_slice() else {
+        panic!("Focused scrolled field opens without a pointer")
+    };
+    assert_eq!(request.anchor, expected);
+}
+
+#[tokio::test]
+async fn mounted_fresh_tab_reveals_offscreen_reference_and_return_reveals_it_again() {
+    for nested in [false, true] {
+        let mut app = inspector(catalog(), OWNER);
+        let original = raw(&app);
+        let source = app.document.bundle().clone();
+        let mut mount = Mount {
+            scrolled: true,
+            nested,
+            ..Default::default()
+        };
+        let fields = mount.frame(&app, &[]).1;
+        assert!(
+            fields
+                .scrolls
+                .iter()
+                .all(|(_, offset)| *offset == Vector::ZERO)
+        );
+        assert!(fields.field(&WidgetId::new("before-reference")).0.y > 180.);
+        let messages = mount
+            .frame(&app, &[(key(keyboard::key::Named::Tab, false), None)])
+            .0;
+        assert!(
+            messages.is_empty(),
+            "Keyboard reveal must not author any input"
+        );
+        let fields = mount.frame(&app, &[]).1;
+        assert!(fields.field(&WidgetId::new("before-reference")).1);
+        assert!(
+            fields.scrolls.iter().all(|(_, offset)| offset.y > 0.),
+            "Every enclosing viewport reveals fresh focus"
+        );
+        let id = trigger::field_id(app.draft.as_ref().unwrap().reference_generation(), PATH);
+        let offset: f32 = fields.scrolls.iter().map(|(_, offset)| offset.y).sum();
+        assert!(
+            fields.field(&id).0.y - offset >= 180.,
+            "The next reference starts below the fold"
+        );
+        let messages = mount
+            .frame(&app, &[(key(keyboard::key::Named::Tab, false), None)])
+            .0;
+        assert!(messages.is_empty());
+        let fields = mount.frame(&app, &[]).1;
+        let offset: f32 = fields.scrolls.iter().map(|(_, offset)| offset.y).sum();
+        let (bounds, focused) = fields.field(&id);
+        assert!(focused);
+        assert!(bounds.y - offset >= -0.01 && bounds.y + bounds.height - offset <= 180.01);
+        let messages = mount
+            .frame(&app, &[(key(keyboard::key::Named::Enter, false), None)])
+            .0;
+        assert_eq!(
+            messages.len(),
+            1,
+            "A newly revealed field opens through Enter"
+        );
+        mount.dispatch(&mut app, messages).await;
+        let return_focus = app.update(Message::Escape);
+        mount
+            .perform(
+                &app,
+                iced::widget::operation::snap_to(
+                    "reference-scroll",
+                    scrollable::RelativeOffset::START,
+                ),
+            )
+            .await;
+        if nested {
+            mount
+                .perform(
+                    &app,
+                    iced::widget::operation::snap_to(
+                        "outer-reference-scroll",
+                        scrollable::RelativeOffset::START,
+                    ),
+                )
+                .await;
+        }
+        assert!(
+            mount
+                .frame(&app, &[])
+                .1
+                .scrolls
+                .iter()
+                .all(|(_, offset)| *offset == Vector::ZERO)
+        );
+        mount.perform(&app, return_focus).await;
+        let fields = mount.frame(&app, &[]).1;
+        let offset: f32 = fields.scrolls.iter().map(|(_, offset)| offset.y).sum();
+        let (bounds, focused) = fields.field(&id);
+        assert!(
+            focused && bounds.y - offset >= -0.01 && bounds.y + bounds.height - offset <= 180.01
+        );
+        assert_eq!(raw(&app), original);
+        assert_eq!(app.document.bundle(), &source);
+    }
+}
+
+#[tokio::test]
+async fn mounted_form_tab_enters_in_both_directions_and_cycles_boundaries_without_losing_focus() {
+    for backwards in [false, true] {
+        let app = inspector(catalog(), OWNER);
+        let original = raw(&app);
+        let mut mount = Mount::default();
+        let reference = trigger::field_id(app.draft.as_ref().unwrap().reference_generation(), PATH);
+        let forward = [
+            WidgetId::new("before-reference"),
+            reference.clone(),
+            WidgetId::new("after-reference"),
+        ];
+        let reverse = [
+            WidgetId::new("after-reference"),
+            reference,
+            WidgetId::new("before-reference"),
+        ];
+        let expected = if backwards { &reverse } else { &forward };
+        for n in 0..7 {
+            let (messages, fields, popup) =
+                mount.frame(&app, &[(key(keyboard::key::Named::Tab, backwards), None)]);
+            assert!(messages.is_empty() && popup.is_none());
+            assert!(fields.field(&expected[n % 3]).1);
+            assert_eq!(
+                fields
+                    .values
+                    .iter()
+                    .filter(|(_, _, focused)| *focused)
+                    .count(),
+                1
+            );
+        }
+        assert_eq!(raw(&app), original);
+        assert!(!app.document.can_undo());
+    }
+}
+
+#[tokio::test]
+async fn mounted_delayed_return_cannot_focus_under_review_and_fresh_modal_tab_owns_its_form() {
+    let mut p = catalog();
+    trace(&mut p, Id::from_u128(300), OWNER, Id::from_u128(200));
+    let mut app = inspector(p, OWNER);
+    let source = app.document.bundle().clone();
+    let original = raw(&app);
+    let mut mount = Mount {
+        show_review: true,
+        ..Default::default()
+    };
+    let id = trigger::field_id(app.draft.as_ref().unwrap().reference_generation(), PATH);
+    let session = app.draft.as_ref().unwrap().reference_session();
+    let fields = mount.frame(&app, &[]).1;
+    let messages = mount.click(&app, fields.field(&id).0.center());
+    mount.dispatch(&mut app, messages).await;
+    let return_focus = app.update(Message::Escape);
+    let fields = mount.frame(&app, &[]).1;
+    let messages = mount.click(
+        &app,
+        fields.field(&WidgetId::new("after-reference")).0.center(),
+    );
+    mount.dispatch(&mut app, messages).await;
+    let _ = app.update(Message::StartSemanticReview(Id::from_u128(300)));
+    let facet = FacetSelector::Header(HeaderFacet::Parent);
+    send_review(&mut app, RowEvent::Select(facet.clone()));
+    send_review(
+        &mut app,
+        RowEvent::Decide(facet, Some(SemanticDecision::Candidate)),
+    );
+    assert_eq!(
+        app.draft.as_ref().unwrap().reference_session(),
+        session,
+        "Old Inspector really remains mounted"
+    );
+    assert_eq!(
+        trigger::field_id(app.draft.as_ref().unwrap().reference_generation(), PATH),
+        id
+    );
+    let review_before = review(&app).recovery_snapshot().unwrap();
+    let review_field = trigger::field_id(
+        review(&app)
+            .reference_form(app.project())
+            .unwrap()
+            .reference_generation(),
+        "/parent",
+    );
+    mount.perform(&app, return_focus).await;
+    let fields = mount.frame(&app, &[]).1;
+    assert!(
+        !fields.field(&id).1,
+        "A live old field underneath a modal cannot receive the stale focus task"
+    );
+    assert!(fields.field(&WidgetId::new("after-reference")).1);
+    assert!(!fields.field(&review_field).1);
+    let (messages, fields, _) = mount.frame(&app, &[(key(keyboard::key::Named::Tab, false), None)]);
+    assert!(messages.is_empty());
+    assert!(
+        fields.field(&review_field).1,
+        "Review entry ignores retained focus under its modal"
+    );
+    assert!(
+        !fields.field(&WidgetId::new("after-reference")).1,
+        "Modal focus acquisition deactivates background inputs"
+    );
+    let messages = mount.frame(&app, &typing("x")).0;
+    assert!(
+        messages.is_empty(),
+        "A character at the focused Review trigger cannot type into the Inspector below it"
+    );
+    let (messages, fields, _) = mount.frame(&app, &[(key(keyboard::key::Named::Tab, true), None)]);
+    assert!(messages.is_empty());
+    assert!(fields.field(&review_field).1);
+    assert!(!fields.field(&id).1);
+    assert_eq!(review(&app).recovery_snapshot().unwrap(), review_before);
+    assert_eq!(raw(&app), original);
+    assert_eq!(app.document.bundle(), &source);
+}
+
+#[tokio::test]
+async fn mounted_review_pointer_open_and_outside_dismissal_keep_background_input_inactive() {
+    let mut p = catalog();
+    trace(&mut p, Id::from_u128(300), OWNER, Id::from_u128(200));
+    let mut app = inspector(p, OWNER);
+    let original = raw(&app);
+    let source = app.document.bundle().clone();
+    let mut mount = Mount {
+        show_review: true,
+        ..Default::default()
+    };
+    let fields = mount.frame(&app, &[]).1;
+    let messages = mount.click(
+        &app,
+        fields.field(&WidgetId::new("after-reference")).0.center(),
+    );
+    mount.dispatch(&mut app, messages).await;
+    let _ = app.update(Message::StartSemanticReview(Id::from_u128(300)));
+    let facet = FacetSelector::Header(HeaderFacet::Parent);
+    send_review(&mut app, RowEvent::Select(facet.clone()));
+    send_review(
+        &mut app,
+        RowEvent::Decide(facet, Some(SemanticDecision::Candidate)),
+    );
+    let saved = review(&app).recovery_snapshot().unwrap();
+    let id = trigger::field_id(
+        review(&app)
+            .reference_form(app.project())
+            .unwrap()
+            .reference_generation(),
+        "/parent",
+    );
+    let fields = mount.frame(&app, &[]).1;
+    assert!(
+        fields.field(&WidgetId::new("after-reference")).1,
+        "Fixture retains Inspector focus before the modal receives input"
+    );
+    let messages = mount.click(&app, fields.field(&id).0.center());
+    mount.dispatch(&mut app, messages).await;
+    assert!(matches!(
+        &app.reference_authoring.opened.as_ref().unwrap().host,
+        Host::Review { .. }
+    ));
+    let fields = mount.frame(&app, &[]).1;
+    assert!(!fields.field(&WidgetId::new("after-reference")).1);
+    let messages = mount.click(&app, Point::new(359., 319.));
+    assert!(matches!(
+        messages.as_slice(),
+        [Message::Workflow(workflow::Event::Semantic(
+            semantic_review::Event::Row {
+                event: RowEvent::ReferenceEvent(chooser::Event {
+                    action: Action::Close(Close::Outside),
+                    ..
+                }),
+                ..
+            }
+        ))]
+    ));
+    for message in messages {
+        let task = app.update(message);
+        assert!(
+            iced_runtime::task::into_stream(task).is_none(),
+            "Outside dismissal must not request focus or apply"
+        );
+    }
+    let (messages, fields, popup) = mount.frame(&app, &typing("x"));
+    assert!(messages.is_empty() && popup.is_none());
+    assert!(!fields.field(&WidgetId::new("after-reference")).1);
+    assert_eq!(review(&app).recovery_snapshot().unwrap(), saved);
+    assert_eq!(raw(&app), original);
+    assert_eq!(app.document.bundle(), &source);
+}
+
+#[tokio::test]
+async fn mounted_reverse_review_required_rationale_remains_editable_beside_candidate_reference_form()
+ {
+    let mut p = persistence::decode(include_bytes!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../harness/fixtures/interface-operation-probe/output/boundary-only.json"
+    )))
+    .unwrap();
+    let sa = p
+        .elements
+        .values()
+        .find(|element| {
+            element.layer() == Layer::Sa
+                && matches!(
+                    element.shared(),
+                    Some(SharedBody::Occurrence {
+                        body: OccurrenceBody::Exchange {
+                            operation: Some(_),
+                            message_kind: MessageKind::Call | MessageKind::Asynchronous,
+                            ..
+                        },
+                        ..
+                    })
+                )
+        })
+        .unwrap()
+        .id;
+    let inspector_id = Id::new_v4();
+    element(
+        &mut p,
+        inspector_id,
+        Kind::DataType,
+        Layer::Oa,
+        "Inspector record",
+        None,
+    );
+    let scenario = p
+        .add_element(Kind::Scenario, Layer::Oa, "Operational counterpart", None)
+        .unwrap();
+    let oa = p
+        .add_element(
+            Kind::Occurrence,
+            Layer::Oa,
+            "Operational message",
+            Some(scenario),
+        )
+        .unwrap();
+    *p.elements.get_mut(&oa).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
+        body: OccurrenceBody::Exchange {
+            exchange: None,
+            sender: None,
+            receiver: None,
+            message_kind: MessageKind::Asynchronous,
+            reply_to: None,
+            values: vec![],
+            operation: None,
+        },
+        precondition: String::new(),
+        postcondition: String::new(),
+    };
+    p.elements
+        .get_mut(&scenario)
+        .unwrap()
+        .steps_mut()
+        .unwrap()
+        .push(oa);
+    let trace_id = Id::new_v4();
+    trace(&mut p, trace_id, oa, sa);
+    let mut app = inspector(p, inspector_id);
+    let source = app.document.bundle().clone();
+    let inspector_raw = raw(&app);
+    let _ = app.update(Message::StartSemanticReview(trace_id));
+    let _ = app.update(Message::Workflow(workflow::Event::Semantic(
+        semantic_review::Event::Direction(TransitionDirection::SaToOa),
+    )));
+    let facet = FacetSelector::Header(HeaderFacet::Parent);
+    send_review(&mut app, RowEvent::Select(facet.clone()));
+    send_review(
+        &mut app,
+        RowEvent::Decide(facet, Some(SemanticDecision::Candidate)),
+    );
+    send_review(&mut app, RowEvent::OperationOmission(true));
+    assert_eq!(review(&app).direction, TransitionDirection::SaToOa);
+    assert_eq!(review(&app).operation_omission.as_deref(), Some(""));
+    let candidate = serde_json::to_value(
+        review(&app)
+            .reference_form(app.project())
+            .unwrap()
+            .recovery_snapshot(),
+    )
+    .unwrap();
+    let mut mount = Mount {
+        show_review: true,
+        ..Default::default()
+    };
+    let fields = mount.frame(&app, &[]).1;
+    let messages = mount.click(
+        &app,
+        fields.field(&WidgetId::new("review-rationale")).0.center(),
+    );
+    mount.dispatch(&mut app, messages).await;
+    let messages = mount.frame(&app, &typing("Engineering reason")).0;
+    assert_eq!(
+        messages.len(),
+        "Engineering reason".chars().count(),
+        "Every key reaches the legitimate sibling inside Review"
+    );
+    assert!(messages.iter().all(|message| matches!(
+        message,
+        Message::Workflow(workflow::Event::Semantic(semantic_review::Event::Row {
+            event: RowEvent::OperationRationale(_),
+            ..
+        }))
+    )));
+    mount.dispatch(&mut app, messages).await;
+    assert_eq!(
+        review(&app).operation_omission.as_deref(),
+        Some("Engineering reason")
+    );
+    assert!(
+        mount
+            .frame(&app, &[])
+            .1
+            .field(&WidgetId::new("review-rationale"))
+            .1
+    );
+    assert_eq!(
+        serde_json::to_value(
+            review(&app)
+                .reference_form(app.project())
+                .unwrap()
+                .recovery_snapshot()
+        )
+        .unwrap(),
+        candidate
+    );
+    assert_eq!(raw(&app), inspector_raw);
+    assert_eq!(app.document.bundle(), &source);
+    assert!(!app.document.can_undo());
+}
@@ -1,263 +0,0 @@
-use super::*;
-
-const VALID: &str = concat!(
-    "arcadia 7;\r\n",
-    "project repair \"Repair 救援\" id \"9e8f0000-0000-4000-8000-000000000001\" {\r\n",
-    "    oa_activity assess \"Assess\" id \"9e8f0000-0000-4000-8000-000000000002\" {}\r\n",
-    "}\r\n",
-);
-
-fn open(app: &mut App, path: &std::path::Path) {
-    let _ = app.update(Message::Loaded(Ok(Some(
-        read_snapshot(path.to_owned()).unwrap(),
-    ))));
-}
-
-fn edit(app: &mut App, text: &str) {
-    let _ = app.update(Message::SourceEdit(text_editor::Action::SelectAll));
-    let _ = app.update(Message::SourceEdit(text_editor::Action::Edit(
-        text_editor::Edit::Paste(Arc::new(text.into())),
-    )));
-}
-
-fn save(app: &mut App, path: &std::path::Path) {
-    let receipt = write_snapshot(
-        app.canvas_document,
-        app.document.revision(),
-        app.document.snapshot(),
-        path.to_owned(),
-        app.disk_project.clone(),
-    )
-    .unwrap();
-    let _ = app.update(Message::Saved(Ok(Some(receipt))));
-}
-
-#[test]
-fn repair_to_previous_saved_bytes_requires_save_at_new_destination_and_guards_close() {
-    for extra in [
-        "    include \"missing.arcadia\";\r\n",
-        "    oa_activity assess \"Duplicate\" id \"9e8f0000-0000-4000-8000-000000000003\" {}\r\n",
-    ] {
-        let first = tempfile::tempdir().unwrap();
-        let second = tempfile::tempdir().unwrap();
-        let first_path = first.path().canonicalize().unwrap().join("project.arcadia");
-        let second_path = second
-            .path()
-            .canonicalize()
-            .unwrap()
-            .join("project.arcadia");
-        let invalid = VALID.strip_suffix("}\r\n").unwrap().to_owned() + extra + "}\r\n";
-        std::fs::write(&first_path, VALID).unwrap();
-        std::fs::write(&second_path, &invalid).unwrap();
-        let mut app = App::with_project(Project::empty());
-        open(&mut app, &first_path);
-        assert!(!app.dirty());
-        let before = app.document.snapshot();
-        let revision = app.document.revision();
-        open(&mut app, &second_path);
-        assert!(!app.source_workspace.applied);
-        assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-        edit(&mut app, VALID);
-        assert!(app.apply_source(), "{}", app.status);
-        assert!(app.source_workspace.applied);
-        assert!(!app.source_dirty());
-        assert_eq!(app.document.bundle(), &before.bundle);
-        assert_eq!(app.project(), &before.decoded.project);
-        assert_eq!(app.document.revision(), revision);
-        assert!(
-            !app.document.can_undo(),
-            "Equal content creates no history step"
-        );
-        assert!(app.document.dirty());
-        assert_eq!(app.hosted_label(), "Unsaved changes");
-        assert_eq!(std::fs::read(&second_path).unwrap(), invalid.as_bytes());
-        assert_eq!(std::fs::read(&first_path).unwrap(), VALID.as_bytes());
-        let close = window::Id::unique();
-        let task = app.update(Message::Request(Pending::Close(close)));
-        assert!(iced_runtime::task::into_stream(task).is_none());
-        assert!(matches!(app.pending, Some(Pending::Close(id)) if id == close));
-        let _ = app.update(Message::Cancel);
-        save(&mut app, &second_path);
-        assert!(!app.dirty());
-        assert_eq!(app.hosted_label(), "All changes saved");
-        assert_eq!(std::fs::read(&second_path).unwrap(), VALID.as_bytes());
-        assert_eq!(std::fs::read(&first_path).unwrap(), VALID.as_bytes());
-    }
-}
-
-#[test]
-fn repair_history_compares_to_new_disk_baseline_and_then_successful_save() {
-    let directory = tempfile::tempdir().unwrap();
-    let path = directory
-        .path()
-        .canonicalize()
-        .unwrap()
-        .join("project.arcadia");
-    std::fs::write(&path, VALID).unwrap();
-    let mut app = App::with_project(Project::empty());
-    open(&mut app, &path);
-    let before = app.document.snapshot();
-    let invalid = format!("{VALID} unfinished {{");
-    std::fs::write(&path, &invalid).unwrap();
-    open(&mut app, &path);
-    let repaired = format!("{VALID}// Repaired rationale\r\n");
-    edit(&mut app, &repaired);
-    assert!(app.apply_source());
-    assert!(app.dirty());
-    let _ = app.update(Message::Undo);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(
-        app.dirty(),
-        "Old saved bytes are not saved at the repair destination"
-    );
-    let _ = app.update(Message::Redo);
-    assert!(app.dirty());
-    assert_eq!(std::fs::read(&path).unwrap(), invalid.as_bytes());
-
-    std::fs::write(&path, "external edit").unwrap();
-    let failed = write_snapshot(
-        app.canvas_document,
-        app.document.revision(),
-        app.document.snapshot(),
-        path.clone(),
-        app.disk_project.clone(),
-    )
-    .unwrap_err();
-    let _ = app.update(Message::Saved(Err(failed)));
-    assert!(app.dirty());
-    assert_eq!(std::fs::read(&path).unwrap(), b"external edit");
-    std::fs::write(&path, &invalid).unwrap();
-    save(&mut app, &path);
-    assert!(!app.dirty());
-    let _ = app.update(Message::Undo);
-    assert!(app.dirty());
-    assert_eq!(app.document.bundle(), &before.bundle);
-    let _ = app.update(Message::Redo);
-    assert!(!app.dirty(), "Redo to the new saved snapshot is clean");
-    assert_eq!(std::fs::read(&path).unwrap(), repaired.as_bytes());
-}
-
-#[test]
-fn valid_equal_content_at_distinct_destinations_stays_clean() {
-    let first = tempfile::tempdir().unwrap();
-    let second = tempfile::tempdir().unwrap();
-    let first_path = first.path().canonicalize().unwrap().join("project.arcadia");
-    let second_path = second
-        .path()
-        .canonicalize()
-        .unwrap()
-        .join("project.arcadia");
-    std::fs::write(&first_path, VALID).unwrap();
-    std::fs::write(&second_path, VALID).unwrap();
-    let mut app = App::with_project(Project::empty());
-    open(&mut app, &first_path);
-    let before = app.document.bundle().clone();
-    open(&mut app, &second_path);
-    assert_eq!(app.document.bundle(), &before);
-    assert_eq!(app.path.as_ref(), Some(&second_path));
-    assert!(!app.dirty());
-    assert_eq!(app.hosted_label(), "All changes saved");
-}
-
-#[test]
-fn recovering_applied_repair_rebinds_rolled_back_disk_bytes_without_changing_model() {
-    let first = tempfile::tempdir().unwrap();
-    let second = tempfile::tempdir().unwrap();
-    let first_path = first.path().canonicalize().unwrap().join("project.arcadia");
-    let root = second.path().canonicalize().unwrap();
-    let path = root.join("project.arcadia");
-    let before = VALID.replace("Repair 救援", "Before 救援");
-    std::fs::write(&first_path, VALID).unwrap();
-    std::fs::write(&path, VALID).unwrap();
-    let journal = root.join(".arcadia-save-project.arcadia.journal");
-    std::fs::create_dir(&journal).unwrap();
-    std::fs::write(
-        journal.join("journal.json"),
-        br#"{"version":1,"entry":"project.arcadia","files":[{"path":"project.arcadia","before":true,"write":true}]}"#,
-    )
-    .unwrap();
-    std::fs::write(journal.join("0.before"), &before).unwrap();
-    std::fs::write(journal.join("0.after"), VALID).unwrap();
-    let mut app = App::with_project(Project::empty());
-    open(&mut app, &first_path);
-    let accepted = app.document.snapshot();
-    open(&mut app, &path);
-    assert_eq!(app.pending_recovery.as_ref(), Some(&path));
-    assert!(!app.source_workspace.applied);
-    assert!(app.apply_source());
-    assert!(
-        !app.dirty(),
-        "Current bytes still match disk before rollback"
-    );
-    let _ = app.update(Message::SourceRecovered(recover_snapshot(path.clone())));
-    assert!(app.pending_recovery.is_none());
-    assert!(!journal.exists());
-    assert_eq!(std::fs::read(&path).unwrap(), before.as_bytes());
-    assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
-    assert!(!app.source_dirty());
-    assert!(app.dirty(), "Recovery changed disk, not the accepted model");
-    assert_eq!(app.hosted_label(), "Unsaved changes");
-    save(&mut app, &path);
-    assert!(!app.dirty());
-    assert_eq!(std::fs::read(&path).unwrap(), VALID.as_bytes());
-}
-
-#[test]
-fn recovery_missing_entry_or_failed_reload_preserves_current_destination_save_authority() {
-    for (current_destination, failed_reload) in
-        [(true, false), (false, false), (true, true), (false, true)]
-    {
-        let directory = tempfile::tempdir().unwrap();
-        let root = directory.path().canonicalize().unwrap();
-        let path = root.join("project.arcadia");
-        std::fs::write(&path, VALID).unwrap();
-        let mut app = App::with_project(Project::empty());
-        open(&mut app, &path);
-        let accepted = app.document.snapshot();
-        let journal = root.join(".arcadia-save-project.arcadia.journal");
-        std::fs::create_dir(&journal).unwrap();
-        std::fs::write(
-            journal.join("journal.json"),
-            br#"{"version":1,"entry":"project.arcadia","files":[{"path":"project.arcadia","before":false,"write":true}]}"#,
-        )
-        .unwrap();
-        std::fs::write(journal.join("0.after"), VALID).unwrap();
-        open(&mut app, &path);
-        assert!(app.apply_source());
-        assert!(!app.dirty());
-        let destination = tempfile::tempdir().unwrap();
-        let saved_elsewhere = destination
-            .path()
-            .canonicalize()
-            .unwrap()
-            .join("project.arcadia");
-        if !current_destination {
-            save(&mut app, &saved_elsewhere);
-            assert_eq!(app.path.as_ref(), Some(&saved_elsewhere));
-            assert_eq!(app.pending_recovery.as_ref(), Some(&path));
-        }
-        let mut receipt = recover_snapshot(path.clone()).unwrap();
-        assert!(
-            receipt.disk.as_ref().unwrap().bundle.files.is_empty(),
-            "Missing entry reloads as an empty repair workspace"
-        );
-        if failed_reload {
-            // Separately exercise the adapter's successful-recovery/failed-read
-            // boundary; first-save rollback itself does not cause a read error.
-            receipt.disk = Err("Injected post-recovery reload failure".into());
-        }
-        let _ = app.update(Message::SourceRecovered(Ok(receipt)));
-        assert!(!path.exists());
-        assert!(!journal.exists());
-        assert!(app.pending_recovery.is_none());
-        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
-        assert_eq!(app.dirty(), current_destination);
-        if current_destination {
-            let _ = app.update(Message::Request(Pending::New));
-            assert!(matches!(app.pending, Some(Pending::New)));
-        } else {
-            assert_eq!(app.path.as_ref(), Some(&saved_elsewhere));
-            assert_eq!(std::fs::read(&saved_elsewhere).unwrap(), VALID.as_bytes());
-        }
-    }
-}
@@ -1,463 +0,0 @@
-//! Current draft navigation, isolated from model application and disk discovery.
-use super::*;
-use crate::source_navigation::{self as nav, query};
-use std::sync::atomic::Ordering;
-
-fn admission_notice(error: query::AdmissionError) -> String {
-    use nav::symbols::{BuildError, InputProblem, Resource};
-    let (limit, resource) = match error {
-        query::AdmissionError::Index(BuildError::Limit { limit, resource, .. }) => (limit, resource),
-        query::AdmissionError::Outline { error, .. } => (error.limit, match error.resource {
-            language::OutlineResource::SourceBytes => Resource::SourceBytes,
-            language::OutlineResource::Tokens => Resource::Tokens,
-            language::OutlineResource::Declarations => Resource::Records,
-        }),
-        query::AdmissionError::Index(BuildError::Input { problem, .. }) => return match problem {
-            InputProblem::NonCanonicalPath | InputProblem::DuplicateOrCaseCollidingPath =>
-                "Navigation needs distinct relative source paths. Check file names and include paths.".into(),
-            _ => "Navigation could not verify the current source locations. Correct source errors and try again.".into(),
-        },
-    };
-    let unit = match resource {
-        Resource::Files => "loaded files",
-        Resource::SourceBytes => "source bytes",
-        Resource::PathBytes => "bytes in file paths",
-        Resource::Tokens => "source tokens",
-        Resource::Records => "declarations and references",
-    };
-    format!(
-        "Navigation reached its limit of {limit} {unit}. Reduce the loaded source size and try again."
-    )
-}
-
-impl App {
-    pub fn source_symbol_context(&self) -> nav::SymbolContext {
-        nav::SymbolContext {
-            session: self.source_workspace.session(),
-            path: self.source_workspace.active.clone(),
-        }
-    }
-
-    pub fn source_symbol_message(&self, event: nav::SymbolEvent) -> Message {
-        Message::SourceSymbols(self.source_symbol_context(), event)
-    }
-
-    pub fn source_find_close_message(&self) -> Message {
-        Message::SourceFindClose(self.source_symbol_context(), self.source_find_instance)
-    }
-    pub fn source_key(&self) -> query::SnapshotKey {
-        query::SnapshotKey {
-            workspace: self.source_workspace.session(),
-            revision: self.source_workspace.revision(),
-        }
-    }
-
-    fn with_source_input<T>(&self, use_input: impl FnOnce(query::Input<'_>) -> T) -> T {
-        let files: Vec<_> = self
-            .source_workspace
-            .files
-            .iter()
-            .map(|(path, buffer)| query::DraftFile {
-                path,
-                text: &buffer.text,
-            })
-            .collect();
-        let accepted = self.document.bundle();
-        let validated: Vec<_> = accepted
-            .files
-            .iter()
-            .map(|(path, text)| query::DraftFile { path, text })
-            .collect();
-        use_input(query::Input {
-            key: self.source_key(),
-            entry: &self.source_workspace.entry,
-            files: &files,
-            applied: self.source_workspace.applied,
-            validation: self
-                .source_workspace
-                .applied
-                .then_some(query::ValidatedSources {
-                    entry: &accepted.entry,
-                    files: &validated,
-                }),
-        })
-    }
-
-    fn source_snapshot_matches(&self, snapshot: &query::Snapshot) -> bool {
-        snapshot.key() == self.source_key()
-            && self.with_source_input(|input| snapshot.matches(input))
-    }
-
-    pub fn source_navigation_available(&self) -> bool {
-        self.page == Page::Text
-            && !self.busy
-            && self.pending.is_none()
-            && self.file_prompt.is_none()
-            && !self.delete_pending
-            && self.workflow.is_none()
-            && !self.hosted.visible
-            && self.model_menu.is_none()
-            && self.architecture.is_none()
-            && !self.behavior.has_pending()
-    }
-
-    /// Mounted widget IDs change when another interaction supersedes a reveal.
-    /// A queued focus operation therefore cannot find a subsequently reused editor.
-    pub fn source_editor_id(&self) -> iced::widget::Id {
-        iced::widget::Id::from(format!(
-            "source-editor-{}-{}-{}",
-            self.source_workspace.session(),
-            self.source_workspace.active,
-            self.source_symbols.interaction
-        ))
-    }
-
-    pub fn source_reveal_ticket(&self) -> Option<Id> {
-        self.source_symbols
-            .reveal
-            .as_ref()
-            .map(|reveal| reveal.ticket)
-    }
-
-    pub(super) fn source_interaction(&mut self) {
-        self.source_symbols.interaction = Id::new_v4();
-        self.source_symbols.request = None;
-        self.source_symbols.reveal = None;
-        self.source_jump = None;
-    }
-
-    pub(super) fn queue_source_reveal(&mut self, cursor: text_editor::Cursor, select_line: bool) {
-        self.source_jump = Some(cursor);
-        self.source_select_line = select_line;
-        self.source_symbols.reveal = Some(nav::Reveal {
-            ticket: Id::new_v4(),
-            interaction: self.source_symbols.interaction,
-            raw_interaction: self.source_symbols.raw_interaction.load(Ordering::SeqCst),
-            snapshot: self.source_key(),
-            path: self.source_workspace.active.clone(),
-        });
-    }
-
-    pub(super) fn restore_source_editor_focus(&mut self) {
-        let cursor = self.source_editor.cursor();
-        if self.source_navigation_available()
-            && nav::exact_cursor(self.source_workspace.text(), cursor)
-        {
-            self.queue_source_reveal(cursor, false);
-        }
-    }
-
-    pub(super) fn source_viewport(&mut self, ticket: Option<Id>) -> Task<Message> {
-        let Some(reveal) = &self.source_symbols.reveal else {
-            return Task::none();
-        };
-        if Some(reveal.ticket) != ticket
-            || reveal.interaction != self.source_symbols.interaction
-            || !nav::interaction::is_current(
-                &self.source_symbols.raw_interaction,
-                reveal.raw_interaction,
-            )
-            || reveal.snapshot != self.source_key()
-            || reveal.path != self.source_workspace.active
-            || !self.source_navigation_available()
-        {
-            return Task::none();
-        }
-        let raw_interaction = reveal.raw_interaction;
-        self.source_symbols.reveal = None;
-        if let Some(cursor) = self.source_jump.take() {
-            if !nav::exact_cursor(self.source_workspace.text(), cursor) {
-                return Task::none();
-            }
-            self.source_editor.move_to(cursor);
-            if self.source_select_line && cursor.selection.is_none() {
-                self.source_editor.perform(text_editor::Action::SelectLine);
-            }
-            return nav::interaction::guarded_focus(
-                self.source_editor_id(),
-                self.source_symbols.raw_interaction.clone(),
-                raw_interaction,
-            );
-        }
-        Task::none()
-    }
-
-    pub(super) fn source_symbol_event(&mut self, event: nav::SymbolEvent) -> Task<Message> {
-        if !self.source_navigation_available() {
-            return Task::none();
-        }
-        match event {
-            nav::SymbolEvent::Close => {
-                self.source_symbols.open = false;
-                self.source_symbols.results = None;
-                self.source_symbols.notice = None;
-            }
-            nav::SymbolEvent::Back => {
-                self.source_symbol_back();
-                // A successful Back needs no empty results panel. Retain an
-                // already open panel, or reveal an actionable return notice.
-                self.source_symbols.open |= self.source_symbols.notice.is_some();
-            }
-            nav::SymbolEvent::Choose {
-                stamp,
-                reference,
-                index,
-            } => {
-                let Some(results) = self.source_symbols.results.clone() else {
-                    return Task::none();
-                };
-                if results.stamp != stamp
-                    || stamp.snapshot != self.source_key()
-                    || self
-                        .source_symbols
-                        .cache
-                        .as_ref()
-                        .is_none_or(|cache| !self.source_snapshot_matches(cache))
-                {
-                    self.source_symbols.notice =
-                        Some("Source changed. Run navigation again for current locations.".into());
-                    return Task::none();
-                }
-                let destination = if reference {
-                    results
-                        .references
-                        .get(index)
-                        .map(|row| (&row.path, row.position, row.end_position))
-                } else {
-                    results
-                        .definitions
-                        .get(index)
-                        .map(|row| (&row.path, row.position, row.end_position))
-                };
-                if let Some((path, start, end)) = destination {
-                    self.source_symbol_jump(path, start, end);
-                }
-            }
-            nav::SymbolEvent::Query(action) => return self.start_source_query(action),
-        }
-        Task::none()
-    }
-
-    fn start_source_query(&mut self, action: query::Action) -> Task<Message> {
-        self.source_symbols.open = true;
-        if !nav::interaction::is_current(
-            &self.source_symbols.raw_interaction,
-            self.source_symbols.raw_interaction.load(Ordering::SeqCst),
-        ) {
-            self.source_symbols.notice = Some("Reopen this workspace to reset navigation.".into());
-            return Task::none();
-        }
-        if self.source_symbols.in_flight.is_some() {
-            self.source_symbols.notice = Some("Navigation is finishing. Try again shortly.".into());
-            return Task::none();
-        }
-        let cursor = self.source_editor.cursor();
-        let Some(offset) = nav::cursor_offset(self.source_workspace.text(), cursor) else {
-            self.source_symbols.notice =
-                Some("Place the cursor on an alias or its @ reference.".into());
-            return Task::none();
-        };
-        self.source_symbols.serial = match self.source_symbols.serial.checked_add(1) {
-            Some(serial) => serial,
-            None => {
-                self.source_workspace.reset_navigation_session();
-                self.source_symbols.back.clear();
-                self.source_symbols.cache = None;
-                0
-            }
-        };
-        let request = nav::Request {
-            job: Id::new_v4(),
-            interaction: self.source_symbols.interaction,
-            raw_interaction: self.source_symbols.raw_interaction.load(Ordering::SeqCst),
-            stamp: query::QueryStamp {
-                snapshot: self.source_key(),
-                serial: self.source_symbols.serial,
-            },
-            path: self.source_workspace.active.clone(),
-            offset,
-            cursor,
-            action,
-        };
-        let cache = self
-            .source_symbols
-            .cache
-            .as_ref()
-            .filter(|cache| self.source_snapshot_matches(cache))
-            .cloned();
-        let input = if cache.is_none() {
-            match self
-                .with_source_input(|input| query::admit_owned(input, query::Limits::default()))
-            {
-                Ok(input) => Some(input),
-                Err(error) => {
-                    self.source_symbols.notice = Some(admission_notice(error));
-                    return Task::none();
-                }
-            }
-        } else {
-            None
-        };
-        self.source_symbols.in_flight = Some(request.job);
-        self.source_symbols.request = Some(request.clone());
-        self.source_symbols.results = None;
-        self.source_symbols.notice = None;
-        Task::perform(
-            async move {
-                let worker_request = request.clone();
-                let result = tokio::task::spawn_blocking(move || {
-                    let snapshot = match cache {
-                        Some(cache) => cache,
-                        None => Arc::new(
-                            input
-                                .expect("admitted input for uncached request")
-                                .capture()
-                                .map_err(admission_notice)?,
-                        ),
-                    };
-                    let results = snapshot
-                        .query(query::Query {
-                            stamp: worker_request.stamp,
-                            path: &worker_request.path,
-                            byte_offset: worker_request.offset,
-                            action: worker_request.action,
-                        })
-                        .map_err(|error| match error {
-                            query::QueryError::ResultEnvelopeLimit => "These result details exceed the display limit. Try literal Find for this alias.".to_owned(),
-                            _ => "Navigation could not verify this location. Place the cursor on an alias and try again.".to_owned(),
-                        })?;
-                    Ok((snapshot, Arc::new(results)))
-                })
-                .await
-                .unwrap_or_else(|error| Err(format!("Navigation task failed: {error}")));
-                nav::Completion { request, result }
-            },
-            Message::SourceSymbolsReady,
-        )
-    }
-
-    pub(super) fn source_symbols_ready(&mut self, completion: nav::Completion) -> Task<Message> {
-        let request = completion.request;
-        if self.source_symbols.in_flight != Some(request.job) {
-            return Task::none();
-        }
-        self.source_symbols.in_flight = None;
-        let wanted = self
-            .source_symbols
-            .request
-            .take()
-            .is_some_and(|current| current.job == request.job)
-            && request.interaction == self.source_symbols.interaction
-            && request.stamp.snapshot == self.source_key()
-            && nav::interaction::is_current(
-                &self.source_symbols.raw_interaction,
-                request.raw_interaction,
-            )
-            && request.path == self.source_workspace.active
-            && request.cursor == self.source_editor.cursor()
-            && self.source_navigation_available();
-        if !wanted {
-            return Task::none();
-        }
-        match completion.result {
-            Ok((snapshot, results)) if self.source_snapshot_matches(&snapshot) => {
-                self.source_symbols.cache = Some(snapshot);
-                self.source_symbols.results = Some(results.clone());
-                if results.disposition == query::Disposition::Direct
-                    && let Some(row) = results.definitions.first()
-                {
-                    self.source_symbol_jump(&row.path, row.position, row.end_position);
-                }
-            }
-            Ok(_) => {
-                self.source_symbols.notice = Some("Source changed. Run navigation again.".into())
-            }
-            Err(error) => self.source_symbols.notice = Some(error),
-        }
-        Task::none()
-    }
-
-    fn source_symbol_jump(&mut self, path: &str, start: query::Position, end: query::Position) {
-        let cursor = text_editor::Cursor {
-            position: text_editor::Position {
-                line: start.line,
-                column: start.byte_column,
-            },
-            selection: Some(text_editor::Position {
-                line: end.line,
-                column: end.byte_column,
-            }),
-        };
-        if self
-            .source_workspace
-            .files
-            .get(path)
-            .is_none_or(|buffer| !nav::exact_cursor(&buffer.text, cursor))
-        {
-            self.source_symbols.notice =
-                Some("That source location is no longer available. Run navigation again.".into());
-            return;
-        }
-        if let Some(buffer) = self
-            .source_workspace
-            .files
-            .get(&self.source_workspace.active)
-        {
-            let origin = nav::HistoryEntry {
-                session: self.source_workspace.session(),
-                path: self.source_workspace.active.clone(),
-                generation: buffer.generation(),
-                cursor: self.source_editor.cursor(),
-            };
-            self.source_symbols
-                .back
-                .retain(|entry| entry.session == origin.session);
-            if self.source_symbols.back.len() == 64 {
-                self.source_symbols.back.remove(0);
-            }
-            self.source_symbols.back.push(origin);
-        }
-        self.source_workspace
-            .switch(path, self.source_editor.cursor());
-        self.show_source_file(false);
-        self.queue_source_reveal(cursor, false);
-    }
-
-    fn source_symbol_back(&mut self) {
-        while let Some(origin) = self.source_symbols.back.pop() {
-            if origin.session != self.source_workspace.session() {
-                continue;
-            }
-            let Some(buffer) = self.source_workspace.files.get(&origin.path) else {
-                self.source_symbols.notice = Some("The previous file is no longer loaded.".into());
-                return;
-            };
-            let unchanged = origin.generation == buffer.generation();
-            let cursor = if unchanged {
-                origin.cursor
-            } else if origin.path == self.source_workspace.active {
-                self.source_editor.cursor()
-            } else {
-                buffer.cursor
-            };
-            if !nav::exact_cursor(&buffer.text, cursor) {
-                self.source_symbols.notice = Some(
-                    "The previous location changed. Open the file to choose a current position."
-                        .into(),
-                );
-                return;
-            }
-            self.source_workspace
-                .switch(&origin.path, self.source_editor.cursor());
-            self.show_source_file(false);
-            self.queue_source_reveal(cursor, false);
-            self.source_symbols.notice =
-                (!unchanged).then(|| "This draft changed; its current cursor was restored.".into());
-            return;
-        }
-        self.source_symbols.notice = Some("No previous source location in this workspace.".into());
-    }
-}
-
-#[cfg(test)]
-mod tests;
@@ -14,10 +14,15 @@ use iced::{
 };
 use oa_core::*;
 use std::collections::BTreeMap;
+pub(crate) mod canvas_workspace;
 #[cfg(test)]
 mod contextual_source_tests;
 pub(crate) mod creation;
+mod form_session;
 pub(crate) mod scenario;
+// Projection acceptance precedes the coordinated scenario renderer integration.
+#[cfg(test)]
+mod scenario_lifecycle;
 pub(crate) mod source_draft;
 pub(crate) mod state_canvas;
 pub(crate) mod state_edit;
@@ -36,6 +41,7 @@ mod scenario_scroll {
    pub(super) fn observe<'a, R: renderer::Renderer + 'a>(
        context: scenario::Context,
        area: scenario::ScrollArea,
+        process: bool,
        restore: Option<scenario::ScrollRestore>,
        content: impl Into<Element<'a, Message, Theme, R>>,
    ) -> Element<'a, Message, Theme, R> {
@@ -43,28 +49,10 @@ mod scenario_scroll {
            content: content.into(),
            context,
            area,
-            process: false,
+            process,
            restore,
        })
    }
-    pub(super) fn observe_topology<'a>(
-        context: topology::Context,
-        area: scenario::ScrollArea,
-        content: impl Into<Element<'a, Message>>,
-    ) -> Element<'a, Message> {
-        Element::new(Observer {
-            content: content.into(),
-            context: scenario::Context {
-                document: context.document,
-                scenario: context.owner,
-                revision: context.revision,
-                epoch: context.epoch,
-            },
-            area,
-            process: true,
-            restore: None,
-        })
-    }
    struct Observer<'a, R = Renderer> {
        content: Element<'a, Message, Theme, R>,
        context: scenario::Context,
@@ -335,7 +323,7 @@ mod scenario_scroll {
        fn observer(height: f32, context: scenario::Context) -> Observer<'static, ()> {
            Observer {
                context,
-                area: scenario::ScrollArea::Canvas,
+                area: scenario::ScrollArea::Page,
                process: false,
                restore: None,
                content: scrollable(iced::widget::Space::new().width(200.).height(height))
@@ -405,7 +393,7 @@ mod scenario_scroll {
                    std::time::Instant::now(),
                ))
            };
-            for area in [ScrollArea::Canvas, ScrollArea::Page] {
+            for area in [ScrollArea::Page] {
                for returned_height in [600., 250.] {
                    let (project, [a, _, _], [use_id, _, _]) = navigation_fixture();
                    let mut app = App::with_project(project.clone());
@@ -1154,6 +1142,7 @@ struct Scene {
    selected: Id,
    scale: f32,
    scroll_offset: iced::Vector,
+    camera_pan: iced::Vector,
    interaction: Option<(scenario::Context, scenario::CanvasTool, bool)>,
    pending_placement: Option<(scenario::Slot, Option<Id>)>,
    lanes: BTreeMap<Id, f32>,
@@ -1208,6 +1197,7 @@ impl Scene {
        let mut scene = Self {
            scale: 1.,
            scroll_offset: iced::Vector::ZERO,
+            camera_pan: iced::Vector::ZERO,
            boxes: vec![],
            lines: vec![],
            size: Size::new(700., 200.),
@@ -1870,9 +1860,12 @@ impl canvas::Program<Message> for Scene {
            }
            _ => cursor,
        };
-        let world = cursor
-            .position_in(bounds)
-            .map(|p| Point::new(p.x / self.scale, p.y / self.scale));
+        let world = cursor.position_in(bounds).map(|p| {
+            Point::new(
+                (p.x - self.camera_pan.x) / self.scale,
+                (p.y - self.camera_pan.y) / self.scale,
+            )
+        });
        match event {
            canvas::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
                if !visible {
@@ -1899,7 +1892,7 @@ impl canvas::Program<Message> for Scene {
                        return Some(Action::request_redraw().and_capture());
                    }
                    if let CanvasTool::Add(tool) = tool {
-                        if !tool.canvas_occurrence() {
+                        if !tool.canvas_occurrence() && tool != scenario::Tool::Lifeline {
                            return None;
                        }
                        state.press = Some(SequencePress::Occurrence {
@@ -1909,10 +1902,18 @@ impl canvas::Program<Message> for Scene {
                        });
                        return Some(Action::request_redraw().and_capture());
                    }
-                    if self.reorder_handle().is_some_and(|r| r.contains(point)) {
+                    if let Some(occurrence) = self
+                        .hit(point)
+                        .filter(|id| self.rows.contains_key(id))
+                        .or_else(|| {
+                            self.reorder_handle()
+                                .filter(|r| r.contains(point))
+                                .map(|_| self.selected)
+                        })
+                    {
                        state.press = Some(SequencePress::Reorder {
-                            occurrence: self.selected,
-                            parent: self.rows[&self.selected].0,
+                            occurrence,
+                            parent: self.rows[&occurrence].0,
                            start: cursor.position()? - self.scroll_offset,
                            moved: false,
                        });
@@ -1987,6 +1988,18 @@ impl canvas::Program<Message> for Scene {
                            );
                        }
                    }
+                    SequencePress::Reorder {
+                        occurrence,
+                        moved: false,
+                        ..
+                    } => {
+                        return Some(
+                            Action::publish(Message::ScenarioCanvas(CanvasEvent::Select(
+                                context, occurrence,
+                            )))
+                            .and_capture(),
+                        );
+                    }
                    SequencePress::Reorder {
                        occurrence,
                        parent,
@@ -2024,6 +2037,7 @@ impl canvas::Program<Message> for Scene {
    ) -> Vec<canvas::Geometry> {
        let mut f = Frame::new(renderer, bounds.size());
        f.fill_rectangle(Point::ORIGIN, bounds.size(), Color::WHITE);
+        f.translate(self.camera_pan);
        f.scale(self.scale);
        for b in &self.boxes {
            let outline = matches!(
@@ -2135,9 +2149,12 @@ impl canvas::Program<Message> for Scene {
        }
        if let Some((context, tool, editable)) = self.interaction {
            let active = editable && state.context == Some(context) && state.tool == tool;
-            let point = cursor
-                .position_in(bounds)
-                .map(|p| Point::new(p.x / self.scale, p.y / self.scale));
+            let point = cursor.position_in(bounds).map(|p| {
+                Point::new(
+                    (p.x - self.camera_pan.x) / self.scale,
+                    (p.y - self.camera_pan.y) / self.scale,
+                )
+            });
            let source = active.then_some(state.source).flatten();
            let reorder = active.then_some(state.press).flatten().and_then(|press| {
                if let SequencePress::Reorder { parent, .. } = press {
@@ -2182,6 +2199,18 @@ impl canvas::Program<Message> for Scene {
            } else {
                None
            };
+            if reorder.is_some()
+                && slot.is_none()
+                && let Some(point) = point
+            {
+                f.fill_text(Text {
+                    content: "Other operand: move stays in the current sequence".into(),
+                    position: Point::new(point.x + 8., point.y + 12.),
+                    size: (11. / self.scale).into(),
+                    color: Color::from_rgb(0.75, 0.2, 0.15),
+                    ..Default::default()
+                });
+            }
            if let Some(slot) = slot {
                f.stroke(
                    &Path::line(
@@ -0,0 +1,243 @@
+//! Shared presentation and input contract; contains no model commands.
+use crate::app::{App, Message};
+use iced::widget::{button, column, container, opaque, row, scrollable, stack, text, tooltip};
+use iced::{Element, Length::Fill, Point, Theme, Vector};
+use oa_core::Id;
+mod control;
+mod focus;
+mod viewport;
+pub use control::Control;
+pub use viewport::Viewport;
+
+pub fn keyboard_enabled(app: &crate::app::App) -> bool {
+    !app.busy
+        && !app.hosted.visible
+        && app.workflow.is_none()
+        && app.file_prompt.is_none()
+        && !app.delete_pending
+        && app.pending.is_none()
+        && app.model_menu.is_none()
+        && !app.reference_input_active()
+}
+
+pub fn controls<'a>(
+    scope: Scope,
+    keyboard: bool,
+    scale: f32,
+    details: Message,
+    focus: Option<Message>,
+    zoom: impl Fn(Option<f32>) -> Message,
+    publish: impl Fn(Event) -> Message + Copy + 'a,
+) -> Element<'a, Message> {
+    let control = |name: &'static str, label: &'static str, message: Option<Message>| {
+        let message = message.map(|message| intent(scope, name, message));
+        Control::new(
+            button(text(label).size(12))
+                .padding(6)
+                .on_press_maybe(message.clone()),
+            scope,
+            name,
+            keyboard,
+            message,
+            publish,
+        )
+    };
+    row![
+        control("Details", "Details", Some(details)),
+        tooltip(control("Canvas", "Canvas", focus),
+            container(text("F6: enter/leave canvas controls · Tab: next · Enter/Space: activate · Esc: leave").size(12)).padding(7).style(crate::style::card),
+            tooltip::Position::Bottom),
+        control("Fit", "Fit", Some(zoom(None))),
+        control("ZoomOut", "−", Some(zoom(Some(scale / 1.25)))),
+        text(format!("{:.0}%", scale * 100.)).size(12),
+        control("ZoomIn", "+", Some(zoom(Some(scale * 1.25)))),
+        control("ActualSize", "100%", Some(zoom(Some(1.)))),
+    ].spacing(4).align_y(iced::Center).into()
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Scope {
+    pub document: Id,
+    pub owner: Id,
+    pub revision: u64,
+    pub epoch: u64,
+}
+impl Scope {
+    pub fn current(app: &App) -> Option<Self> {
+        if let Some(context) = app.scenario_context() {
+            Some(Self {
+                document: context.document,
+                owner: context.scenario,
+                revision: context.revision,
+                epoch: app.camera_epoch,
+            })
+        } else {
+            let context = app.topology_context()?;
+            Some(Self {
+                document: context.document,
+                owner: context.owner,
+                revision: context.revision,
+                epoch: app.camera_epoch,
+            })
+        }
+    }
+    pub fn input_owner(app: &App) -> Option<Self> {
+        if keyboard_enabled(app)
+            && !app.behavior.has_pending()
+            && !app.draft_dirty()
+            && !app.source_dirty()
+        {
+            Self::current(app)
+        } else {
+            None
+        }
+    }
+
+    pub fn control_id(self, name: &str) -> iced::advanced::widget::Id {
+        iced::advanced::widget::Id::from(format!(
+            "behavior-control:{}:{}:{}:{name}",
+            self.document, self.owner, self.revision
+        ))
+    }
+}
+/// Only a live presentation intent may carry a toolbar action across its own pan.
+#[derive(Debug, Clone)]
+pub struct Intent {
+    pub scope: Scope,
+    pub name: &'static str,
+    pub message: Box<Message>,
+}
+pub fn intent(scope: Scope, name: &'static str, message: Message) -> Message {
+    Message::BehaviorControl(Intent {
+        scope,
+        name,
+        message: Box::new(message),
+    })
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum Event {
+    CancelGesture,
+    Pan(Vector),
+    Zoom { factor: f32, at: Point, base: f32 },
+    Focus,
+    Traverse(bool),
+    ControlFocus(&'static str),
+    ToggleFocus,
+    Leave,
+}
+
+pub use focus::{focus_task, root as focus_root};
+/// Fold relative input in event order. The base scale is used only on leaving Fit.
+pub fn change(pan: &mut Vector, zoom: &mut Option<f32>, fit: &mut bool, event: Event) -> bool {
+    match event {
+        Event::Pan(delta) if delta.x.is_finite() && delta.y.is_finite() => {
+            let next = *pan + delta;
+            if next.x.is_finite() && next.y.is_finite() && next != *pan {
+                *pan = next;
+                true
+            } else {
+                false
+            }
+        }
+        Event::Zoom { factor, at, base }
+            if factor.is_finite()
+                && factor > 0.
+                && base.is_finite()
+                && base > 0.
+                && at.x.is_finite()
+                && at.y.is_finite() =>
+        {
+            let old = if *fit { base } else { zoom.unwrap_or(base) };
+            let next = (old * factor).clamp(0.05, 3.);
+            if old == next {
+                return false;
+            }
+            let anchor = Vector::new(at.x, at.y);
+            let next_pan = anchor - (anchor - *pan) * (next / old);
+            if !next_pan.x.is_finite() || !next_pan.y.is_finite() {
+                return false;
+            }
+            *pan = next_pan;
+            *zoom = Some(next);
+            *fit = false;
+            true
+        }
+        _ => false,
+    }
+}
+
+/// Constant-width labelled palette. Arming a tool never reallocates the canvas.
+pub fn palette<'a>(
+    scope: Scope,
+    keyboard: bool,
+    publish: impl Fn(Event) -> Message + Copy + 'a,
+    entries: impl IntoIterator<Item = (&'static str, &'static str, bool, Option<Message>)>,
+) -> Element<'a, Message> {
+    let mut tools = column![].spacing(3);
+    for (glyph, label, selected, message) in entries {
+        let message = message.map(|message| intent(scope, glyph, message));
+        tools = tools.push(tooltip(
+            container(Control::new(
+                button(text(glyph).size(12))
+                    .width(34)
+                    .height(30)
+                    .padding(3)
+                    .style(if selected {
+                        button::primary
+                    } else {
+                        crate::style::nav
+                    })
+                    .on_press_maybe(message.clone()),
+                scope,
+                glyph,
+                keyboard,
+                message,
+                publish,
+            ))
+            .id(format!("behavior-tool:{glyph}")),
+            container(text(label).size(12))
+                .padding(7)
+                .style(crate::style::card),
+            tooltip::Position::Left,
+        ));
+    }
+    container(scrollable(tools).id(scope.control_id("palette-scroll")))
+        .width(40)
+        .height(Fill)
+        .padding(3)
+        .style(crate::style::panel)
+        .into()
+}
+
+/// Header and palette are permanent. Details/editors overlay the same viewport.
+pub fn host<'a, Message: 'a, R: iced::advanced::text::Renderer + 'a>(
+    header: Element<'a, Message, Theme, R>,
+    palette: Element<'a, Message, Theme, R>,
+    canvas: Element<'a, Message, Theme, R>,
+    editor: Option<Element<'a, Message, Theme, R>>,
+) -> Element<'a, Message, Theme, R> {
+    let mut body = stack![canvas];
+    if let Some(editor) = editor {
+        body = body.push(
+            container(opaque(
+                container(editor)
+                    .width(300)
+                    .height(Fill)
+                    .style(crate::style::card),
+            ))
+            .align_right(Fill)
+            .height(Fill)
+            .padding(8),
+        );
+    }
+    column![header, row![body, palette].height(Fill)]
+        .spacing(6)
+        .padding(8)
+        .width(Fill)
+        .height(Fill)
+        .into()
+}
+
+#[cfg(test)]
+pub(crate) mod tests;
@@ -0,0 +1,258 @@
+//! A real focusable keyboard target around the existing styled pointer button.
+use super::{Event as CameraEvent, Scope, focus::Member};
+use iced::advanced::{
+    Clipboard, Layout, Shell, Widget, layout, overlay, renderer,
+    widget::{Operation, Tree, operation, tree},
+};
+use iced::{Border, Element, Event, Length, Rectangle, Size, Theme, Vector, keyboard, mouse};
+
+#[derive(Default)]
+struct Input {
+    identity: Option<iced::advanced::widget::Id>,
+    focused: bool,
+}
+impl operation::Focusable for Input {
+    fn is_focused(&self) -> bool {
+        self.focused
+    }
+    fn focus(&mut self) {
+        self.focused = true;
+    }
+    fn unfocus(&mut self) {
+        self.focused = false;
+    }
+}
+pub struct Control<'a, Message, R = iced::Renderer>
+where
+    R: renderer::Renderer,
+{
+    content: Element<'a, Message, Theme, R>,
+    scope: Scope,
+    name: &'static str,
+    enabled: bool,
+    activate: Option<Message>,
+    publish: Box<dyn Fn(CameraEvent) -> Message + 'a>,
+}
+impl<'a, Message, R: renderer::Renderer> Control<'a, Message, R> {
+    pub fn new(
+        content: impl Into<Element<'a, Message, Theme, R>>,
+        scope: Scope,
+        name: &'static str,
+        enabled: bool,
+        activate: Option<Message>,
+        publish: impl Fn(CameraEvent) -> Message + 'a,
+    ) -> Self {
+        Self {
+            content: content.into(),
+            scope,
+            name,
+            enabled: enabled && activate.is_some(),
+            activate,
+            publish: Box::new(publish),
+        }
+    }
+}
+impl<Message: Clone, R: renderer::Renderer> Widget<Message, Theme, R> for Control<'_, Message, R> {
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<Input>()
+    }
+    fn state(&self) -> tree::State {
+        tree::State::new(Input {
+            identity: Some(self.scope.control_id(self.name)),
+            focused: false,
+        })
+    }
+    fn children(&self) -> Vec<Tree> {
+        vec![Tree::new(self.content.as_widget())]
+    }
+    fn diff(&self, tree: &mut Tree) {
+        let state = tree.state.downcast_mut::<Input>();
+        let identity = self.scope.control_id(self.name);
+        if state.identity.as_ref() != Some(&identity) || !self.enabled {
+            *state = Input {
+                identity: Some(identity),
+                focused: false,
+            };
+        }
+        tree.diff_children(std::slice::from_ref(&self.content));
+    }
+    fn size(&self) -> Size<Length> {
+        self.content.as_widget().size()
+    }
+    fn layout(&mut self, tree: &mut Tree, renderer: &R, limits: &layout::Limits) -> layout::Node {
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+    fn operate(
+        &mut self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn Operation,
+    ) {
+        let id = self.scope.control_id(self.name);
+        operation.container(Some(&id), layout.bounds());
+        if self.enabled {
+            operation.custom(Some(&id), layout.bounds(), &mut Member(self.scope));
+            operation.focusable(
+                Some(&id),
+                layout.bounds(),
+                tree.state.downcast_mut::<Input>(),
+            );
+        }
+        operation.traverse(&mut |operation| {
+            self.content.as_widget_mut().operate(
+                &mut tree.children[0],
+                layout,
+                renderer,
+                operation,
+            );
+        });
+    }
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        if shell.is_event_captured() {
+            return;
+        }
+        let state = tree.state.downcast_mut::<Input>();
+        if self.enabled {
+            if let Event::Keyboard(keyboard::Event::KeyPressed {
+                key,
+                modifiers,
+                repeat,
+                ..
+            }) = event
+                && state.focused
+            {
+                use keyboard::{Key, key::Named};
+                let action = match key.as_ref() {
+                    Key::Named(Named::Tab) => {
+                        Some((self.publish)(CameraEvent::Traverse(modifiers.shift())))
+                    }
+                    Key::Named(Named::Escape) => Some((self.publish)(CameraEvent::Leave)),
+                    Key::Named(Named::F6) if modifiers.is_empty() && !repeat => {
+                        Some((self.publish)(CameraEvent::ToggleFocus))
+                    }
+                    Key::Named(Named::Enter | Named::Space) if modifiers.is_empty() && !repeat => {
+                        self.activate.clone()
+                    }
+                    _ => None,
+                };
+                if let Some(action) = action {
+                    shell.publish(action);
+                    shell.capture_event();
+                    shell.request_redraw();
+                    return;
+                }
+            }
+            if matches!(
+                event,
+                Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
+            ) {
+                if !layout
+                    .bounds()
+                    .intersection(viewport)
+                    .is_some_and(|bounds| cursor.is_over(bounds))
+                {
+                    state.focused = false;
+                }
+            }
+        }
+        if matches!(event, Event::Window(iced::window::Event::Unfocused)) {
+            state.focused = false;
+        }
+        self.content.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+    }
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            style,
+            layout,
+            cursor,
+            viewport,
+        );
+        if self.enabled && tree.state.downcast_ref::<Input>().focused {
+            renderer.fill_quad(
+                renderer::Quad {
+                    bounds: layout.bounds(),
+                    border: Border {
+                        color: crate::style::INK,
+                        width: 2.,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                iced::Color::TRANSPARENT,
+            );
+        }
+    }
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        self.content.as_widget().mouse_interaction(
+            &tree.children[0],
+            layout,
+            cursor,
+            viewport,
+            renderer,
+        )
+    }
+    fn overlay<'a>(
+        &'a mut self,
+        tree: &'a mut Tree,
+        layout: Layout<'a>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'a, Message, Theme, R>> {
+        self.content.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
+    }
+}
+impl<'a, Message: Clone + 'a, R: renderer::Renderer + 'a> From<Control<'a, Message, R>>
+    for Element<'a, Message, Theme, R>
+{
+    fn from(control: Control<'a, Message, R>) -> Self {
+        Element::new(control)
+    }
+}
@@ -0,0 +1,293 @@
+//! Explicit canvas entry; ordinary initial Tab continues to belong to Inspector.
+use super::{Event, Scope};
+use iced::advanced::widget::{Id, Operation, Tree, operation};
+use iced::advanced::{Clipboard, Layout, Shell, Widget, layout, overlay, renderer};
+use iced::{Element, Event as InputEvent, Length, Rectangle, Size, Theme, Vector, mouse};
+
+pub(super) struct Member(pub Scope);
+
+pub fn focus_task<Message: Send + 'static>(scope: Scope, event: Event) -> iced::Task<Message> {
+    iced::advanced::widget::operate(Collect {
+        scope,
+        valid: false,
+        event,
+        members: vec![],
+        focused: None,
+        palette: None,
+    })
+}
+struct Collect {
+    scope: Scope,
+    valid: bool,
+    event: Event,
+    members: Vec<(Id, Rectangle)>,
+    focused: Option<usize>,
+    palette: Option<(Rectangle, Rectangle)>,
+}
+impl<T: Send + 'static> Operation<T> for Collect {
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation<T>)) {
+        visit(self);
+    }
+    fn custom(&mut self, id: Option<&Id>, bounds: Rectangle, value: &mut dyn std::any::Any) {
+        if let Some(owner) = value.downcast_ref::<Owner>() {
+            self.valid = owner.0 == Some(self.scope);
+        }
+        if self.valid
+            && value
+                .downcast_ref::<Member>()
+                .is_some_and(|m| m.0 == self.scope)
+            && let Some(id) = id
+        {
+            self.members.push((id.clone(), bounds));
+        }
+    }
+    fn focusable(&mut self, id: Option<&Id>, _: Rectangle, value: &mut dyn operation::Focusable) {
+        if value.is_focused() {
+            self.focused = self
+                .members
+                .iter()
+                .position(|(member, _)| Some(member) == id)
+                .or(self.focused);
+        }
+    }
+    fn scrollable(
+        &mut self,
+        id: Option<&Id>,
+        bounds: Rectangle,
+        content: Rectangle,
+        _: Vector,
+        _: &mut dyn operation::Scrollable,
+    ) {
+        if id == Some(&self.scope.control_id("palette-scroll")) {
+            self.palette = Some((bounds, content));
+        }
+    }
+    fn finish(&self) -> operation::Outcome<T> {
+        let canvas = self.scope.control_id("viewport");
+        // An enabled viewport witnesses the live lifetime. Hidden/dirty/modal
+        // owners expose no members; a delayed request cannot clear their focus.
+        if !self.valid || !self.members.iter().any(|(id, _)| *id == canvas) {
+            return operation::Outcome::None;
+        }
+        let target = match self.event {
+            Event::Focus => Some(canvas),
+            Event::ControlFocus(name) => Some(self.scope.control_id(name)),
+            Event::ToggleFocus if self.focused.is_none() => Some(canvas),
+            Event::ToggleFocus | Event::Leave if self.focused.is_some() => None,
+            Event::Traverse(back) => {
+                let Some(current) = self.focused else {
+                    return operation::Outcome::None;
+                };
+                let next = if back {
+                    (current + self.members.len() - 1) % self.members.len()
+                } else {
+                    (current + 1) % self.members.len()
+                };
+                Some(self.members[next].0.clone())
+            }
+            _ => return operation::Outcome::None,
+        };
+        if target
+            .as_ref()
+            .is_some_and(|target| !self.members.iter().any(|(id, _)| id == target))
+        {
+            return operation::Outcome::None;
+        }
+        let reveal = target.as_ref().and_then(|target| {
+            let (_, field) = self.members.iter().find(|(id, _)| id == target)?;
+            let (bounds, content) = self.palette?;
+            // Only the palette has member controls inside this scrollable.
+            (field.x >= bounds.x && field.x < bounds.x + bounds.width).then(|| {
+                (field.center_y() - bounds.y - bounds.height / 2.)
+                    .clamp(0., (content.height - bounds.height).max(0.))
+            })
+        });
+        operation::Outcome::Chain(Box::new(Apply {
+            scope: self.scope,
+            valid: false,
+            target,
+            members: self.members.iter().map(|(id, _)| id.clone()).collect(),
+            palette: self.scope.control_id("palette-scroll"),
+            reveal,
+        }))
+    }
+}
+struct Apply {
+    scope: Scope,
+    valid: bool,
+    target: Option<Id>,
+    members: Vec<Id>,
+    palette: Id,
+    reveal: Option<f32>,
+}
+impl<T> Operation<T> for Apply {
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation<T>)) {
+        visit(self);
+    }
+    fn custom(&mut self, _: Option<&Id>, _: Rectangle, value: &mut dyn std::any::Any) {
+        if let Some(owner) = value.downcast_ref::<Owner>() {
+            self.valid = owner.0 == Some(self.scope);
+        }
+    }
+    fn focusable(&mut self, id: Option<&Id>, _: Rectangle, state: &mut dyn operation::Focusable) {
+        if !self.valid {
+            return;
+        }
+        if self
+            .target
+            .as_ref()
+            .is_some_and(|target| Some(target) == id)
+        {
+            state.focus();
+        } else if self.target.is_some() || id.is_some_and(|id| self.members.contains(id)) {
+            state.unfocus();
+        }
+    }
+    fn scrollable(
+        &mut self,
+        id: Option<&Id>,
+        _: Rectangle,
+        _: Rectangle,
+        _: Vector,
+        state: &mut dyn operation::Scrollable,
+    ) {
+        if self.valid
+            && id == Some(&self.palette)
+            && let Some(y) = self.reveal
+        {
+            state.scroll_to(operation::scrollable::AbsoluteOffset {
+                x: None,
+                y: Some(y),
+            });
+        }
+    }
+}
+
+// Every Collect/Apply pass observes current ownership before touching any field.
+struct Owner(Option<Scope>);
+
+struct Root<'a, Message, R: renderer::Renderer> {
+    owner: Option<Scope>,
+    content: Element<'a, Message, Theme, R>,
+}
+
+pub fn root<'a, Message: 'a, R: renderer::Renderer + 'a>(
+    content: impl Into<Element<'a, Message, Theme, R>>,
+    owner: Option<Scope>,
+) -> Element<'a, Message, Theme, R> {
+    Element::new(Root {
+        owner,
+        content: content.into(),
+    })
+}
+
+impl<Message, R: renderer::Renderer> Widget<Message, Theme, R> for Root<'_, Message, R> {
+    fn children(&self) -> Vec<Tree> {
+        vec![Tree::new(self.content.as_widget())]
+    }
+
+    fn diff(&self, tree: &mut Tree) {
+        tree.diff_children(std::slice::from_ref(&self.content));
+    }
+
+    fn size(&self) -> Size<Length> {
+        self.content.as_widget().size()
+    }
+
+    fn layout(&mut self, tree: &mut Tree, renderer: &R, limits: &layout::Limits) -> layout::Node {
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+
+    fn operate(
+        &mut self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn Operation,
+    ) {
+        operation.custom(None, layout.bounds(), &mut Owner(self.owner));
+        self.content
+            .as_widget_mut()
+            .operate(&mut tree.children[0], layout, renderer, operation);
+    }
+
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &InputEvent,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+    }
+
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            style,
+            layout,
+            cursor,
+            viewport,
+        );
+    }
+
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        self.content.as_widget().mouse_interaction(
+            &tree.children[0],
+            layout,
+            cursor,
+            viewport,
+            renderer,
+        )
+    }
+
+    fn overlay<'b>(
+        &'b mut self,
+        tree: &'b mut Tree,
+        layout: Layout<'b>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'b, Message, Theme, R>> {
+        self.content.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
+    }
+}
@@ -0,0 +1,753 @@
+use super::*;
+use crate::app::{App, Message};
+use iced::advanced::{Layout, Shell, layout, widget};
+use iced::futures::{
+    StreamExt,
+    stream::{BoxStream, SelectAll},
+};
+use iced::{Rectangle, Size, mouse};
+use iced_runtime::{
+    Action,
+    user_interface::{Cache, UserInterface},
+};
+use std::collections::HashMap;
+
+type Pending = SelectAll<BoxStream<'static, Action<Message>>>;
+
+// iced_winit drains messages while collecting immediately ready actions. A
+// pending Task stream survives until its widget operation sends its result.
+fn enqueue(task: iced::Task<Message>, ready: &mut Vec<Action<Message>>, pending: &mut Pending) {
+    if let Some(mut stream) = iced_runtime::task::into_stream(task) {
+        let waker = iced::futures::task::noop_waker();
+        let mut context = std::task::Context::from_waker(&waker);
+        loop {
+            match stream.poll_next_unpin(&mut context) {
+                std::task::Poll::Ready(Some(action)) => ready.push(action),
+                std::task::Poll::Ready(None) => break,
+                std::task::Poll::Pending => {
+                    pending.push(stream);
+                    break;
+                }
+            }
+        }
+    }
+}
+
+#[derive(Default)]
+pub(crate) struct Geometry {
+    pub containers: HashMap<widget::Id, Rectangle>,
+    pub focused: Vec<(Option<widget::Id>, Rectangle, bool)>,
+    pub text_inputs: Vec<Rectangle>,
+    pub scrolls: HashMap<widget::Id, (Rectangle, Vector)>,
+}
+impl widget::Operation for Geometry {
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn widget::Operation)) {
+        visit(self);
+    }
+    fn focusable(
+        &mut self,
+        id: Option<&widget::Id>,
+        bounds: Rectangle,
+        state: &mut dyn widget::operation::Focusable,
+    ) {
+        self.focused.push((id.cloned(), bounds, state.is_focused()));
+    }
+    fn text_input(
+        &mut self,
+        _: Option<&widget::Id>,
+        bounds: Rectangle,
+        _: &mut dyn widget::operation::TextInput,
+    ) {
+        self.text_inputs.push(bounds);
+    }
+    fn container(&mut self, id: Option<&widget::Id>, bounds: Rectangle) {
+        if let Some(id) = id {
+            self.containers.insert(id.clone(), bounds);
+        }
+    }
+    fn scrollable(
+        &mut self,
+        id: Option<&widget::Id>,
+        bounds: Rectangle,
+        _: Rectangle,
+        offset: Vector,
+        _: &mut dyn widget::operation::Scrollable,
+    ) {
+        if let Some(id) = id {
+            self.scrolls.insert(id.clone(), (bounds, offset));
+        }
+    }
+}
+impl Geometry {
+    pub fn bounds(&self, id: &str) -> Rectangle {
+        self.containers[&widget::Id::from(id.to_owned())]
+    }
+}
+
+/// Mount the actual App root, production widgets and renderer. Events are
+/// delivered in order with Iced's final-batch cursor, then fed through App::update.
+/// This deliberately does not seed any private canvas gesture state.
+pub(crate) struct Mounted {
+    pub renderer: iced::Renderer,
+    cache: Cache,
+    pub operations: usize,
+}
+impl Mounted {
+    pub async fn new(app: &mut App) -> Self {
+        use iced::advanced::renderer::Headless;
+        let renderer = <iced::Renderer as Headless>::new(iced::Font::DEFAULT, 16.into(), None)
+            .await
+            .expect("production mounted tests require the supported WGPU headless renderer");
+        let mut mounted = Self {
+            renderer,
+            cache: Cache::new(),
+            operations: 0,
+        };
+        mounted.settle(app).await;
+        mounted
+    }
+    pub fn geometry(&mut self, app: &App) -> Geometry {
+        let mut geometry = Geometry::default();
+        self.operate(app, &mut geometry);
+        geometry
+    }
+    /// One operation pass, including every nested overlay, via installed Iced.
+    pub fn operate(&mut self, app: &App, operation: &mut dyn widget::Operation) {
+        let mut ui = UserInterface::build(
+            app.view(),
+            app.window_size,
+            std::mem::take(&mut self.cache),
+            &mut self.renderer,
+        );
+        ui.operate(&self.renderer, operation);
+        self.cache = ui.into_cache();
+    }
+    pub async fn settle(&mut self, app: &mut App) {
+        for _ in 0..3 {
+            self.batch(
+                app,
+                &[iced::Event::Window(iced::window::Event::RedrawRequested(
+                    std::time::Instant::now(),
+                ))],
+                mouse::Cursor::Unavailable,
+            )
+            .await;
+        }
+    }
+    pub async fn batch(
+        &mut self,
+        app: &mut App,
+        events: &[iced::Event],
+        cursor: mouse::Cursor,
+    ) -> Vec<Message> {
+        let messages = self.input(app, events, cursor);
+        let mut ready = vec![];
+        let mut pending = Pending::new();
+        for message in messages.iter().cloned() {
+            enqueue(app.update(message), &mut ready, &mut pending);
+        }
+        self.drain(app, ready, pending).await;
+        messages
+    }
+    pub fn input(
+        &mut self,
+        app: &App,
+        events: &[iced::Event],
+        cursor: mouse::Cursor,
+    ) -> Vec<Message> {
+        let mut messages = vec![];
+        let mut ui = UserInterface::build(
+            app.view(),
+            app.window_size,
+            std::mem::take(&mut self.cache),
+            &mut self.renderer,
+        );
+        let _ = ui.update(
+            events,
+            cursor,
+            &mut self.renderer,
+            &mut iced::advanced::clipboard::Null,
+            &mut messages,
+        );
+        self.cache = ui.into_cache();
+        messages
+    }
+    pub async fn perform(&mut self, app: &mut App, task: iced::Task<Message>) {
+        let mut ready = vec![];
+        let mut pending = Pending::new();
+        enqueue(task, &mut ready, &mut pending);
+        self.drain(app, ready, pending).await;
+    }
+    async fn drain(
+        &mut self,
+        app: &mut App,
+        mut ready: Vec<Action<Message>>,
+        mut pending: Pending,
+    ) {
+        loop {
+            let mut outputs = vec![];
+            if !ready.is_empty() {
+                // Build only after all App messages in this cycle have run.
+                let mut ui = UserInterface::build(
+                    app.view(),
+                    app.window_size,
+                    std::mem::take(&mut self.cache),
+                    &mut self.renderer,
+                );
+                for action in ready.drain(..) {
+                    match action {
+                        Action::Output(message) => outputs.push(message),
+                        Action::Widget(mut operation) => {
+                            self.operations += 1;
+                            loop {
+                                ui.operate(&self.renderer, &mut *operation);
+                                match operation.finish() {
+                                    widget::operation::Outcome::Chain(next) => operation = next,
+                                    widget::operation::Outcome::None
+                                    | widget::operation::Outcome::Some(()) => break,
+                                }
+                            }
+                        }
+                        action => {
+                            panic!("Unexpected native action in mounted App harness: {action:?}")
+                        }
+                    }
+                }
+                self.cache = ui.into_cache();
+            }
+            for message in outputs {
+                enqueue(app.update(message), &mut ready, &mut pending);
+            }
+            if !ready.is_empty() {
+                continue;
+            }
+            let Some(action) = pending.next().await else {
+                break;
+            };
+            ready.push(action);
+            let waker = iced::futures::task::noop_waker();
+            let mut context = std::task::Context::from_waker(&waker);
+            while let std::task::Poll::Ready(Some(action)) = pending.poll_next_unpin(&mut context) {
+                ready.push(action);
+            }
+        }
+    }
+    pub fn pixels(&mut self, app: &App) -> Vec<u8> {
+        use iced::advanced::renderer::Headless;
+        let mut ui = UserInterface::build(
+            app.view(),
+            app.window_size,
+            std::mem::take(&mut self.cache),
+            &mut self.renderer,
+        );
+        // update initializes the nested overlay layout used by draw.
+        let mut messages = vec![];
+        let _ = ui.update(
+            &[],
+            mouse::Cursor::Unavailable,
+            &mut self.renderer,
+            &mut iced::advanced::clipboard::Null,
+            &mut messages,
+        );
+        assert!(
+            messages.is_empty(),
+            "An empty draw preparation must not drop App messages"
+        );
+        ui.draw(
+            &mut self.renderer,
+            &crate::style::theme(),
+            &iced::advanced::renderer::Style {
+                text_color: crate::style::INK,
+            },
+            mouse::Cursor::Unavailable,
+        );
+        self.cache = ui.into_cache();
+        self.renderer.screenshot(
+            Size::new(app.window_size.width as u32, app.window_size.height as u32),
+            1.,
+            crate::style::BG,
+        )
+    }
+    pub async fn click(&mut self, app: &mut App, point: Point) -> Vec<Message> {
+        self.batch(
+            app,
+            &[
+                iced::Event::Mouse(mouse::Event::CursorMoved { position: point }),
+                iced::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+                iced::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
+            ],
+            mouse::Cursor::Available(point),
+        )
+        .await
+    }
+    pub async fn pan(&mut self, app: &mut App, start: Point, end: Point) -> Vec<Message> {
+        self.batch(
+            app,
+            &[
+                iced::Event::Mouse(mouse::Event::CursorMoved { position: start }),
+                iced::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Middle)),
+                iced::Event::Mouse(mouse::Event::CursorMoved { position: end }),
+                iced::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Middle)),
+            ],
+            mouse::Cursor::Available(end),
+        )
+        .await
+    }
+    pub fn scroll(&mut self, app: &App, id: &str, offset: f32) {
+        let mut operation = widget::operation::scrollable::scroll_to::<()>(
+            widget::Id::from(id.to_owned()),
+            widget::operation::scrollable::AbsoluteOffset {
+                x: None,
+                y: Some(offset),
+            },
+        );
+        self.operate(app, &mut operation);
+    }
+}
+
+pub(crate) fn key(named: iced::keyboard::key::Named) -> iced::Event {
+    use iced::keyboard::{self, Key};
+    iced::Event::Keyboard(keyboard::Event::KeyPressed {
+        key: Key::Named(named),
+        modified_key: Key::Named(named),
+        physical_key: keyboard::key::Physical::Unidentified(
+            keyboard::key::NativeCode::Unidentified,
+        ),
+        location: keyboard::Location::Standard,
+        modifiers: keyboard::Modifiers::empty(),
+        text: None,
+        repeat: false,
+    })
+}
+
+#[test]
+fn relative_camera_zoom_keeps_the_cursor_world_point_and_rejects_nonfinite_inputs() {
+    for scale in [0.05, 0.5, 1., 2.] {
+        let mut pan = Vector::new(-130., 75.);
+        let mut zoom = Some(scale);
+        let mut fit = false;
+        let at = Point::new(171., 93.);
+        let world = (at - Point::ORIGIN - pan) / scale;
+        change(
+            &mut pan,
+            &mut zoom,
+            &mut fit,
+            Event::Zoom {
+                factor: 1.25,
+                at,
+                base: scale,
+            },
+        );
+        let after = (at - Point::ORIGIN - pan) / zoom.unwrap();
+        assert!((after.x - world.x).abs() < 0.001 && (after.y - world.y).abs() < 0.001);
+        let before = (pan, zoom, fit);
+        for input in [
+            Event::Pan(Vector::new(f32::INFINITY, 0.)),
+            Event::Zoom {
+                factor: f32::NAN,
+                at,
+                base: scale,
+            },
+            Event::Zoom {
+                factor: 0.,
+                at,
+                base: scale,
+            },
+        ] {
+            assert!(!change(&mut pan, &mut zoom, &mut fit, input));
+            assert_eq!((pan, zoom, fit), before);
+        }
+    }
+}
+
+#[test]
+fn viewport_ordered_batch_uses_each_event_position_and_cancels_before_camera_motion() {
+    use iced::widget::Space;
+    let scope = Scope {
+        document: Id::new_v4(),
+        owner: Id::new_v4(),
+        revision: 2,
+        epoch: 0,
+    };
+    let mut view: Element<'_, Event, Theme, ()> = Viewport::new(
+        Space::new().width(Fill).height(Fill),
+        scope,
+        1.,
+        true,
+        |e| e,
+    )
+    .into();
+    let mut tree = widget::Tree::new(view.as_widget());
+    let node = view
+        .as_widget_mut()
+        .layout(
+            &mut tree,
+            &(),
+            &layout::Limits::new(Size::ZERO, Size::new(400., 300.)),
+        )
+        .move_to(Point::new(30., 80.));
+    let start = Point::new(90., 160.);
+    let middle = Point::new(125., 175.);
+    let end = Point::new(145., 185.);
+    let mut messages = vec![];
+    for event in [
+        mouse::Event::CursorMoved { position: start },
+        mouse::Event::ButtonPressed(mouse::Button::Middle),
+        mouse::Event::CursorMoved { position: middle },
+        mouse::Event::CursorMoved { position: end },
+        mouse::Event::ButtonReleased(mouse::Button::Middle),
+    ] {
+        view.as_widget_mut().update(
+            &mut tree,
+            &iced::Event::Mouse(event),
+            Layout::new(&node),
+            mouse::Cursor::Available(end),
+            &(),
+            &mut iced::advanced::clipboard::Null,
+            &mut Shell::new(&mut messages),
+            &Rectangle::with_size(Size::new(700., 600.)),
+        );
+    }
+    assert!(matches!(messages.first(), Some(Event::CancelGesture)));
+    let total = messages
+        .iter()
+        .fold(Vector::ZERO, |total, event| match event {
+            Event::Pan(delta) => total + *delta,
+            _ => total,
+        });
+    assert_eq!(total, end - start);
+}
+
+pub(crate) fn scope(app: &App) -> Scope {
+    if let Some(context) = app.scenario_context() {
+        Scope {
+            document: context.document,
+            owner: context.scenario,
+            revision: context.revision,
+            epoch: app.camera_epoch,
+        }
+    } else {
+        let context = app.topology_context().expect("mounted behavior owner");
+        Scope {
+            document: context.document,
+            owner: context.owner,
+            revision: context.revision,
+            epoch: app.camera_epoch,
+        }
+    }
+}
+pub(crate) fn focused(mounted: &mut Mounted, app: &App, name: &str) -> bool {
+    let id = scope(app).control_id(name);
+    mounted
+        .geometry(app)
+        .focused
+        .iter()
+        .any(|(member, _, focused)| member.as_ref() == Some(&id) && *focused)
+}
+pub(crate) async fn tab_to(mounted: &mut Mounted, app: &mut App, name: &str) {
+    for _ in 0..32 {
+        if focused(mounted, app, name) {
+            return;
+        }
+        mounted
+            .batch(
+                app,
+                &[key(iced::keyboard::key::Named::Tab)],
+                mouse::Cursor::Unavailable,
+            )
+            .await;
+    }
+    panic!("Keyboard traversal did not reach {name}");
+}
+pub(crate) fn camera_delta(messages: &[Message]) -> Message {
+    messages.iter().find(|m| matches!(m,
+        Message::ScenarioCanvas(crate::behavior::scenario::CanvasEvent::Camera(_, _, Event::Pan(delta)))
+        | Message::TopologyCanvas(crate::behavior::topology::CanvasEvent::Camera(_, _, Event::Pan(delta))) if *delta != Vector::ZERO
+    )).expect("actual nonzero camera delta from a mounted gesture").clone()
+}
+pub(crate) async fn press_middle(mounted: &mut Mounted, app: &mut App, point: Point) {
+    mounted
+        .batch(
+            app,
+            &[
+                iced::Event::Mouse(mouse::Event::CursorMoved { position: point }),
+                iced::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Middle)),
+            ],
+            mouse::Cursor::Available(point),
+        )
+        .await;
+}
+pub(crate) async fn release_middle(
+    mounted: &mut Mounted,
+    app: &mut App,
+    point: Point,
+) -> Vec<Message> {
+    mounted
+        .batch(
+            app,
+            &[
+                iced::Event::Mouse(mouse::Event::CursorMoved { position: point }),
+                iced::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Middle)),
+            ],
+            mouse::Cursor::Available(point),
+        )
+        .await
+}
+pub(crate) fn assert_drawn_focus(before: &[u8], after: &[u8], size: Size, bounds: Rectangle) {
+    let width = size.width as usize;
+    assert_eq!(before.len(), width * size.height as usize * 4);
+    assert_eq!(after.len(), before.len());
+    let mut changed = 0;
+    for y in bounds.y.ceil() as usize..(bounds.y + bounds.height).floor() as usize {
+        for x in bounds.x.ceil() as usize..(bounds.x + bounds.width).floor() as usize {
+            if x as f32 - bounds.x > 2.
+                && bounds.x + bounds.width - x as f32 > 2.
+                && y as f32 - bounds.y > 2.
+                && bounds.y + bounds.height - y as f32 > 2.
+            {
+                continue;
+            }
+            let start = (y * width + x) * 4;
+            if before[start..start + 3] != after[start..start + 3] {
+                changed += 1;
+            }
+        }
+    }
+    assert!(
+        changed >= bounds.width.min(bounds.height) as usize,
+        "Focus must change visible border pixels, changed={changed}, bounds={bounds:?}"
+    );
+}
+
+pub(crate) fn character(value: &str) -> iced::Event {
+    let mut event = key(iced::keyboard::key::Named::Space);
+    if let iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
+        key,
+        modified_key,
+        text,
+        ..
+    }) = &mut event
+    {
+        *key = iced::keyboard::Key::Character(value.into());
+        *modified_key = key.clone();
+        *text = Some(value.into());
+    }
+    event
+}
+
+/// Inspect the action without stripping the lifetime from retained packets.
+pub(crate) fn intent_action(message: &Message) -> &Message {
+    match message {
+        Message::BehaviorControl(intent) => &intent.message,
+        message => message,
+    }
+}
+
+/// Deliberately retain a returned Chain to test the stronger ownership invariant.
+/// Native Iced runs Chain passes synchronously; this is not a native interleaving.
+pub(crate) async fn retained_focus_apply(
+    mounted: &mut Mounted,
+    app: &mut App,
+) -> Box<dyn widget::Operation> {
+    let entry = mounted.input(
+        app,
+        &[key(iced::keyboard::key::Named::F6)],
+        mouse::Cursor::Unavailable,
+    );
+    assert_eq!(
+        entry.len(),
+        1,
+        "actual initial F6 must emit one canvas focus request"
+    );
+    let mut stream = iced_runtime::task::into_stream(app.update(entry[0].clone()))
+        .expect("F6 returns a widget Task");
+    let Some(Action::Widget(mut operation)) = stream.next().await else {
+        panic!("F6 first action must be Collect");
+    };
+    mounted.operate(app, &mut *operation);
+    match operation.finish() {
+        widget::operation::Outcome::Chain(apply) => apply,
+        _ => panic!("Live Collect must produce its guarded Apply pass"),
+    }
+}
+
+pub(crate) async fn overflow_last_tool(mounted: &mut Mounted, app: &mut App, last: &'static str) {
+    use iced::keyboard::key::Named;
+    let geometry = mounted.geometry(app);
+    let last_bounds = geometry.containers[&scope(app).control_id(last)];
+    let (rail, offset) = geometry.scrolls[&scope(app).control_id("palette-scroll")];
+    assert_eq!(offset.y, 0.);
+    assert!(
+        last_bounds.y >= rail.y + rail.height,
+        "last tool starts fully below the overflowing palette: tool={last_bounds:?}, rail={rail:?}"
+    );
+    mounted
+        .batch(app, &[key(Named::F6)], mouse::Cursor::Unavailable)
+        .await;
+    tab_to(mounted, app, last).await;
+    let geometry = mounted.geometry(app);
+    let mut visible = geometry.containers[&scope(app).control_id(last)];
+    let (rail, offset) = geometry.scrolls[&scope(app).control_id("palette-scroll")];
+    assert!(offset.y > 0., "keyboard traversal must scroll the palette");
+    visible.x -= offset.x;
+    visible.y -= offset.y;
+    assert!(
+        visible.y >= rail.y && visible.y + visible.height <= rail.y + rail.height + 0.5,
+        "the entire last tool is revealed: tool={visible:?}, rail={rail:?}"
+    );
+    let messages = mounted
+        .batch(app, &[key(Named::Enter)], mouse::Cursor::Unavailable)
+        .await;
+    assert!(
+        messages.iter().any(
+            |message| matches!(message, Message::BehaviorControl(intent) if intent.name == last)
+        ),
+        "the revealed last tool is keyboard activated"
+    );
+    assert!(focused(mounted, app, last));
+    let on = mounted.pixels(app);
+    mounted
+        .batch(app, &[key(Named::Escape)], mouse::Cursor::Unavailable)
+        .await;
+    let off = mounted.pixels(app);
+    assert_drawn_focus(&off, &on, app.window_size, visible);
+}
+
+pub(crate) async fn retained_toolbar_boundaries(
+    mounted: &mut Mounted,
+    app: &mut App,
+    tool: &'static str,
+) {
+    use iced::keyboard::key::Named;
+    for boundary in ["Chooser", "Dirty", "Picker"] {
+        let mut packets = vec![];
+        for name in ["Fit", tool, "Details", "Panels", "Canvas"] {
+            packets.push(capture_toolbar(mounted, app, name));
+        }
+        let lifetime = app.camera_epoch;
+        let epoch = app.canvas_epoch;
+        let process = app.behavior.topology.camera_boundary();
+        let scenario = app.behavior.scenario.camera_boundary();
+        match boundary {
+            "Chooser" => {
+                let draft = app.draft.as_ref().unwrap();
+                let id = crate::forms::reference_chooser::trigger::field_id(
+                    draft.reference_generation(),
+                    "/parent",
+                );
+                let bounds = mounted
+                    .geometry(app)
+                    .focused
+                    .iter()
+                    .find(|(field, _, _)| field.as_ref() == Some(&id))
+                    .expect("real Inspector parent reference trigger")
+                    .1;
+                let request = draft.reference_open(app.project(), "/parent", bounds);
+                let task = app.update(Message::FieldReferenceOpen(request));
+                mounted.perform(app, task).await;
+                assert!(app.reference_input_active());
+                mounted
+                    .batch(app, &[key(Named::Escape)], mouse::Cursor::Unavailable)
+                    .await;
+                assert!(!app.reference_input_active());
+            }
+            "Dirty" => {
+                let task = app.update(Message::Field(
+                    "/name".into(),
+                    "Unsaved camera boundary".into(),
+                ));
+                mounted.perform(app, task).await;
+                assert!(app.draft_dirty());
+                // Every retained packet is also rejected while the owner is dirty.
+                for packet in packets.iter().cloned() {
+                    let task = app.update(packet);
+                    mounted.perform(app, task).await;
+                }
+                assert!(app.draft_dirty());
+                let task = app.update(Message::RevertProperties);
+                mounted.perform(app, task).await;
+                assert!(!app.draft_dirty());
+            }
+            "Picker" => {
+                // Public transitions, with cancellation injected at the external
+                // picker boundary. Never poll the native dialog future here.
+                let picker = app.update(Message::Save(true));
+                if cfg!(target_os = "linux") {
+                    assert!(app.file_prompt.is_some());
+                    mounted.perform(app, picker).await;
+                    let task = app.update(Message::CancelFile);
+                    mounted.perform(app, task).await;
+                } else {
+                    assert!(app.busy, "Save As enters the real native-picker busy state");
+                    drop(picker);
+                    for packet in packets.iter().cloned() {
+                        let task = app.update(packet);
+                        mounted.perform(app, task).await;
+                    }
+                    let task = app.update(Message::SavePath(None));
+                    mounted.perform(app, task).await;
+                    assert!(!app.busy);
+                }
+            }
+            _ => unreachable!(),
+        }
+        assert_ne!(
+            app.camera_epoch, lifetime,
+            "{boundary} changes the presentation lifetime"
+        );
+        assert_eq!(
+            app.canvas_epoch, epoch,
+            "{boundary} cycle leaves semantic context unchanged"
+        );
+        let focus_before = mounted
+            .geometry(app)
+            .focused
+            .into_iter()
+            .filter(|(_, _, value)| *value)
+            .collect::<Vec<_>>();
+        let current_lifetime = app.camera_epoch;
+        for packet in packets {
+            let task = app.update(packet);
+            mounted.perform(app, task).await;
+        }
+        assert_eq!(
+            app.camera_epoch, current_lifetime,
+            "{boundary} retained intents cannot start a new lifetime"
+        );
+        assert!(
+            app.behavior.topology.camera_boundary() == process,
+            "{boundary} retained toolbar packet changed process presentation"
+        );
+        assert!(
+            app.behavior.scenario.camera_boundary() == scenario,
+            "{boundary} retained toolbar packet changed scenario presentation"
+        );
+        assert_eq!(
+            mounted
+                .geometry(app)
+                .focused
+                .into_iter()
+                .filter(|(_, _, value)| *value)
+                .collect::<Vec<_>>(),
+            focus_before,
+            "{boundary} retained toolbar packet stole field focus"
+        );
+    }
+}
+
+pub(crate) fn capture_toolbar(mounted: &mut Mounted, app: &App, name: &'static str) -> Message {
+    let point = mounted.geometry(app).containers[&scope(app).control_id(name)].center();
+    mounted
+        .input(
+            app,
+            &[
+                iced::Event::Mouse(mouse::Event::CursorMoved { position: point }),
+                iced::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+                iced::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
+            ],
+            mouse::Cursor::Available(point),
+        )
+        .into_iter()
+        .find(|message| matches!(message, Message::BehaviorControl(intent) if intent.name == name))
+        .expect("actual production toolbar packet")
+}
@@ -0,0 +1,426 @@
+use super::{Event as CameraEvent, Scope};
+use iced::advanced::{
+    Clipboard, Layout, Shell, Widget, layout, overlay, renderer,
+    widget::{Operation, Tree, operation, tree},
+};
+use iced::{Border, Element, Event, Length, Point, Rectangle, Size, Theme, Vector};
+use iced::{keyboard, mouse};
+
+#[derive(Default)]
+struct Input {
+    scope: Option<Scope>,
+    focused: bool,
+    pointer: Option<Point>,
+    pan: Option<(mouse::Button, Point)>,
+    space: bool,
+    bounds: Option<Rectangle>,
+}
+impl operation::Focusable for Input {
+    fn is_focused(&self) -> bool {
+        self.focused
+    }
+    fn focus(&mut self) {
+        self.focused = true;
+    }
+    fn unfocus(&mut self) {
+        self.focused = false;
+        self.pan = None;
+        self.space = false;
+    }
+}
+pub struct Viewport<'a, Message, R = iced::Renderer>
+where
+    R: renderer::Renderer,
+{
+    content: Element<'a, Message, Theme, R>,
+    scope: Scope,
+    scale: f32,
+    keyboard: bool,
+    blank_pan: bool,
+    publish: Box<dyn Fn(CameraEvent) -> Message + 'a>,
+}
+impl<'a, Message, R: renderer::Renderer> Viewport<'a, Message, R> {
+    pub fn new(
+        content: impl Into<Element<'a, Message, Theme, R>>,
+        scope: Scope,
+        scale: f32,
+        keyboard: bool,
+        publish: impl Fn(CameraEvent) -> Message + 'a,
+    ) -> Self {
+        Self {
+            content: content.into(),
+            scope,
+            scale,
+            keyboard,
+            blank_pan: false,
+            publish: Box::new(publish),
+        }
+    }
+    pub fn pan_background(mut self, enabled: bool) -> Self {
+        self.blank_pan = enabled;
+        self
+    }
+}
+impl<Message, R: renderer::Renderer> Widget<Message, Theme, R> for Viewport<'_, Message, R> {
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<Input>()
+    }
+    fn state(&self) -> tree::State {
+        tree::State::new(Input {
+            scope: Some(self.scope),
+            ..Default::default()
+        })
+    }
+    fn children(&self) -> Vec<Tree> {
+        vec![Tree::new(self.content.as_widget())]
+    }
+    fn diff(&self, tree: &mut Tree) {
+        let state = tree.state.downcast_mut::<Input>();
+        if state.scope.is_none_or(|s| {
+            (s.document, s.owner, s.revision)
+                != (self.scope.document, self.scope.owner, self.scope.revision)
+        }) {
+            *state = Input::default();
+        }
+        if state
+            .scope
+            .is_some_and(|scope| scope.epoch != self.scope.epoch)
+            || !self.keyboard
+        {
+            state.pan = None;
+            state.space = false;
+        }
+        if !self.keyboard {
+            state.focused = false;
+        }
+        state.scope = Some(self.scope);
+        tree.diff_children(std::slice::from_ref(&self.content));
+    }
+    fn size(&self) -> Size<Length> {
+        Size::new(Length::Fill, Length::Fill)
+    }
+    fn layout(&mut self, tree: &mut Tree, renderer: &R, limits: &layout::Limits) -> layout::Node {
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+    fn operate(
+        &mut self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn Operation,
+    ) {
+        if self.keyboard {
+            let id = self.scope.control_id("viewport");
+            operation.custom(
+                Some(&id),
+                layout.bounds(),
+                &mut super::focus::Member(self.scope),
+            );
+            operation.focusable(
+                Some(&id),
+                layout.bounds(),
+                tree.state.downcast_mut::<Input>(),
+            );
+        }
+        self.content
+            .as_widget_mut()
+            .operate(&mut tree.children[0], layout, renderer, operation);
+    }
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        if shell.is_event_captured() {
+            return;
+        }
+        let state = tree.state.downcast_mut::<Input>();
+        let changed_bounds = state.bounds.is_some_and(|bounds| bounds != layout.bounds());
+        state.bounds = Some(layout.bounds());
+        if changed_bounds || !self.keyboard {
+            state.pan = None;
+            state.space = false;
+        }
+        if !self.keyboard {
+            state.focused = false;
+        }
+        if let Event::Mouse(mouse::Event::CursorMoved { position }) = event {
+            state.pointer = Some(*position);
+        }
+        let pointer = match event {
+            Event::Mouse(
+                mouse::Event::ButtonPressed(_)
+                | mouse::Event::ButtonReleased(_)
+                | mouse::Event::WheelScrolled { .. },
+            ) => state.pointer.or_else(|| cursor.position()),
+            Event::Mouse(mouse::Event::CursorMoved { position }) => Some(*position),
+            _ => cursor.position().or(state.pointer),
+        };
+        let visible = layout.bounds().intersection(viewport);
+        let inside = pointer.is_some_and(|p| visible.is_some_and(|v| v.contains(p)))
+            && cursor.position().is_some();
+        if !self.keyboard {
+            state.space = false;
+        }
+        let mut cancel = changed_bounds;
+        let mut camera = None;
+        let mut capture = false;
+        match event {
+            Event::Window(iced::window::Event::Unfocused | iced::window::Event::Resized(_)) => {
+                state.pan = None;
+                state.space = false;
+                state.focused = false;
+            }
+            Event::Mouse(mouse::Event::CursorLeft) => {
+                state.pan = None;
+                state.pointer = None;
+            }
+            Event::Mouse(mouse::Event::ButtonPressed(button)) => {
+                if state.pan.is_some_and(|(held, _)| held != *button) || !inside {
+                    state.pan = None;
+                    state.space = false;
+                    cancel = true;
+                }
+                state.focused = inside && self.keyboard;
+                if inside
+                    && self.keyboard
+                    && (*button == mouse::Button::Middle
+                        || (*button == mouse::Button::Left && state.space))
+                {
+                    state.pan = pointer.map(|p| (*button, p));
+                    cancel = true;
+                    camera = Some(CameraEvent::CancelGesture);
+                    capture = true;
+                }
+            }
+            Event::Mouse(mouse::Event::CursorMoved { position }) => {
+                if let Some((button, previous)) = state.pan {
+                    state.pan = Some((button, *position));
+                    camera = Some(CameraEvent::Pan(*position - previous));
+                    capture = true;
+                }
+            }
+            Event::Mouse(mouse::Event::ButtonReleased(button)) => {
+                if let Some((held, previous)) = state.pan
+                    && held == *button
+                {
+                    state.pan = None;
+                    camera = pointer
+                        .filter(|_| inside)
+                        .map(|p| CameraEvent::Pan(p - previous));
+                    capture = true;
+                }
+            }
+            Event::Mouse(mouse::Event::WheelScrolled { delta }) if inside && state.focused => {
+                state.pan = None;
+                cancel = true;
+                let y = match delta {
+                    mouse::ScrollDelta::Lines { y, .. } => *y,
+                    mouse::ScrollDelta::Pixels { y, .. } => *y / 40.,
+                };
+                if y != 0. {
+                    let at = pointer.unwrap() - Vector::new(layout.bounds().x, layout.bounds().y);
+                    camera = Some(CameraEvent::Zoom {
+                        factor: 1.1_f32.powf(y.clamp(-8., 8.)),
+                        at,
+                        base: self.scale,
+                    });
+                    capture = true;
+                }
+            }
+            Event::Keyboard(keyboard::Event::KeyPressed {
+                key: keyboard::Key::Named(keyboard::key::Named::F6),
+                modifiers,
+                repeat: false,
+                ..
+            }) if self.keyboard && modifiers.is_empty() => {
+                camera = Some(CameraEvent::ToggleFocus);
+                capture = true;
+                cancel = true;
+            }
+            Event::Keyboard(keyboard::Event::KeyPressed { key, modifiers, .. })
+                if state.focused && self.keyboard =>
+            {
+                use keyboard::{Key, key::Named};
+                match key.as_ref() {
+                    Key::Named(Named::Space) => {
+                        state.space = true;
+                        cancel = true;
+                        camera = Some(CameraEvent::CancelGesture);
+                        capture = true;
+                    }
+                    Key::Named(Named::Tab) => {
+                        camera = Some(CameraEvent::Traverse(modifiers.shift()));
+                        capture = true;
+                    }
+                    Key::Named(Named::Escape) => {
+                        state.pan = None;
+                        state.space = false;
+                        camera = Some(CameraEvent::Leave);
+                        capture = true;
+                    }
+                    Key::Named(key) if modifiers.is_empty() => {
+                        let delta = match key {
+                            Named::ArrowLeft => Some(Vector::new(60., 0.)),
+                            Named::ArrowRight => Some(Vector::new(-60., 0.)),
+                            Named::ArrowUp => Some(Vector::new(0., 60.)),
+                            Named::ArrowDown => Some(Vector::new(0., -60.)),
+                            _ => None,
+                        };
+                        camera = delta.map(CameraEvent::Pan);
+                        capture = camera.is_some();
+                        cancel = capture;
+                    }
+                    _ => {}
+                }
+            }
+            Event::Keyboard(keyboard::Event::KeyReleased { key, .. })
+                if *key == keyboard::Key::Named(keyboard::key::Named::Space) =>
+            {
+                state.space = false;
+            }
+            _ => {}
+        }
+        if cancel {
+            self.content.as_widget_mut().update(
+                &mut tree.children[0],
+                &Event::Window(iced::window::Event::Unfocused),
+                layout,
+                cursor,
+                renderer,
+                clipboard,
+                shell,
+                viewport,
+            );
+        }
+        if let Some(event) = camera {
+            shell.publish((self.publish)(event));
+        }
+        if capture {
+            shell.capture_event();
+            shell.request_redraw();
+            return;
+        }
+        if matches!(event, Event::Keyboard(_)) && (!state.focused || !self.keyboard) {
+            return;
+        }
+        let child_cursor = if inside {
+            pointer.map_or(mouse::Cursor::Unavailable, mouse::Cursor::Available)
+        } else {
+            mouse::Cursor::Unavailable
+        };
+        self.content.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            child_cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+        // A semantic hit or armed creation tool gets first refusal. In Select,
+        // an otherwise unused blank press starts the same camera gesture.
+        if self.blank_pan
+            && self.keyboard
+            && inside
+            && !shell.is_event_captured()
+            && matches!(
+                event,
+                Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
+            )
+        {
+            state.pan = pointer.map(|p| (mouse::Button::Left, p));
+            shell.publish((self.publish)(CameraEvent::CancelGesture));
+            shell.capture_event();
+            shell.request_redraw();
+        }
+    }
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        renderer.with_layer(layout.bounds(), |renderer| {
+            self.content.as_widget().draw(
+                &tree.children[0],
+                renderer,
+                theme,
+                style,
+                layout,
+                cursor,
+                viewport,
+            );
+        });
+        if tree.state.downcast_ref::<Input>().focused && self.keyboard {
+            renderer.fill_quad(
+                renderer::Quad {
+                    bounds: layout.bounds(),
+                    border: Border {
+                        color: crate::style::TEAL,
+                        width: 1.,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                iced::Color::TRANSPARENT,
+            );
+        }
+    }
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        if tree.state.downcast_ref::<Input>().pan.is_some() {
+            mouse::Interaction::Grabbing
+        } else {
+            self.content.as_widget().mouse_interaction(
+                &tree.children[0],
+                layout,
+                cursor,
+                viewport,
+                renderer,
+            )
+        }
+    }
+    fn overlay<'a>(
+        &'a mut self,
+        tree: &'a mut Tree,
+        layout: Layout<'a>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'a, Message, Theme, R>> {
+        self.content.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
+    }
+}
+impl<'a, Message: 'a, R: renderer::Renderer + 'a> From<Viewport<'a, Message, R>>
+    for Element<'a, Message, Theme, R>
+{
+    fn from(viewport: Viewport<'a, Message, R>) -> Self {
+        Element::new(viewport)
+    }
+}
@@ -0,0 +1,148 @@
+//! Keep behavior field state within one editing session and reset it on replacement.
+use iced::advanced::widget::{Operation, Tree, tree};
+use iced::advanced::{Clipboard, Layout, Shell, Widget, layout, overlay, renderer};
+use iced::{Element, Event, Length, Rectangle, Size, Theme, Vector, mouse};
+use oa_core::Id;
+
+struct Identity(Id);
+
+struct Session<'a, Message, R: renderer::Renderer> {
+    identity: Id,
+    content: Element<'a, Message, Theme, R>,
+}
+
+pub(super) fn reset_on_change<'a, Message: 'a, R: renderer::Renderer + 'a>(
+    identity: Id,
+    content: impl Into<Element<'a, Message, Theme, R>>,
+) -> Element<'a, Message, Theme, R> {
+    Element::new(Session {
+        identity,
+        content: content.into(),
+    })
+}
+
+impl<Message, R: renderer::Renderer> Widget<Message, Theme, R> for Session<'_, Message, R> {
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<Identity>()
+    }
+
+    fn state(&self) -> tree::State {
+        tree::State::new(Identity(self.identity))
+    }
+
+    fn children(&self) -> Vec<Tree> {
+        vec![Tree::new(self.content.as_widget())]
+    }
+
+    fn diff(&self, tree: &mut Tree) {
+        let retained = tree.state.downcast_mut::<Identity>();
+        if retained.0 != self.identity {
+            retained.0 = self.identity;
+            // Iced's keyed column preserves same-length child replacements.
+            // An editing-session replacement must instead get fresh field state.
+            tree.children = self.children();
+        } else {
+            tree.diff_children(std::slice::from_ref(&self.content));
+        }
+    }
+
+    fn size(&self) -> Size<Length> {
+        self.content.as_widget().size()
+    }
+
+    fn layout(&mut self, tree: &mut Tree, renderer: &R, limits: &layout::Limits) -> layout::Node {
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+
+    fn operate(
+        &mut self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn Operation,
+    ) {
+        self.content
+            .as_widget_mut()
+            .operate(&mut tree.children[0], layout, renderer, operation);
+    }
+
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+    }
+
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            style,
+            layout,
+            cursor,
+            viewport,
+        );
+    }
+
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        self.content.as_widget().mouse_interaction(
+            &tree.children[0],
+            layout,
+            cursor,
+            viewport,
+            renderer,
+        )
+    }
+
+    fn overlay<'b>(
+        &'b mut self,
+        tree: &'b mut Tree,
+        layout: Layout<'b>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'b, Message, Theme, R>> {
+        self.content.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
+    }
+}
@@ -5,6 +5,7 @@ use super::*;
 use iced::widget::{Column, column, text_input};
 use std::{cell::RefCell, collections::BTreeSet};
 mod workspace;
+pub(crate) use workspace::NAME_INPUT;
 pub use workspace::{Shelf, view};

 #[cfg(test)]
@@ -98,7 +99,9 @@ pub enum CanvasEvent {
    Scrolled(Context, ScrollArea, iced::Vector),
    Restored(Context, Id, ScrollArea, iced::Vector),
    Viewport(Context, Size),
+    FormShown(Context, Id),
    Zoom(Context, Option<f32>),
+    Camera(Context, u64, super::canvas_workspace::Event),
    Focus(Context),
    Shelf(Context, Shelf),
    OpenUse(Context, Id),
@@ -137,7 +140,9 @@ impl CanvasEvent {
            | Self::Scrolled(context, _, _)
            | Self::Restored(context, ..)
            | Self::Viewport(context, _)
+            | Self::FormShown(context, _)
            | Self::Zoom(context, _)
+            | Self::Camera(context, ..)
            | Self::Focus(context)
            | Self::Shelf(context, _)
            | Self::OpenUse(context, _)
@@ -200,6 +205,8 @@ const VALUE_PAGE_SIZE: usize = 24;
 #[derive(Default)]
 pub struct State {
    draft: Option<Draft>,
+    form_session: Id,
+    form_focus_pending: bool,
    canvas_tool: Option<(Id, CanvasTool)>,
    call_choices: RefCell<Option<(CallChoiceContext, Vec<Choice>)>>,
    scroll_offsets: [iced::Vector; 2],
@@ -282,6 +289,18 @@ struct Draft {
    choice_page: usize,
 }
 impl State {
+    pub(crate) fn camera_boundary(&self) -> impl PartialEq + use<> {
+        (
+            self.canvas_tool,
+            self.presentation.focused,
+            self.presentation.shelf,
+            self.presentation.viewport,
+            self.presentation.pan,
+            self.presentation.zoom,
+            self.presentation.fit,
+        )
+    }
+
    pub(super) fn pending_name(&self) -> Option<&str> {
        self.draft.as_ref().map(|d| d.name.as_str())
    }
@@ -318,9 +337,31 @@ impl State {
    pub(crate) fn viewport(&mut self, size: Size) -> bool {
        self.presentation.viewport(size)
    }
+    pub(crate) fn camera(&mut self, event: super::canvas_workspace::Event) -> bool {
+        let p = &mut self.presentation;
+        super::canvas_workspace::change(&mut p.pan, &mut p.zoom, &mut p.fit, event)
+    }
    pub(crate) fn zoom(&mut self, scale: Option<f32>) -> bool {
        self.presentation.zoom(scale)
    }
+    pub(crate) fn camera_zoom(&mut self, p: &Project, owner: Id, zoom: Option<f32>) -> bool {
+        let size = Scene::sequence(p, owner, owner).size;
+        let old = self.presentation.scale(size);
+        if let Some(next) = zoom {
+            let viewport = self.presentation.viewport.unwrap_or(Size::new(500., 300.));
+            self.camera(super::canvas_workspace::Event::Zoom {
+                factor: next / old,
+                at: Point::new(viewport.width / 2., viewport.height / 2.),
+                base: old,
+            })
+        } else {
+            self.zoom(None);
+            let fitted = self.presentation.scale(size);
+            self.zoom(Some(fitted));
+            self.presentation.pan = iced::Vector::ZERO;
+            true
+        }
+    }
    pub(crate) fn focused(&self) -> bool {
        self.presentation.focused
    }
@@ -388,7 +429,7 @@ impl State {
            owner: frame.owner,
            token: Id::new_v4(),
            offsets: frame.offsets,
-            pending: [true; 2],
+            pending: [false, true],
        });
    }
    pub(super) fn scroll_restore(
@@ -447,10 +488,25 @@ impl State {
        let draft = serde_json::from_value(value).map_err(|e| e.to_string())?;
        Ok(Self {
            draft: Some(draft),
+            form_session: Id::new_v4(),
+            form_focus_pending: true,
            ..Default::default()
        })
    }

+    pub(crate) fn form_session(&self) -> Option<Id> {
+        self.draft.as_ref().map(|_| self.form_session)
+    }
+
+    pub(crate) fn take_form_focus(&mut self, session: Id) -> bool {
+        if self.form_session() == Some(session) && self.form_focus_pending {
+            self.form_focus_pending = false;
+            true
+        } else {
+            false
+        }
+    }
+
    pub(crate) fn scrolled(&mut self, area: ScrollArea, offset: iced::Vector) -> bool {
        if !offset.x.is_finite() || !offset.y.is_finite() || offset.x < 0. || offset.y < 0. {
            return false;
@@ -463,6 +519,7 @@ impl State {
        self.scroll_offsets[index] = offset;
        changed
    }
+    #[cfg(test)]
    fn scroll_offset(&self) -> iced::Vector {
        // The former page scroll now belongs to a sibling outline shelf.
        self.scroll_offsets[0]
@@ -671,6 +728,8 @@ impl State {
                if p.elements.get(&owner).map(oa_core::Element::kind) != Some(Kind::Scenario) {
                    return Err("Choose a scenario.".into());
                }
+                self.form_session = Id::new_v4();
+                self.form_focus_pending = true;
                self.draft = Some(Draft {
                    source: Default::default(),
                    invocation: Id::new_v4(),
@@ -0,0 +1,283 @@
+//! Read-only lifecycle geometry. Operand screen order is never execution order.
+use oa_core::{FragmentOperator, Id, Kind, MessageKind, OccurrenceBody, Project, SharedBody};
+use std::collections::{BTreeMap, BTreeSet};
+
+/// Maps already recorded by the sequence renderer. Rows carry their owning sequence.
+pub(crate) struct Geometry<'a> {
+    pub rows: &'a BTreeMap<Id, (Id, f32)>,
+    pub scopes: &'a BTreeMap<Id, (f32, f32)>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) struct Span {
+    pub start: f32,
+    pub end: f32,
+}
+impl Span {
+    fn valid(self) -> bool {
+        self.start.is_finite() && self.end.is_finite() && self.start <= self.end
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Life {
+    Alive,
+    Absent,
+    Unresolved,
+}
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) struct Interval {
+    pub scope: Id,
+    pub span: Span,
+    pub life: Life,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum MarkerKind {
+    Birth,
+    Death,
+}
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) struct Marker {
+    pub occurrence: Id,
+    pub scope: Id,
+    pub y: f32,
+    pub kind: MarkerKind,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum UncertaintyReason {
+    Conditional,
+    Repeated,
+    Parallel,
+    MissingGeometry,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct Uncertainty {
+    pub scope: Id,
+    pub reason: UncertaintyReason,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct LaneLifetime {
+    pub lifeline: Id,
+    pub intervals: Vec<Interval>,
+    pub markers: Vec<Marker>,
+    pub uncertainties: Vec<Uncertainty>,
+}
+
+/// Stable lane-ID order; source/model/history and caller-owned geometry are untouched.
+/// An opaque ScenarioUse is a local use, not a caller birth/death contract.
+pub(crate) fn project_lifetimes(
+    project: &Project,
+    scenario: Id,
+    geometry: &Geometry<'_>,
+) -> Vec<LaneLifetime> {
+    if project
+        .elements
+        .get(&scenario)
+        .is_none_or(|e| e.kind() != Kind::Scenario)
+    {
+        return vec![];
+    }
+    project
+        .elements
+        .values()
+        .filter(|e| e.kind() == Kind::Lifeline && e.parent == Some(scenario))
+        .map(|e| {
+            let mut projection = Projection {
+                project,
+                geometry,
+                lane: e.id,
+                visiting: BTreeSet::new(),
+                result: LaneLifetime {
+                    lifeline: e.id,
+                    intervals: vec![],
+                    markers: vec![],
+                    uncertainties: vec![],
+                },
+            };
+            let initial = if projection.contains(scenario, Some(MarkerKind::Birth)) {
+                Life::Unresolved
+            } else {
+                Life::Alive
+            };
+            projection.sequence(scenario, initial);
+            projection.result
+        })
+        .collect()
+}
+
+struct Projection<'a, 'g> {
+    project: &'a Project,
+    geometry: &'a Geometry<'g>,
+    lane: Id,
+    visiting: BTreeSet<Id>,
+    result: LaneLifetime,
+}
+impl Projection<'_, '_> {
+    fn body(&self, id: Id) -> Option<&OccurrenceBody> {
+        match self.project.elements.get(&id)?.shared()? {
+            SharedBody::Occurrence { body, .. } => Some(body),
+            _ => None,
+        }
+    }
+    fn event(&self, id: Id) -> Option<MarkerKind> {
+        match self.body(id)? {
+            OccurrenceBody::Exchange {
+                receiver: Some(line),
+                message_kind,
+                ..
+            } if *line == self.lane => match message_kind {
+                MessageKind::Create => Some(MarkerKind::Birth),
+                MessageKind::Delete => Some(MarkerKind::Death),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+    fn contains(&self, scope: Id, kind: Option<MarkerKind>) -> bool {
+        // Local structural walk only: no guards, iteration simulation or reuse expansion.
+        let mut pending = vec![scope];
+        let mut seen = BTreeSet::new();
+        while let Some(id) = pending.pop() {
+            if !seen.insert(id) {
+                continue;
+            }
+            if self
+                .event(id)
+                .is_some_and(|event| kind.is_none_or(|k| event == k))
+            {
+                return true;
+            }
+            if let Some(steps) = self.project.elements.get(&id).and_then(|e| e.steps()) {
+                pending.extend(steps);
+            }
+            if let Some(OccurrenceBody::Fragment { branches, .. }) = self.body(id) {
+                pending.extend(branches);
+            }
+        }
+        false
+    }
+    fn span(&self, scope: Id) -> Option<Span> {
+        let &(start, end) = self.geometry.scopes.get(&scope)?;
+        let span = Span { start, end };
+        span.valid().then_some(span)
+    }
+    fn uncertain(&mut self, scope: Id, reason: UncertaintyReason) {
+        let value = Uncertainty { scope, reason };
+        if !self.result.uncertainties.contains(&value) {
+            self.result.uncertainties.push(value);
+        }
+    }
+    fn interval(&mut self, scope: Id, start: f32, end: f32, life: Life) {
+        if start < end && start.is_finite() && end.is_finite() {
+            self.result.intervals.push(Interval {
+                scope,
+                span: Span { start, end },
+                life,
+            });
+        }
+    }
+    fn sequence(&mut self, scope: Id, entry: Life) -> Life {
+        let Some(span) = self.span(scope) else {
+            self.uncertain(scope, UncertaintyReason::MissingGeometry);
+            return Life::Unresolved;
+        };
+        if !self.visiting.insert(scope) {
+            self.uncertain(scope, UncertaintyReason::MissingGeometry);
+            return Life::Unresolved;
+        }
+        let steps = self
+            .project
+            .elements
+            .get(&scope)
+            .and_then(|e| e.steps())
+            .cloned()
+            .unwrap_or_default();
+        // A creation directly in this sequence fixes its local birth boundary.
+        // A creation only in a nested operand cannot fix its ancestor's entry.
+        let mut life = if steps
+            .iter()
+            .any(|&id| self.event(id) == Some(MarkerKind::Birth))
+        {
+            Life::Absent
+        } else {
+            entry
+        };
+        let mut cursor = span.start;
+        for id in steps {
+            let event = self.event(id);
+            let fragment = match self.body(id) {
+                Some(OccurrenceBody::Fragment { operator, branches }) => {
+                    Some((*operator, branches.clone()))
+                }
+                _ => None,
+            };
+            if event.is_none() && fragment.is_none() {
+                continue;
+            }
+            let y = self
+                .geometry
+                .rows
+                .get(&id)
+                .filter(|(owner, y)| {
+                    *owner == scope && y.is_finite() && *y >= cursor && *y <= span.end
+                })
+                .map(|(_, y)| *y);
+            let Some(y) = y else {
+                self.uncertain(id, UncertaintyReason::MissingGeometry);
+                life = Life::Unresolved;
+                continue;
+            };
+            self.interval(scope, cursor, y, life);
+            cursor = y;
+            if let Some(kind) = event {
+                self.result.markers.push(Marker {
+                    occurrence: id,
+                    scope,
+                    y,
+                    kind,
+                });
+                life = match kind {
+                    MarkerKind::Birth => Life::Alive,
+                    MarkerKind::Death => Life::Absent,
+                };
+            }
+            if let Some((operator, branches)) = fragment {
+                let entry = life;
+                let mut missing = false;
+                for branch in branches {
+                    let bounds = self
+                        .span(branch)
+                        .filter(|s| s.start >= cursor && s.end <= span.end);
+                    if let Some(bounds) = bounds {
+                        // Every sibling inherits the same entry, never its displayed predecessor's exit.
+                        self.sequence(branch, entry);
+                        cursor = bounds.end;
+                    } else {
+                        self.uncertain(branch, UncertaintyReason::MissingGeometry);
+                        missing = true;
+                    }
+                }
+                if self.contains(id, None) {
+                    let reason = match operator {
+                        FragmentOperator::Alternative | FragmentOperator::Optional => {
+                            UncertaintyReason::Conditional
+                        }
+                        FragmentOperator::Loop => UncertaintyReason::Repeated,
+                        FragmentOperator::Parallel => UncertaintyReason::Parallel,
+                    };
+                    self.uncertain(id, reason);
+                    life = Life::Unresolved;
+                } else if missing {
+                    life = Life::Unresolved;
+                }
+            }
+        }
+        self.interval(scope, cursor, span.end, life);
+        self.visiting.remove(&scope);
+        life
+    }
+}
+
+#[cfg(test)]
+#[path = "scenario_lifecycle/tests.rs"]
+mod tests;
@@ -0,0 +1,470 @@
+use super::*;
+use oa_core::*;
+
+struct Fixture {
+    p: Project,
+    owner: Id,
+    a: Id,
+    b: Id,
+    exchange: Id,
+    rows: BTreeMap<Id, (Id, f32)>,
+    scopes: BTreeMap<Id, (f32, f32)>,
+}
+impl Fixture {
+    fn new(layer: Layer) -> Self {
+        let mut p = Project::empty();
+        let kind = if layer == Layer::Oa {
+            Kind::Activity
+        } else {
+            Kind::Function
+        };
+        let a = p.add_element(kind, layer, "Request", None).unwrap();
+        let b = p.add_element(kind, layer, "Provide", None).unwrap();
+        let owner = p
+            .add_element(Kind::Scenario, layer, "Lifecycle", None)
+            .unwrap();
+        let exchange = p.relate(
+            if layer == Layer::Oa {
+                RelationKind::Interaction
+            } else {
+                RelationKind::FunctionalExchange
+            },
+            "Service",
+            a,
+            b,
+        );
+        let line = |p: &mut Project, represented| {
+            let id = p
+                .add_element(Kind::Lifeline, layer, "Participant", Some(owner))
+                .unwrap();
+            *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::Lifeline {
+                represented: Some(represented),
+            };
+            id
+        };
+        let a = line(&mut p, a);
+        let b = line(&mut p, b);
+        Self {
+            p,
+            owner,
+            a,
+            b,
+            exchange,
+            rows: BTreeMap::new(),
+            scopes: [(owner, (0., 600.))].into(),
+        }
+    }
+    fn occurrence(&mut self, owner: Id, y: f32, body: OccurrenceBody) -> Id {
+        let mut e = self
+            .p
+            .make_element(
+                Kind::Occurrence,
+                self.p.elements[&owner].layer(),
+                "Occurrence",
+                Some(owner),
+            )
+            .unwrap();
+        let id = e.id;
+        *e.shared_mut().unwrap() = SharedBody::Occurrence {
+            body,
+            precondition: String::new(),
+            postcondition: String::new(),
+        };
+        self.p.elements.insert(id, e);
+        if let Some(steps) = self.p.elements.get_mut(&owner).unwrap().steps_mut() {
+            steps.push(id);
+        } else if let Some(SharedBody::Occurrence {
+            body: OccurrenceBody::Fragment { branches, .. },
+            ..
+        }) = self.p.elements.get_mut(&owner).unwrap().shared_mut()
+        {
+            branches.push(id);
+        }
+        self.rows.insert(id, (owner, y));
+        id
+    }
+    fn message(&mut self, owner: Id, y: f32, kind: MessageKind) -> Id {
+        self.occurrence(
+            owner,
+            y,
+            OccurrenceBody::Exchange {
+                exchange: Some(self.exchange),
+                sender: Some(self.a),
+                receiver: Some(self.b),
+                message_kind: kind,
+                operation: None,
+                reply_to: None,
+                values: vec![],
+            },
+        )
+    }
+    fn fragment(&mut self, owner: Id, y: f32, operator: FragmentOperator) -> Id {
+        self.occurrence(
+            owner,
+            y,
+            OccurrenceBody::Fragment {
+                operator,
+                branches: vec![],
+            },
+        )
+    }
+    fn branch(&mut self, fragment: Id, start: f32, end: f32) -> Id {
+        let id = self.occurrence(
+            fragment,
+            start,
+            OccurrenceBody::Branch {
+                guard: "condition".into(),
+                occurrences: vec![],
+            },
+        );
+        self.scopes.insert(id, (start, end));
+        id
+    }
+    fn project(&self) -> Vec<LaneLifetime> {
+        let errors: Vec<_> = validation::validate(&self.p)
+            .into_iter()
+            .filter(|i| i.severity == validation::Severity::Error)
+            .collect();
+        assert!(
+            errors.is_empty(),
+            "fixture must be ordinarily admitted: {errors:?}"
+        );
+        let before = self.p.clone();
+        let source = source_project::format_bundle(&self.p);
+        let geometry = Geometry {
+            rows: &self.rows,
+            scopes: &self.scopes,
+        };
+        let result = project_lifetimes(&self.p, self.owner, &geometry);
+        assert_eq!(result, project_lifetimes(&self.p, self.owner, &geometry));
+        assert_eq!(self.p, before);
+        assert_eq!(source_project::format_bundle(&self.p), source);
+        assert!(
+            result
+                .windows(2)
+                .all(|pair| pair[0].lifeline < pair[1].lifeline)
+        );
+        result
+    }
+    fn lane(&self) -> LaneLifetime {
+        self.project()
+            .into_iter()
+            .find(|lane| lane.lifeline == self.b)
+            .unwrap()
+    }
+}
+fn intervals(lane: &LaneLifetime, scope: Id) -> Vec<(f32, f32, Life)> {
+    lane.intervals
+        .iter()
+        .filter(|i| i.scope == scope)
+        .map(|i| (i.span.start, i.span.end, i.life))
+        .collect()
+}
+
+#[test]
+fn root_lifetime_has_exact_birth_death_boundaries_without_source_mutation() {
+    for layer in [Layer::Oa, Layer::Sa] {
+        let mut f = Fixture::new(layer);
+        let create = f.message(f.owner, 100., MessageKind::Create);
+        f.message(f.owner, 200., MessageKind::Asynchronous);
+        let delete = f.message(f.owner, 300., MessageKind::Delete);
+        let lane = f.lane();
+        assert_eq!(
+            intervals(&lane, f.owner),
+            vec![
+                (0., 100., Life::Absent),
+                (100., 300., Life::Alive),
+                (300., 600., Life::Absent)
+            ]
+        );
+        assert_eq!(
+            lane.markers,
+            vec![
+                Marker {
+                    occurrence: create,
+                    scope: f.owner,
+                    y: 100.,
+                    kind: MarkerKind::Birth
+                },
+                Marker {
+                    occurrence: delete,
+                    scope: f.owner,
+                    y: 300.,
+                    kind: MarkerKind::Death
+                },
+            ]
+        );
+        let sender = f
+            .project()
+            .into_iter()
+            .find(|lane| lane.lifeline == f.a)
+            .unwrap();
+        assert_eq!(intervals(&sender, f.owner), vec![(0., 600., Life::Alive)]);
+    }
+}
+
+#[test]
+fn alternative_death_does_not_kill_its_displayed_sibling() {
+    let mut f = Fixture::new(Layer::Sa);
+    let fragment = f.fragment(f.owner, 100., FragmentOperator::Alternative);
+    let left = f.branch(fragment, 120., 250.);
+    let right = f.branch(fragment, 300., 450.);
+    f.message(left, 200., MessageKind::Delete);
+    f.message(right, 350., MessageKind::Asynchronous);
+    let lane = f.lane();
+    assert_eq!(
+        intervals(&lane, left),
+        vec![(120., 200., Life::Alive), (200., 250., Life::Absent)]
+    );
+    assert_eq!(intervals(&lane, right), vec![(300., 450., Life::Alive)]);
+    assert_eq!(
+        intervals(&lane, f.owner),
+        vec![(0., 100., Life::Alive), (450., 600., Life::Unresolved)]
+    );
+    assert_eq!(
+        lane.uncertainties,
+        vec![Uncertainty {
+            scope: fragment,
+            reason: UncertaintyReason::Conditional
+        }]
+    );
+}
+
+#[test]
+fn conditional_birth_does_not_infer_absence_in_siblings_or_ancestors() {
+    for operator in [FragmentOperator::Alternative, FragmentOperator::Optional] {
+        let mut f = Fixture::new(Layer::Oa);
+        let fragment = f.fragment(f.owner, 100., operator);
+        let left = f.branch(fragment, 120., 250.);
+        let right = f.branch(fragment, 300., 450.);
+        f.message(left, 200., MessageKind::Create);
+        let lane = f.lane();
+        assert_eq!(
+            intervals(&lane, left),
+            vec![(120., 200., Life::Absent), (200., 250., Life::Alive)]
+        );
+        assert_eq!(
+            intervals(&lane, right),
+            vec![(300., 450., Life::Unresolved)]
+        );
+        assert_eq!(
+            intervals(&lane, f.owner),
+            vec![(0., 100., Life::Unresolved), (450., 600., Life::Unresolved)]
+        );
+    }
+}
+
+#[test]
+fn loop_lifetime_is_local_and_warning_bearing_loops_remain_drawable() {
+    for balanced in [true, false] {
+        let mut f = Fixture::new(Layer::Sa);
+        let fragment = f.fragment(f.owner, 100., FragmentOperator::Loop);
+        let iteration = f.branch(fragment, 120., 450.);
+        let create = f.message(iteration, 160., MessageKind::Create);
+        f.message(iteration, 250., MessageKind::Asynchronous);
+        if balanced {
+            f.message(iteration, 350., MessageKind::Delete);
+        }
+        let lane = f.lane();
+        assert_eq!(lane.markers.len(), if balanced { 2 } else { 1 });
+        assert_eq!(lane.markers[0].occurrence, create);
+        assert!(lane.uncertainties.contains(&Uncertainty {
+            scope: fragment,
+            reason: UncertaintyReason::Repeated
+        }));
+        assert_eq!(
+            intervals(&lane, f.owner).last().unwrap().2,
+            Life::Unresolved
+        );
+        assert_eq!(
+            validation::validate(&f.p)
+                .iter()
+                .any(|i| i.code == "lifeline_repetition"),
+            !balanced
+        );
+    }
+}
+
+#[test]
+fn optional_cleanup_inside_loop_does_not_claim_balanced_or_definite_exit() {
+    let mut f = Fixture::new(Layer::Sa);
+    let repeated = f.fragment(f.owner, 100., FragmentOperator::Loop);
+    let iteration = f.branch(repeated, 120., 500.);
+    f.message(iteration, 160., MessageKind::Create);
+    let optional = f.fragment(iteration, 280., FragmentOperator::Optional);
+    let cleanup = f.branch(optional, 320., 400.);
+    f.message(cleanup, 350., MessageKind::Delete);
+    let lane = f.lane();
+    assert_eq!(
+        intervals(&lane, cleanup),
+        vec![(320., 350., Life::Alive), (350., 400., Life::Absent)]
+    );
+    assert_eq!(
+        intervals(&lane, iteration),
+        vec![
+            (120., 160., Life::Absent),
+            (160., 280., Life::Alive),
+            (400., 500., Life::Unresolved)
+        ]
+    );
+    assert!(
+        validation::validate(&f.p)
+            .iter()
+            .any(|i| i.code == "lifeline_repetition")
+    );
+    assert!(lane.uncertainties.contains(&Uncertainty {
+        scope: optional,
+        reason: UncertaintyReason::Conditional
+    }));
+    assert!(lane.uncertainties.contains(&Uncertainty {
+        scope: repeated,
+        reason: UncertaintyReason::Repeated
+    }));
+}
+
+#[test]
+fn lifecycle_free_fragments_do_not_poison_other_lanes() {
+    let mut f = Fixture::new(Layer::Oa);
+    let fragment = f.fragment(f.owner, 100., FragmentOperator::Parallel);
+    let left = f.branch(fragment, 120., 250.);
+    let right = f.branch(fragment, 300., 450.);
+    f.message(left, 200., MessageKind::Delete);
+    let result = f.project();
+    let sender = result.iter().find(|lane| lane.lifeline == f.a).unwrap();
+    assert!(sender.intervals.iter().all(|i| i.life == Life::Alive));
+    assert!(sender.uncertainties.is_empty());
+    let target = result.iter().find(|lane| lane.lifeline == f.b).unwrap();
+    assert!(target.uncertainties.contains(&Uncertainty {
+        scope: fragment,
+        reason: UncertaintyReason::Parallel
+    }));
+    assert_eq!(intervals(target, right), vec![(300., 450., Life::Alive)]);
+}
+
+#[test]
+fn explicit_receiver_is_authoritative_even_with_missing_exchange() {
+    let mut f = Fixture::new(Layer::Oa);
+    let create = f.message(f.owner, 100., MessageKind::Create);
+    if let Some(SharedBody::Occurrence {
+        body: OccurrenceBody::Exchange { exchange, .. },
+        ..
+    }) = f.p.elements.get_mut(&create).unwrap().shared_mut()
+    {
+        *exchange = None;
+    }
+    assert_eq!(f.lane().markers[0].occurrence, create);
+    if let Some(SharedBody::Occurrence {
+        body: OccurrenceBody::Exchange {
+            receiver, exchange, ..
+        },
+        ..
+    }) = f.p.elements.get_mut(&create).unwrap().shared_mut()
+    {
+        *receiver = None;
+        *exchange = Some(f.exchange);
+    }
+    assert!(
+        f.lane().markers.is_empty(),
+        "exchange endpoints never invent a receiver"
+    );
+}
+
+#[test]
+fn missing_geometry_is_reported_without_nonfinite_or_guessed_markers() {
+    let mut f = Fixture::new(Layer::Oa);
+    let create = f.message(f.owner, 100., MessageKind::Create);
+    f.rows.insert(create, (f.owner, f32::NAN));
+    let lane = f.lane();
+    assert!(lane.markers.is_empty());
+    assert_eq!(
+        lane.uncertainties,
+        vec![Uncertainty {
+            scope: create,
+            reason: UncertaintyReason::MissingGeometry
+        }]
+    );
+    assert_eq!(
+        intervals(&lane, f.owner),
+        vec![(0., 600., Life::Unresolved)]
+    );
+    f.scopes.remove(&f.owner);
+    let lane = f.lane();
+    assert!(lane.intervals.is_empty());
+    assert_eq!(lane.uncertainties[0].scope, f.owner);
+}
+
+#[test]
+fn scenario_use_is_opaque_and_never_imports_callee_lifecycle_events() {
+    let mut f = Fixture::new(Layer::Oa);
+    let callee =
+        f.p.add_element(Kind::Scenario, Layer::Oa, "Callee", None)
+            .unwrap();
+    let remote_a =
+        f.p.add_element(Kind::Lifeline, Layer::Oa, "Remote A", Some(callee))
+            .unwrap();
+    let remote_b =
+        f.p.add_element(Kind::Lifeline, Layer::Oa, "Remote B", Some(callee))
+            .unwrap();
+    for (remote, local) in [(remote_a, f.a), (remote_b, f.b)] {
+        let body = f.p.elements[&local].shared().unwrap().clone();
+        *f.p.elements.get_mut(&remote).unwrap().shared_mut().unwrap() = body;
+    }
+    f.occurrence(
+        callee,
+        200.,
+        OccurrenceBody::Exchange {
+            exchange: Some(f.exchange),
+            sender: Some(remote_a),
+            receiver: Some(remote_b),
+            message_kind: MessageKind::Create,
+            operation: None,
+            reply_to: None,
+            values: vec![],
+        },
+    );
+    f.occurrence(
+        f.owner,
+        100.,
+        OccurrenceBody::ScenarioUse {
+            scenario: Some(callee),
+            bindings: vec![
+                LifelineBinding {
+                    referenced: remote_a,
+                    local: f.a,
+                },
+                LifelineBinding {
+                    referenced: remote_b,
+                    local: f.b,
+                },
+            ],
+        },
+    );
+    let lane = f.lane();
+    assert_eq!(intervals(&lane, f.owner), vec![(0., 600., Life::Alive)]);
+    assert!(lane.markers.is_empty());
+    assert!(lane.uncertainties.is_empty());
+}
+
+#[test]
+fn projection_retains_exact_authored_source_and_does_not_enter_history() {
+    use crate::document::Document;
+    let mut f = Fixture::new(Layer::Oa);
+    f.message(f.owner, 100., MessageKind::Create);
+    f.message(f.owner, 300., MessageKind::Delete);
+    let mut source = source_project::format_bundle(&f.p);
+    let text = source.files.get_mut(&source.entry).unwrap();
+    *text = format!("// Retained author note — 雨\r\n{text}\n");
+    let document =
+        Document::from_bundle(source.clone(), source_project::ProjectLimits::default()).unwrap();
+    let accepted = document.project().clone();
+    let geometry = Geometry {
+        rows: &f.rows,
+        scopes: &f.scopes,
+    };
+    let result = project_lifetimes(document.project(), f.owner, &geometry);
+    assert_eq!(result, f.project());
+    assert_eq!(document.bundle(), &source);
+    assert_eq!(document.project(), &accepted);
+    assert!(!document.can_undo());
+    assert!(!document.can_redo());
+}
@@ -325,73 +325,50 @@ impl State {
    ) -> Option<UiElement<'a, Event, iced::Theme, R>> {
        let d = self.editing.as_ref()?;
        let event = move |edit| Event::Edit(d.token, edit);
-        let kinds = d.scope.kinds(d.layer);
-        let determined = kinds.len() == 1 && d.kind == kinds.first().copied();
        let mut fields = column![
-            text(if determined {
-                format!("New {} · {}", kinds[0], d.layer)
-            } else {
-                format!("New source · {}", d.layer)
+            text(format!("New source · {}", d.layer)).size(18),
+            text(match d.scope {
+                Scope::Lifeline { owner, viewpoint } =>
+                    format!("For a lifeline in {} · {:?}", p.named(owner), viewpoint),
+                Scope::Work { owner } => format!("For a contribution in {}", p.named(owner)),
+                Scope::Machine { .. } => "Owner for the pending state machine".into(),
            })
-            .size(14),
+            .size(12),
+            text("The parent form is retained. This source is created only with its consumer.")
+                .size(12)
+        ]
+        .spacing(8);
+        for kind in d.scope.kinds(d.layer) {
+            fields = fields.push(
+                button(text(kind.to_string()))
+                    .on_press(event(Edit::Kind(kind)))
+                    .style(if d.kind == Some(kind) {
+                        button::primary
+                    } else {
+                        button::secondary
+                    }),
+            );
+        }
+        fields = fields.push(
            text_input("Source name (independent of the consumer name)", &d.name)
                .id(NAME_INPUT)
                .on_input(move |v| event(Edit::Name(v)))
-                .size(14)
-                .padding(6),
-        ]
-        .spacing(4);
-        if !determined {
-            let mut choices = row![].spacing(6);
-            for kind in kinds {
-                choices = choices.push(
-                    container(
-                        button(text(kind.to_string()).size(14))
-                            .padding(4)
-                            .on_press(event(Edit::Kind(kind)))
-                            .style(if d.kind == Some(kind) {
-                                button::primary
-                            } else {
-                                button::secondary
-                            }),
-                    )
-                    .id(format!("behavior-source-kind-{kind:?}")),
-                );
-            }
-            fields = fields.push(choices.wrap());
-        }
+                .padding(8),
+        );
        fields = fields.push(
-            container(
-                text(format!(
-                    "Semantic parent: {}",
-                    d.parent
-                        .as_ref()
-                        .map_or(format!("{} layer root", d.layer), |e| format!(
-                            "{} · {} · @{}",
-                            e.name,
-                            e.kind(),
-                            e.alias
-                        ))
-                ))
-                .size(12),
-            )
-            .id("behavior-source-parent"),
+            text(format!(
+                "Semantic parent: {}",
+                d.parent
+                    .as_ref()
+                    .map_or(format!("{} layer root", d.layer), |e| format!(
+                        "{} · {} · @{}",
+                        e.name,
+                        e.kind(),
+                        e.alias
+                    ))
+            ))
+            .size(12),
        );
-        fields = fields
-            .push(
-                text(match d.scope {
-                    Scope::Lifeline { owner, viewpoint } => {
-                        format!("For a lifeline in {} · {:?}", p.named(owner), viewpoint)
-                    }
-                    Scope::Work { owner } => format!("For a contribution in {}", p.named(owner)),
-                    Scope::Machine { .. } => "Owner for the pending state machine".into(),
-                })
-                .size(12),
-            )
-            .push(
-                text("The parent form is retained. This source is created only with its consumer.")
-                    .size(12),
-            );
        if let Some(kind) = d.kind {
            fields = fields.push(button("Use layer root").on_press_maybe(
                validation::can_parent(p, kind, d.layer, None).then(|| event(Edit::Parent(None))),
@@ -509,526 +486,3 @@ impl Draft {
        Ok(command)
    }
 }
-
-#[cfg(all(test, debug_assertions))]
-mod layout_tests {
-    use super::*;
-    use iced::advanced::{Layout, Shell, graphics, layout, renderer, text as shaped, widget};
-    use iced::{Background, Color, Font, Pixels, Point, Rectangle, Size, Transformation, Vector};
-
-    // Use Iced's real paragraph shaping/measurement without a window or GPU.
-    // The unit renderer's zero-size paragraphs cannot detect this regression.
-    struct FontLayout;
-    impl renderer::Renderer for FontLayout {
-        fn start_layer(&mut self, _: Rectangle) {}
-        fn end_layer(&mut self) {}
-        fn start_transformation(&mut self, _: Transformation) {}
-        fn end_transformation(&mut self) {}
-        fn reset(&mut self, _: Rectangle) {}
-        fn fill_quad(&mut self, _: renderer::Quad, _: impl Into<Background>) {}
-        fn allocate_image(
-            &mut self,
-            handle: &iced::advanced::image::Handle,
-            callback: impl FnOnce(
-                Result<iced::advanced::image::Allocation, iced::advanced::image::Error>,
-            ) + Send
-            + 'static,
-        ) {
-            renderer::Renderer::allocate_image(&mut (), handle, callback);
-        }
-    }
-    impl shaped::Renderer for FontLayout {
-        type Font = Font;
-        type Paragraph = graphics::text::Paragraph;
-        type Editor = ();
-        const ICON_FONT: Font = Font::DEFAULT;
-        const CHECKMARK_ICON: char = '0';
-        const ARROW_DOWN_ICON: char = '0';
-        const SCROLL_UP_ICON: char = '0';
-        const SCROLL_DOWN_ICON: char = '0';
-        const SCROLL_LEFT_ICON: char = '0';
-        const SCROLL_RIGHT_ICON: char = '0';
-        const ICED_LOGO: char = '0';
-        fn default_font(&self) -> Font {
-            Font::DEFAULT
-        }
-        fn default_size(&self) -> Pixels {
-            Pixels(16.)
-        }
-        fn fill_paragraph(&mut self, _: &Self::Paragraph, _: Point, _: Color, _: Rectangle) {}
-        fn fill_editor(&mut self, _: &Self::Editor, _: Point, _: Color, _: Rectangle) {}
-        fn fill_text(&mut self, _: shaped::Text, _: Point, _: Color, _: Rectangle) {}
-    }
-    #[derive(Default)]
-    struct Geometry {
-        fields: Option<Rectangle>,
-        content: Option<Rectangle>,
-        name: Option<Rectangle>,
-        parent: Option<Rectangle>,
-        actions: Option<Rectangle>,
-        kinds: BTreeMap<String, Rectangle>,
-        text: Vec<(String, Rectangle)>,
-        focus_name: bool,
-    }
-    impl widget::Operation for Geometry {
-        fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn widget::Operation)) {
-            visit(self);
-        }
-        fn container(&mut self, id: Option<&widget::Id>, bounds: Rectangle) {
-            if id == Some(&widget::Id::new("behavior-source-actions")) {
-                self.actions = Some(bounds);
-            }
-            if id == Some(&widget::Id::new("behavior-source-parent")) {
-                self.parent = Some(bounds);
-            }
-            for kind in [
-                Kind::Entity,
-                Kind::Actor,
-                Kind::Role,
-                Kind::System,
-                Kind::SystemActor,
-                Kind::Activity,
-                Kind::Function,
-            ] {
-                if id == Some(&widget::Id::from(format!("behavior-source-kind-{kind:?}"))) {
-                    self.kinds.insert(kind.to_string(), bounds);
-                }
-            }
-        }
-        fn scrollable(
-            &mut self,
-            id: Option<&widget::Id>,
-            bounds: Rectangle,
-            content: Rectangle,
-            offset: Vector,
-            _: &mut dyn widget::operation::Scrollable,
-        ) {
-            if id == Some(&widget::Id::new("behavior-source-fields")) {
-                assert_eq!(
-                    offset,
-                    Vector::ZERO,
-                    "Initial fields must be visible without scrolling"
-                );
-                self.fields = Some(bounds);
-                self.content = Some(content);
-            }
-        }
-        fn text_input(
-            &mut self,
-            id: Option<&widget::Id>,
-            bounds: Rectangle,
-            _: &mut dyn widget::operation::TextInput,
-        ) {
-            if id == Some(&widget::Id::new(NAME_INPUT)) {
-                self.name = Some(bounds);
-            }
-        }
-        fn focusable(
-            &mut self,
-            id: Option<&widget::Id>,
-            _: Rectangle,
-            state: &mut dyn widget::operation::Focusable,
-        ) {
-            if self.focus_name && id == Some(&widget::Id::new(NAME_INPUT)) {
-                state.focus();
-            }
-        }
-        fn text(&mut self, _: Option<&widget::Id>, bounds: Rectangle, text: &str) {
-            self.text.push((text.into(), bounds));
-        }
-    }
-    fn contains(outer: Rectangle, inner: Rectangle) -> bool {
-        inner.width > 0.
-            && inner.height > 0.
-            && inner.x >= outer.x - 0.1
-            && inner.y >= outer.y - 0.1
-            && inner.x + inner.width <= outer.x + outer.width + 0.1
-            && inner.y + inner.height <= outer.y + outer.height + 0.1
-    }
-    fn host<'a>(
-        state: &'a State,
-        p: &'a Project,
-        caption: &str,
-    ) -> UiElement<'a, Event, iced::Theme, FontLayout> {
-        iced::widget::column![text(caption.to_owned()).size(12), state.view(p).unwrap()]
-            .spacing(6)
-            .height(Fill)
-            .width(Fill)
-            .into()
-    }
-    fn geometry(
-        view: &mut UiElement<'_, Event, iced::Theme, FontLayout>,
-        tree: &mut widget::Tree,
-        size: Size,
-    ) -> (layout::Node, Geometry) {
-        let node =
-            view.as_widget_mut()
-                .layout(tree, &FontLayout, &layout::Limits::new(Size::ZERO, size));
-        let mut geometry = Geometry::default();
-        view.as_widget_mut()
-            .operate(tree, Layout::new(&node), &FontLayout, &mut geometry);
-        (node, geometry)
-    }
-    fn fixture(layer: Layer, viewpoint: Option<ScenarioViewpoint>, work: bool) -> (Project, State) {
-        let mut p = Project::empty();
-        let scope = if work {
-            let owner = p
-                .add_element(
-                    if layer == Layer::Oa {
-                        Kind::Process
-                    } else {
-                        Kind::FunctionalChain
-                    },
-                    layer,
-                    "Consumer",
-                    None,
-                )
-                .unwrap();
-            Scope::Work { owner }
-        } else if let Some(viewpoint) = viewpoint {
-            let owner = p
-                .add_element(
-                    Kind::Scenario,
-                    layer,
-                    "Incident coordination with a long contextual heading 雨 Ω",
-                    None,
-                )
-                .unwrap();
-            if let Some(SharedBody::Scenario { viewpoint: v, .. }) =
-                p.elements.get_mut(&owner).unwrap().shared_mut()
-            {
-                *v = viewpoint;
-            }
-            Scope::Lifeline { owner, viewpoint }
-        } else {
-            Scope::Machine { layer }
-        };
-        let mut state = State::default();
-        let invocation = Id::new_v4();
-        state
-            .update(&p, scope, invocation, Event::Open(invocation))
-            .unwrap();
-        (p, state)
-    }
-    #[test]
-    fn contextual_source_layout_initial_essentials_fit_short_composed_host_with_real_paragraphs() {
-        for (layer, viewpoint, work) in [
-            (
-                Layer::Oa,
-                Some(ScenarioViewpoint::OperationalActivity),
-                false,
-            ),
-            (Layer::Sa, Some(ScenarioViewpoint::Functional), false),
-            (
-                Layer::Oa,
-                Some(ScenarioViewpoint::ParticipantInteraction),
-                false,
-            ),
-            (Layer::Sa, Some(ScenarioViewpoint::BoundaryInterface), false),
-            (Layer::Oa, None, false),
-            (Layer::Sa, None, false),
-            (Layer::Oa, None, true),
-            (Layer::Sa, None, true),
-        ] {
-            let (p, state) = fixture(layer, viewpoint, work);
-            let raw = serde_json::to_value(&state).unwrap();
-            for width in [340., 500.] {
-                // The retained caption + 6px gap leaves approximately the observed 194px card.
-                let size = Size::new(width, 215.);
-                let mut view = host(&state, &p, "Consumer name: Assessment lifeline");
-                let mut tree = widget::Tree::new(view.as_widget());
-                let (_, g) = geometry(&mut view, &mut tree, size);
-                let fields = g.fields.unwrap();
-                assert!(
-                    (125. ..=132.).contains(&fields.height),
-                    "Measured field viewport: {fields:?}"
-                );
-                assert!(
-                    contains(fields, g.name.unwrap()),
-                    "Name clipped: {layer:?}/{viewpoint:?}/{work}/{width}"
-                );
-                assert!(
-                    contains(fields, g.parent.unwrap()),
-                    "Parent clipped: {layer:?}/{viewpoint:?}/{work}/{width}"
-                );
-                assert!(contains(
-                    Rectangle::new(Point::ORIGIN, size),
-                    g.actions.unwrap()
-                ));
-                assert!(fields.y + fields.height <= g.actions.unwrap().y);
-                let expected = state.editing.as_ref().unwrap().scope.kinds(layer);
-                assert_eq!(
-                    g.kinds.len(),
-                    if expected.len() == 1 {
-                        0
-                    } else {
-                        expected.len()
-                    }
-                );
-                for bounds in g.kinds.values() {
-                    assert!(
-                        contains(fields, *bounds),
-                        "Kind clipped: {bounds:?} in {fields:?}"
-                    );
-                }
-                let parent_text = g
-                    .text
-                    .iter()
-                    .find(|(s, _)| s.starts_with("Semantic parent:"))
-                    .unwrap();
-                assert_eq!(
-                    parent_text.0,
-                    format!("Semantic parent: {layer} layer root")
-                );
-                assert!(
-                    parent_text.1.height > 0.,
-                    "Paragraph measurement must not be null"
-                );
-                let explanation = g
-                    .text
-                    .iter()
-                    .find(|(s, _)| s.starts_with("The parent form"))
-                    .unwrap();
-                assert!(explanation.1.y >= g.parent.unwrap().y + g.parent.unwrap().height);
-            }
-            assert_eq!(
-                serde_json::to_value(&state).unwrap(),
-                raw,
-                "Layout must not choose a kind or mutate the draft"
-            );
-            if state.editing.as_ref().unwrap().scope.kinds(layer).len() == 1 {
-                let mut incomplete = state.clone();
-                incomplete.editing.as_mut().unwrap().kind = None;
-                let mut view = host(&incomplete, &p, "Consumer name: Assessment lifeline");
-                let mut tree = widget::Tree::new(view.as_widget());
-                let (_, g) = geometry(&mut view, &mut tree, Size::new(340., 215.));
-                assert_eq!(
-                    g.kinds.len(),
-                    1,
-                    "An incomplete recovery still needs an explicit repair choice"
-                );
-                assert!(contains(
-                    g.fields.unwrap(),
-                    *g.kinds.values().next().unwrap()
-                ));
-                assert!(contains(g.fields.unwrap(), g.name.unwrap()));
-                assert_eq!(incomplete.editing.as_ref().unwrap().kind, None);
-            }
-        }
-    }
-    #[test]
-    fn contextual_source_layout_long_parent_wraps_after_visible_name_without_losing_raw_data() {
-        let (mut p, mut state) = fixture(Layer::Oa, None, true);
-        let parent = p
-            .add_element(
-                Kind::Activity,
-                Layer::Oa,
-                "Northern operations coordination — exact parent 雨",
-                None,
-            )
-            .unwrap();
-        let d = state.editing.as_ref().unwrap();
-        let token = d.token;
-        let scope = d.scope;
-        let invocation = Id::new_v4();
-        state
-            .update(
-                &p,
-                scope,
-                invocation,
-                Event::Edit(token, Edit::Parent(Some(parent))),
-            )
-            .unwrap();
-        state
-            .update(
-                &p,
-                scope,
-                invocation,
-                Event::Edit(token, Edit::Name("  Distinct source 雨  ".into())),
-            )
-            .unwrap();
-        let raw = serde_json::to_value(&state).unwrap();
-        for width in [340., 500.] {
-            let size = Size::new(width, 235.);
-            let mut view = host(
-                &state,
-                &p,
-                "Consumer name: Coordination with a long independent label 雨 Ω",
-            );
-            let mut tree = widget::Tree::new(view.as_widget());
-            let (_, g) = geometry(&mut view, &mut tree, size);
-            assert!(contains(g.fields.unwrap(), g.name.unwrap()));
-            assert!(contains(g.fields.unwrap(), g.parent.unwrap()));
-            assert!(contains(
-                Rectangle::new(Point::ORIGIN, size),
-                g.actions.unwrap()
-            ));
-            let summary = g
-                .text
-                .iter()
-                .find(|(s, _)| s.starts_with("Semantic parent:"))
-                .unwrap();
-            assert!(summary.0.contains(&p.elements[&parent].name));
-            assert!(summary.0.contains(&p.elements[&parent].alias));
-            assert!(
-                summary.1.height > 15.,
-                "Long parent should exercise real wrapping"
-            );
-        }
-        assert_eq!(serde_json::to_value(&state).unwrap(), raw);
-        assert_eq!(
-            state.editing.as_ref().unwrap().name,
-            "  Distinct source 雨  "
-        );
-
-        let (mut p, mut state) = fixture(
-            Layer::Oa,
-            Some(ScenarioViewpoint::ParticipantInteraction),
-            false,
-        );
-        let parent = p
-            .add_element(
-                Kind::Entity,
-                Layer::Oa,
-                // Eight repetitions need not exceed a whole viewport with the
-                // platform's measured font. Exercise substantial real overflow.
-                &"Northern operational responsibility 雨 ".repeat(32),
-                None,
-            )
-            .unwrap();
-        let d = state.editing.as_ref().unwrap();
-        let token = d.token;
-        let scope = d.scope;
-        state
-            .update(
-                &p,
-                scope,
-                Id::new_v4(),
-                Event::Edit(token, Edit::Kind(Kind::Actor)),
-            )
-            .unwrap();
-        state
-            .update(
-                &p,
-                scope,
-                Id::new_v4(),
-                Event::Edit(token, Edit::Parent(Some(parent))),
-            )
-            .unwrap();
-        let raw = serde_json::to_value(&state).unwrap();
-        let recovered: State = serde_json::from_value(raw.clone()).unwrap();
-        let mut view = host(&recovered, &p, "Consumer name: Assessment lifeline");
-        let mut tree = widget::Tree::new(view.as_widget());
-        let (_, g) = geometry(&mut view, &mut tree, Size::new(340., 215.));
-        let fields = g.fields.unwrap();
-        assert!(contains(fields, g.name.unwrap()));
-        assert_eq!(g.kinds.len(), 3);
-        for bounds in g.kinds.values() {
-            assert!(
-                contains(fields, *bounds),
-                "Long parent must not hide a semantic choice"
-            );
-            assert!(bounds.y + bounds.height <= g.parent.unwrap().y);
-        }
-        // Arbitrary authored detail may scroll, but its label and first line are
-        // visible after the required kind controls, never in front of them.
-        let parent_bounds = g.parent.unwrap();
-        assert!(parent_bounds.y + 16. <= fields.y + fields.height);
-        assert!(
-            parent_bounds.height > fields.height,
-            "Exercise genuinely overflowing parent text: {parent_bounds:?} in {fields:?}"
-        );
-        let content = g.content.unwrap();
-        assert!(
-            content.height > fields.height && contains(content, parent_bounds),
-            "Full parent must remain in scrollable content: {parent_bounds:?}, {content:?}, {fields:?}"
-        );
-        let summary = g
-            .text
-            .iter()
-            .find(|(s, _)| s.starts_with("Semantic parent:"))
-            .unwrap();
-        assert!(summary.0.contains(&p.elements[&parent].name));
-        assert!(summary.0.contains(&p.elements[&parent].alias));
-        assert!(contains(
-            Rectangle::new(Point::ORIGIN, Size::new(340., 215.)),
-            g.actions.unwrap()
-        ));
-        assert_eq!(serde_json::to_value(&recovered).unwrap(), raw);
-    }
-    #[test]
-    fn contextual_source_layout_visible_kind_click_keeps_choice_explicit_and_name_input_works() {
-        let (p, mut state) = fixture(
-            Layer::Oa,
-            Some(ScenarioViewpoint::ParticipantInteraction),
-            false,
-        );
-        let original = p.clone();
-        let token = state.editing.as_ref().unwrap().token;
-        let scope = state.editing.as_ref().unwrap().scope;
-        assert_eq!(state.editing.as_ref().unwrap().kind, None);
-        let size = Size::new(340., 215.);
-        let mut view = host(&state, &p, "Consumer name: Assessment lifeline");
-        let mut tree = widget::Tree::new(view.as_widget());
-        let (node, g) = geometry(&mut view, &mut tree, size);
-        let mut messages = Vec::new();
-        for kind in [Kind::Entity, Kind::Actor, Kind::Role] {
-            let bounds = g.kinds[&kind.to_string()];
-            assert!(contains(g.fields.unwrap(), bounds));
-            for action in [
-                iced::mouse::Event::ButtonPressed(iced::mouse::Button::Left),
-                iced::mouse::Event::ButtonReleased(iced::mouse::Button::Left),
-            ] {
-                view.as_widget_mut().update(
-                    &mut tree,
-                    &iced::Event::Mouse(action),
-                    Layout::new(&node),
-                    iced::mouse::Cursor::Available(bounds.center()),
-                    &FontLayout,
-                    &mut iced::advanced::clipboard::Null,
-                    &mut Shell::new(&mut messages),
-                    &Rectangle::new(Point::ORIGIN, size),
-                );
-            }
-            assert!(
-                matches!(messages.pop(), Some(Event::Edit(id, Edit::Kind(k))) if id == token && k == kind)
-            );
-        }
-        let mut focus = Geometry {
-            focus_name: true,
-            ..Geometry::default()
-        };
-        view.as_widget_mut()
-            .operate(&mut tree, Layout::new(&node), &FontLayout, &mut focus);
-        let event = iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
-            key: iced::keyboard::Key::Character("Ω".into()),
-            modified_key: iced::keyboard::Key::Character("Ω".into()),
-            physical_key: iced::keyboard::key::Physical::Code(iced::keyboard::key::Code::KeyA),
-            location: iced::keyboard::Location::Standard,
-            modifiers: iced::keyboard::Modifiers::empty(),
-            text: Some("Ω".into()),
-            repeat: false,
-        });
-        view.as_widget_mut().update(
-            &mut tree,
-            &event,
-            Layout::new(&node),
-            iced::mouse::Cursor::Unavailable,
-            &FontLayout,
-            &mut iced::advanced::clipboard::Null,
-            &mut Shell::new(&mut messages),
-            &Rectangle::new(Point::ORIGIN, size),
-        );
-        let edit = messages.pop().unwrap();
-        assert!(matches!(&edit, Event::Edit(id, Edit::Name(name)) if *id == token && name == "Ω"));
-        drop(view);
-        state.update(&p, scope, Id::new_v4(), edit).unwrap();
-        assert_eq!(
-            state.editing.as_ref().unwrap().kind,
-            None,
-            "Rendering/click event production must not silently adopt a kind"
-        );
-        assert_eq!(state.editing.as_ref().unwrap().name, "Ω");
-        assert_eq!(p, original);
-    }
-}
@@ -81,9 +81,10 @@ pub struct State {
    tool: CanvasTool,
    expanded: BTreeSet<Id>,
    scroll_offsets: [iced::Vector; 2],
-    return_to: Vec<(Id, Id, Option<oa_core::topology_context::ContextAddress>)>,
+    return_to: Vec<direct::ReturnFrame>,
    draft: Option<Draft>,
    viewport: Option<Size>,
+    pan: iced::Vector,
    zoom: Option<f32>,
    fit: bool,
    pub(crate) focused: bool,
@@ -125,6 +126,18 @@ struct Draft {
    contextual: Option<contextual::Draft>,
 }
 impl State {
+    pub(crate) fn camera_boundary(&self) -> impl PartialEq + use<> {
+        (
+            self.tool,
+            self.focused,
+            self.shelf,
+            self.viewport,
+            self.pan,
+            self.zoom,
+            self.fit,
+        )
+    }
+
    pub(super) fn pending_name(&self) -> Option<&str> {
        self.draft.as_ref().map(|d| d.name.as_str())
    }
@@ -348,10 +361,12 @@ impl State {
        )
    }

+    #[cfg(test)]
    fn canvas_offset(&self) -> iced::Vector {
        self.scroll_offsets[0]
    }

+    #[cfg(test)]
    fn fit_limited(&self, graph: Size, fallback_width: f32) -> bool {
        let available = self.fit_area(fallback_width);
        self.fit && (graph.width * 0.05 > available.width || graph.height * 0.05 > available.height)
@@ -970,6 +985,8 @@ struct Graph<'a> {
    project: &'a Project,
    interaction: Option<(Context, CanvasTool, bool)>,
    scroll_offset: iced::Vector,
+    camera_pan: iced::Vector,
+    pending_insertion: Option<Insertion>,
    nodes: Vec<GraphNode>,
    edges: Vec<GraphEdge>,
    ordered_paths: Vec<OrderedPath>,
@@ -1302,6 +1319,8 @@ impl<'a> Graph<'a> {
            project: p,
            interaction: None,
            scroll_offset: iced::Vector::ZERO,
+            camera_pan: iced::Vector::ZERO,
+            pending_insertion: None,
            nodes,
            edges,
            ordered_paths,
@@ -1401,6 +1420,7 @@ impl canvas::Program<Message> for Graph<'_> {
    ) -> Vec<canvas::Geometry> {
        let mut f = Frame::new(renderer, bounds.size());
        f.fill_rectangle(Point::ORIGIN, bounds.size(), Color::WHITE);
+        f.translate(self.camera_pan);
        f.scale(self.scale);
        for pass in PAINT_PASSES {
            match pass {
@@ -1616,7 +1636,10 @@ impl canvas::Program<Message> for Graph<'_> {
        cursor: mouse::Cursor,
    ) -> mouse::Interaction {
        if cursor.position_in(bounds).is_some_and(|p| {
-            let p = Point::new(p.x / self.scale, p.y / self.scale);
+            let p = Point::new(
+                (p.x - self.camera_pan.x) / self.scale,
+                (p.y - self.camera_pan.y) / self.scale,
+            );
            self.nodes.iter().any(|n| n.rect.contains(p))
                || self.ordered_paths.iter().any(|path| {
                    path.points.windows(2).any(|pair| {
@@ -60,6 +60,7 @@ pub enum CanvasEvent {
    Open(Context, Id),
    Back(Context),
    Zoom(Context, Option<f32>),
+    Camera(Context, u64, super::super::canvas_workspace::Event),
    Focus(Context),
    Viewport(Context, Size),
 }
@@ -77,6 +78,7 @@ impl CanvasEvent {
            | Self::Back(c)
            | Self::AppendExchange(c)
            | Self::Zoom(c, ..)
+            | Self::Camera(c, ..)
            | Self::Focus(c)
            | Self::Viewport(c, ..) => *c,
            Self::Begin { context, .. }
@@ -86,6 +88,19 @@ impl CanvasEvent {
        }
    }
 }
+pub(super) struct ReturnFrame {
+    identity: Option<(Id, Id)>,
+    owner: Id,
+    occurrence: Id,
+    target: Id,
+    address: Option<oa_core::topology_context::ContextAddress>,
+    pan: iced::Vector,
+    zoom: Option<f32>,
+    fit: bool,
+    viewport: Option<Size>,
+    expanded: BTreeSet<Id>,
+    contextual_expanded: BTreeSet<OccurrenceEndpoint>,
+}
 impl State {
    pub(crate) fn select_context(&mut self, address: oa_core::topology_context::ContextAddress) {
        self.selected_context = Some(address);
@@ -138,6 +153,7 @@ impl State {
        if self.identity != Some((document, owner)) {
            self.identity = Some((document, owner));
            self.tool = CanvasTool::Select;
+            self.pan = iced::Vector::ZERO;
            self.zoom = Some(1.);
            self.fit = false;
            self.viewport = None;
@@ -162,11 +178,21 @@ impl State {
        // Choosing how to edit must retain the user's current view.
        self.tool = tool;
    }
+    pub(crate) fn camera(&mut self, event: super::super::canvas_workspace::Event) -> bool {
+        super::super::canvas_workspace::change(&mut self.pan, &mut self.zoom, &mut self.fit, event)
+    }
    pub(crate) fn zoom(&mut self, value: Option<f32>) {
        self.fit = value.is_none();
-        self.zoom = value.map(|v| v.clamp(0.5, 2.));
+        self.zoom = value.map(|v| v.clamp(0.05, 3.));
    }
    pub(crate) fn viewport(&mut self, size: Size) -> bool {
+        if !size.width.is_finite()
+            || !size.height.is_finite()
+            || size.width <= 0.
+            || size.height <= 0.
+        {
+            return false;
+        }
        let changed = self.viewport != Some(size);
        self.viewport = Some(size);
        changed
@@ -188,24 +214,73 @@ impl State {
        }
        true
    }
-    pub(crate) fn remember(&mut self, owner: Id, occurrence: Id) {
-        self.return_to
-            .push((owner, occurrence, self.selected_context.clone()));
+    pub(crate) fn remember(&mut self, owner: Id, occurrence: Id, target: Id) {
+        if self.return_to.len() == 32 {
+            self.return_to.remove(0);
+        }
+        self.return_to.push(ReturnFrame {
+            identity: self.identity,
+            owner,
+            occurrence,
+            target,
+            address: self.selected_context.clone(),
+            pan: self.pan,
+            zoom: self.zoom,
+            fit: self.fit,
+            viewport: self.viewport,
+            expanded: self.expanded.clone(),
+            contextual_expanded: self.contextual_expanded.clone(),
+        });
    }
    pub(crate) fn back(&mut self, p: &Project) -> Option<(Id, Id)> {
-        while let Some((owner, occurrence, address)) = self.return_to.pop() {
-            if is_contribution(p, owner, occurrence) {
-                self.selected_context = address.filter(|address| {
-                    address.owner == owner
-                        && oa_core::topology_context::TopologyIndex::new(p)
-                            .resolve(owner, &address.endpoint)
-                            .is_ok()
+        while let Some(frame) = self.return_to.pop() {
+            if frame.identity.map(|i| i.0) != self.identity.map(|i| i.0) {
+                continue;
+            }
+            let valid = referenced(p, frame.owner, frame.occurrence) == Some(frame.target)
+                || if let Some(address) = &frame.address {
+                    oa_core::topology_context::TopologyIndex::new(p)
+                        .resolve(frame.owner, &address.endpoint)
+                        .is_ok_and(|r| r.defining_sequence == frame.target)
+                } else {
+                    false
+                };
+            if valid && is_contribution(p, frame.owner, frame.occurrence) {
+                self.identity = frame.identity;
+                self.selected_context = frame.address.filter(|a| {
+                    oa_core::topology_context::TopologyIndex::new(p)
+                        .resolve(frame.owner, &a.endpoint)
+                        .is_ok()
                });
-                return Some((owner, occurrence));
+                self.pan = frame.pan;
+                self.zoom = frame.zoom;
+                self.fit = frame.fit;
+                self.viewport = frame.viewport;
+                self.expanded = frame.expanded;
+                self.contextual_expanded = frame.contextual_expanded;
+                return Some((frame.owner, frame.occurrence));
            }
        }
        None
    }
+    pub(crate) fn camera_zoom(&mut self, p: &Project, owner: Id, zoom: Option<f32>) {
+        let graph =
+            Graph::expanded_qualified(p, owner, owner, &self.expanded, &self.contextual_expanded);
+        let old = self.scale(graph.size, 500.);
+        if let Some(next) = zoom {
+            let size = self.viewport.unwrap_or(Size::new(500., 300.));
+            self.camera(super::super::canvas_workspace::Event::Zoom {
+                factor: next / old,
+                at: Point::new(size.width / 2., size.height / 2.),
+                base: old,
+            });
+        } else {
+            self.zoom(None);
+            let fitted = self.scale(graph.size, 500.);
+            self.zoom(Some(fitted));
+            self.pan = iced::Vector::ZERO;
+        }
+    }
    pub(crate) fn created_selection(&self, p: &Project, command: &Command) -> Option<Id> {
        let owner = self.pending_owner()?;
        if self
@@ -575,9 +650,12 @@ impl Graph<'_> {
            }
            _ => cursor,
        };
-        let world = cursor
-            .position_in(bounds)
-            .map(|p| Point::new(p.x / self.scale, p.y / self.scale));
+        let world = cursor.position_in(bounds).map(|p| {
+            Point::new(
+                (p.x - self.camera_pan.x) / self.scale,
+                (p.y - self.camera_pan.y) / self.scale,
+            )
+        });
        let publish = |event| Some(Action::publish(Message::TopologyCanvas(event)).and_capture());
        match event {
            canvas::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) if visible => {
@@ -730,6 +808,22 @@ impl Graph<'_> {
        let Some((context, tool, editable)) = self.interaction else {
            return;
        };
+        if let Some(insertion) = self.pending_insertion {
+            if let Some(edge) = insertion
+                .link
+                .and_then(|id| self.edges.iter().find(|e| e.id == id))
+            {
+                draw_arrow(f, &edge.points, style::TEAL, 3.);
+            } else if let Some(node) = insertion
+                .before
+                .and_then(|id| self.nodes.iter().find(|n| n.id == id))
+            {
+                f.stroke(
+                    &Path::rounded_rectangle(node.rect.position(), node.rect.size(), 10.into()),
+                    Stroke::default().with_color(style::TEAL).with_width(3.),
+                );
+            }
+        }
        if !editable {
            return;
        }
@@ -738,7 +832,12 @@ impl Graph<'_> {
            .map(|p| p + self.scroll_offset)
            .or_else(|| cursor.position())
            .filter(|p| bounds.contains(*p))
-            .map(|p| Point::new((p.x - bounds.x) / self.scale, (p.y - bounds.y) / self.scale));
+            .map(|p| {
+                Point::new(
+                    (p.x - bounds.x - self.camera_pan.x) / self.scale,
+                    (p.y - bounds.y - self.camera_pan.y) / self.scale,
+                )
+            });
        let live =
            state.context == Some(context) && state.tool == tool && state.bounds == Some(bounds);
        if live && let Some(source) = state.source {
@@ -853,12 +952,7 @@ impl Graph<'_> {
 }

 impl State {
-    pub(crate) fn selection_offset(
-        &self,
-        p: &Project,
-        owner: Id,
-        id: Id,
-    ) -> Option<scrollable::AbsoluteOffset> {
+    pub(crate) fn reveal_selection(&mut self, p: &Project, owner: Id, id: Id) -> bool {
        let graph =
            Graph::expanded_qualified(p, owner, id, &self.expanded, &self.contextual_expanded);
        let scale = self.scale(graph.size, 500.);
@@ -870,10 +964,25 @@ impl State {
                self.qualified_selection(p, owner)
                    .map_or(n.rect, |a| n.endpoint_rect(&a.endpoint))
            })
-            .or_else(|| graph.edges.iter().find(|e| e.id == id).map(|e| e.label))?;
-        Some(scrollable::AbsoluteOffset {
-            x: (rect.x * scale - 12.).max(0.),
-            y: (rect.y * scale - 12.).max(0.),
-        })
+            .or_else(|| graph.edges.iter().find(|e| e.id == id).map(|e| e.label));
+        let Some(rect) = rect else {
+            return false;
+        };
+        let viewport = self.viewport.unwrap_or(Size::new(500., 300.));
+        let x = rect.x * scale + self.pan.x;
+        let y = rect.y * scale + self.pan.y;
+        let delta = iced::Vector::new(
+            if x < 12. || x + rect.width * scale > viewport.width - 12. {
+                12. - x
+            } else {
+                0.
+            },
+            if y < 12. || y + rect.height * scale > viewport.height - 12. {
+                12. - y
+            } else {
+                0.
+            },
+        );
+        self.camera(super::super::canvas_workspace::Event::Pan(delta))
    }
 }
@@ -732,7 +732,7 @@ fn direct_process_readable_default_fit_expansion_and_bounded_choices() {
    state.zoom(None);
    assert!(state.scale(Size::new(3262., 220.), 500.) < 0.2);
    state.zoom(Some(0.1));
-    assert_eq!(state.scale(Size::new(3262., 220.), 500.), 0.5);
+    assert_eq!(state.scale(Size::new(3262., 220.), 500.), 0.1);
    state.enter(Id::new_v4(), f.owner);
    assert_eq!(state.scale(Size::new(3262., 220.), 500.), 1.);
    let mut all = Vec::new();
@@ -1364,82 +1364,6 @@ fn direct_process_palette_preserves_fit_and_manual_camera() {
    }
 }

-#[test]
-fn direct_process_pending_form_diff_retains_the_canvas_scroll_state() {
-    use iced::advanced::widget::{Tree, tree};
-    use std::rc::Rc;
-    fn path_to(tree: &Tree, tag: tree::Tag) -> Option<Vec<usize>> {
-        if tree.tag == tag {
-            return Some(Vec::new());
-        }
-        tree.children.iter().enumerate().find_map(|(index, child)| {
-            let mut path = path_to(child, tag)?;
-            path.insert(0, index);
-            Some(path)
-        })
-    }
-    fn at<'a>(mut tree: &'a mut Tree, path: &[usize]) -> &'a mut Tree {
-        for &index in path {
-            tree = &mut tree.children[index];
-        }
-        tree
-    }
-    for layer in [Layer::Oa, Layer::Sa] {
-        for size in [Size::new(1440., 900.), Size::new(1100., 700.)] {
-            for tool in [Tool::Control, Tool::Branch, Tool::Connect] {
-                let f = fixture(layer);
-                let mut app = App::with_project(f.p.clone());
-                let _ = app.update(Message::Select(f.nodes[1]));
-                let _ = app.update(Message::Page(crate::app::Page::Behavior));
-                app.window_size = size;
-                let original = app.document.snapshot();
-                let graph: Element<'_, Message> =
-                    canvas::Canvas::new(Graph::new(app.project(), f.owner, f.nodes[1])).into();
-                let canvas_tag = Tree::new(graph.as_widget()).tag;
-                drop(graph);
-                let scroll: Element<'_, Message> = scrollable(text("")).into();
-                let scroll_tag = Tree::new(scroll.as_widget()).tag;
-                let mut tree = Tree::new(view::view(&app, f.owner, Column::new()).as_widget());
-                let mut scroll_path = path_to(&tree, canvas_tag).unwrap();
-                scroll_path.pop();
-                assert_eq!(at(&mut tree, &scroll_path).tag, scroll_tag);
-                // Scrollable::diff treats its local state as opaque. A retained marker
-                // proves the real Iced diff preserves the state that owns the offsets.
-                // No layout or input operation runs on this test-only marker state.
-                let marker = Rc::new(());
-                at(&mut tree, &scroll_path).state = tree::State::new(Rc::clone(&marker));
-                let _ = app.update(Message::Behavior(super::super::Event::Topology(
-                    Event::Start(f.owner, tool, Some(f.nodes[1])),
-                )));
-                assert!(app.behavior.has_pending());
-                tree.diff(view::view(&app, f.owner, Column::new()).as_widget());
-                assert_eq!(
-                    Rc::strong_count(&marker),
-                    2,
-                    "form open: {layer:?} {size:?} {tool:?}"
-                );
-                let mut current_path = path_to(&tree, canvas_tag).unwrap();
-                current_path.pop();
-                assert_eq!(current_path, scroll_path);
-                assert!(Rc::ptr_eq(
-                    at(&mut tree, &scroll_path).state.downcast_ref::<Rc<()>>(),
-                    &marker,
-                ));
-                let _ = app.update(Message::Behavior(super::super::Event::Topology(
-                    Event::Cancel,
-                )));
-                tree.diff(view::view(&app, f.owner, Column::new()).as_widget());
-                assert_eq!(
-                    Rc::strong_count(&marker),
-                    2,
-                    "form cancel: {layer:?} {size:?} {tool:?}"
-                );
-                assert!(std::sync::Arc::ptr_eq(&app.document.snapshot(), &original));
-            }
-        }
-    }
-}
-
 #[test]
 fn direct_process_scaled_control_and_link_gestures_use_visible_positions() {
    for layer in [Layer::Oa, Layer::Sa] {
@@ -66,107 +66,7 @@ pub(super) fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Ele
    let pending = state.draft.is_some();
    let ordered = !legacy_order(p, owner).is_empty();
    let selected = is_contribution(p, owner, app.selected).then_some(app.selected);
-    let choose = |tool| Message::TopologyCanvas(CanvasEvent::Choose(context, tool));
-    let mut controls = Column::new().spacing(6);
-    if !pending {
-        controls = controls
-            .push(
-                row![
-                    button("Select / reorder")
-                        .style(if state.tool == CanvasTool::Select {
-                            button::primary
-                        } else {
-                            style::nav
-                        })
-                        .on_press(choose(CanvasTool::Select)),
-                    button("Work")
-                        .style(
-                            if state.tool == CanvasTool::Add(Tool::Work, ControlKind::Choice) {
-                                button::primary
-                            } else {
-                                style::nav
-                            }
-                        )
-                        .on_press(choose(CanvasTool::Add(Tool::Work, ControlKind::Choice))),
-                    button("Exchange")
-                        .style(
-                            if state.tool == CanvasTool::Add(Tool::Exchange, ControlKind::Choice) {
-                                button::primary
-                            } else {
-                                style::nav
-                            }
-                        )
-                        .on_press(choose(CanvasTool::Add(Tool::Exchange, ControlKind::Choice))),
-                    button("Reuse")
-                        .style(
-                            if state.tool == CanvasTool::Add(Tool::Reuse, ControlKind::Choice) {
-                                button::primary
-                            } else {
-                                style::nav
-                            }
-                        )
-                        .on_press(choose(CanvasTool::Add(Tool::Reuse, ControlKind::Choice)))
-                ]
-                .spacing(6),
-            )
-            .push(
-                row![
-                    pick_list(
-                        vec![
-                            ControlKind::Choice,
-                            ControlKind::Merge,
-                            ControlKind::Fork,
-                            ControlKind::Join,
-                            ControlKind::Loop
-                        ]
-                        .into_iter()
-                        .map(ControlChoice)
-                        .collect::<Vec<_>>(),
-                        if let CanvasTool::Add(Tool::Control, kind) = state.tool {
-                            Some(ControlChoice(kind))
-                        } else {
-                            None
-                        },
-                        move |c| Message::TopologyCanvas(CanvasEvent::Choose(
-                            context,
-                            CanvasTool::Add(Tool::Control, c.0)
-                        ))
-                    )
-                    .placeholder("Draw control…")
-                    .text_size(12)
-                    .padding(8),
-                    button("Sequence link")
-                        .style(if state.tool == CanvasTool::Connect {
-                            button::primary
-                        } else {
-                            style::nav
-                        })
-                        .on_press(choose(CanvasTool::Connect)),
-                    button("Two paths…").on_press(event(Event::Start(
-                        owner,
-                        Tool::Branch,
-                        selected
-                    )))
-                ]
-                .spacing(6),
-            );
-    }
-    controls=controls.push(label(if pending{"Pending contribution · apply or cancel below"}else if ordered{"Ordered exchange path · click a path to insert or empty canvas to continue; the edit preserves its order"}else{match state.tool{
-        CanvasTool::Select=>"Select local contributions and paths · drag path endpoints to reconnect · ↕ reorders within a column",
-        CanvasTool::Connect=>"Sequence link · click or drag from preceding to following contribution · Escape cancels",
-        CanvasTool::Add(..)=>"Choose a highlighted path or contribution position · existing work stays shared · Escape cancels"}}));
-    if !pending && ordered {
-        controls = controls.push(button("Append exchange…").on_press(Message::TopologyCanvas(
-            CanvasEvent::AppendExchange(context),
-        )));
-        let commands = preserved_order(p, owner, None);
-        if !commands.is_empty() {
-            controls = controls.push(
-                button("Edit path links and guards")
-                    .on_press(Message::Command(unique_batch(p, commands))),
-            );
-        }
-    }
+    let clean = !app.behavior.has_pending() && !app.draft_dirty() && !app.source_dirty();
    // A fixed sibling keeps Iced's canvas scroll state through selection/form changes.
    let mut navigation = column![].spacing(6);
    if let Some(Relation {
@@ -211,11 +111,6 @@ pub(super) fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Ele
            );
        }
    }
-    if !pending {
-        controls = controls.push(button("Qualified link / assembly…").on_press(event(
-            Event::Start(owner, Tool::Contextual, Some(app.selected)),
-        )));
-    }
    if let Some(id) = selected {
        let mut actions =
            row![button("Contribution properties").on_press(Message::EditProperties(id))]
@@ -256,27 +151,79 @@ pub(super) fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Ele
            button("Back to caller").on_press(Message::TopologyCanvas(CanvasEvent::Back(context))),
        );
    }
-    let diagram = {
-        let mut graph = Graph::expanded_qualified(
-            p,
-            owner,
-            app.selected,
-            &state.expanded,
-            &state.contextual_expanded,
+    navigation = navigation
+        .push(
+            button("Two paths...").on_press_maybe(clean.then_some(event(Event::Start(
+                owner,
+                Tool::Branch,
+                selected,
+            )))),
+        )
+        .push(
+            button("Qualified link / assembly...").on_press_maybe(clean.then_some(event(
+                Event::Start(owner, Tool::Contextual, Some(app.selected)),
+            ))),
        );
-        graph.scale = state.scale(graph.size, (app.window_size.width - 600.).max(200.));
-        graph.interaction = Some((
-            context,
-            state.tool,
-            !app.behavior.has_pending() && !app.draft_dirty() && !app.source_dirty(),
-        ));
-        // Explicit graphs no longer have a scrolling page ancestor. A retained
-        // offset from an ordered view must not distort their pointer coordinates.
-        graph.scroll_offset = state.canvas_offset();
-        let scale = graph.scale;
-        let mut header = column![
-            row![
-                out.width(Fill),
+    if ordered {
+        navigation = navigation.push(button("Append exchange...").on_press_maybe(clean.then_some(
+            Message::TopologyCanvas(CanvasEvent::AppendExchange(context)),
+        )));
+        let commands = preserved_order(p, owner, None);
+        if !commands.is_empty() {
+            navigation = navigation.push(
+                button("Edit path links and guards")
+                    .on_press_maybe(clean.then_some(Message::Command(unique_batch(p, commands)))),
+            );
+        }
+    }
+    let mut graph = Graph::expanded_qualified(
+        p,
+        owner,
+        app.selected,
+        &state.expanded,
+        &state.contextual_expanded,
+    );
+    graph.scale = state.scale(graph.size, (app.window_size.width - 600.).max(200.));
+    graph.camera_pan = state.pan;
+    graph.pending_insertion = state
+        .draft
+        .as_ref()
+        .filter(|d| d.owner == owner && d.fixed)
+        .map(|d| d.insertion);
+    graph.interaction = Some((context, state.tool, clean));
+    let scale = graph.scale;
+    let scope = super::super::canvas_workspace::Scope {
+        document: context.document,
+        owner,
+        revision: context.revision,
+        epoch: app.camera_epoch,
+    };
+    let keyboard = clean && super::super::canvas_workspace::keyboard_enabled(app);
+    let camera = move |e| Message::TopologyCanvas(CanvasEvent::Camera(context, scope.epoch, e));
+    let canvas = container(
+        iced::widget::sensor(
+            super::super::canvas_workspace::Viewport::new(
+                canvas::Canvas::new(graph).width(Fill).height(Fill),
+                scope,
+                scale,
+                keyboard,
+                camera,
+            )
+            .pan_background(state.tool == CanvasTool::Select),
+        )
+        .key((context.document, owner))
+        .on_show(move |size| Message::TopologyCanvas(CanvasEvent::Viewport(context, size)))
+        .on_resize(move |size| Message::TopologyCanvas(CanvasEvent::Viewport(context, size))),
+    )
+    .id("process-viewport")
+    .width(Fill)
+    .height(Fill)
+    .style(style::card)
+    .into();
+    let header = column![
+        row![
+            out.width(Fill),
+            super::super::canvas_workspace::Control::new(
                button(
                    text(if state.focused {
                        "Restore panels"
@@ -285,121 +232,104 @@ pub(super) fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Ele
                    })
                    .size(12)
                )
-                .on_press(Message::TopologyCanvas(CanvasEvent::Focus(context)))
                .padding(6)
-            ]
-            .spacing(6)
-            .align_y(iced::Center),
-            row![
-                button(text("Tools").size(12))
-                    .padding(6)
-                    .style(if state.shelf == Some(Shelf::Tools) {
-                        button::primary
-                    } else {
-                        style::nav
-                    })
-                    .on_press(event(Event::Shelf(Shelf::Tools))),
-                button(text("Selection details").size(12))
-                    .padding(6)
-                    .style(if state.shelf == Some(Shelf::Selection) {
-                        button::primary
-                    } else {
-                        style::nav
-                    })
-                    .on_press(event(Event::Shelf(Shelf::Selection))),
-                button(text("Fit overview").size(12))
-                    .padding(6)
-                    .on_press(Message::TopologyCanvas(CanvasEvent::Zoom(context, None))),
-                button(text("−").size(12))
-                    .padding(6)
-                    .on_press(Message::TopologyCanvas(CanvasEvent::Zoom(
-                        context,
-                        Some(scale / 1.25)
-                    ))),
-                label(format!("{:.0}%", scale * 100.)),
-                button(text("+").size(12))
-                    .padding(6)
-                    .on_press(Message::TopologyCanvas(CanvasEvent::Zoom(
-                        context,
-                        Some(scale * 1.25)
-                    ))),
-                button(text("100%").size(12))
-                    .padding(6)
-                    .on_press(Message::TopologyCanvas(CanvasEvent::Zoom(
-                        context,
-                        Some(1.)
-                    )))
-            ]
-            .spacing(6)
-            .wrap(),
+                .on_press(super::super::canvas_workspace::intent(
+                    scope,
+                    "Panels",
+                    Message::TopologyCanvas(CanvasEvent::Focus(context))
+                )),
+                scope,
+                "Panels",
+                keyboard,
+                Some(super::super::canvas_workspace::intent(
+                    scope,
+                    "Panels",
+                    Message::TopologyCanvas(CanvasEvent::Focus(context))
+                )),
+                camera
+            )
        ]
-        .spacing(6);
-        if state.fit_limited(graph.size, (app.window_size.width - 600.).max(200.)) {
-            header = header
-                .push(text("Minimum zoom reached · scroll to see the remaining graph.").size(11));
-        }
-        if graph.nodes.is_empty() {
-            controls = controls.push(label(
-                "Choose Work, Exchange, Reuse or a control, then click the canvas to start.",
-            ));
-        }
-        let size = Size::new(graph.size.width * scale, graph.size.height * scale);
-        let canvas = scrollable(
-            canvas::Canvas::new(graph)
-                .width(size.width)
-                .height(size.height),
-        )
-        .id("process-canvas")
-        .direction(scrollable::Direction::Both {
-            vertical: scrollable::Scrollbar::default(),
-            horizontal: scrollable::Scrollbar::default(),
-        })
-        .width(Fill)
-        .height(Fill);
-        let canvas = container(
-            iced::widget::sensor(super::super::scenario_scroll::observe_topology(
+        .spacing(6),
+        super::super::canvas_workspace::controls(
+            scope,
+            keyboard,
+            scale,
+            event(Event::Shelf(Shelf::Selection)),
+            clean.then_some(Message::TopologyCanvas(CanvasEvent::Camera(
                context,
-                scenario::ScrollArea::Canvas,
-                canvas,
-            ))
-            .on_show(move |size| Message::TopologyCanvas(CanvasEvent::Viewport(context, size)))
-            .on_resize(move |size| Message::TopologyCanvas(CanvasEvent::Viewport(context, size))),
+                scope.epoch,
+                super::super::canvas_workspace::Event::Focus
+            ))),
+            move |zoom| Message::TopologyCanvas(CanvasEvent::Zoom(context, zoom)),
+            camera
        )
-        .padding(8)
-        .width(Fill)
-        .height(Fill)
-        .style(style::card);
-        if !pending && !p.children(owner).any(|e| is_contribution(p, owner, e.id)) {
-            let title = if p.layer_of(owner) == Some(Layer::Oa) {
-                "Add first activity contribution"
-            } else {
-                "Add first function contribution"
-            };
-            header = header.push(button(title).on_press_maybe(
-                (!app.behavior.has_pending() && !app.draft_dirty() && !app.source_dirty()).then(
-                    || {
-                        Message::TopologyCanvas(CanvasEvent::Begin {
-                            context,
-                            tool: Tool::Work,
-                            control: ControlKind::Choice,
-                            insertion: Insertion::default(),
-                        })
-                    },
-                ),
-            ));
-        }
-        let details: Element<'_, Message> = match state.shelf {
-            Some(Shelf::Tools) => controls.into(),
-            _ => navigation.push(text("Full qualified identities and definition actions appear here for the selected contribution or link.").size(11)).into(),
-        };
-        explicit_pane(
-            header.into(),
-            details,
-            canvas.into(),
-            state.shelf.is_some(),
-            pending,
-        )
-    };
+    ]
+    .spacing(4);
+    let entries = [
+        ("S", "Select contributions or paths", CanvasTool::Select),
+        (
+            "W",
+            "Work: click a path or empty space",
+            CanvasTool::Add(Tool::Work, ControlKind::Choice),
+        ),
+        (
+            "E",
+            "Exchange: click a path or empty space",
+            CanvasTool::Add(Tool::Exchange, ControlKind::Choice),
+        ),
+        (
+            "ref",
+            "Reuse process / chain",
+            CanvasTool::Add(Tool::Reuse, ControlKind::Choice),
+        ),
+        (
+            "OR",
+            "Choice",
+            CanvasTool::Add(Tool::Control, ControlKind::Choice),
+        ),
+        (
+            "M",
+            "Merge",
+            CanvasTool::Add(Tool::Control, ControlKind::Merge),
+        ),
+        (
+            "AND",
+            "Fork",
+            CanvasTool::Add(Tool::Control, ControlKind::Fork),
+        ),
+        (
+            "J",
+            "Join",
+            CanvasTool::Add(Tool::Control, ControlKind::Join),
+        ),
+        (
+            "IT",
+            "Loop",
+            CanvasTool::Add(Tool::Control, ControlKind::Loop),
+        ),
+        (
+            "->",
+            "Sequence link: click or drag between contributions",
+            CanvasTool::Connect,
+        ),
+    ];
+    let palette = super::super::canvas_workspace::palette(
+        scope,
+        keyboard,
+        camera,
+        entries.into_iter().map(|(glyph, label, choice)| {
+            (
+                glyph,
+                label,
+                choice == state.tool,
+                clean.then_some(Message::TopologyCanvas(CanvasEvent::Choose(
+                    context, choice,
+                ))),
+            )
+        }),
+    );
+    let details = scrollable(navigation.push(text("Layout is derived. The reorder handle changes display order within its column; it does not author a position.").size(11)))
+        .id("process-details").width(Fill).height(Fill).into();
    let mut form_panel: Element<'_, Message> = iced::widget::Space::new().height(0).into();
    if let Some(d) = state.draft.as_ref().filter(|d| d.owner == owner) {
        if let Some(child) = d.source.view(p) {
@@ -617,77 +547,37 @@ pub(super) fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Ele
                button("Cancel").on_press(event(Event::Cancel))
            ]
            .spacing(7);
-            form_panel = editor_panel(actions.into(), form.into());
+            form_panel = editor_panel(d.invocation, actions.into(), form.into());
        }
    }
-    panes(diagram, form_panel, pending)
-}
-
-/// A permanent three-slot tree: variable controls never remount the canvas.
-/// The shelf scrolls independently; the canvas receives actual remaining height.
-fn explicit_pane<'a, R: iced::advanced::text::Renderer + 'a>(
-    header: iced::Element<'a, Message, iced::Theme, R>,
-    details: iced::Element<'a, Message, iced::Theme, R>,
-    canvas: iced::Element<'a, Message, iced::Theme, R>,
-    show_details: bool,
-    pending: bool,
-) -> iced::Element<'a, Message, iced::Theme, R> {
-    // Column::push drops Fixed(0) children. from_vec retains the closed shelf
-    // slot so its disclosure cannot move/remount the following canvas tree.
-    Column::from_vec(vec![
-        container(header).width(Fill).into(),
-        scrollable(details)
-            .id("process-details")
-            .width(Fill)
-            .height(if show_details {
-                if pending { 64. } else { 112. }
-            } else {
-                0.
-            })
-            .into(),
-        container(canvas).width(Fill).height(Fill).into(),
-    ])
-    .spacing(6)
-    .padding(8)
-    .width(Fill)
-    .height(Fill)
-    .into()
-}
-
-/// Keep the diagram mounted while an independent editor uses the remaining
-/// workspace height. The editor must never be clipped by the page scrollable.
-fn panes<'a, R: iced::advanced::Renderer + 'a>(
-    diagram: iced::Element<'a, Message, iced::Theme, R>,
-    form: iced::Element<'a, Message, iced::Theme, R>,
-    pending: bool,
-) -> iced::Element<'a, Message, iced::Theme, R> {
-    column![
-        container(diagram).width(Fill).height(if pending {
-            iced::Length::FillPortion(1)
-        } else {
-            Fill
-        }),
-        container(form).width(Fill).height(if pending {
-            iced::Length::FillPortion(1)
-        } else {
-            iced::Length::Shrink
-        }),
-    ]
-    .width(Fill)
-    .height(Fill)
-    .into()
+    let editor = if pending {
+        Some(form_panel)
+    } else {
+        state.shelf.map(|_| details)
+    };
+    super::super::canvas_workspace::host(header.into(), palette, canvas, editor)
 }

 fn editor_panel<'a, R: iced::advanced::text::Renderer + 'a>(
+    session: Id,
    actions: iced::Element<'a, Message, iced::Theme, R>,
    fields: iced::Element<'a, Message, iced::Theme, R>,
 ) -> iced::Element<'a, Message, iced::Theme, R> {
    container(
-        container(column![actions, scrollable(fields).id("process-form").height(Fill)].spacing(8))
-            .width(Fill)
-            .height(Fill)
-            .padding(12)
-            .style(style::card),
+        container(
+            column![
+                container(actions).id("process-actions"),
+                super::super::form_session::reset_on_change(
+                    session,
+                    scrollable(fields).id("process-form").height(Fill)
+                )
+            ]
+            .spacing(8),
+        )
+        .width(Fill)
+        .height(Fill)
+        .padding(12)
+        .style(style::card),
    )
    .width(Fill)
    .height(Fill)
@@ -95,7 +95,7 @@ pub struct Document {
    past: Vec<HistoryEntry>,
    future: Vec<HistoryEntry>,
    current_bytes: usize,
-    saved: Option<Arc<SourceBundle>>,
+    saved: Arc<SourceBundle>,
    revision: u64,
    view_index: std::cell::OnceCell<oa_core::view_options::ViewIndex>,
    limits: ProjectLimits,
@@ -125,7 +125,7 @@ impl Document {
            current_bytes,
            past: Vec::new(),
            future: Vec::new(),
-            saved: Some(Arc::new(bundle)),
+            saved: Arc::new(bundle),
            revision: 0,
            view_index: Default::default(),
            limits,
@@ -156,7 +156,7 @@ impl Document {
    }

    pub fn dirty(&self) -> bool {
-        self.recovered_unsaved || self.saved.as_deref() != Some(self.bundle())
+        self.recovered_unsaved || self.bundle() != self.saved.as_ref()
    }

    /// Recovered work is a detached copy until explicitly saved by its user.
@@ -181,24 +181,10 @@ impl Document {
    /// Records the bytes actually saved, even when later edits remain current.
    /// The I/O adapter owns document identity and save completion ordering.
    pub fn mark_saved(&mut self, snapshot: Arc<CompiledSourceProject>) {
-        self.saved = Some(Arc::new(snapshot.bundle.clone()));
+        self.saved = Arc::new(snapshot.bundle.clone());
        self.recovered_unsaved = false;
    }

-    /// Bind an installed or recovered repair destination to source read there.
-    /// These bytes may be invalid or differ from the retained accepted model,
-    /// but must replace the previous disk baseline. Accepted history is retained;
-    /// applying or undoing to old saved content does not save this destination.
-    pub(crate) fn bind_repair_baseline(&mut self, source: SourceBundle) {
-        self.saved = Some(Arc::new(source));
-    }
-
-    /// Recovery changed the current destination, but its source could not be
-    /// reloaded. No accepted or historical snapshot is known to be saved there.
-    pub(crate) fn invalidate_saved_baseline(&mut self) {
-        self.saved = None;
-    }
-
    /// Check a source Save as before writing any files. A retained included file
    /// must never be displaced by the new entry, including on a later Undo.
    pub fn check_save_entry(&self, entry: &str) -> Result<(), DocumentError> {
@@ -18,6 +18,7 @@ mod context_fields;
 mod data_fields;
 mod history_fields;
 mod port_fields;
+pub(crate) mod reference_chooser;
 mod view_fields;

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -85,6 +86,8 @@ pub struct Draft {
    pub value_browsers: BTreeMap<String, ValueBrowser>,
    pub reference_browsers: BTreeMap<String, ReferenceBrowser>,
    history: history_fields::State,
+    reference_session: Id,
+    reference_generation: Id,
 }

 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -209,11 +212,14 @@ impl Draft {
            value_browsers: BTreeMap::new(),
            reference_browsers: BTreeMap::new(),
            history: Default::default(),
+            reference_session: Id::new_v4(),
+            reference_generation: Id::new_v4(),
        };
        draft.rebuild();
        Some(draft)
    }
    fn rebuild(&mut self) {
+        self.reference_generation = Id::new_v4();
        // Array/variant edits can change the meaning of a row path.
        self.value_browsers.clear();
        self.inputs.clear();
@@ -274,6 +280,9 @@ impl Draft {
            .unwrap_or_else(|| self.materialize().unwrap_or_else(|_| self.value.clone()))
    }
    pub fn set_context(&mut self, context: Option<Value>) {
+        if self.context != context {
+            self.reference_generation = Id::new_v4();
+        }
        self.context = context;
    }
    /// Materialize selected scalar subtrees without parsing retained, unselected drafts.
@@ -359,6 +368,9 @@ impl Draft {
    }
    pub fn input(&mut self, path: &str, value: String) {
        if let Some(input) = self.inputs.get_mut(path) {
+            if input.raw != value {
+                self.reference_generation = Id::new_v4();
+            }
            input.editor = text_editor::Content::with_text(&value);
            input.raw = value;
        }
@@ -366,7 +378,11 @@ impl Draft {
    pub fn edit_text(&mut self, path: &str, action: text_editor::Action) {
        if let Some(input) = self.inputs.get_mut(path) {
            input.editor.perform(action);
-            input.raw = input.editor.text();
+            let raw = input.editor.text();
+            if input.raw != raw {
+                self.reference_generation = Id::new_v4();
+            }
+            input.raw = raw;
        }
    }
    pub fn shape(&mut self, path: &str, value: Value) -> Result<(), String> {
@@ -1795,7 +1811,7 @@ pub fn view<'a>(draft: &'a Draft, project: &'a Project) -> View<'a, Message> {
            ));
        }
    }
-    content.into()
+    reference_chooser::trigger::scope(content, draft.reference_session)
 }

 /// Render one closed property subtree for a workflow-owned typed draft.
@@ -1937,41 +1953,12 @@ fn property<'a>(
        return out.into();
    }
    if reference(path) && (value.is_string() || value.is_null()) {
-        let raw = draft
-            .inputs
-            .get(path)
-            .map(|v| v.raw.as_str())
-            .or_else(|| value.as_str());
-        let current = raw.and_then(|s| s.parse::<Id>().ok()).unwrap_or(Id::nil());
-        let choices = reference_choices(draft, project, path, current);
-        let selected = choices.iter().find(|c| c.id == current).cloned();
-        let owned_path = path.to_string();
-        let optional = optional_reference(path);
-        let mut content = column![
+        return column![
            label_view(),
-            pick_list(choices, selected, move |choice| Message::FieldShape(
-                owned_path.clone(),
-                if choice.id.is_nil() && optional {
-                    Value::Null
-                } else {
-                    json!(choice.id)
-                }
-            ))
-            .text_size(12)
-            .padding(8)
-            .width(Fill)
+            reference_chooser::adapter::field(draft, project, path)
        ]
-        .spacing(5);
-        if let Some(raw) = raw
-            && raw.parse::<Id>().is_err()
-        {
-            content = content.push(
-                text(format!("Invalid reference retained in the draft: {raw}"))
-                    .size(11)
-                    .color(style::MUTED),
-            );
-        }
-        return content.into();
+        .spacing(5)
+        .into();
    }
    match value {
        Value::Object(map) => {
@@ -0,0 +1,389 @@
+//! Isolated live-reference chooser experiment, declared only under cfg(test).
+//! The host supplies an eligible catalog and revalidates every
+//! Write intent against the current document before changing a staged scalar.
+//! No core command, draft serialization, or App message belongs in this module.
+use oa_core::Id;
+use std::collections::BTreeSet;
+
+pub mod adapter;
+#[cfg(test)]
+mod tests;
+pub mod trigger;
+pub mod widget;
+
+pub const MAX_ROWS: usize = 6;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Context {
+    pub document: Id,
+    pub revision: u64,
+    pub draft: Id,
+    pub record: Id,
+    pub path: String,
+    pub optional: bool,
+}
+impl Context {
+    /// This is an additional historical-path guard, not live schema discovery.
+    /// Call only after the parent form has identified a live reference field.
+    pub fn live(
+        document: Id,
+        revision: u64,
+        draft: Id,
+        record: Id,
+        path: impl Into<String>,
+        optional: bool,
+    ) -> Result<Self, &'static str> {
+        let path = path.into();
+        if !path.starts_with('/') || path.split('/').any(|part| part == "baseline") {
+            return Err("The chooser requires a live reference property.");
+        }
+        Ok(Self {
+            document,
+            revision,
+            draft,
+            record,
+            path,
+            optional,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Candidate {
+    /// For a diagram placement this is the placement ID, not its element ID.
+    pub id: Id,
+    pub name: String,
+    pub alias: String,
+    pub kind: String,
+    pub scope: String,
+    pub containment: String,
+}
+impl Candidate {
+    pub fn context_label(&self) -> String {
+        format!("{} · {} · {}", self.scope, self.kind, self.containment)
+    }
+    pub fn detail(&self) -> String {
+        format!(
+            "{} · @{} · {} · {}",
+            self.name,
+            self.alias,
+            self.context_label(),
+            self.id
+        )
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Current {
+    Unassigned,
+    Valid(Candidate),
+    Incompatible(Candidate),
+    Missing(Id),
+    InvalidRaw(String),
+}
+impl Current {
+    pub fn label(&self) -> String {
+        match self {
+            Self::Unassigned => "Not assigned".into(),
+            Self::Valid(c) => format!("Current: {} · @{}", c.name, c.alias),
+            Self::Incompatible(c) => {
+                format!("Current choice needs review: {} · @{}", c.name, c.alias)
+            }
+            Self::Missing(id) => format!("Missing reference: {id}"),
+            Self::InvalidRaw(raw) => format!("Invalid reference retained: {raw}"),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct Searchable {
+    candidate: Candidate,
+    all: String,
+    alias: String,
+    name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Stamp {
+    pub context: Context,
+    pub invocation: Id,
+    pub results: u64,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Close {
+    Escape,
+    Tab { backwards: bool },
+    Outside,
+    WindowChanged,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Action {
+    /// The mounted text input numbers emitted edits. Multiple edits in one
+    /// runtime batch may share the old result stamp; none may be dropped.
+    Query {
+        text: String,
+        serial: u64,
+    },
+    Move {
+        delta: i32,
+        rows: usize,
+    },
+    Page {
+        delta: i32,
+        rows: usize,
+    },
+    Highlight(Id),
+    Choose(Id),
+    Clear,
+    Close(Close),
+}
+impl Action {
+    pub fn writes_staged_value(&self) -> bool {
+        matches!(self, Self::Choose(_) | Self::Clear)
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Event {
+    pub stamp: Stamp,
+    pub action: Action,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Outcome {
+    Ignored,
+    Browsed,
+    Closed(Close),
+    /// The host must still check current eligibility and scoped draft guards.
+    Write {
+        context: Context,
+        value: Option<Id>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct State {
+    context: Context,
+    invocation: Id,
+    results: u64,
+    serial: u64,
+    open: bool,
+    candidates: Vec<Searchable>,
+    filtered: Vec<usize>,
+    query: String,
+    start: usize,
+    highlight: Option<usize>,
+    pub current: Current,
+    pub scope_label: String,
+}
+impl State {
+    pub fn open(
+        context: Context,
+        candidates: Vec<Candidate>,
+        current: Current,
+        scope_label: impl Into<String>,
+    ) -> Result<Self, &'static str> {
+        // Context fields are public for host comparisons; check again in case
+        // a caller constructed one without the live-path constructor.
+        if !context.path.starts_with('/') || context.path.split('/').any(|p| p == "baseline") {
+            return Err("Historical values are not live reference candidates.");
+        }
+        let mut seen = BTreeSet::new();
+        let mut indexed = Vec::with_capacity(candidates.len());
+        for candidate in candidates {
+            if candidate.id.is_nil() || !seen.insert(candidate.id) {
+                return Err("Eligible references must have distinct, non-nil identities.");
+            }
+            indexed.push(Searchable {
+                all: candidate.detail().to_lowercase(),
+                alias: candidate.alias.to_lowercase(),
+                name: candidate.name.to_lowercase(),
+                candidate,
+            });
+        }
+        indexed.sort_by(|a, b| {
+            (&a.name, &a.alias, a.candidate.id).cmp(&(&b.name, &b.alias, b.candidate.id))
+        });
+        let filtered: Vec<_> = (0..indexed.len()).collect();
+        let highlight = (!filtered.is_empty()).then_some(0);
+        Ok(Self {
+            context,
+            invocation: Id::new_v4(),
+            results: 0,
+            serial: 0,
+            open: true,
+            candidates: indexed,
+            filtered,
+            query: String::new(),
+            start: 0,
+            highlight,
+            current,
+            scope_label: scope_label.into(),
+        })
+    }
+    pub fn stamp(&self) -> Stamp {
+        Stamp {
+            context: self.context.clone(),
+            invocation: self.invocation,
+            results: self.results,
+        }
+    }
+    pub fn event(&self, action: Action) -> Event {
+        Event {
+            stamp: self.stamp(),
+            action,
+        }
+    }
+    pub fn is_open(&self) -> bool {
+        self.open
+    }
+    pub fn query(&self) -> &str {
+        &self.query
+    }
+    pub fn query_serial(&self) -> u64 {
+        self.serial
+    }
+    pub fn count(&self) -> usize {
+        self.filtered.len()
+    }
+    pub fn start(&self) -> usize {
+        self.start
+    }
+    pub fn optional(&self) -> bool {
+        self.context.optional
+    }
+    pub fn highlighted(&self) -> Option<&Candidate> {
+        self.highlight.and_then(|i| self.at(i))
+    }
+    fn at(&self, index: usize) -> Option<&Candidate> {
+        self.filtered
+            .get(index)
+            .map(|i| &self.candidates[*i].candidate)
+    }
+    pub fn visible(&self, rows: usize) -> impl Iterator<Item = &Candidate> {
+        self.filtered
+            .iter()
+            .skip(self.start)
+            .take(rows.min(MAX_ROWS))
+            .map(|index| &self.candidates[*index].candidate)
+    }
+    /// The host calls this before rendering on any path/document/facet/context
+    /// replacement. Existing events remain tied to the old invocation.
+    pub fn invalidate(&mut self) {
+        self.open = false;
+    }
+
+    pub fn update(&mut self, event: Event) -> Outcome {
+        if !self.open
+            || event.stamp.context != self.context
+            || event.stamp.invocation != self.invocation
+        {
+            return Outcome::Ignored;
+        }
+        // Absolute row actions require exactly the presented result set.
+        // Relative navigation and dismissal are processed in input order within
+        // this session: typing must not make a following Escape stale.
+        if matches!(event.action, Action::Choose(_) | Action::Highlight(_))
+            && event.stamp.results != self.results
+        {
+            return Outcome::Ignored;
+        }
+        match event.action {
+            Action::Query { text, serial } => {
+                if serial <= self.serial {
+                    return Outcome::Ignored;
+                }
+                self.serial = serial;
+                self.query = text;
+                let query = self.query.to_lowercase();
+                let terms: Vec<_> = query.split_whitespace().collect();
+                self.filtered = self
+                    .candidates
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(i, c)| {
+                        terms
+                            .iter()
+                            .all(|term| match term.strip_prefix('@') {
+                                Some(alias) => c.alias.contains(alias),
+                                None => c.all.contains(term),
+                            })
+                            .then_some(i)
+                    })
+                    .collect();
+                self.start = 0;
+                self.highlight = (!self.filtered.is_empty()).then_some(0);
+            }
+            Action::Page { delta, rows } => {
+                let rows = rows.clamp(1, MAX_ROWS);
+                if self.filtered.is_empty() {
+                    return Outcome::Ignored;
+                }
+                let relative = self
+                    .highlight
+                    .unwrap_or(self.start)
+                    .saturating_sub(self.start)
+                    .min(rows - 1);
+                let last_page = (self.filtered.len() - 1) / rows * rows;
+                self.start = (self.start as i64 + i64::from(delta) * rows as i64)
+                    .clamp(0, last_page as i64) as usize;
+                self.highlight = Some((self.start + relative).min(self.filtered.len() - 1));
+            }
+            Action::Move { delta, rows } => {
+                let rows = rows.clamp(1, MAX_ROWS);
+                if self.filtered.is_empty() {
+                    return Outcome::Ignored;
+                }
+                let current = self.highlight.unwrap_or(self.start) as i64;
+                let next =
+                    (current + i64::from(delta)).clamp(0, self.filtered.len() as i64 - 1) as usize;
+                self.highlight = Some(next);
+                if next < self.start {
+                    self.start = next;
+                }
+                if next >= self.start + rows {
+                    self.start = next + 1 - rows;
+                }
+            }
+            Action::Highlight(id) => {
+                let Some(index) = self
+                    .filtered
+                    .iter()
+                    .position(|i| self.candidates[*i].candidate.id == id)
+                else {
+                    return Outcome::Ignored;
+                };
+                if self.highlight == Some(index) {
+                    return Outcome::Ignored;
+                }
+                self.highlight = Some(index);
+            }
+            Action::Choose(id) => {
+                if !self
+                    .filtered
+                    .iter()
+                    .any(|i| self.candidates[*i].candidate.id == id)
+                {
+                    return Outcome::Ignored;
+                }
+                self.open = false;
+                return Outcome::Write {
+                    context: self.context.clone(),
+                    value: Some(id),
+                };
+            }
+            Action::Clear if self.context.optional => {
+                self.open = false;
+                return Outcome::Write {
+                    context: self.context.clone(),
+                    value: None,
+                };
+            }
+            Action::Clear => return Outcome::Ignored,
+            Action::Close(reason) => {
+                self.open = false;
+                return Outcome::Closed(reason);
+            }
+        }
+        self.results = self.results.wrapping_add(1);
+        Outcome::Browsed
+    }
+}
@@ -0,0 +1,307 @@
+//! Live form adapter. Compatibility stays in the existing parent adapter;
+//! browser metadata and scoped writes never reinterpret historical UUID text.
+use super::super::{Draft, friendly, history_fields, optional_reference, reference, reference_ids};
+use super::{Candidate, Context, Current, State, trigger};
+use crate::{app::Message, style};
+use iced::{
+    Element, Fill, Rectangle,
+    widget::{column, container, row, text, tooltip},
+};
+use oa_core::{Id, Project};
+use serde_json::{Value, json};
+use std::collections::BTreeSet;
+
+#[derive(Debug, Clone)]
+pub struct Open {
+    pub document: Id,
+    pub session: Id,
+    pub generation: Id,
+    pub record: Id,
+    pub path: String,
+    pub anchor: Rectangle,
+}
+#[derive(Debug, Clone)]
+pub struct Set {
+    pub context: Context,
+    pub generation: Id,
+    pub value: Option<Id>,
+}
+impl Draft {
+    pub fn reference_session(&self) -> Id {
+        self.reference_session
+    }
+    pub fn reference_generation(&self) -> Id {
+        self.reference_generation
+    }
+    pub fn reference_open(&self, project: &Project, path: &str, anchor: Rectangle) -> Open {
+        Open {
+            document: project.id,
+            session: self.reference_session,
+            generation: self.reference_generation,
+            record: self.original,
+            path: path.into(),
+            anchor,
+        }
+    }
+    pub fn reference_matches(&self, request: &Open) -> bool {
+        self.reference_session == request.session
+            && self.reference_generation == request.generation
+            && self.original == request.record
+            && self.live_reference(&request.path)
+    }
+    fn live_reference(&self, path: &str) -> bool {
+        !history_fields::is_path(path)
+            && reference(path)
+            && self
+                .value
+                .pointer(path)
+                .is_some_and(|v| v.is_string() || v.is_null())
+    }
+    pub fn reference_catalog(
+        &self,
+        project: &Project,
+        request: &Open,
+        revision: u64,
+    ) -> Result<State, String> {
+        if request.document != project.id || !self.reference_matches(request) {
+            return Err("The reference field changed. Open its chooser again.".into());
+        }
+        let allowed: BTreeSet<_> = reference_ids(self, project, &request.path)
+            .into_iter()
+            .filter(|id| !id.is_nil())
+            .collect();
+        let candidates = allowed
+            .iter()
+            .filter_map(|id| candidate(project, *id))
+            .collect();
+        let raw = self
+            .inputs
+            .get(&request.path)
+            .map(|v| v.raw.as_str())
+            .or_else(|| self.value.pointer(&request.path).and_then(Value::as_str));
+        let current = match raw {
+            None => Current::Unassigned,
+            Some(raw) => match raw.parse::<Id>() {
+                Ok(id) if id.is_nil() => Current::Unassigned,
+                Ok(id) => match candidate(project, id) {
+                    Some(c) if allowed.contains(&id) => Current::Valid(c),
+                    Some(c) => Current::Incompatible(c),
+                    None => Current::Missing(id),
+                },
+                Err(_) => Current::InvalidRaw(raw.into()),
+            },
+        };
+        let context = Context::live(
+            project.id,
+            revision,
+            self.reference_session,
+            self.original,
+            &request.path,
+            optional_reference(&request.path),
+        )
+        .map_err(str::to_owned)?;
+        State::open(
+            context,
+            candidates,
+            current,
+            format!(
+                "{} · compatible references",
+                friendly(request.path.rsplit('/').next().unwrap_or("Reference"))
+            ),
+        )
+        .map_err(str::to_owned)
+    }
+    pub fn reference_set(&mut self, project: &Project, intent: &Set) -> Result<(), String> {
+        let value = self.reference_value(project, intent)?;
+        self.shape_scoped(&intent.context.path, value)
+    }
+    pub fn reference_value(&self, project: &Project, intent: &Set) -> Result<Value, String> {
+        let context = &intent.context;
+        if context.document != project.id
+            || context.draft != self.reference_session
+            || context.record != self.original
+            || intent.generation != self.reference_generation
+            || !self.live_reference(&context.path)
+            || context.optional != optional_reference(&context.path)
+        {
+            return Err("The originating reference field is no longer current.".into());
+        }
+        let value = match intent.value {
+            Some(id)
+                if !id.is_nil() && reference_ids(self, project, &context.path).contains(&id) =>
+            {
+                json!(id)
+            }
+            None if context.optional => Value::Null,
+            _ => return Err("Choose a currently compatible reference.".into()),
+        };
+        Ok(value)
+    }
+}
+
+fn named(project: &Project, id: Id) -> String {
+    if let Some(e) = project.elements.get(&id) {
+        format!("{} · @{}", e.name, e.alias)
+    } else {
+        project.named(id).into()
+    }
+}
+fn ancestry(project: &Project, id: Id) -> String {
+    let mut parts = vec![];
+    let mut seen = BTreeSet::new();
+    let mut current = project.elements.get(&id).and_then(|e| e.parent);
+    while let Some(id) = current {
+        if !seen.insert(id) {
+            parts.push("[containment cycle]".into());
+            break;
+        }
+        parts.push(named(project, id));
+        current = project.elements.get(&id).and_then(|e| e.parent);
+    }
+    parts.reverse();
+    if parts.is_empty() {
+        project.name.clone()
+    } else {
+        parts.join(" / ")
+    }
+}
+pub(crate) fn candidate(project: &Project, id: Id) -> Option<Candidate> {
+    let layer = |layer| format!("{layer:?}").to_uppercase();
+    if id == project.id {
+        return Some(Candidate {
+            id,
+            name: project.name.clone(),
+            alias: project.alias.clone(),
+            kind: "Project".into(),
+            scope: "Model".into(),
+            containment: "Model root".into(),
+        });
+    }
+    if let Some(e) = project.elements.get(&id) {
+        return Some(Candidate {
+            id,
+            name: e.name.clone(),
+            alias: e.alias.clone(),
+            kind: e.kind().to_string(),
+            scope: layer(e.layer()),
+            containment: ancestry(project, id),
+        });
+    }
+    if let Some(r) = project.relations.get(&id) {
+        return Some(Candidate {
+            id,
+            name: r.name.clone(),
+            alias: r.alias.clone(),
+            kind: r.kind().to_string(),
+            scope: project.layer_of(id).map_or_else(|| "Model".into(), layer),
+            containment: format!(
+                "{} → {}",
+                named(project, r.source()),
+                named(project, r.target())
+            ),
+        });
+    }
+    for diagram in project.diagrams.values() {
+        if id == diagram.id {
+            return Some(Candidate {
+                id,
+                name: diagram.name.clone(),
+                alias: diagram.alias.clone(),
+                kind: format!("{:?} diagram", diagram.projection),
+                scope: layer(diagram.layer),
+                containment: project.name.clone(),
+            });
+        }
+        if let Some(node) = diagram.nodes.get(&id) {
+            return Some(Candidate {
+                id,
+                name: project.named(node.element).into(),
+                alias: node.alias.clone(),
+                kind: "Placement".into(),
+                scope: layer(diagram.layer),
+                containment: format!(
+                    "{} · @{} / {}",
+                    diagram.name,
+                    diagram.alias,
+                    named(project, node.element)
+                ),
+            });
+        }
+    }
+    if let Some(link) = project.artifact_links.get(&id) {
+        return Some(Candidate {
+            id,
+            name: link.name.clone(),
+            alias: link.alias.clone(),
+            kind: "Artifact link".into(),
+            scope: project
+                .layer_of(link.owner)
+                .map_or_else(|| "Model".into(), layer),
+            containment: named(project, link.owner),
+        });
+    }
+    project.traces.get(&id).map(|trace| Candidate {
+        id,
+        name: trace.name.clone(),
+        alias: trace.alias.clone(),
+        kind: "Trace".into(),
+        scope: "OA ↔ SA".into(),
+        containment: format!(
+            "{} ↔ {}",
+            named(project, trace.oa),
+            named(project, trace.sa)
+        ),
+    })
+}
+
+pub fn field<'a, R: iced::advanced::text::Renderer<Font = iced::Font> + 'a>(
+    draft: &'a Draft,
+    project: &'a Project,
+    path: &str,
+) -> Element<'a, Message, iced::Theme, R> {
+    let raw = draft
+        .inputs
+        .get(path)
+        .map(|v| v.raw.as_str())
+        .or_else(|| draft.value.pointer(path).and_then(Value::as_str));
+    let (label, detail) = match raw {
+        None => (
+            if optional_reference(path) {
+                "Not assigned"
+            } else {
+                "Choose a reference…"
+            }
+            .into(),
+            String::new(),
+        ),
+        Some(raw) => match raw.parse::<Id>() {
+            Ok(id) if id.is_nil() => ("Choose a reference…".into(), String::new()),
+            Ok(id) => match candidate(project, id) {
+                Some(c) => (format!("{} · @{}", c.name, c.alias), c.detail()),
+                None => ("Missing reference".into(), raw.into()),
+            },
+            Err(_) => ("Invalid reference retained".into(), raw.into()),
+        },
+    };
+    let label = crate::views::short(&label, 35);
+    let body = container(row![text(label).size(12).width(Fill), text("⌄").size(12)].spacing(6))
+        .padding(8)
+        .width(Fill);
+    let path = path.to_owned();
+    let id = trigger::field_id(draft.reference_generation, &path);
+    let field = trigger::Field::new(body, id, move |anchor| {
+        Message::FieldReferenceOpen(draft.reference_open(project, &path, anchor))
+    });
+    if detail.is_empty() {
+        field.into()
+    } else {
+        tooltip(
+            field,
+            container(column![text(detail).size(11)])
+                .padding(8)
+                .style(style::card),
+            tooltip::Position::Left,
+        )
+        .into()
+    }
+}
@@ -0,0 +1,803 @@
+use super::*;
+use iced::{
+    Element, Event as Input, Point, Rectangle, Size, Theme, Vector,
+    advanced::{Layout, Shell, layout, widget::Tree},
+    keyboard, mouse,
+    widget::{Space, mouse_area},
+};
+
+fn context(optional: bool) -> Context {
+    Context::live(
+        Id::from_u128(1),
+        7,
+        Id::from_u128(2),
+        Id::from_u128(3),
+        "/body/SequenceUse/sequence",
+        optional,
+    )
+    .unwrap()
+}
+fn candidate(index: u128) -> Candidate {
+    Candidate {
+        id: Id::from_u128(10_000 + index),
+        name: "Control".into(),
+        alias: format!("controller_{index:04}"),
+        kind: "Function".into(),
+        scope: "SA".into(),
+        containment: format!("System / Subsystem {} / Controller", index / 100),
+    }
+}
+fn thousand(current: Current, optional: bool) -> State {
+    // Reverse the fixture input to falsify accidental dependence on ingestion
+    // order. Expected IDs and aliases below are literal fixture identities.
+    State::open(
+        context(optional),
+        (0..1_000).rev().map(candidate).collect(),
+        current,
+        "SA · compatible functions",
+    )
+    .unwrap()
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Message {
+    Chooser(Event),
+    UnderPress,
+    UnderRelease,
+}
+
+#[derive(Default)]
+struct Clipboard(Option<String>);
+impl iced::advanced::Clipboard for Clipboard {
+    fn read(&self, _: iced::advanced::clipboard::Kind) -> Option<String> {
+        self.0.clone()
+    }
+    fn write(&mut self, _: iced::advanced::clipboard::Kind, text: String) {
+        self.0 = Some(text);
+    }
+}
+
+struct Mount {
+    tree: Option<Tree>,
+    size: Size,
+    anchor: Rectangle,
+    clipboard: Clipboard,
+}
+impl Default for Mount {
+    fn default() -> Self {
+        Self {
+            tree: None,
+            size: Size::new(1100., 700.),
+            anchor: Rectangle {
+                x: 790.,
+                y: 640.,
+                width: 278.,
+                height: 32.,
+            },
+            clipboard: Clipboard::default(),
+        }
+    }
+}
+impl Mount {
+    fn batch(
+        &mut self,
+        state: Option<&State>,
+        events: &[(Input, Option<Point>)],
+    ) -> (Vec<Message>, Option<layout::Node>) {
+        let underneath: Element<'_, Message, Theme, ()> =
+            mouse_area(Space::new().width(iced::Fill).height(iced::Fill))
+                .on_press(Message::UnderPress)
+                .on_release(Message::UnderRelease)
+                .into();
+        let mut view: Element<'_, Message, Theme, ()> =
+            widget::Popup::new(underneath, state, self.anchor, Message::Chooser).into();
+        let tree = self.tree.get_or_insert_with(|| Tree::new(view.as_widget()));
+        view.as_widget().diff(tree);
+        let node =
+            view.as_widget_mut()
+                .layout(tree, &(), &layout::Limits::new(Size::ZERO, self.size));
+        let viewport = Rectangle::with_size(self.size);
+        let overlay_node = view
+            .as_widget_mut()
+            .overlay(tree, Layout::new(&node), &(), &viewport, Vector::ZERO)
+            .map(|mut overlay| overlay.as_overlay_mut().layout(&(), self.size));
+        let mut messages = Vec::new();
+        for (event, point) in events {
+            let cursor = point.map_or(mouse::Cursor::Unavailable, mouse::Cursor::Available);
+            let mut shell = Shell::new(&mut messages);
+            if let Some(overlay_node) = &overlay_node {
+                // Reconstruct the overlay between layout and every input, as
+                // Iced does. Geometry must live in the measured layout tree.
+                let mut overlay = view
+                    .as_widget_mut()
+                    .overlay(tree, Layout::new(&node), &(), &viewport, Vector::ZERO)
+                    .unwrap();
+                overlay.as_overlay_mut().update(
+                    event,
+                    Layout::new(overlay_node),
+                    cursor,
+                    &(),
+                    &mut self.clipboard,
+                    &mut shell,
+                );
+                overlay.as_overlay().draw(
+                    &mut (),
+                    &crate::style::theme(),
+                    &iced::advanced::renderer::Style {
+                        text_color: iced::Color::BLACK,
+                    },
+                    Layout::new(overlay_node),
+                    cursor,
+                );
+                if matches!(
+                    event,
+                    Input::Mouse(_) | Input::Keyboard(_) | Input::Touch(_) | Input::InputMethod(_)
+                ) {
+                    assert!(shell.is_event_captured(), "An open chooser owns input");
+                }
+            } else {
+                view.as_widget_mut().update(
+                    tree,
+                    event,
+                    Layout::new(&node),
+                    cursor,
+                    &(),
+                    &mut self.clipboard,
+                    &mut shell,
+                    &viewport,
+                );
+            }
+        }
+        (messages, overlay_node)
+    }
+    fn send(&mut self, state: &mut State, event: Input) -> Vec<Outcome> {
+        let (messages, _) = self.batch(Some(state), &[(event, None)]);
+        messages
+            .into_iter()
+            .map(|message| match message {
+                Message::Chooser(event) => state.update(event),
+                _ => panic!("Popup leaked input to its parent"),
+            })
+            .collect()
+    }
+    fn type_text(&mut self, state: &mut State, text: &str) -> Vec<Outcome> {
+        let (messages, _) = self.batch(Some(state), &typing(text));
+        messages
+            .into_iter()
+            .map(|message| match message {
+                Message::Chooser(event) => state.update(event),
+                _ => panic!("Typing leaked input to its parent"),
+            })
+            .collect()
+    }
+    fn geometry(&mut self, state: &State) -> widget::Geometry {
+        let (_, node) = self.batch(Some(state), &[]);
+        widget::Geometry::from_bounds(node.unwrap().children()[0].bounds())
+    }
+    fn click(&mut self, state: &State, point: Point) -> Vec<Message> {
+        self.batch(
+            Some(state),
+            &[
+                (
+                    Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+                    Some(point),
+                ),
+                (
+                    Input::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
+                    Some(point),
+                ),
+            ],
+        )
+        .0
+    }
+}
+
+fn named(key: keyboard::key::Named) -> Input {
+    Input::Keyboard(keyboard::Event::KeyPressed {
+        key: keyboard::Key::Named(key),
+        modified_key: keyboard::Key::Named(key),
+        physical_key: keyboard::key::Physical::Code(keyboard::key::Code::Space),
+        location: keyboard::Location::Standard,
+        modifiers: keyboard::Modifiers::empty(),
+        text: None,
+        repeat: false,
+    })
+}
+// Iced 0.14's physical-key path intentionally inserts one scalar from text.
+// Whole-string typing is several key events; paste and IME commit are separate
+// input paths and are exercised below rather than faked as one physical key.
+fn typed(character: char) -> Input {
+    let text = character.to_string();
+    Input::Keyboard(keyboard::Event::KeyPressed {
+        key: keyboard::Key::Character(text.clone().into()),
+        modified_key: keyboard::Key::Character(text.clone().into()),
+        physical_key: keyboard::key::Physical::Code(keyboard::key::Code::KeyA),
+        location: keyboard::Location::Standard,
+        modifiers: keyboard::Modifiers::empty(),
+        text: Some(text.into()),
+        repeat: false,
+    })
+}
+fn typing(text: &str) -> Vec<(Input, Option<Point>)> {
+    text.chars()
+        .map(|character| (typed(character), None))
+        .collect()
+}
+fn query(state: &mut State, value: &str) {
+    let event = state.event(Action::Query {
+        text: value.into(),
+        serial: state.query_serial() + 1,
+    });
+    assert_eq!(state.update(event), Outcome::Browsed);
+}
+
+#[test]
+fn catalog_search_disambiguates_repeated_names_containment_alias_and_exact_placement_identity() {
+    let mut state = thousand(Current::Unassigned, false);
+    assert_eq!(
+        state.visible(6).map(|c| c.id).collect::<Vec<_>>(),
+        (10_000..10_006).map(Id::from_u128).collect::<Vec<_>>()
+    );
+    query(&mut state, "control subsystem 6 @controller_0617");
+    assert_eq!(state.count(), 1);
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(10_617));
+    query(&mut state, "OA");
+    assert_eq!(state.count(), 0);
+    query(&mut state, &Id::from_u128(10_617).to_string());
+    assert_eq!(state.count(), 1);
+    assert_eq!(state.highlighted().unwrap().alias, "controller_0617");
+
+    let placement = Candidate {
+        id: Id::from_u128(20_001),
+        name: "Control".into(),
+        alias: "control_placement".into(),
+        kind: "Placement".into(),
+        scope: "SA".into(),
+        containment: "Architecture / Main diagram / Control".into(),
+    };
+    let mut state = State::open(
+        context(false),
+        vec![placement],
+        Current::Unassigned,
+        "SA · placements",
+    )
+    .unwrap();
+    query(&mut state, "placement main");
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(20_001));
+    let event = state.event(Action::Choose(Id::from_u128(20_000)));
+    assert_eq!(
+        state.update(event),
+        Outcome::Ignored,
+        "Semantic ID is not the placement identity"
+    );
+    assert!(
+        State::open(
+            context(false),
+            vec![candidate(1), candidate(1)],
+            Current::Unassigned,
+            "SA"
+        )
+        .is_err()
+    );
+}
+
+#[test]
+fn mounted_overlay_clamps_at_three_field_positions_and_keeps_results_and_query_bounded() {
+    let state = thousand(Current::InvalidRaw("not a uuid".into()), true);
+    for size in [
+        Size::new(1100., 700.),
+        Size::new(1600., 1000.),
+        Size::new(320., 320.),
+    ] {
+        for y in [5., size.height / 2., size.height - 34.] {
+            let mut mount = Mount {
+                size,
+                anchor: Rectangle {
+                    x: size.width - 300.,
+                    y,
+                    width: 278.,
+                    height: 32.,
+                },
+                ..Default::default()
+            };
+            let (_, node) = mount.batch(Some(&state), &[]);
+            let node = node.unwrap();
+            let bounds = node.children()[0].bounds();
+            let geometry = widget::Geometry::from_bounds(bounds);
+            assert!(bounds.x >= 8. && bounds.y >= 8.);
+            assert!(bounds.x + bounds.width <= size.width - 8.);
+            assert!(bounds.y + bounds.height <= size.height - 8.);
+            assert!(bounds.width <= 420. && bounds.height <= 360.);
+            assert!(geometry.rows > 0 && geometry.rows <= 6);
+            assert_eq!(geometry.rows, if size.height == 320. { 4 } else { 6 });
+            let search = node.children()[1].bounds();
+            assert!(
+                bounds.contains(search.position())
+                    && bounds.contains(Point::new(
+                        search.x + search.width,
+                        search.y + search.height
+                    ))
+            );
+            assert!(geometry.row(geometry.rows - 1).y + 34. <= geometry.detail.y);
+            assert_eq!(state.visible(geometry.rows).count(), geometry.rows);
+        }
+    }
+}
+
+#[test]
+fn mounted_input_preserves_rapid_same_batch_typing_and_cursor_across_controlled_rebuilds() {
+    let mut state = thousand(Current::Unassigned, false);
+    let mut mount = Mount::default();
+    let (messages, _) = mount.batch(Some(&state), &[(typed('a'), None), (typed('b'), None)]);
+    assert_eq!(
+        messages.len(),
+        2,
+        "Actual focused input must publish each edit"
+    );
+    let mut queries = Vec::new();
+    for message in messages {
+        let Message::Chooser(event) = message else {
+            panic!("Unexpected parent event")
+        };
+        let Action::Query { text, .. } = &event.action else {
+            panic!("Typing must not choose a reference")
+        };
+        queries.push(text.clone());
+        assert_eq!(state.update(event), Outcome::Browsed);
+    }
+    assert_eq!(queries, ["a", "ab"]);
+    assert_eq!(state.query(), "ab");
+    assert!(
+        mount
+            .send(&mut state, named(keyboard::key::Named::Home))
+            .is_empty()
+    );
+    assert_eq!(mount.send(&mut state, typed('z')), [Outcome::Browsed]);
+    assert_eq!(
+        state.query(),
+        "zab",
+        "Rebuilding the controlled widget must not refocus at the end"
+    );
+    assert_eq!(state.current, Current::Unassigned);
+}
+
+#[test]
+fn mounted_keyboard_pages_and_selects_only_the_highlighted_visible_candidate_once() {
+    let mut state = thousand(Current::Unassigned, false);
+    let mut mount = Mount::default();
+    assert_eq!(
+        mount.send(&mut state, named(keyboard::key::Named::PageDown)),
+        [Outcome::Browsed]
+    );
+    assert_eq!(state.start(), 6);
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(10_006));
+    assert_eq!(
+        mount.send(&mut state, named(keyboard::key::Named::ArrowDown)),
+        [Outcome::Browsed]
+    );
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(10_007));
+    let (messages, _) = mount.batch(
+        Some(&state),
+        &[
+            (named(keyboard::key::Named::Enter), None),
+            (named(keyboard::key::Named::Enter), None),
+        ],
+    );
+    assert_eq!(messages.len(), 1);
+    let Message::Chooser(event) = messages.into_iter().next().unwrap() else {
+        panic!()
+    };
+    assert!(event.action.writes_staged_value());
+    assert_eq!(
+        state.update(event),
+        Outcome::Write {
+            context: context(false),
+            value: Some(Id::from_u128(10_007))
+        }
+    );
+    assert!(!state.is_open());
+}
+
+#[test]
+fn mounted_filtered_row_click_uses_the_displayed_identity_and_scoped_write_intent() {
+    let mut state = thousand(Current::Missing(Id::from_u128(99)), false);
+    let mut mount = Mount::default();
+    let query = "@controller_0731";
+    assert_eq!(
+        mount.type_text(&mut state, query),
+        vec![Outcome::Browsed; query.chars().count()]
+    );
+    assert_eq!(state.query(), query);
+    assert_eq!(state.count(), 1);
+    let point = mount.geometry(&state).row(0).center();
+    let messages = mount.click(&state, point);
+    assert_eq!(messages.len(), 1);
+    let Message::Chooser(event) = messages[0].clone() else {
+        panic!()
+    };
+    assert_eq!(
+        state.update(event),
+        Outcome::Write {
+            context: context(false),
+            value: Some(Id::from_u128(10_731))
+        }
+    );
+    assert_eq!(state.current, Current::Missing(Id::from_u128(99)));
+}
+
+#[test]
+fn mounted_query_change_rejects_old_release_and_old_result_events_without_locking_popup() {
+    let mut state = thousand(Current::Unassigned, false);
+    let mut mount = Mount::default();
+    let point = mount.geometry(&state).row(4).center();
+    let captured = mount.click(&state, point);
+    let Message::Chooser(old_choice) = captured[0].clone() else {
+        panic!()
+    };
+    query(&mut state, "@controller_0700");
+    assert_eq!(state.update(old_choice), Outcome::Ignored);
+    // The rejected old Choose had marked the widget closing; a changed result
+    // context must unlock it so an explicit current click can complete.
+    let point = mount.geometry(&state).row(0).center();
+    let messages = mount.click(&state, point);
+    assert_eq!(messages.len(), 1);
+    let Message::Chooser(event) = messages[0].clone() else {
+        panic!()
+    };
+    assert_eq!(
+        state.update(event),
+        Outcome::Write {
+            context: context(false),
+            value: Some(Id::from_u128(10_700))
+        }
+    );
+
+    let mut state = thousand(Current::Unassigned, false);
+    let point = mount.geometry(&state).row(0).center();
+    assert!(
+        mount
+            .batch(
+                Some(&state),
+                &[(
+                    Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+                    Some(point)
+                )]
+            )
+            .0
+            .is_empty()
+    );
+    query(&mut state, "@controller_0319");
+    assert!(
+        mount
+            .batch(
+                Some(&state),
+                &[(
+                    Input::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
+                    Some(point)
+                )]
+            )
+            .0
+            .is_empty()
+    );
+    assert!(state.is_open());
+}
+
+#[test]
+fn captured_choice_cannot_cross_document_revision_draft_record_or_array_path() {
+    let source = thousand(Current::Unassigned, false);
+    let mut mount = Mount::default();
+    let point = mount.geometry(&source).row(0).center();
+    let Message::Chooser(event) = mount.click(&source, point).remove(0) else {
+        panic!()
+    };
+    for changed in 0..6 {
+        let mut destination = context(false);
+        match changed {
+            0 => destination.document = Id::from_u128(999),
+            1 => destination.revision += 1,
+            2 => destination.draft = Id::from_u128(999),
+            3 => destination.record = Id::from_u128(999),
+            4 => destination.path = "/body/SomeList/members/1/scenario".into(),
+            _ => {} // A new invocation even with every semantic ID unchanged.
+        }
+        let mut state = State::open(
+            destination,
+            vec![candidate(0)],
+            Current::InvalidRaw("unfinished".into()),
+            "SA",
+        )
+        .unwrap();
+        assert_eq!(state.update(event.clone()), Outcome::Ignored);
+        assert_eq!(state.current, Current::InvalidRaw("unfinished".into()));
+        assert!(state.is_open());
+    }
+    let mut invalidated = source.clone();
+    invalidated.invalidate();
+    assert_eq!(invalidated.update(event), Outcome::Ignored);
+}
+
+#[test]
+fn empty_search_escape_tab_and_optional_clear_do_not_silently_choose_nil() {
+    for current in [
+        Current::Missing(Id::from_u128(999)),
+        Current::InvalidRaw("@incomplete/".into()),
+        Current::Incompatible(candidate(999)),
+    ] {
+        let mut state = thousand(current.clone(), false);
+        let mut mount = Mount::default();
+        let query = "no match exists";
+        assert_eq!(
+            mount.type_text(&mut state, query),
+            vec![Outcome::Browsed; query.chars().count()]
+        );
+        assert_eq!(state.query(), query);
+        assert_eq!(
+            state.count(),
+            0,
+            "Verify actual input reached the empty-result state before Enter"
+        );
+        assert!(
+            mount
+                .send(&mut state, named(keyboard::key::Named::Enter))
+                .is_empty()
+        );
+        assert!(state.is_open());
+        assert_eq!(state.current, current);
+        assert_eq!(
+            mount.send(&mut state, named(keyboard::key::Named::Escape)),
+            [Outcome::Closed(Close::Escape)]
+        );
+        assert_eq!(state.current, current);
+    }
+    let mut state = thousand(Current::Unassigned, false);
+    let mut mount = Mount::default();
+    assert_eq!(
+        mount.send(&mut state, named(keyboard::key::Named::Tab)),
+        [Outcome::Closed(Close::Tab { backwards: false })]
+    );
+    let mut state = thousand(Current::InvalidRaw("?".into()), true);
+    let point = mount.geometry(&state).clear.center();
+    let Message::Chooser(event) = mount.click(&state, point).remove(0) else {
+        panic!()
+    };
+    assert_eq!(
+        state.update(event),
+        Outcome::Write {
+            context: context(true),
+            value: None
+        }
+    );
+    let mut required = thousand(Current::Unassigned, false);
+    let clear = required.event(Action::Clear);
+    assert_eq!(required.update(clear), Outcome::Ignored);
+}
+
+#[test]
+fn dismissal_swallows_matching_release_across_closed_rebuild_but_next_click_reaches_parent() {
+    let mut state = thousand(Current::Unassigned, false);
+    let mut mount = Mount::default();
+    let outside = Point::new(20., 20.);
+    let (messages, _) = mount.batch(
+        Some(&state),
+        &[(
+            Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+            Some(outside),
+        )],
+    );
+    let [Message::Chooser(event)] = messages.as_slice() else {
+        panic!("Expected only popup dismissal")
+    };
+    assert_eq!(state.update(event.clone()), Outcome::Closed(Close::Outside));
+    let release = Input::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left));
+    assert!(
+        mount
+            .batch(None, &[(release.clone(), Some(outside))])
+            .0
+            .is_empty()
+    );
+    assert_eq!(
+        mount
+            .batch(
+                None,
+                &[
+                    (
+                        Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+                        Some(outside)
+                    ),
+                    (release, Some(outside)),
+                ]
+            )
+            .0,
+        [Message::UnderPress, Message::UnderRelease]
+    );
+}
+
+#[test]
+fn historical_paths_never_open_and_only_explicit_choice_or_clear_is_a_write() {
+    for path in [
+        "/baseline",
+        "/baseline/oa/value",
+        "/baseline/sa/value/TypeRef/Named",
+    ] {
+        assert!(
+            Context::live(
+                Id::from_u128(1),
+                0,
+                Id::from_u128(2),
+                Id::from_u128(3),
+                path,
+                true
+            )
+            .is_err()
+        );
+        let mut forged = context(true);
+        forged.path = path.into();
+        assert!(State::open(forged, vec![candidate(0)], Current::Unassigned, "History").is_err());
+    }
+    for action in [
+        Action::Query {
+            text: "Control".into(),
+            serial: 1,
+        },
+        Action::Highlight(Id::from_u128(10_000)),
+        Action::Move { delta: 1, rows: 6 },
+        Action::Page { delta: 1, rows: 6 },
+        Action::Close(Close::Escape),
+    ] {
+        assert!(!action.writes_staged_value());
+    }
+    assert!(Action::Choose(Id::from_u128(10_000)).writes_staged_value());
+    assert!(Action::Clear.writes_staged_value());
+}
+
+#[test]
+fn out_of_order_query_serials_cannot_restore_obsolete_results() {
+    let mut state = thousand(Current::Unassigned, false);
+    let old = state.event(Action::Query {
+        text: "@controller_0001".into(),
+        serial: 1,
+    });
+    let new = state.event(Action::Query {
+        text: "@controller_0999".into(),
+        serial: 2,
+    });
+    assert_eq!(state.update(new), Outcome::Browsed);
+    assert_eq!(state.update(old), Outcome::Ignored);
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(10_999));
+}
+
+#[test]
+fn mounted_query_then_escape_in_one_batch_closes_and_relative_keys_keep_input_order() {
+    let mut state = thousand(Current::InvalidRaw("unfinished".into()), false);
+    let mut mount = Mount::default();
+    let query = "@controller_0720";
+    let mut inputs = typing(query);
+    inputs.push((named(keyboard::key::Named::Escape), None));
+    let (messages, _) = mount.batch(Some(&state), &inputs);
+    let outcomes: Vec<_> = messages
+        .into_iter()
+        .map(|message| {
+            let Message::Chooser(event) = message else {
+                panic!("Input escaped the popup")
+            };
+            state.update(event)
+        })
+        .collect();
+    let mut expected = vec![Outcome::Browsed; query.chars().count()];
+    expected.push(Outcome::Closed(Close::Escape));
+    assert_eq!(outcomes, expected);
+    assert_eq!(state.query(), "@controller_0720");
+    assert_eq!(state.current, Current::InvalidRaw("unfinished".into()));
+
+    let mut state = thousand(Current::Unassigned, false);
+    let old_absolute_row = state.event(Action::Choose(Id::from_u128(10_000)));
+    let (messages, _) = mount.batch(
+        Some(&state),
+        &[
+            (named(keyboard::key::Named::PageDown), None),
+            (named(keyboard::key::Named::PageDown), None),
+            (named(keyboard::key::Named::ArrowUp), None),
+        ],
+    );
+    assert_eq!(messages.len(), 3);
+    for message in messages {
+        let Message::Chooser(event) = message else {
+            panic!("Input escaped the popup")
+        };
+        assert_eq!(state.update(event), Outcome::Browsed);
+    }
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(10_011));
+    assert_eq!(state.start(), 11);
+    assert_eq!(state.update(old_absolute_row), Outcome::Ignored);
+    assert!(state.is_open());
+}
+
+#[test]
+fn mounted_clipboard_paste_and_ime_commit_preserve_whole_strings_without_selecting() {
+    let mut state = thousand(Current::Unassigned, false);
+    let mut mount = Mount::default();
+    mount.clipboard.0 = Some("@controller_0472".into());
+    let paste = Input::Keyboard(keyboard::Event::KeyPressed {
+        key: keyboard::Key::Character("v".into()),
+        modified_key: keyboard::Key::Character("v".into()),
+        physical_key: keyboard::key::Physical::Code(keyboard::key::Code::KeyV),
+        location: keyboard::Location::Standard,
+        modifiers: keyboard::Modifiers::COMMAND,
+        text: None,
+        repeat: false,
+    });
+    let (messages, _) = mount.batch(
+        Some(&state),
+        &[
+            (
+                Input::Keyboard(keyboard::Event::ModifiersChanged(
+                    keyboard::Modifiers::COMMAND,
+                )),
+                None,
+            ),
+            (paste, None),
+            (
+                Input::Keyboard(keyboard::Event::ModifiersChanged(
+                    keyboard::Modifiers::empty(),
+                )),
+                None,
+            ),
+        ],
+    );
+    let [Message::Chooser(event)] = messages.as_slice() else {
+        panic!("Paste should emit exactly one whole-string query")
+    };
+    assert_eq!(state.update(event.clone()), Outcome::Browsed);
+    assert_eq!(state.query(), "@controller_0472");
+    assert_eq!(state.count(), 1);
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(10_472));
+    assert_eq!(state.current, Current::Unassigned);
+    assert!(state.is_open());
+
+    let unicode_name = "Режим Δ負荷";
+    let unicode = Candidate {
+        id: Id::from_u128(30_111),
+        name: unicode_name.into(),
+        alias: "mode_unicode".into(),
+        kind: "Function".into(),
+        scope: "SA".into(),
+        containment: "Система / 控制".into(),
+    };
+    let mut state = State::open(
+        context(false),
+        vec![unicode],
+        Current::InvalidRaw("retained".into()),
+        "SA",
+    )
+    .unwrap();
+    use iced::advanced::input_method::Event as Ime;
+    let preedit = [
+        (Input::InputMethod(Ime::Opened), None),
+        (
+            Input::InputMethod(Ime::Preedit(unicode_name.into(), None)),
+            None,
+        ),
+    ];
+    assert!(
+        mount.batch(Some(&state), &preedit).0.is_empty(),
+        "Composition is not a committed query"
+    );
+    assert_eq!(state.query(), "");
+    let (messages, _) = mount.batch(
+        Some(&state),
+        &[
+            (Input::InputMethod(Ime::Preedit(String::new(), None)), None),
+            (Input::InputMethod(Ime::Commit(unicode_name.into())), None),
+            (Input::InputMethod(Ime::Closed), None),
+        ],
+    );
+    let [Message::Chooser(event)] = messages.as_slice() else {
+        panic!("IME commit should emit one complete query")
+    };
+    assert_eq!(state.update(event.clone()), Outcome::Browsed);
+    assert_eq!(state.query(), unicode_name);
+    assert_eq!(state.count(), 1);
+    assert_eq!(state.highlighted().unwrap().id, Id::from_u128(30_111));
+    assert_eq!(state.current, Current::InvalidRaw("retained".into()));
+    assert!(state.is_open());
+}
@@ -0,0 +1,447 @@
+//! Keyboard entry and focus operations scoped to one property form. Focus
+//! targets include the draft generation so delayed operations cannot focus a
+//! replacement array row or a recovered document with the same semantic IDs.
+use crate::style;
+use iced::{
+    Border, Color, Element, Event, Length, Rectangle, Size, Task, Theme, Vector,
+    advanced::{
+        Clipboard, Layout, Shell, Widget, layout, overlay, renderer,
+        widget::{Id, Operation, Tree, operation, tree},
+    },
+    keyboard, mouse,
+    widget::container,
+};
+use oa_core::Id as ModelId;
+mod focus;
+
+#[derive(Clone, Copy)]
+pub struct FormScope {
+    pub session: ModelId,
+    pub modal: bool,
+}
+pub(super) struct FormOwner(pub Option<FormScope>);
+const REVIEW_MODAL: &str = "reference-owning-review-modal";
+
+/// Marks the entire Review dialog without changing its layout or event flow.
+pub fn modal<'a, Message: 'a, R: renderer::Renderer + 'a>(
+    content: impl Into<Element<'a, Message, Theme, R>>,
+) -> Element<'a, Message, Theme, R> {
+    Field {
+        content: content.into(),
+        id: Some(Id::new(REVIEW_MODAL)),
+        on_open: None,
+    }
+    .into()
+}
+
+pub fn field_id(generation: ModelId, path: &str) -> Id {
+    Id::new(format!("reference:{generation}:{path}"))
+}
+pub fn scope_id(session: ModelId) -> Id {
+    Id::new(format!("reference-form:{session}"))
+}
+
+#[derive(Default)]
+struct Interaction {
+    focused: bool,
+    pressed: bool,
+    identity: Option<Id>,
+    anchor: Option<Rectangle>,
+}
+impl operation::Focusable for Interaction {
+    fn is_focused(&self) -> bool {
+        self.focused
+    }
+    fn focus(&mut self) {
+        self.focused = true;
+    }
+    fn unfocus(&mut self) {
+        self.focused = false;
+        self.pressed = false;
+    }
+}
+pub struct Field<'a, Message, R = iced::Renderer>
+where
+    R: renderer::Renderer,
+{
+    content: Element<'a, Message, Theme, R>,
+    id: Option<Id>,
+    on_open: Option<Box<dyn Fn(Rectangle) -> Message + 'a>>,
+}
+impl<'a, Message, R: renderer::Renderer> Field<'a, Message, R> {
+    pub fn new(
+        content: impl Into<Element<'a, Message, Theme, R>>,
+        id: Id,
+        on_open: impl Fn(Rectangle) -> Message + 'a,
+    ) -> Self {
+        Self {
+            content: content.into(),
+            id: Some(id),
+            on_open: Some(Box::new(on_open)),
+        }
+    }
+}
+pub fn scope<'a, Message: 'a, R: renderer::Renderer + 'a>(
+    content: impl Into<Element<'a, Message, Theme, R>>,
+    session: ModelId,
+) -> Element<'a, Message, Theme, R> {
+    container(Field {
+        content: content.into(),
+        id: None,
+        on_open: None,
+    })
+    .id(scope_id(session))
+    .width(Length::Fill)
+    .into()
+}
+
+fn run<Message, R: renderer::Renderer>(
+    content: &mut Element<'_, Message, Theme, R>,
+    tree: &mut Tree,
+    layout: Layout<'_>,
+    renderer: &R,
+    mut operation: Box<dyn Operation>,
+) -> bool {
+    let mut changed = false;
+    loop {
+        content
+            .as_widget_mut()
+            .operate(tree, layout, renderer, &mut *operation);
+        match operation.finish() {
+            operation::Outcome::Chain(next) => {
+                operation = next;
+                changed = true;
+            }
+            _ => break,
+        }
+    }
+    changed
+}
+
+pub(super) fn tab<Message, R: renderer::Renderer>(
+    content: &mut Element<'_, Message, Theme, R>,
+    tree: &mut Tree,
+    layout: Layout<'_>,
+    renderer: &R,
+    scope: FormScope,
+    backwards: bool,
+) -> bool {
+    run(
+        content,
+        tree,
+        layout,
+        renderer,
+        Box::new(focus::relative(scope.session, backwards, scope.modal)),
+    )
+}
+pub(super) fn own_input<Message, R: renderer::Renderer>(
+    content: &mut Element<'_, Message, Theme, R>,
+    tree: &mut Tree,
+    layout: Layout<'_>,
+    renderer: &R,
+) {
+    content
+        .as_widget_mut()
+        .operate(tree, layout, renderer, &mut focus::exclusive());
+}
+impl<Message, R: renderer::Renderer> Widget<Message, Theme, R> for Field<'_, Message, R> {
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<Interaction>()
+    }
+    fn state(&self) -> tree::State {
+        tree::State::new(Interaction {
+            identity: self.id.clone(),
+            ..Default::default()
+        })
+    }
+    fn children(&self) -> Vec<Tree> {
+        vec![Tree::new(self.content.as_widget())]
+    }
+    fn diff(&self, tree: &mut Tree) {
+        let state = tree.state.downcast_mut::<Interaction>();
+        if state.identity != self.id {
+            *state = Interaction {
+                identity: self.id.clone(),
+                ..Default::default()
+            };
+        }
+        tree.diff_children(std::slice::from_ref(&self.content));
+    }
+    fn size(&self) -> Size<Length> {
+        self.content.as_widget().size()
+    }
+    fn layout(&mut self, tree: &mut Tree, renderer: &R, limits: &layout::Limits) -> layout::Node {
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+    fn operate(
+        &mut self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn Operation,
+    ) {
+        if let Some(id) = &self.id
+            && self.on_open.is_some()
+        {
+            operation.focusable(
+                Some(id),
+                layout.bounds(),
+                tree.state.downcast_mut::<Interaction>(),
+            );
+            operation.custom(
+                Some(id),
+                layout.bounds(),
+                tree.state.downcast_mut::<Interaction>(),
+            );
+        }
+        if self.on_open.is_none() {
+            operation.container(self.id.as_ref(), layout.bounds());
+            operation.traverse(&mut |operation| {
+                self.content.as_widget_mut().operate(
+                    &mut tree.children[0],
+                    layout,
+                    renderer,
+                    operation,
+                )
+            });
+        } else {
+            self.content.as_widget_mut().operate(
+                &mut tree.children[0],
+                layout,
+                renderer,
+                operation,
+            );
+        }
+    }
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        if self.on_open.is_some() {
+            let state = tree.state.downcast_mut::<Interaction>();
+            let visible = layout.bounds().intersection(viewport);
+            let hovered = visible.is_some_and(|bounds| cursor.is_over(bounds));
+            let activate = match event {
+                Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) if hovered => {
+                    state.focused = true;
+                    state.pressed = true;
+                    shell.capture_event();
+                    shell.request_redraw();
+                    false
+                }
+                Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => {
+                    let activate = state.pressed && hovered;
+                    if state.pressed {
+                        shell.capture_event();
+                    }
+                    state.pressed = false;
+                    activate
+                }
+                Event::Keyboard(keyboard::Event::KeyPressed {
+                    key:
+                        keyboard::Key::Named(keyboard::key::Named::Enter | keyboard::key::Named::Space),
+                    repeat: false,
+                    ..
+                }) if state.focused => true,
+                Event::Mouse(mouse::Event::ButtonPressed(_)) => {
+                    state.focused = false;
+                    state.pressed = false;
+                    false
+                }
+                _ => false,
+            };
+            if activate && let Some(bounds) = state.anchor {
+                shell.publish(self.on_open.as_ref().unwrap()(bounds));
+                shell.capture_event();
+                return;
+            }
+        }
+        self.content.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+    }
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        renderer_style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        if self.on_open.is_some() {
+            let focus = tree.state.downcast_ref::<Interaction>().focused;
+            renderer.fill_quad(
+                renderer::Quad {
+                    bounds: layout.bounds(),
+                    border: Border {
+                        color: if focus || cursor.is_over(layout.bounds()) {
+                            style::TEAL
+                        } else {
+                            style::LINE
+                        },
+                        width: if focus { 2. } else { 1. },
+                        radius: 5.into(),
+                    },
+                    ..Default::default()
+                },
+                Color::WHITE,
+            );
+        }
+        self.content.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            renderer_style,
+            layout,
+            cursor,
+            viewport,
+        );
+    }
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        if self.on_open.is_some() && cursor.is_over(layout.bounds()) {
+            mouse::Interaction::Pointer
+        } else {
+            self.content.as_widget().mouse_interaction(
+                &tree.children[0],
+                layout,
+                cursor,
+                viewport,
+                renderer,
+            )
+        }
+    }
+    fn overlay<'b>(
+        &'b mut self,
+        tree: &'b mut Tree,
+        layout: Layout<'b>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'b, Message, Theme, R>> {
+        self.content.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
+    }
+}
+
+/// Scrollable child updates use content coordinates. The root visits the
+/// retained tree before each input, so field anchors use current window
+/// coordinates even when a wheel event and activation share one runtime batch.
+pub(super) fn measure<Message, R: renderer::Renderer>(
+    content: &mut Element<'_, Message, Theme, R>,
+    tree: &mut Tree,
+    layout: Layout<'_>,
+    renderer: &R,
+    viewport: Rectangle,
+) {
+    content.as_widget_mut().operate(
+        tree,
+        layout,
+        renderer,
+        &mut Measure {
+            translation: Vector::ZERO,
+            viewport: Some(viewport),
+            pending: None,
+        },
+    );
+}
+struct Measure {
+    translation: Vector,
+    viewport: Option<Rectangle>,
+    pending: Option<(Vector, Option<Rectangle>)>,
+}
+impl Operation for Measure {
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation)) {
+        let previous = (self.translation, self.viewport);
+        if let Some((translation, viewport)) = self.pending.take() {
+            self.translation = translation;
+            self.viewport = viewport;
+        }
+        visit(self);
+        (self.translation, self.viewport) = previous;
+    }
+    fn scrollable(
+        &mut self,
+        _: Option<&Id>,
+        bounds: Rectangle,
+        _: Rectangle,
+        translation: Vector,
+        _: &mut dyn operation::Scrollable,
+    ) {
+        let bounds = Rectangle {
+            x: bounds.x - self.translation.x,
+            y: bounds.y - self.translation.y,
+            ..bounds
+        };
+        self.pending = Some((
+            self.translation + translation,
+            self.viewport
+                .and_then(|viewport| viewport.intersection(&bounds)),
+        ));
+    }
+    fn custom(&mut self, _: Option<&Id>, bounds: Rectangle, state: &mut dyn std::any::Any) {
+        if let Some(state) = state.downcast_mut::<Interaction>() {
+            let bounds = Rectangle {
+                x: bounds.x - self.translation.x,
+                y: bounds.y - self.translation.y,
+                ..bounds
+            };
+            state.anchor = self
+                .viewport
+                .and_then(|viewport| viewport.intersection(&bounds));
+        }
+    }
+}
+impl<'a, Message: 'a, R: renderer::Renderer + 'a> From<Field<'a, Message, R>>
+    for Element<'a, Message, Theme, R>
+{
+    fn from(field: Field<'a, Message, R>) -> Self {
+        Element::new(field)
+    }
+}
+
+pub fn focus_operation(
+    session: ModelId,
+    generation: ModelId,
+    path: &str,
+    step: i32,
+) -> impl Operation + 'static {
+    focus::exact(session, generation, path, step)
+}
+pub fn focus<Message>(
+    session: ModelId,
+    generation: ModelId,
+    path: &str,
+    step: i32,
+) -> Task<Message> {
+    iced::advanced::widget::operate(focus_operation(session, generation, path, step)).discard()
+}
@@ -0,0 +1,303 @@
+//! Focus movement and reveal share one root traversal. A form may be inside a
+//! scrollable; restricting traversal to its container would hide that ancestor.
+use super::{FormOwner, Id, ModelId, Operation, Rectangle, Vector, field_id, operation, scope_id};
+use std::collections::BTreeMap;
+
+enum Origin {
+    Current,
+    Exact(Id),
+}
+#[derive(Clone)]
+struct Scroll {
+    index: usize,
+    bounds: Rectangle,
+    capacity: Vector,
+    offset: Vector,
+}
+struct Field {
+    id: Option<Id>,
+    bounds: Rectangle,
+    ancestors: Vec<Scroll>,
+}
+pub(super) struct Collect {
+    scope: Id,
+    origin: Origin,
+    step: i32,
+    inside: bool,
+    entering: Option<bool>,
+    translation: Vector,
+    scrolls: Vec<Scroll>,
+    pending_scroll: Option<Scroll>,
+    scroll_index: usize,
+    fields: Vec<Field>,
+    focused: Option<usize>,
+    outside_focused: bool,
+    modal: bool,
+    owner_valid: bool,
+}
+impl Collect {
+    fn new(scope: Id, origin: Origin, step: i32) -> Self {
+        let owner_valid = matches!(origin, Origin::Current);
+        Self {
+            scope,
+            origin,
+            step,
+            inside: false,
+            entering: None,
+            translation: Vector::ZERO,
+            scrolls: vec![],
+            pending_scroll: None,
+            scroll_index: 0,
+            fields: vec![],
+            focused: None,
+            outside_focused: false,
+            modal: false,
+            owner_valid,
+        }
+    }
+}
+pub(super) fn relative(session: ModelId, backwards: bool, modal: bool) -> Collect {
+    Collect {
+        modal,
+        ..Collect::new(
+            scope_id(session),
+            Origin::Current,
+            if backwards { -1 } else { 1 },
+        )
+    }
+}
+pub(super) fn exact(session: ModelId, generation: ModelId, path: &str, step: i32) -> Collect {
+    Collect::new(
+        scope_id(session),
+        Origin::Exact(field_id(generation, path)),
+        step,
+    )
+}
+impl Operation for Collect {
+    fn custom(&mut self, _: Option<&Id>, _: Rectangle, state: &mut dyn std::any::Any) {
+        if let Some(owner) = state.downcast_ref::<FormOwner>() {
+            self.owner_valid = owner
+                .0
+                .is_some_and(|owner| scope_id(owner.session) == self.scope);
+            self.modal = owner.0.is_some_and(|owner| owner.modal);
+        }
+    }
+    fn container(&mut self, id: Option<&Id>, _: Rectangle) {
+        self.entering = Some(self.inside || id == Some(&self.scope));
+    }
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation)) {
+        let previous = (self.inside, self.translation, self.scrolls.len());
+        if let Some(inside) = self.entering.take() {
+            self.inside = inside;
+        }
+        if let Some(scroll) = self.pending_scroll.take() {
+            self.translation += scroll.offset;
+            self.scrolls.push(scroll);
+        }
+        visit(self);
+        self.inside = previous.0;
+        self.translation = previous.1;
+        self.scrolls.truncate(previous.2);
+    }
+    fn scrollable(
+        &mut self,
+        _: Option<&Id>,
+        bounds: Rectangle,
+        content: Rectangle,
+        offset: Vector,
+        _: &mut dyn operation::Scrollable,
+    ) {
+        self.pending_scroll = Some(Scroll {
+            index: self.scroll_index,
+            bounds: translated(bounds, self.translation),
+            capacity: Vector::new(
+                (content.width - bounds.width).max(0.),
+                (content.height - bounds.height).max(0.),
+            ),
+            offset,
+        });
+        self.scroll_index += 1;
+    }
+    fn focusable(
+        &mut self,
+        id: Option<&Id>,
+        bounds: Rectangle,
+        state: &mut dyn operation::Focusable,
+    ) {
+        if !self.inside {
+            self.outside_focused |= state.is_focused();
+            return;
+        }
+        if state.is_focused() {
+            self.focused = Some(self.fields.len());
+        }
+        self.fields.push(Field {
+            id: id.cloned(),
+            bounds: translated(bounds, self.translation),
+            ancestors: self.scrolls.clone(),
+        });
+    }
+    fn finish(&self) -> operation::Outcome<()> {
+        if !self.owner_valid || self.fields.is_empty() {
+            return operation::Outcome::None;
+        }
+        let origin = match &self.origin {
+            Origin::Current if self.focused.is_none() && self.outside_focused && !self.modal => {
+                return operation::Outcome::None;
+            }
+            Origin::Current => self
+                .focused
+                .map(|index| index as i64)
+                .unwrap_or(if self.step < 0 {
+                    self.fields.len() as i64
+                } else {
+                    -1
+                }),
+            Origin::Exact(id) => {
+                let Some(index) = self
+                    .fields
+                    .iter()
+                    .position(|field| field.id.as_ref() == Some(id))
+                else {
+                    return operation::Outcome::None;
+                };
+                index as i64
+            }
+        };
+        // A form keeps a reachable focus at both boundaries. Initial Tab enters
+        // the first field; initial Shift+Tab enters the last field.
+        let target = (origin + i64::from(self.step)).rem_euclid(self.fields.len() as i64) as usize;
+        let field = &self.fields[target];
+        let mut bounds = field.bounds;
+        let mut shifts = BTreeMap::new();
+        for ancestor in field.ancestors.iter().rev() {
+            let dx = reveal_axis(
+                bounds.x,
+                bounds.width,
+                ancestor.bounds.x,
+                ancestor.bounds.width,
+            );
+            let dy = reveal_axis(
+                bounds.y,
+                bounds.height,
+                ancestor.bounds.y,
+                ancestor.bounds.height,
+            );
+            let delta = Vector::new(
+                (ancestor.offset.x + dx).clamp(0., ancestor.capacity.x) - ancestor.offset.x,
+                (ancestor.offset.y + dy).clamp(0., ancestor.capacity.y) - ancestor.offset.y,
+            );
+            if delta != Vector::ZERO {
+                shifts.insert(ancestor.index, delta);
+            }
+            bounds = translated(bounds, delta);
+        }
+        operation::Outcome::Chain(Box::new(Apply {
+            scope: self.scope.clone(),
+            inside: false,
+            entering: None,
+            target,
+            field_index: 0,
+            scroll_index: 0,
+            shifts,
+            owner_valid: matches!(self.origin, Origin::Current),
+            clear_outside: self.modal,
+            preserve_inside: false,
+        }))
+    }
+}
+fn translated(bounds: Rectangle, delta: Vector) -> Rectangle {
+    Rectangle {
+        x: bounds.x - delta.x,
+        y: bounds.y - delta.y,
+        ..bounds
+    }
+}
+fn reveal_axis(start: f32, length: f32, viewport_start: f32, viewport_length: f32) -> f32 {
+    if start < viewport_start || length > viewport_length {
+        start - viewport_start
+    } else {
+        (start + length - viewport_start - viewport_length).max(0.)
+    }
+}
+pub(super) struct Apply {
+    scope: Id,
+    inside: bool,
+    entering: Option<bool>,
+    target: usize,
+    field_index: usize,
+    scroll_index: usize,
+    shifts: BTreeMap<usize, Vector>,
+    owner_valid: bool,
+    clear_outside: bool,
+    preserve_inside: bool,
+}
+pub(super) fn exclusive() -> Apply {
+    Apply {
+        scope: Id::new(super::REVIEW_MODAL),
+        inside: false,
+        entering: None,
+        target: 0,
+        field_index: 0,
+        scroll_index: 0,
+        shifts: BTreeMap::new(),
+        owner_valid: true,
+        clear_outside: true,
+        preserve_inside: true,
+    }
+}
+impl Operation for Apply {
+    fn custom(&mut self, _: Option<&Id>, _: Rectangle, state: &mut dyn std::any::Any) {
+        if let Some(owner) = state.downcast_ref::<FormOwner>() {
+            self.owner_valid = owner
+                .0
+                .is_some_and(|owner| scope_id(owner.session) == self.scope);
+            self.clear_outside = owner.0.is_some_and(|owner| owner.modal);
+        }
+    }
+    fn container(&mut self, id: Option<&Id>, _: Rectangle) {
+        self.entering = Some(self.inside || id == Some(&self.scope));
+    }
+    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation)) {
+        let previous = self.inside;
+        if let Some(inside) = self.entering.take() {
+            self.inside = inside;
+        }
+        visit(self);
+        self.inside = previous;
+    }
+    fn scrollable(
+        &mut self,
+        _: Option<&Id>,
+        bounds: Rectangle,
+        content: Rectangle,
+        _: Vector,
+        state: &mut dyn operation::Scrollable,
+    ) {
+        if self.owner_valid
+            && let Some(delta) = self.shifts.get(&self.scroll_index)
+        {
+            state.scroll_by(
+                operation::scrollable::AbsoluteOffset {
+                    x: delta.x,
+                    y: delta.y,
+                },
+                bounds,
+                content,
+            );
+        }
+        self.scroll_index += 1;
+    }
+    fn focusable(&mut self, _: Option<&Id>, _: Rectangle, state: &mut dyn operation::Focusable) {
+        if self.owner_valid && self.inside && !self.preserve_inside {
+            if self.field_index == self.target {
+                state.focus();
+            } else {
+                state.unfocus();
+            }
+            self.field_index += 1;
+        } else if self.owner_valid && !self.inside && self.clear_outside {
+            state.unfocus();
+        }
+    }
+}
@@ -0,0 +1,994 @@
+//! Root overlay adapter. Keep the wrapper mounted while closed so the release
+//! from a dismissal gesture cannot reach the underlying content. Parent modal
+//! ownership is supplied by the host (pass no chooser while a modal is active).
+use super::{Action, Close, Event as ChoiceEvent, MAX_ROWS, Stamp, State as Chooser};
+use crate::style;
+use iced::{
+    Border, Color, Element, Event, Font, Length, Point, Rectangle, Size, Theme, Vector,
+    advanced::{
+        Clipboard, Layout, Shell, Widget, layout, overlay, renderer,
+        text::{self, Paragraph as _},
+        widget::{Operation, Tree, tree},
+    },
+    alignment, keyboard, mouse, touch,
+    widget::text_input,
+    window,
+};
+use std::{cell::Cell, rc::Rc};
+
+const ROW: f32 = 34.;
+const MARGIN: f32 = 8.;
+
+#[derive(Debug, Clone, Copy)]
+pub(super) struct Geometry {
+    pub popup: Rectangle,
+    pub search: Rectangle,
+    pub current: Rectangle,
+    pub detail: Rectangle,
+    pub close: Rectangle,
+    pub previous: Rectangle,
+    pub next: Rectangle,
+    pub clear: Rectangle,
+    pub rows: usize,
+}
+impl Geometry {
+    fn new(anchor: Rectangle, viewport: Size) -> Self {
+        let width = anchor
+            .width
+            .clamp(278., 420.)
+            .min((viewport.width - 2. * MARGIN).max(0.));
+        let height = 360f32.min((viewport.height - 2. * MARGIN).max(0.));
+        let x = anchor.x.clamp(
+            MARGIN.min(viewport.width / 2.),
+            (viewport.width - MARGIN - width).max(MARGIN.min(viewport.width / 2.)),
+        );
+        let below = anchor.y + anchor.height + 4.;
+        let preferred = if below + height + MARGIN <= viewport.height {
+            below
+        } else {
+            anchor.y - height - 4.
+        };
+        let y = preferred.clamp(
+            MARGIN.min(viewport.height / 2.),
+            (viewport.height - MARGIN - height).max(MARGIN.min(viewport.height / 2.)),
+        );
+        Self::from_bounds(Rectangle {
+            x,
+            y,
+            width,
+            height,
+        })
+    }
+    pub(super) fn from_bounds(popup: Rectangle) -> Self {
+        let inner = (popup.width - 16.).max(0.);
+        let rect = |left, top, width, height| Rectangle {
+            x: popup.x + left,
+            y: popup.y + top,
+            width,
+            height,
+        };
+        let footer = (popup.height - 32.).max(0.);
+        let detail_height = if popup.height >= 180. { 32. } else { 0. };
+        let detail_top = (footer - detail_height - 4.).max(84.);
+        let rows = (((detail_top - 88.).max(0.) / ROW) as usize).min(MAX_ROWS);
+        Self {
+            popup,
+            search: rect(8., 28., inner, 30.),
+            current: rect(8., 62., inner, 18.),
+            detail: rect(8., detail_top, inner, detail_height),
+            close: rect((popup.width - 58.).max(0.), 4., 50f32.min(popup.width), 22.),
+            previous: rect(8., footer, 28., 24.),
+            next: rect(40., footer, 28., 24.),
+            clear: rect((popup.width - 84.).max(0.), footer, 76., 24.),
+            rows,
+        }
+    }
+    pub fn row(&self, index: usize) -> Rectangle {
+        Rectangle {
+            x: self.popup.x + 8.,
+            y: self.popup.y + 84. + index as f32 * ROW,
+            width: (self.popup.width - 16.).max(0.),
+            height: ROW,
+        }
+    }
+    fn hit(&self, chooser: &Chooser, point: Point) -> Option<Action> {
+        if self.close.contains(point) {
+            return Some(Action::Close(Close::Escape));
+        }
+        if self.previous.contains(point) && chooser.start() > 0 {
+            return Some(Action::Page {
+                delta: -1,
+                rows: self.rows,
+            });
+        }
+        if self.next.contains(point) && chooser.start() + self.rows < chooser.count() {
+            return Some(Action::Page {
+                delta: 1,
+                rows: self.rows,
+            });
+        }
+        if self.clear.contains(point) && chooser.optional() {
+            return Some(Action::Clear);
+        }
+        chooser
+            .visible(self.rows)
+            .enumerate()
+            .find_map(|(i, c)| self.row(i).contains(point).then_some(Action::Choose(c.id)))
+    }
+}
+
+#[derive(Default)]
+struct Interaction {
+    stamp: Option<Stamp>,
+    serial: u64,
+    pressed: Option<(ChoiceEvent, Pointer)>,
+    closing: bool,
+    swallow_mouse: Option<mouse::Button>,
+    swallow_touch: Option<touch::Finger>,
+    held_mouse: Option<mouse::Button>,
+    held_touch: Option<touch::Finger>,
+    detail_scroll: f32,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Pointer {
+    Mouse,
+    Touch(touch::Finger),
+}
+impl Interaction {
+    fn swallow(&mut self, event: &Event) -> bool {
+        match event {
+            Event::Mouse(mouse::Event::ButtonReleased(button))
+                if self.swallow_mouse == Some(*button) =>
+            {
+                self.swallow_mouse = None;
+                true
+            }
+            Event::Touch(
+                touch::Event::FingerLifted { id, .. } | touch::Event::FingerLost { id, .. },
+            ) if self.swallow_touch == Some(*id) => {
+                self.swallow_touch = None;
+                true
+            }
+            _ => false,
+        }
+    }
+}
+
+pub struct Popup<'a, Message, R = iced::Renderer>
+where
+    R: text::Renderer<Font = Font>,
+{
+    content: Element<'a, Message, Theme, R>,
+    input: Element<'a, String, Theme, R>,
+    chooser: Option<&'a Chooser>,
+    anchor: Rectangle,
+    on_event: Rc<dyn Fn(ChoiceEvent) -> Message + 'a>,
+    focus_scope: Option<super::trigger::FormScope>,
+}
+impl<'a, Message: Clone + 'a, R: text::Renderer<Font = Font> + 'a> Popup<'a, Message, R> {
+    pub fn new(
+        content: impl Into<Element<'a, Message, Theme, R>>,
+        chooser: Option<&'a Chooser>,
+        anchor: Rectangle,
+        on_event: impl Fn(ChoiceEvent) -> Message + 'a,
+    ) -> Self {
+        let chooser = chooser.filter(|state| state.is_open());
+        let input = text_input(
+            "Name, @alias, kind or containment",
+            chooser.map_or("", Chooser::query),
+        )
+        .on_input(std::convert::identity)
+        .size(12)
+        .padding(6)
+        .width(Length::Fill)
+        .into();
+        Self {
+            content: content.into(),
+            input,
+            chooser,
+            anchor,
+            on_event: Rc::new(on_event),
+            focus_scope: None,
+        }
+    }
+    pub fn focus_scope(mut self, scope: Option<super::trigger::FormScope>) -> Self {
+        self.focus_scope = scope;
+        self
+    }
+    fn reconcile(&self, tree: &mut Tree) {
+        let state = tree.state.downcast_mut::<Interaction>();
+        let stamp = self.chooser.map(Chooser::stamp);
+        if state.stamp.as_ref().map(|s| s.invocation) != stamp.as_ref().map(|s| s.invocation) {
+            let input = tree.children[1]
+                .state
+                .downcast_mut::<text_input::State<R::Paragraph>>();
+            if stamp.is_some() {
+                input.focus();
+            } else {
+                input.unfocus();
+            }
+            state.closing = false;
+            state.serial = self.chooser.map_or(0, Chooser::query_serial);
+        }
+        if state.stamp != stamp {
+            state.pressed = None;
+            // A queued Choose can be rejected after a preceding query changed
+            // the result generation. Reconciliation must unlock this view.
+            state.closing = false;
+            state.detail_scroll = 0.;
+        }
+        state.stamp = stamp;
+    }
+}
+impl<Message: Clone, R: text::Renderer<Font = Font>> Widget<Message, Theme, R>
+    for Popup<'_, Message, R>
+{
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<Interaction>()
+    }
+    fn state(&self) -> tree::State {
+        tree::State::new(Interaction::default())
+    }
+    fn children(&self) -> Vec<Tree> {
+        vec![
+            Tree::new(self.content.as_widget()),
+            Tree::new(self.input.as_widget()),
+        ]
+    }
+    fn diff(&self, tree: &mut Tree) {
+        tree.children[0].diff(self.content.as_widget());
+        tree.children[1].diff(self.input.as_widget());
+        self.reconcile(tree);
+    }
+    fn size(&self) -> Size<Length> {
+        self.content.as_widget().size()
+    }
+    fn layout(&mut self, tree: &mut Tree, renderer: &R, limits: &layout::Limits) -> layout::Node {
+        self.reconcile(tree);
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+    fn operate(
+        &mut self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn Operation,
+    ) {
+        let mut owner =
+            super::trigger::FormOwner(self.focus_scope.filter(|_| self.chooser.is_none()));
+        operation.custom(None, layout.bounds(), &mut owner);
+        self.content
+            .as_widget_mut()
+            .operate(&mut tree.children[0], layout, renderer, operation);
+    }
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        let state = tree.state.downcast_mut::<Interaction>();
+        if state.swallow(event) || self.chooser.is_some() && is_input(event) {
+            shell.capture_event();
+            return;
+        }
+        if is_input(event) && self.focus_scope.is_some_and(|scope| scope.modal) {
+            super::trigger::own_input(&mut self.content, &mut tree.children[0], layout, renderer);
+        }
+        if let Event::Keyboard(keyboard::Event::KeyPressed {
+            key: keyboard::Key::Named(keyboard::key::Named::Tab),
+            modifiers,
+            ..
+        }) = event
+            && let Some(scope) = self.focus_scope
+            && super::trigger::tab(
+                &mut self.content,
+                &mut tree.children[0],
+                layout,
+                renderer,
+                scope,
+                modifiers.shift(),
+            )
+        {
+            shell.capture_event();
+            shell.request_redraw();
+            return;
+        }
+        super::trigger::measure(
+            &mut self.content,
+            &mut tree.children[0],
+            layout,
+            renderer,
+            *viewport,
+        );
+        self.content.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+    }
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            style,
+            layout,
+            if self.chooser.is_some() {
+                mouse::Cursor::Unavailable
+            } else {
+                cursor
+            },
+            viewport,
+        );
+    }
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        if self.chooser.is_some() {
+            mouse::Interaction::None
+        } else {
+            self.content.as_widget().mouse_interaction(
+                &tree.children[0],
+                layout,
+                cursor,
+                viewport,
+                renderer,
+            )
+        }
+    }
+    fn overlay<'b>(
+        &'b mut self,
+        tree: &'b mut Tree,
+        layout: Layout<'b>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'b, Message, Theme, R>> {
+        if let Some(chooser) = self.chooser {
+            Some(overlay::Element::new(Box::new(ChooserOverlay {
+                chooser,
+                anchor: self.anchor,
+                state: tree.state.downcast_mut(),
+                input: &mut self.input,
+                input_tree: &mut tree.children[1],
+                on_event: &*self.on_event,
+            })))
+        } else {
+            self.content.as_widget_mut().overlay(
+                &mut tree.children[0],
+                layout,
+                renderer,
+                viewport,
+                translation,
+            )
+        }
+    }
+}
+impl<'a, Message: Clone + 'a, R: text::Renderer<Font = Font> + 'a> From<Popup<'a, Message, R>>
+    for Element<'a, Message, Theme, R>
+{
+    fn from(popup: Popup<'a, Message, R>) -> Self {
+        Element::new(popup)
+    }
+}
+
+struct ChooserOverlay<'b, 'a, Message, R: text::Renderer<Font = Font>> {
+    chooser: &'a Chooser,
+    anchor: Rectangle,
+    state: &'b mut Interaction,
+    input: &'b mut Element<'a, String, Theme, R>,
+    input_tree: &'b mut Tree,
+    on_event: &'b dyn Fn(ChoiceEvent) -> Message,
+}
+impl<Message, R: text::Renderer<Font = Font>> ChooserOverlay<'_, '_, Message, R> {
+    fn geometry(&self, layout: Layout<'_>) -> Geometry {
+        Geometry::from_bounds(
+            layout
+                .children()
+                .next()
+                .expect("measured chooser bounds")
+                .bounds(),
+        )
+    }
+    fn publish(&mut self, action: Action, shell: &mut Shell<'_, Message>) {
+        if self.state.closing {
+            return;
+        }
+        if action.writes_staged_value() || matches!(action, Action::Close(_)) {
+            self.state.closing = true;
+            self.state.swallow_mouse = self.state.held_mouse.or(self.state.swallow_mouse);
+            self.state.swallow_touch = self.state.held_touch.or(self.state.swallow_touch);
+        }
+        shell.publish((self.on_event)(self.chooser.event(action)));
+    }
+    fn press(
+        &mut self,
+        point: Point,
+        pointer: Pointer,
+        geometry: Geometry,
+        shell: &mut Shell<'_, Message>,
+    ) {
+        if !geometry.popup.contains(point) {
+            self.publish(Action::Close(Close::Outside), shell);
+        } else {
+            self.state.pressed = geometry
+                .hit(self.chooser, point)
+                .map(|action| (self.chooser.event(action), pointer));
+        }
+    }
+    fn release(
+        &mut self,
+        point: Point,
+        pointer: Pointer,
+        geometry: Geometry,
+        shell: &mut Shell<'_, Message>,
+    ) {
+        if let Some((pressed, origin)) = self.state.pressed.take()
+            && origin == pointer
+            && pressed.stamp == self.chooser.stamp()
+            && geometry.hit(self.chooser, point).as_ref() == Some(&pressed.action)
+        {
+            self.publish(pressed.action, shell);
+        }
+    }
+}
+impl<Message: Clone, R: text::Renderer<Font = Font>> overlay::Overlay<Message, Theme, R>
+    for ChooserOverlay<'_, '_, Message, R>
+{
+    fn layout(&mut self, renderer: &R, bounds: Size) -> layout::Node {
+        let geometry = Geometry::new(self.anchor, bounds);
+        let input = self
+            .input
+            .as_widget_mut()
+            .layout(
+                self.input_tree,
+                renderer,
+                &layout::Limits::new(Size::ZERO, geometry.search.size()),
+            )
+            .move_to(geometry.search.position());
+        layout::Node::with_children(
+            bounds,
+            vec![
+                layout::Node::new(geometry.popup.size()).move_to(geometry.popup.position()),
+                input,
+            ],
+        )
+    }
+    fn operate(&mut self, layout: Layout<'_>, renderer: &R, operation: &mut dyn Operation) {
+        self.input.as_widget_mut().operate(
+            self.input_tree,
+            layout.children().nth(1).unwrap(),
+            renderer,
+            operation,
+        );
+    }
+    fn update(
+        &mut self,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+    ) {
+        let geometry = self.geometry(layout);
+        match event {
+            Event::Mouse(mouse::Event::ButtonPressed(button)) => {
+                self.state.held_mouse = Some(*button)
+            }
+            Event::Mouse(mouse::Event::ButtonReleased(button))
+                if self.state.held_mouse == Some(*button) =>
+            {
+                self.state.held_mouse = None
+            }
+            Event::Touch(touch::Event::FingerPressed { id, .. }) => {
+                self.state.held_touch = Some(*id)
+            }
+            Event::Touch(
+                touch::Event::FingerLifted { id, .. } | touch::Event::FingerLost { id, .. },
+            ) if self.state.held_touch == Some(*id) => self.state.held_touch = None,
+            _ => {}
+        }
+        if self.state.swallow(event) {
+            shell.capture_event();
+            return;
+        }
+        if self.state.closing {
+            if is_input(event) {
+                shell.capture_event();
+            }
+            return;
+        }
+        let mut handled = false;
+        match event {
+            Event::Keyboard(keyboard::Event::KeyPressed { key, modifiers, .. }) => {
+                use keyboard::key::Named;
+                let action = match key {
+                    keyboard::Key::Named(Named::Escape) => Some(Action::Close(Close::Escape)),
+                    keyboard::Key::Named(Named::Tab) => Some(Action::Close(Close::Tab {
+                        backwards: modifiers.shift(),
+                    })),
+                    keyboard::Key::Named(Named::ArrowDown) => Some(Action::Move {
+                        delta: 1,
+                        rows: geometry.rows,
+                    }),
+                    keyboard::Key::Named(Named::ArrowUp) => Some(Action::Move {
+                        delta: -1,
+                        rows: geometry.rows,
+                    }),
+                    keyboard::Key::Named(Named::PageDown) => Some(Action::Page {
+                        delta: 1,
+                        rows: geometry.rows,
+                    }),
+                    keyboard::Key::Named(Named::PageUp) => Some(Action::Page {
+                        delta: -1,
+                        rows: geometry.rows,
+                    }),
+                    keyboard::Key::Named(Named::Enter) => {
+                        handled = true;
+                        self.chooser
+                            .highlighted()
+                            .filter(|c| self.chooser.visible(geometry.rows).any(|v| v.id == c.id))
+                            .map(|c| Action::Choose(c.id))
+                    }
+                    keyboard::Key::Character(c)
+                        if modifiers.control()
+                            && modifiers.shift()
+                            && c.eq_ignore_ascii_case("c") =>
+                    {
+                        clipboard.write(
+                            iced::advanced::clipboard::Kind::Standard,
+                            self.chooser
+                                .highlighted()
+                                .map_or_else(|| self.chooser.current.label(), |c| c.detail()),
+                        );
+                        handled = true;
+                        None
+                    }
+                    _ => None,
+                };
+                if let Some(action) = action {
+                    self.publish(action, shell);
+                    handled = true;
+                }
+            }
+            Event::Window(window::Event::Resized(_) | window::Event::Unfocused) => {
+                self.publish(Action::Close(Close::WindowChanged), shell);
+                handled = true;
+            }
+            Event::Mouse(mouse::Event::ButtonPressed(button)) => {
+                if let Some(point) = cursor.position() {
+                    if !geometry.popup.contains(point) {
+                        self.state.swallow_mouse = Some(*button);
+                        self.press(point, Pointer::Mouse, geometry, shell);
+                        handled = true;
+                    } else if *button == mouse::Button::Left && !geometry.search.contains(point) {
+                        self.press(point, Pointer::Mouse, geometry, shell);
+                        handled = true;
+                    }
+                }
+            }
+            Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
+                if self.state.pressed.is_some() =>
+            {
+                if let Some(point) = cursor.position() {
+                    self.release(point, Pointer::Mouse, geometry, shell);
+                } else {
+                    self.state.pressed = None;
+                }
+                handled = true;
+            }
+            Event::Mouse(mouse::Event::CursorMoved { position })
+                if self.state.pressed.is_none() =>
+            {
+                if let Some(Action::Choose(id)) = geometry.hit(self.chooser, *position)
+                    && self
+                        .chooser
+                        .highlighted()
+                        .is_none_or(|candidate| candidate.id != id)
+                {
+                    self.publish(Action::Highlight(id), shell);
+                }
+            }
+            Event::Mouse(mouse::Event::WheelScrolled { delta }) => {
+                let (x, y) = match delta {
+                    mouse::ScrollDelta::Lines { x, y } => (*x * 24., *y * 24.),
+                    mouse::ScrollDelta::Pixels { x, y } => (*x, *y),
+                };
+                self.state.pressed = None;
+                if cursor
+                    .position()
+                    .is_some_and(|p| geometry.detail.contains(p))
+                {
+                    let detail = self
+                        .chooser
+                        .highlighted()
+                        .map_or_else(|| self.chooser.current.label(), |c| c.detail());
+                    let max = (measure::<R>(&detail, 11., renderer.default_font())
+                        - geometry.detail.width)
+                        .max(0.);
+                    self.state.detail_scroll =
+                        (self.state.detail_scroll - if x != 0. { x } else { y }).clamp(0., max);
+                    shell.request_redraw();
+                } else if y != 0. {
+                    self.publish(
+                        Action::Page {
+                            delta: if y < 0. { 1 } else { -1 },
+                            rows: geometry.rows,
+                        },
+                        shell,
+                    );
+                }
+                handled = true;
+            }
+            Event::Touch(touch::Event::FingerPressed { id, position })
+                if !geometry.search.contains(*position) =>
+            {
+                if !geometry.popup.contains(*position) {
+                    self.state.swallow_touch = Some(*id);
+                }
+                self.press(*position, Pointer::Touch(*id), geometry, shell);
+                handled = true;
+            }
+            Event::Touch(touch::Event::FingerLifted { id, position })
+                if self.state.pressed.is_some() =>
+            {
+                self.release(*position, Pointer::Touch(*id), geometry, shell);
+                handled = true;
+            }
+            Event::Touch(touch::Event::FingerLost { .. } | touch::Event::FingerMoved { .. }) => {
+                self.state.pressed = None;
+            }
+            _ => {}
+        }
+        if !handled {
+            let mut messages = Vec::new();
+            let mut input_shell = Shell::new(&mut messages);
+            self.input.as_widget_mut().update(
+                self.input_tree,
+                event,
+                layout.children().nth(1).unwrap(),
+                cursor,
+                renderer,
+                clipboard,
+                &mut input_shell,
+                &geometry.popup,
+            );
+            let serial = Cell::new(self.state.serial);
+            shell.merge(input_shell, |text| {
+                serial.set(serial.get().saturating_add(1));
+                (self.on_event)(self.chooser.event(Action::Query {
+                    text,
+                    serial: serial.get(),
+                }))
+            });
+            self.state.serial = serial.get();
+        }
+        if is_input(event) {
+            shell.capture_event();
+        }
+    }
+    fn draw(
+        &self,
+        renderer: &mut R,
+        theme: &Theme,
+        renderer_style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+    ) {
+        let geometry = self.geometry(layout);
+        renderer.fill_quad(
+            renderer::Quad {
+                bounds: geometry.popup,
+                border: Border {
+                    color: style::LINE,
+                    width: 1.,
+                    radius: 8.into(),
+                },
+                ..Default::default()
+            },
+            Color::WHITE,
+        );
+        renderer.with_layer(geometry.popup, |renderer| {
+            label(
+                renderer,
+                &self.chooser.scope_label,
+                11.,
+                style::MUTED,
+                Rectangle {
+                    x: geometry.popup.x + 8.,
+                    y: geometry.popup.y + 4.,
+                    width: (geometry.popup.width - 78.).max(0.),
+                    height: 22.,
+                },
+            );
+            label(renderer, "Close", 11., style::TEAL, geometry.close);
+            label(
+                renderer,
+                &self.chooser.current.label(),
+                11.,
+                style::MUTED,
+                geometry.current,
+            );
+            for (i, candidate) in self.chooser.visible(geometry.rows).enumerate() {
+                let row = geometry.row(i);
+                if self
+                    .chooser
+                    .highlighted()
+                    .is_some_and(|c| c.id == candidate.id)
+                {
+                    renderer.fill_quad(
+                        renderer::Quad {
+                            bounds: row,
+                            ..Default::default()
+                        },
+                        Color::from_rgb8(218, 238, 235),
+                    );
+                }
+                let alias_width = (row.width * 0.42).min(
+                    measure::<R>(
+                        &format!("@{}", candidate.alias),
+                        11.,
+                        renderer.default_font(),
+                    ) + 4.,
+                );
+                label(
+                    renderer,
+                    &candidate.name,
+                    12.,
+                    style::INK,
+                    Rectangle {
+                        width: (row.width - alias_width - 6.).max(0.),
+                        height: 17.,
+                        ..row
+                    },
+                );
+                label(
+                    renderer,
+                    &format!("@{}", candidate.alias),
+                    11.,
+                    style::INK,
+                    Rectangle {
+                        x: row.x + row.width - alias_width,
+                        width: alias_width,
+                        height: 17.,
+                        ..row
+                    },
+                );
+                label(
+                    renderer,
+                    &candidate.context_label(),
+                    10.,
+                    style::MUTED,
+                    Rectangle {
+                        y: row.y + 17.,
+                        height: 17.,
+                        ..row
+                    },
+                );
+            }
+            if self.chooser.count() == 0 {
+                label(
+                    renderer,
+                    "No compatible matches. Clear the query.",
+                    11.,
+                    style::MUTED,
+                    geometry.row(0),
+                );
+            }
+            let detail = self
+                .chooser
+                .highlighted()
+                .map_or_else(|| self.chooser.current.label(), |c| c.detail());
+            renderer.with_layer(geometry.detail, |renderer| {
+                raw_label(
+                    renderer,
+                    detail,
+                    11.,
+                    style::MUTED,
+                    Rectangle {
+                        x: geometry.detail.x - self.state.detail_scroll,
+                        width: geometry.detail.width + self.state.detail_scroll,
+                        height: 16.,
+                        ..geometry.detail
+                    },
+                );
+                label(
+                    renderer,
+                    "Scroll details · Ctrl+Shift+C copies",
+                    10.,
+                    style::MUTED,
+                    Rectangle {
+                        y: geometry.detail.y + 16.,
+                        height: 16.,
+                        ..geometry.detail
+                    },
+                );
+            });
+            label(
+                renderer,
+                "‹",
+                15.,
+                if self.chooser.start() > 0 {
+                    style::TEAL
+                } else {
+                    style::MUTED
+                },
+                geometry.previous,
+            );
+            label(
+                renderer,
+                "›",
+                15.,
+                if self.chooser.start() + geometry.rows < self.chooser.count() {
+                    style::TEAL
+                } else {
+                    style::MUTED
+                },
+                geometry.next,
+            );
+            let count = if self.chooser.count() == 0 {
+                "0 results".into()
+            } else {
+                format!(
+                    "{}–{} / {}",
+                    self.chooser.start() + 1,
+                    (self.chooser.start() + geometry.rows).min(self.chooser.count()),
+                    self.chooser.count()
+                )
+            };
+            label(
+                renderer,
+                &count,
+                11.,
+                style::MUTED,
+                Rectangle {
+                    x: geometry.next.x + 30.,
+                    width: (geometry.clear.x - geometry.next.x - 32.).max(0.),
+                    ..geometry.next
+                },
+            );
+            if self.chooser.optional() {
+                label(
+                    renderer,
+                    "Clear reference",
+                    10.,
+                    style::TEAL,
+                    geometry.clear,
+                );
+            }
+            self.input.as_widget().draw(
+                self.input_tree,
+                renderer,
+                theme,
+                renderer_style,
+                layout.children().nth(1).unwrap(),
+                cursor,
+                &geometry.popup,
+            );
+        });
+    }
+    fn mouse_interaction(
+        &self,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        let geometry = self.geometry(layout);
+        if cursor
+            .position()
+            .is_some_and(|p| geometry.hit(self.chooser, p).is_some())
+        {
+            mouse::Interaction::Pointer
+        } else {
+            self.input.as_widget().mouse_interaction(
+                self.input_tree,
+                layout.children().nth(1).unwrap(),
+                cursor,
+                &geometry.popup,
+                renderer,
+            )
+        }
+    }
+}
+
+fn is_input(event: &Event) -> bool {
+    matches!(
+        event,
+        Event::Mouse(_) | Event::Touch(_) | Event::Keyboard(_) | Event::InputMethod(_)
+    )
+}
+fn measure<R: text::Renderer<Font = Font>>(content: &str, size: f32, font: Font) -> f32 {
+    R::Paragraph::with_text(text::Text {
+        content,
+        bounds: Size::INFINITE,
+        size: size.into(),
+        line_height: text::LineHeight::default(),
+        font,
+        align_x: text::Alignment::Left,
+        align_y: alignment::Vertical::Center,
+        shaping: text::Shaping::Advanced,
+        wrapping: text::Wrapping::None,
+    })
+    .min_width()
+}
+fn label<R: text::Renderer<Font = Font>>(
+    renderer: &mut R,
+    content: &str,
+    size: f32,
+    color: Color,
+    bounds: Rectangle,
+) {
+    let font = renderer.default_font();
+    let mut display = content.to_owned();
+    if measure::<R>(content, size, font) > bounds.width {
+        let ends: Vec<_> = content
+            .char_indices()
+            .map(|(i, _)| i)
+            .chain(std::iter::once(content.len()))
+            .collect();
+        let (mut low, mut high) = (0, ends.len());
+        while low + 1 < high {
+            let middle = (low + high) / 2;
+            if measure::<R>(&format!("{}…", &content[..ends[middle]]), size, font) <= bounds.width
+            {
+                low = middle;
+            } else {
+                high = middle;
+            }
+        }
+        display = format!("{}…", &content[..ends[low]]);
+    }
+    raw_label(renderer, display, size, color, bounds);
+}
+fn raw_label<R: text::Renderer<Font = Font>>(
+    renderer: &mut R,
+    content: String,
+    size: f32,
+    color: Color,
+    bounds: Rectangle,
+) {
+    renderer.fill_text(
+        text::Text {
+            content,
+            bounds: bounds.size(),
+            size: size.into(),
+            line_height: text::LineHeight::default(),
+            font: renderer.default_font(),
+            align_x: text::Alignment::Left,
+            align_y: alignment::Vertical::Center,
+            shaping: text::Shaping::Advanced,
+            wrapping: text::Wrapping::None,
+        },
+        Point::new(bounds.x, bounds.center_y()),
+        color,
+        bounds,
+    );
+}
@@ -87,6 +87,9 @@ pub enum RowEvent {
    ValuePath(String, crate::data_values::FieldPathKey),
    ValueBrowse(String, Option<crate::data_values::FieldPathKey>, usize),
    ReferenceBrowse(String, String, usize),
+    ReferenceOpen(crate::forms::reference_chooser::adapter::Open),
+    ReferenceEvent(crate::forms::reference_chooser::Event),
+    ReferenceSet(crate::forms::reference_chooser::adapter::Set),
    OperationOmission(bool),
    OperationRationale(String),
    Tab(Tab),
@@ -1,147 +1,147 @@
-use super::artifacts::{Editor, Event, Raw};
-use super::*;
-use iced::{
-    Element as View, Fill,
-    widget::{button, checkbox, column, pick_list, row, text, text_editor, text_input},
-};
-pub(super) fn pairs<'a>(editor: &'a Editor, p: &'a Project, trace: &'a Trace) -> View<'a, Event> {
-    let mut content=column![text("Artifact links and metadata").size(16),text("Pair links attached to these reviewed owners. Presence is attachment to the owner; taking identified source absence deletes the destination link, while a destination-only link is retained.").size(12),text_input("Filter artifact identities",&editor.search).on_input(Event::Search).padding(7)].spacing(9);
-    for (layer, label, selected) in [
-        (Layer::Oa, "Operational", editor.oa.clone()),
-        (Layer::Sa, "System", editor.sa.clone()),
-    ] {
-        content = content.push(text(label).size(12)).push(
-            row![
-                pick_list(editor.choices(p, trace, layer), selected, move |v| {
-                    Event::Pick(layer, Some(v))
-                })
-                .placeholder("Choose exact artifact identity")
-                .width(Fill)
-                .padding(7),
-                button("No identity")
-                    .padding(7)
-                    .on_press(Event::Pick(layer, None))
-            ]
-            .spacing(7),
-        );
-    }
-    content.push(row![button("Reserve a new destination counterpart").padding(7).on_press(Event::Reserve),button("Review this exact artifact pair").padding(7).on_press(Event::Stage)].spacing(7).wrap()).push(text("Reservation retains a fresh identity and seeds metadata from the source. It creates nothing until Presence and all seven metadata facets are explicitly reviewed and the combined Apply succeeds. New unrelated links use ordinary artifact creation.").size(11)).padding(iced::Padding::default().right(18)).into()
-}
-pub(super) fn candidate<'a>(
-    editor: &'a Editor,
-    p: &'a Project,
-    facet: &'a FacetSelector,
-) -> Option<View<'a, Event>> {
-    let value = editor.drafts.get(facet)?;
-    let (_, which) = artifacts::parts(facet)?;
-    let mut content =
-        column![text(format!("Final artifact {}", artifacts::field(which)?)).size(12)].spacing(7);
-    match value {
-        Raw::Text(_) if which == ArtifactFacet::Description => {
-            let draft = editor.descriptions.get(facet)?;
-            let facet = facet.clone();
-            content = content.push(
-                text_editor(draft)
-                    .height(110)
-                    .on_action(move |action| Event::Description(facet.clone(), action)),
-            );
-        }
-        Raw::Text(value) => {
-            let facet = facet.clone();
-            content = content.push(
-                text_input("Exact text", value)
-                    .on_input(move |value| Event::Input(facet.clone(), Raw::Text(value)))
-                    .padding(7),
-            );
-        }
-        Raw::Owner(value) => {
-            let mut choices: Vec<_> = p
-                .identities()
-                .into_iter()
-                .map(|(id, alias)| Choice {
-                    id,
-                    label: format!("{} · @{alias}", p.named(id)),
-                })
-                .collect();
-            choices.sort_by_cached_key(|c| c.label.to_lowercase());
-            let selected = value.parse::<Id>().ok().map(|id| view::choice(p, id));
-            let raw_facet = facet.clone();
-            let pick_facet = facet.clone();
-            content = content
-                .push(
-                    pick_list(choices, selected, move |v: Choice| {
-                        Event::Input(pick_facet.clone(), Raw::Owner(v.id.to_string()))
-                    })
-                    .placeholder("Explicit final owner")
-                    .width(Fill)
-                    .padding(7),
-                )
-                .push(
-                    text_input("Owner identity (retains rejected input)", value)
-                        .on_input(move |v| Event::Input(raw_facet.clone(), Raw::Owner(v)))
-                        .padding(7),
-                );
-        }
-        Raw::Relation(value) => {
-            let facet = facet.clone();
-            let variants = [
-                ArtifactRelation::References,
-                ArtifactRelation::Satisfies,
-                ArtifactRelation::Verifies,
-                ArtifactRelation::Implements,
-                ArtifactRelation::DerivedFrom,
-            ];
-            let choices: Vec<_> = variants.into_iter().map(RelationChoice).collect();
-            content = content.push(
-                pick_list(choices, Some(RelationChoice(*value)), move |v| {
-                    Event::Input(facet.clone(), Raw::Relation(v.0))
-                })
-                .padding(7),
-            );
-        }
-        Raw::Optional {
-            present,
-            text: value,
-        } => {
-            let toggle_facet = facet.clone();
-            let retained = value.clone();
-            let input_facet = facet.clone();
-            let enabled = *present;
-            content = content
-                .push(
-                    checkbox(*present)
-                        .label("Present (checked with empty text means an explicit empty value)")
-                        .on_toggle(move |present| {
-                            Event::Input(
-                                toggle_facet.clone(),
-                                Raw::Optional {
-                                    present,
-                                    text: retained.clone(),
-                                },
-                            )
-                        }),
-                )
-                .push(
-                    text_input("Retained optional text", value)
-                        .on_input(move |text| {
-                            Event::Input(
-                                input_facet.clone(),
-                                Raw::Optional {
-                                    present: enabled,
-                                    text,
-                                },
-                            )
-                        })
-                        .padding(7),
-                );
-        }
-    }
-    Some(content.into())
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-struct RelationChoice(ArtifactRelation);
-impl std::fmt::Display for RelationChoice {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self.0)
-    }
-}
+use super::artifacts::{Editor, Event, Raw};
+use super::*;
+use iced::{
+    Element as View, Fill,
+    widget::{button, checkbox, column, pick_list, row, text, text_editor, text_input},
+};
+pub(super) fn pairs<'a>(editor: &'a Editor, p: &'a Project, trace: &'a Trace) -> View<'a, Event> {
+    let mut content=column![text("Artifact links and metadata").size(16),text("Pair links attached to these reviewed owners. Presence is attachment to the owner; taking identified source absence deletes the destination link, while a destination-only link is retained.").size(12),text_input("Filter artifact identities",&editor.search).on_input(Event::Search).padding(7)].spacing(9);
+    for (layer, label, selected) in [
+        (Layer::Oa, "Operational", editor.oa.clone()),
+        (Layer::Sa, "System", editor.sa.clone()),
+    ] {
+        content = content.push(text(label).size(12)).push(
+            row![
+                pick_list(editor.choices(p, trace, layer), selected, move |v| {
+                    Event::Pick(layer, Some(v))
+                })
+                .placeholder("Choose exact artifact identity")
+                .width(Fill)
+                .padding(7),
+                button("No identity")
+                    .padding(7)
+                    .on_press(Event::Pick(layer, None))
+            ]
+            .spacing(7),
+        );
+    }
+    content.push(row![button("Reserve a new destination counterpart").padding(7).on_press(Event::Reserve),button("Review this exact artifact pair").padding(7).on_press(Event::Stage)].spacing(7).wrap()).push(text("Reservation retains a fresh identity and seeds metadata from the source. It creates nothing until Presence and all seven metadata facets are explicitly reviewed and the combined Apply succeeds. New unrelated links use ordinary artifact creation.").size(11)).padding(iced::Padding::default().right(18)).into()
+}
+pub(super) fn candidate<'a>(
+    editor: &'a Editor,
+    p: &'a Project,
+    facet: &'a FacetSelector,
+) -> Option<View<'a, Event>> {
+    let value = editor.drafts.get(facet)?;
+    let (_, which) = artifacts::parts(facet)?;
+    let mut content =
+        column![text(format!("Final artifact {}", artifacts::field(which)?)).size(12)].spacing(7);
+    match value {
+        Raw::Text(_) if which == ArtifactFacet::Description => {
+            let draft = editor.descriptions.get(facet)?;
+            let facet = facet.clone();
+            content = content.push(
+                text_editor(draft)
+                    .height(110)
+                    .on_action(move |action| Event::Description(facet.clone(), action)),
+            );
+        }
+        Raw::Text(value) => {
+            let facet = facet.clone();
+            content = content.push(
+                text_input("Exact text", value)
+                    .on_input(move |value| Event::Input(facet.clone(), Raw::Text(value)))
+                    .padding(7),
+            );
+        }
+        Raw::Owner(value) => {
+            let mut choices: Vec<_> = p
+                .identities()
+                .into_iter()
+                .map(|(id, alias)| Choice {
+                    id,
+                    label: format!("{} · @{alias}", p.named(id)),
+                })
+                .collect();
+            choices.sort_by_cached_key(|c| c.label.to_lowercase());
+            let selected = value.parse::<Id>().ok().map(|id| view::choice(p, id));
+            let raw_facet = facet.clone();
+            let pick_facet = facet.clone();
+            content = content
+                .push(
+                    pick_list(choices, selected, move |v: Choice| {
+                        Event::Input(pick_facet.clone(), Raw::Owner(v.id.to_string()))
+                    })
+                    .placeholder("Explicit final owner")
+                    .width(Fill)
+                    .padding(7),
+                )
+                .push(
+                    text_input("Owner identity (retains rejected input)", value)
+                        .on_input(move |v| Event::Input(raw_facet.clone(), Raw::Owner(v)))
+                        .padding(7),
+                );
+        }
+        Raw::Relation(value) => {
+            let facet = facet.clone();
+            let variants = [
+                ArtifactRelation::References,
+                ArtifactRelation::Satisfies,
+                ArtifactRelation::Verifies,
+                ArtifactRelation::Implements,
+                ArtifactRelation::DerivedFrom,
+            ];
+            let choices: Vec<_> = variants.into_iter().map(RelationChoice).collect();
+            content = content.push(
+                pick_list(choices, Some(RelationChoice(*value)), move |v| {
+                    Event::Input(facet.clone(), Raw::Relation(v.0))
+                })
+                .padding(7),
+            );
+        }
+        Raw::Optional {
+            present,
+            text: value,
+        } => {
+            let toggle_facet = facet.clone();
+            let retained = value.clone();
+            let input_facet = facet.clone();
+            let enabled = *present;
+            content = content
+                .push(
+                    checkbox(*present)
+                        .label("Present (checked with empty text means an explicit empty value)")
+                        .on_toggle(move |present| {
+                            Event::Input(
+                                toggle_facet.clone(),
+                                Raw::Optional {
+                                    present,
+                                    text: retained.clone(),
+                                },
+                            )
+                        }),
+                )
+                .push(
+                    text_input("Retained optional text", value)
+                        .on_input(move |text| {
+                            Event::Input(
+                                input_facet.clone(),
+                                Raw::Optional {
+                                    present: enabled,
+                                    text,
+                                },
+                            )
+                        })
+                        .padding(7),
+                );
+        }
+    }
+    Some(content.into())
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct RelationChoice(ArtifactRelation);
+impl std::fmt::Display for RelationChoice {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
@@ -1,79 +1,79 @@
-//! Explicit attachment pair and final destination field controls.
-use super::{
-    attachments::{Editor, Event, Family},
-    *,
-};
-use iced::{
-    Element as View, Fill,
-    widget::{button, column, pick_list, row, text, text_input},
-};
-
-pub(super) fn pairs<'a>(
-    editor: &'a Editor,
-    project: &'a Project,
-    trace: &'a Trace,
-) -> View<'a, Event> {
-    let mut content = column![
-        text("Existing children and relationship endpoints").size(16),
-        text("Choose explicit Operational and System identities. A child's final parent or a relationship's final endpoint is reviewed independently; opening another trace keeps this draft.").size(12),
-        pick_list([Family::Child, Family::Source, Family::Target], Some(editor.family), Event::Family).text_size(12).padding(7).width(Fill),
-        text_input("Filter attachment identities by name or alias", &editor.search).on_input(Event::Search).size(12).padding(7),
-    ].spacing(9);
-    for layer in [Layer::Oa, Layer::Sa] {
-        let label = if layer == Layer::Oa {
-            "Operational"
-        } else {
-            "System"
-        };
-        let owner = if layer == Layer::Oa {
-            trace.oa
-        } else {
-            trace.sa
-        };
-        content = content.push(text(format!("{label} owner: {}", project.named(owner))).size(12));
-        content = content.push(
-            row![
-                pick_list(
-                    editor.choices(project, trace, layer),
-                    editor.selection(layer).cloned(),
-                    move |choice| Event::Pick(layer, Some(choice))
-                )
-                .placeholder(format!("Choose an existing {label} identity"))
-                .text_size(12)
-                .padding(7)
-                .width(Fill),
-                button(text("No identity on this side").size(11))
-                    .style(crate::style::nav)
-                    .padding(7)
-                    .on_press(Event::Pick(layer, None)),
-            ]
-            .spacing(7),
-        );
-    }
-    content = content.push(
-        button(text("Use exact attachment pair").size(12))
-            .padding(8)
-            .style(crate::style::nav)
-            .on_press(Event::Stage),
-    );
-    content.push(text("Taking an absent relationship endpoint requires an explicit final replacement. New child and relationship creation uses a separate explicit transition mapping.").size(11)).padding(iced::Padding::default().right(18)).into()
-}
-
-pub(super) fn candidate<'a>(
-    editor: &'a Editor,
-    project: &'a Project,
-    facet: &'a FacetSelector,
-    layer: Layer,
-) -> Option<View<'a, Message>> {
-    let draft = editor.drafts.get(facet)?;
-    let (id, _) = attachments::actual_slot(facet, layer)?;
-    let path = attachments::path(project, facet, layer)?;
-    Some(
-        column![
-            text(format!("Destination record: {}", project.named(id))).size(12),
-            crate::forms::scoped(draft, project, &path, attachments::label(facet)),
-        ]
-        .spacing(7)
-        .into(),
-    )
-}
+//! Explicit attachment pair and final destination field controls.
+use super::{
+    attachments::{Editor, Event, Family},
+    *,
+};
+use iced::{
+    Element as View, Fill,
+    widget::{button, column, pick_list, row, text, text_input},
+};
+
+pub(super) fn pairs<'a>(
+    editor: &'a Editor,
+    project: &'a Project,
+    trace: &'a Trace,
+) -> View<'a, Event> {
+    let mut content = column![
+        text("Existing children and relationship endpoints").size(16),
+        text("Choose explicit Operational and System identities. A child's final parent or a relationship's final endpoint is reviewed independently; opening another trace keeps this draft.").size(12),
+        pick_list([Family::Child, Family::Source, Family::Target], Some(editor.family), Event::Family).text_size(12).padding(7).width(Fill),
+        text_input("Filter attachment identities by name or alias", &editor.search).on_input(Event::Search).size(12).padding(7),
+    ].spacing(9);
+    for layer in [Layer::Oa, Layer::Sa] {
+        let label = if layer == Layer::Oa {
+            "Operational"
+        } else {
+            "System"
+        };
+        let owner = if layer == Layer::Oa {
+            trace.oa
+        } else {
+            trace.sa
+        };
+        content = content.push(text(format!("{label} owner: {}", project.named(owner))).size(12));
+        content = content.push(
+            row![
+                pick_list(
+                    editor.choices(project, trace, layer),
+                    editor.selection(layer).cloned(),
+                    move |choice| Event::Pick(layer, Some(choice))
+                )
+                .placeholder(format!("Choose an existing {label} identity"))
+                .text_size(12)
+                .padding(7)
+                .width(Fill),
+                button(text("No identity on this side").size(11))
+                    .style(crate::style::nav)
+                    .padding(7)
+                    .on_press(Event::Pick(layer, None)),
+            ]
+            .spacing(7),
+        );
+    }
+    content = content.push(
+        button(text("Use exact attachment pair").size(12))
+            .padding(8)
+            .style(crate::style::nav)
+            .on_press(Event::Stage),
+    );
+    content.push(text("Taking an absent relationship endpoint requires an explicit final replacement. New child and relationship creation uses a separate explicit transition mapping.").size(11)).padding(iced::Padding::default().right(18)).into()
+}
+
+pub(super) fn candidate<'a>(
+    editor: &'a Editor,
+    project: &'a Project,
+    facet: &'a FacetSelector,
+    layer: Layer,
+) -> Option<View<'a, Message>> {
+    let draft = editor.drafts.get(facet)?;
+    let (id, _) = attachments::actual_slot(facet, layer)?;
+    let path = attachments::path(project, facet, layer)?;
+    Some(
+        column![
+            text(format!("Destination record: {}", project.named(id))).size(12),
+            crate::forms::scoped(draft, project, &path, attachments::label(facet)),
+        ]
+        .spacing(7)
+        .into(),
+    )
+}
@@ -296,6 +296,51 @@ impl State {
        }
        Ok(())
    }
+    pub(crate) fn reference_form(&self, project: &Project) -> Option<&Draft> {
+        let facet = self.active.selected.as_ref()?;
+        if self.frozen(project).is_err()
+            || self.active.tab != Tab::Facts
+            || self.active.decisions.get(facet) != Some(&SemanticDecision::Candidate)
+        {
+            return None;
+        }
+        self.active.candidate_draft(facet)
+    }
+    pub(crate) fn reference_draft(
+        &self,
+        project: &Project,
+        address: Option<RowAddress>,
+        facet: &FacetSelector,
+        path: &str,
+    ) -> Option<&Draft> {
+        if self.frozen(project).is_err()
+            || self.active_address != address
+            || self.active.tab != Tab::Facts
+        {
+            return None;
+        }
+        self.active.reference_draft(project, facet, path)
+    }
+    pub(crate) fn set_reference(
+        &mut self,
+        project: &Project,
+        address: Option<RowAddress>,
+        facet: &FacetSelector,
+        intent: crate::forms::reference_chooser::adapter::Set,
+    ) -> Result<(), String> {
+        self.reference_draft(project, address, facet, &intent.context.path)
+            .ok_or("The originating review row or property is no longer active.")?
+            .reference_value(project, &intent)?;
+        self.update(
+            project,
+            Event::Row {
+                address,
+                facet: Some(facet.clone()),
+                event: RowEvent::ReferenceSet(intent),
+            },
+        );
+        Ok(())
+    }
    pub fn update(&mut self, project: &Project, event: impl Into<Event>) {
        let event = event.into();
        #[cfg(test)]
@@ -303,6 +348,30 @@ impl State {
            Event::Editor(event) => self.address_event(event),
            other => other,
        };
+        match &event {
+            Event::Row {
+                event: RowEvent::ReferenceOpen(_) | RowEvent::ReferenceEvent(_),
+                ..
+            }
+            | Event::Editor(RowEvent::ReferenceOpen(_) | RowEvent::ReferenceEvent(_)) => return,
+            Event::Row {
+                address,
+                facet,
+                event: RowEvent::ReferenceSet(intent),
+            } => {
+                let valid = facet
+                    .as_ref()
+                    .and_then(|facet| {
+                        self.reference_draft(project, *address, facet, &intent.context.path)
+                    })
+                    .is_some_and(|draft| draft.reference_value(project, intent).is_ok());
+                if !valid {
+                    return;
+                }
+            }
+            Event::Editor(RowEvent::ReferenceSet(_)) => return,
+            _ => {}
+        }
        if let Err(error) = self.frozen(project) {
            // Withdrawing a pending reset is authored intent only. Retain it while
            // keeping the original accepted base and disabling every stale plan.
@@ -464,7 +533,8 @@ impl State {
                            );
                            let scoped_edit = matches!(
                                event,
-                                RowEvent::Input(_, _)
+                                RowEvent::ReferenceSet(_)
+                                    | RowEvent::Input(_, _)
                                    | RowEvent::Text(_, _)
                                    | RowEvent::Shape(_, _)
                                    | RowEvent::Variant(_, _)
@@ -747,13 +817,15 @@ impl State {
        if let Some(notice) = &self.notice {
            header = header.push(text(notice).size(11));
        }
-        self.active
+        let view = self
+            .active
            .view(&self.base, header.into(), self.can_apply())
            .map(move |message| match message {
                Message::Workflow(crate::workflow::Event::Semantic(Event::Editor(event))) => {
                    Message::Workflow(crate::workflow::Event::Semantic(self.address_event(event)))
                }
                other => other,
-            })
+            });
+        crate::forms::reference_chooser::trigger::modal(view)
    }
 }
@@ -1,350 +1,350 @@
-//! Closed presence-only adapter. The core independently validates the full final record.
-use super::*;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub enum Family {
-    Member(ReferenceCollection),
-    Literal,
-    Annotation,
-    Binding,
-}
-impl std::fmt::Display for Family {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(match self {
-            Self::Member(ReferenceCollection::FunctionInputItems) => "Function input items",
-            Self::Member(ReferenceCollection::FunctionOutputItems) => "Function output items",
-            Self::Member(ReferenceCollection::SignalItems) => "Signal items",
-            Self::Member(ReferenceCollection::CategoryExchanges) => "Category exchanges",
-            Self::Member(ReferenceCollection::ExchangeItems) => "Exchange items",
-            Self::Member(ReferenceCollection::TransitionTriggers) => "Transition triggers",
-            Self::Member(ReferenceCollection::TransitionEffects) => "Transition effects",
-            Self::Member(ReferenceCollection::Constrained) => "Constrained identities",
-            Self::Member(ReferenceCollection::Steps) => "Ordered steps",
-            Self::Member(ReferenceCollection::FragmentBranches) => "Fragment branches",
-            Self::Literal => "Enumeration literals",
-            Self::Annotation => "Message values",
-            Self::Binding => "Scenario lifeline bindings",
-        })
-    }
-}
-pub(super) const FAMILIES: [Family; 13] = [
-    Family::Member(ReferenceCollection::Steps),
-    Family::Member(ReferenceCollection::FragmentBranches),
-    Family::Member(ReferenceCollection::FunctionInputItems),
-    Family::Member(ReferenceCollection::FunctionOutputItems),
-    Family::Member(ReferenceCollection::SignalItems),
-    Family::Member(ReferenceCollection::ExchangeItems),
-    Family::Member(ReferenceCollection::CategoryExchanges),
-    Family::Member(ReferenceCollection::TransitionTriggers),
-    Family::Member(ReferenceCollection::TransitionEffects),
-    Family::Member(ReferenceCollection::Constrained),
-    Family::Literal,
-    Family::Annotation,
-    Family::Binding,
-];
-pub(super) fn family(facet: &FacetSelector) -> Option<Family> {
-    let family = match facet {
-        FacetSelector::Member { collection, .. } => Family::Member(*collection),
-        FacetSelector::Literal(_) => Family::Literal,
-        FacetSelector::Annotation(_) => Family::Annotation,
-        FacetSelector::Binding(_) => Family::Binding,
-        _ => return None,
-    };
-    FAMILIES.contains(&family).then_some(family)
-}
-pub(super) fn supported(facet: &FacetSelector) -> bool {
-    family(facet).is_some()
-}
-
-// Fixed paths for the closed collections and the exact enum literal set.
-// They are selected by the typed facet; callers cannot supply arbitrary paths.
-pub(super) fn path(value: &Value, family: Family) -> Option<String> {
-    let prefixes = ["/body/Oa/Shared", "/body/Sa/Shared"];
-    let tails: &[&str] = match family {
-        Family::Member(ReferenceCollection::Steps) => {
-            return [
-                "/body/Oa/Process/steps",
-                "/body/Sa/FunctionalChain/steps",
-                "/body/Oa/Shared/Scenario/steps",
-                "/body/Sa/Shared/Scenario/steps",
-                "/body/Oa/Shared/Occurrence/body/Branch/occurrences",
-                "/body/Sa/Shared/Occurrence/body/Branch/occurrences",
-            ]
-            .into_iter()
-            .find(|p| value.pointer(p).is_some_and(Value::is_array))
-            .map(str::to_owned);
-        }
-        Family::Member(ReferenceCollection::FragmentBranches) => {
-            &["Occurrence/body/Fragment/branches"]
-        }
-        Family::Member(ReferenceCollection::FunctionInputItems) => {
-            &["Port/contract/FunctionInput/incoming_items"]
-        }
-        Family::Member(ReferenceCollection::FunctionOutputItems) => {
-            &["Port/contract/FunctionOutput/outgoing_items"]
-        }
-        Family::Member(ReferenceCollection::CategoryExchanges) => &["ExchangeCategory/exchanges"],
-        Family::Member(ReferenceCollection::SignalItems) => &["Event/body/Signal/items"],
-        Family::Member(ReferenceCollection::Constrained) => &["Constraint/constrained"],
-        Family::Literal => &["DataType/definition/Enumeration/literals"],
-        Family::Annotation => &["Occurrence/body/Exchange/values"],
-        Family::Binding => &["Occurrence/body/ScenarioUse/bindings"],
-        Family::Member(ReferenceCollection::ExchangeItems) => {
-            return [
-                "Interaction",
-                "FunctionalExchange",
-                "BoundaryExchange",
-                "CommunicationMean",
-            ]
-            .iter()
-            .map(|kind| format!("/body/{kind}/items"))
-            .find(|p| value.pointer(p).is_some_and(Value::is_array));
-        }
-        Family::Member(ReferenceCollection::TransitionTriggers) => {
-            return value
-                .pointer("/body/StateTransition/triggers")
-                .is_some_and(Value::is_array)
-                .then(|| "/body/StateTransition/triggers".into());
-        }
-        Family::Member(ReferenceCollection::TransitionEffects) => {
-            return value
-                .pointer("/body/StateTransition/effects")
-                .is_some_and(Value::is_array)
-                .then(|| "/body/StateTransition/effects".into());
-        }
-    };
-    prefixes
-        .iter()
-        .flat_map(|prefix| tails.iter().map(move |tail| format!("{prefix}/{tail}")))
-        .find(|p| value.pointer(p).is_some_and(Value::is_array))
-}
-pub(super) fn key(facet: &FacetSelector, layer: Layer) -> Option<Value> {
-    match facet {
-        FacetSelector::Member { keys, .. } => if layer == Layer::Oa { keys.oa } else { keys.sa }
-            .map(|id| serde_json::to_value(id).expect("Id")),
-        FacetSelector::Literal(keys) => if layer == Layer::Oa {
-            keys.oa.as_ref()
-        } else {
-            keys.sa.as_ref()
-        }
-        .map(|v| Value::String(v.clone())),
-        FacetSelector::Annotation(keys) => if layer == Layer::Oa {
-            keys.oa.as_ref()
-        } else {
-            keys.sa.as_ref()
-        }
-        .map(|key| serde_json::to_value(key).expect("Annotation key")),
-        FacetSelector::Binding(keys) => if layer == Layer::Oa { keys.oa } else { keys.sa }
-            .map(|id| serde_json::to_value(id).expect("Binding key")),
-        _ => None,
-    }
-}
-pub(super) fn overlap(a: &FacetSelector, b: &FacetSelector) -> bool {
-    if family(a).is_none() || family(a) != family(b) {
-        return false;
-    }
-    [Layer::Oa, Layer::Sa]
-        .into_iter()
-        .any(|layer| key(a, layer).is_some() && key(a, layer) == key(b, layer))
-}
-pub(super) fn project_presence(
-    value: &mut Value,
-    facet: &FacetSelector,
-    layer: Layer,
-    present: bool,
-) -> Result<(), String> {
-    let family = family(facet).ok_or("This keyed family remains read-only.")?;
-    let key = key(facet, layer)
-        .ok_or("Choose the destination identity in Members before setting or taking presence.")?;
-    let path =
-        path(value, family).ok_or("This collection is not applicable to the destination kind.")?;
-    let list = value
-        .pointer_mut(&path)
-        .and_then(Value::as_array_mut)
-        .ok_or("Destination collection is unavailable.")?;
-    if present {
-        if !list.contains(&key) {
-            list.push(key);
-        }
-    } else {
-        list.retain(|v| v != &key);
-    }
-    Ok(())
-}
-
-impl ReviewRow {
-    pub(super) fn keyed_value(
-        &self,
-        project: &Project,
-        trace: &Trace,
-        value: &mut Value,
-        facet: &FacetSelector,
-        decision: SemanticDecision,
-    ) -> Result<(), String> {
-        if keyed_rows::supported(facet) {
-            return self.project_row(project, trace, value, facet, decision);
-        }
-        let present = match decision {
-            SemanticDecision::KeepTarget => return Ok(()),
-            SemanticDecision::TakeSource => {
-                // A missing source identity is a target-local row, not a removal.
-                if key(facet, self.direction.source_layer()).is_none() {
-                    return Ok(());
-                }
-                let fact = capture_facet(project, trace.oa, trace.sa, facet)?;
-                scalar::value(&fact, self.direction.source_layer()).and_then(|v| v.as_bool()).ok_or("Source collection is not applicable; choose an explicit final presence or Keep.")?
-            }
-            SemanticDecision::Candidate => *self
-                .presence
-                .get(facet)
-                .ok_or("Choose final membership presence.")?,
-        };
-        project_presence(value, facet, self.direction.target_layer(), present)
-    }
-
-    pub(super) fn member_families(&self, project: &Project) -> Vec<Family> {
-        let Some(trace) = self.effective_trace(project) else {
-            return vec![];
-        };
-        let values: Vec<_> = [trace.oa, trace.sa]
-            .into_iter()
-            .filter_map(|id| Draft::from_project(project, id).map(|d| d.value))
-            .collect();
-        FAMILIES
-            .into_iter()
-            .filter(|family| values.iter().any(|value| path(value, *family).is_some()))
-            .collect()
-    }
-
-    pub(super) fn member_choices(&self, project: &Project, layer: Layer) -> Vec<Choice> {
-        if self.member_family == Family::Binding {
-            return self.binding_choices(project, layer, true);
-        }
-        let Some(trace) = self.effective_trace(project) else {
-            return vec![];
-        };
-        let id = if layer == Layer::Oa {
-            trace.oa
-        } else {
-            trace.sa
-        };
-        let Some(mut draft) = Draft::from_project(project, id) else {
-            return vec![];
-        };
-        if layer == self.direction.target_layer() {
-            draft.set_context(self.combined_value(project, true).ok());
-        }
-        let selected = if layer == Layer::Oa {
-            &self.member_oa
-        } else {
-            &self.member_sa
-        };
-        let Some(path) = path(&draft.context_value(), self.member_family) else {
-            return selected.iter().cloned().collect();
-        };
-        crate::forms::reference_choices(
-            &draft,
-            project,
-            &format!("{path}/0"),
-            selected.as_ref().map_or(Id::nil(), |c| c.id),
-        )
-        .into_iter()
-        .filter(|c| !c.id.is_nil())
-        .collect()
-    }
-
-    pub(super) fn edit_pair(
-        &mut self,
-        project: &Project,
-        facet: FacetSelector,
-    ) -> Result<(), String> {
-        self.member_family = family(&facet).ok_or("This keyed family remains read-only.")?;
-        match facet {
-            FacetSelector::Annotation(keys) => {
-                self.annotation_oa.selected = keys.oa.map(|key| crate::data_values::FieldPathKey {
-                    path: key.path,
-                    field: key.field,
-                });
-                self.annotation_sa.selected = keys.sa.map(|key| crate::data_values::FieldPathKey {
-                    path: key.path,
-                    field: key.field,
-                });
-            }
-            FacetSelector::Binding(keys) => {
-                self.member_oa = keys.oa.map(|id| view::choice(project, id));
-                self.member_sa = keys.sa.map(|id| view::choice(project, id));
-            }
-            FacetSelector::Member { keys, .. } => {
-                self.member_oa = keys.oa.map(|id| view::choice(project, id));
-                self.member_sa = keys.sa.map(|id| view::choice(project, id));
-            }
-            FacetSelector::Literal(keys) => {
-                self.literal_oa = keys.oa.is_some();
-                self.literal_sa = keys.sa.is_some();
-                self.literal = keys.oa.or(keys.sa).unwrap_or_default();
-            }
-            _ => unreachable!(),
-        }
-        self.tab = Tab::Members;
-        Ok(())
-    }
-
-    pub(super) fn stage_member(&mut self, project: &Project) -> Result<(), String> {
-        if !FAMILIES.contains(&self.member_family) {
-            return Err("This keyed family remains read-only.".into());
-        }
-        let facet = match self.member_family {
-            Family::Member(collection) => FacetSelector::Member {
-                collection,
-                keys: KeyPair {
-                    oa: self.member_oa.as_ref().map(|c| c.id),
-                    sa: self.member_sa.as_ref().map(|c| c.id),
-                },
-            },
-            Family::Literal => FacetSelector::Literal(KeyPair {
-                oa: self.literal_oa.then(|| self.literal.clone()),
-                sa: self.literal_sa.then(|| self.literal.clone()),
-            }),
-            Family::Annotation => FacetSelector::Annotation(KeyPair {
-                oa: self
-                    .annotation_oa
-                    .selected
-                    .as_ref()
-                    .map(|key| AnnotationKey {
-                        path: key.path.clone(),
-                        field: key.field,
-                    }),
-                sa: self
-                    .annotation_sa
-                    .selected
-                    .as_ref()
-                    .map(|key| AnnotationKey {
-                        path: key.path.clone(),
-                        field: key.field,
-                    }),
-            }),
-            Family::Binding => FacetSelector::Binding(KeyPair {
-                oa: self.member_oa.as_ref().map(|c| c.id),
-                sa: self.member_sa.as_ref().map(|c| c.id),
-            }),
-        };
-        let trace = self.effective_trace(project).ok_or("Choose a trace.")?;
-        capture_facet(project, trace.oa, trace.sa, &facet)?;
-        self.stage_row_references(&facet)?;
-        if let FacetSelector::Member {
-            keys:
-                KeyPair {
-                    oa: Some(oa),
-                    sa: Some(sa),
-                },
-            ..
-        } = &facet
-        {
-            self.references.insert(*oa, *sa);
-        }
-        self.staged.insert(facet.clone());
-        self.selected = Some(facet);
-        self.tab = Tab::Facts;
-        Ok(())
-    }
-}
+//! Closed presence-only adapter. The core independently validates the full final record.
+use super::*;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum Family {
+    Member(ReferenceCollection),
+    Literal,
+    Annotation,
+    Binding,
+}
+impl std::fmt::Display for Family {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::Member(ReferenceCollection::FunctionInputItems) => "Function input items",
+            Self::Member(ReferenceCollection::FunctionOutputItems) => "Function output items",
+            Self::Member(ReferenceCollection::SignalItems) => "Signal items",
+            Self::Member(ReferenceCollection::CategoryExchanges) => "Category exchanges",
+            Self::Member(ReferenceCollection::ExchangeItems) => "Exchange items",
+            Self::Member(ReferenceCollection::TransitionTriggers) => "Transition triggers",
+            Self::Member(ReferenceCollection::TransitionEffects) => "Transition effects",
+            Self::Member(ReferenceCollection::Constrained) => "Constrained identities",
+            Self::Member(ReferenceCollection::Steps) => "Ordered steps",
+            Self::Member(ReferenceCollection::FragmentBranches) => "Fragment branches",
+            Self::Literal => "Enumeration literals",
+            Self::Annotation => "Message values",
+            Self::Binding => "Scenario lifeline bindings",
+        })
+    }
+}
+pub(super) const FAMILIES: [Family; 13] = [
+    Family::Member(ReferenceCollection::Steps),
+    Family::Member(ReferenceCollection::FragmentBranches),
+    Family::Member(ReferenceCollection::FunctionInputItems),
+    Family::Member(ReferenceCollection::FunctionOutputItems),
+    Family::Member(ReferenceCollection::SignalItems),
+    Family::Member(ReferenceCollection::ExchangeItems),
+    Family::Member(ReferenceCollection::CategoryExchanges),
+    Family::Member(ReferenceCollection::TransitionTriggers),
+    Family::Member(ReferenceCollection::TransitionEffects),
+    Family::Member(ReferenceCollection::Constrained),
+    Family::Literal,
+    Family::Annotation,
+    Family::Binding,
+];
+pub(super) fn family(facet: &FacetSelector) -> Option<Family> {
+    let family = match facet {
+        FacetSelector::Member { collection, .. } => Family::Member(*collection),
+        FacetSelector::Literal(_) => Family::Literal,
+        FacetSelector::Annotation(_) => Family::Annotation,
+        FacetSelector::Binding(_) => Family::Binding,
+        _ => return None,
+    };
+    FAMILIES.contains(&family).then_some(family)
+}
+pub(super) fn supported(facet: &FacetSelector) -> bool {
+    family(facet).is_some()
+}
+
+// Fixed paths for the closed collections and the exact enum literal set.
+// They are selected by the typed facet; callers cannot supply arbitrary paths.
+pub(super) fn path(value: &Value, family: Family) -> Option<String> {
+    let prefixes = ["/body/Oa/Shared", "/body/Sa/Shared"];
+    let tails: &[&str] = match family {
+        Family::Member(ReferenceCollection::Steps) => {
+            return [
+                "/body/Oa/Process/steps",
+                "/body/Sa/FunctionalChain/steps",
+                "/body/Oa/Shared/Scenario/steps",
+                "/body/Sa/Shared/Scenario/steps",
+                "/body/Oa/Shared/Occurrence/body/Branch/occurrences",
+                "/body/Sa/Shared/Occurrence/body/Branch/occurrences",
+            ]
+            .into_iter()
+            .find(|p| value.pointer(p).is_some_and(Value::is_array))
+            .map(str::to_owned);
+        }
+        Family::Member(ReferenceCollection::FragmentBranches) => {
+            &["Occurrence/body/Fragment/branches"]
+        }
+        Family::Member(ReferenceCollection::FunctionInputItems) => {
+            &["Port/contract/FunctionInput/incoming_items"]
+        }
+        Family::Member(ReferenceCollection::FunctionOutputItems) => {
+            &["Port/contract/FunctionOutput/outgoing_items"]
+        }
+        Family::Member(ReferenceCollection::CategoryExchanges) => &["ExchangeCategory/exchanges"],
+        Family::Member(ReferenceCollection::SignalItems) => &["Event/body/Signal/items"],
+        Family::Member(ReferenceCollection::Constrained) => &["Constraint/constrained"],
+        Family::Literal => &["DataType/definition/Enumeration/literals"],
+        Family::Annotation => &["Occurrence/body/Exchange/values"],
+        Family::Binding => &["Occurrence/body/ScenarioUse/bindings"],
+        Family::Member(ReferenceCollection::ExchangeItems) => {
+            return [
+                "Interaction",
+                "FunctionalExchange",
+                "BoundaryExchange",
+                "CommunicationMean",
+            ]
+            .iter()
+            .map(|kind| format!("/body/{kind}/items"))
+            .find(|p| value.pointer(p).is_some_and(Value::is_array));
+        }
+        Family::Member(ReferenceCollection::TransitionTriggers) => {
+            return value
+                .pointer("/body/StateTransition/triggers")
+                .is_some_and(Value::is_array)
+                .then(|| "/body/StateTransition/triggers".into());
+        }
+        Family::Member(ReferenceCollection::TransitionEffects) => {
+            return value
+                .pointer("/body/StateTransition/effects")
+                .is_some_and(Value::is_array)
+                .then(|| "/body/StateTransition/effects".into());
+        }
+    };
+    prefixes
+        .iter()
+        .flat_map(|prefix| tails.iter().map(move |tail| format!("{prefix}/{tail}")))
+        .find(|p| value.pointer(p).is_some_and(Value::is_array))
+}
+pub(super) fn key(facet: &FacetSelector, layer: Layer) -> Option<Value> {
+    match facet {
+        FacetSelector::Member { keys, .. } => if layer == Layer::Oa { keys.oa } else { keys.sa }
+            .map(|id| serde_json::to_value(id).expect("Id")),
+        FacetSelector::Literal(keys) => if layer == Layer::Oa {
+            keys.oa.as_ref()
+        } else {
+            keys.sa.as_ref()
+        }
+        .map(|v| Value::String(v.clone())),
+        FacetSelector::Annotation(keys) => if layer == Layer::Oa {
+            keys.oa.as_ref()
+        } else {
+            keys.sa.as_ref()
+        }
+        .map(|key| serde_json::to_value(key).expect("Annotation key")),
+        FacetSelector::Binding(keys) => if layer == Layer::Oa { keys.oa } else { keys.sa }
+            .map(|id| serde_json::to_value(id).expect("Binding key")),
+        _ => None,
+    }
+}
+pub(super) fn overlap(a: &FacetSelector, b: &FacetSelector) -> bool {
+    if family(a).is_none() || family(a) != family(b) {
+        return false;
+    }
+    [Layer::Oa, Layer::Sa]
+        .into_iter()
+        .any(|layer| key(a, layer).is_some() && key(a, layer) == key(b, layer))
+}
+pub(super) fn project_presence(
+    value: &mut Value,
+    facet: &FacetSelector,
+    layer: Layer,
+    present: bool,
+) -> Result<(), String> {
+    let family = family(facet).ok_or("This keyed family remains read-only.")?;
+    let key = key(facet, layer)
+        .ok_or("Choose the destination identity in Members before setting or taking presence.")?;
+    let path =
+        path(value, family).ok_or("This collection is not applicable to the destination kind.")?;
+    let list = value
+        .pointer_mut(&path)
+        .and_then(Value::as_array_mut)
+        .ok_or("Destination collection is unavailable.")?;
+    if present {
+        if !list.contains(&key) {
+            list.push(key);
+        }
+    } else {
+        list.retain(|v| v != &key);
+    }
+    Ok(())
+}
+
+impl ReviewRow {
+    pub(super) fn keyed_value(
+        &self,
+        project: &Project,
+        trace: &Trace,
+        value: &mut Value,
+        facet: &FacetSelector,
+        decision: SemanticDecision,
+    ) -> Result<(), String> {
+        if keyed_rows::supported(facet) {
+            return self.project_row(project, trace, value, facet, decision);
+        }
+        let present = match decision {
+            SemanticDecision::KeepTarget => return Ok(()),
+            SemanticDecision::TakeSource => {
+                // A missing source identity is a target-local row, not a removal.
+                if key(facet, self.direction.source_layer()).is_none() {
+                    return Ok(());
+                }
+                let fact = capture_facet(project, trace.oa, trace.sa, facet)?;
+                scalar::value(&fact, self.direction.source_layer()).and_then(|v| v.as_bool()).ok_or("Source collection is not applicable; choose an explicit final presence or Keep.")?
+            }
+            SemanticDecision::Candidate => *self
+                .presence
+                .get(facet)
+                .ok_or("Choose final membership presence.")?,
+        };
+        project_presence(value, facet, self.direction.target_layer(), present)
+    }
+
+    pub(super) fn member_families(&self, project: &Project) -> Vec<Family> {
+        let Some(trace) = self.effective_trace(project) else {
+            return vec![];
+        };
+        let values: Vec<_> = [trace.oa, trace.sa]
+            .into_iter()
+            .filter_map(|id| Draft::from_project(project, id).map(|d| d.value))
+            .collect();
+        FAMILIES
+            .into_iter()
+            .filter(|family| values.iter().any(|value| path(value, *family).is_some()))
+            .collect()
+    }
+
+    pub(super) fn member_choices(&self, project: &Project, layer: Layer) -> Vec<Choice> {
+        if self.member_family == Family::Binding {
+            return self.binding_choices(project, layer, true);
+        }
+        let Some(trace) = self.effective_trace(project) else {
+            return vec![];
+        };
+        let id = if layer == Layer::Oa {
+            trace.oa
+        } else {
+            trace.sa
+        };
+        let Some(mut draft) = Draft::from_project(project, id) else {
+            return vec![];
+        };
+        if layer == self.direction.target_layer() {
+            draft.set_context(self.combined_value(project, true).ok());
+        }
+        let selected = if layer == Layer::Oa {
+            &self.member_oa
+        } else {
+            &self.member_sa
+        };
+        let Some(path) = path(&draft.context_value(), self.member_family) else {
+            return selected.iter().cloned().collect();
+        };
+        crate::forms::reference_choices(
+            &draft,
+            project,
+            &format!("{path}/0"),
+            selected.as_ref().map_or(Id::nil(), |c| c.id),
+        )
+        .into_iter()
+        .filter(|c| !c.id.is_nil())
+        .collect()
+    }
+
+    pub(super) fn edit_pair(
+        &mut self,
+        project: &Project,
+        facet: FacetSelector,
+    ) -> Result<(), String> {
+        self.member_family = family(&facet).ok_or("This keyed family remains read-only.")?;
+        match facet {
+            FacetSelector::Annotation(keys) => {
+                self.annotation_oa.selected = keys.oa.map(|key| crate::data_values::FieldPathKey {
+                    path: key.path,
+                    field: key.field,
+                });
+                self.annotation_sa.selected = keys.sa.map(|key| crate::data_values::FieldPathKey {
+                    path: key.path,
+                    field: key.field,
+                });
+            }
+            FacetSelector::Binding(keys) => {
+                self.member_oa = keys.oa.map(|id| view::choice(project, id));
+                self.member_sa = keys.sa.map(|id| view::choice(project, id));
+            }
+            FacetSelector::Member { keys, .. } => {
+                self.member_oa = keys.oa.map(|id| view::choice(project, id));
+                self.member_sa = keys.sa.map(|id| view::choice(project, id));
+            }
+            FacetSelector::Literal(keys) => {
+                self.literal_oa = keys.oa.is_some();
+                self.literal_sa = keys.sa.is_some();
+                self.literal = keys.oa.or(keys.sa).unwrap_or_default();
+            }
+            _ => unreachable!(),
+        }
+        self.tab = Tab::Members;
+        Ok(())
+    }
+
+    pub(super) fn stage_member(&mut self, project: &Project) -> Result<(), String> {
+        if !FAMILIES.contains(&self.member_family) {
+            return Err("This keyed family remains read-only.".into());
+        }
+        let facet = match self.member_family {
+            Family::Member(collection) => FacetSelector::Member {
+                collection,
+                keys: KeyPair {
+                    oa: self.member_oa.as_ref().map(|c| c.id),
+                    sa: self.member_sa.as_ref().map(|c| c.id),
+                },
+            },
+            Family::Literal => FacetSelector::Literal(KeyPair {
+                oa: self.literal_oa.then(|| self.literal.clone()),
+                sa: self.literal_sa.then(|| self.literal.clone()),
+            }),
+            Family::Annotation => FacetSelector::Annotation(KeyPair {
+                oa: self
+                    .annotation_oa
+                    .selected
+                    .as_ref()
+                    .map(|key| AnnotationKey {
+                        path: key.path.clone(),
+                        field: key.field,
+                    }),
+                sa: self
+                    .annotation_sa
+                    .selected
+                    .as_ref()
+                    .map(|key| AnnotationKey {
+                        path: key.path.clone(),
+                        field: key.field,
+                    }),
+            }),
+            Family::Binding => FacetSelector::Binding(KeyPair {
+                oa: self.member_oa.as_ref().map(|c| c.id),
+                sa: self.member_sa.as_ref().map(|c| c.id),
+            }),
+        };
+        let trace = self.effective_trace(project).ok_or("Choose a trace.")?;
+        capture_facet(project, trace.oa, trace.sa, &facet)?;
+        self.stage_row_references(&facet)?;
+        if let FacetSelector::Member {
+            keys:
+                KeyPair {
+                    oa: Some(oa),
+                    sa: Some(sa),
+                },
+            ..
+        } = &facet
+        {
+            self.references.insert(*oa, *sa);
+        }
+        self.staged.insert(facet.clone());
+        self.selected = Some(facet);
+        self.tab = Tab::Facts;
+        Ok(())
+    }
+}
@@ -1,345 +1,345 @@
-//! Atomic message-value and lifeline-binding rows with exact, immutable keys.
-use super::*;
-use crate::data_values::{FieldPathChoice, FieldPathKey};
-
-#[derive(Default)]
-pub struct AddressDraft {
-    pub selected: Option<FieldPathKey>,
-    pub scope: Option<FieldPathKey>,
-    pub page: usize,
-}
-
-#[derive(Default)]
-pub struct RowDraft {
-    pub expression: String,
-    pub editor: text_editor::Content,
-    pub local: Option<Choice>,
-}
-
-pub(super) fn supported(facet: &FacetSelector) -> bool {
-    matches!(
-        facet,
-        FacetSelector::Annotation(_) | FacetSelector::Binding(_)
-    )
-}
-
-pub(super) fn target_selector(facet: &FacetSelector, layer: Layer) -> FacetSelector {
-    match facet {
-        FacetSelector::Annotation(keys) => FacetSelector::Annotation(KeyPair {
-            oa: (layer == Layer::Oa).then(|| keys.oa.clone()).flatten(),
-            sa: (layer == Layer::Sa).then(|| keys.sa.clone()).flatten(),
-        }),
-        FacetSelector::Binding(keys) => FacetSelector::Binding(KeyPair {
-            oa: if layer == Layer::Oa { keys.oa } else { None },
-            sa: if layer == Layer::Sa { keys.sa } else { None },
-        }),
-        _ => facet.clone(),
-    }
-}
-
-impl ReviewRow {
-    pub(super) fn annotation_address(&self, layer: Layer) -> &AddressDraft {
-        if layer == Layer::Oa {
-            &self.annotation_oa
-        } else {
-            &self.annotation_sa
-        }
-    }
-
-    pub(super) fn annotation_address_mut(&mut self, layer: Layer) -> &mut AddressDraft {
-        if layer == Layer::Oa {
-            &mut self.annotation_oa
-        } else {
-            &mut self.annotation_sa
-        }
-    }
-
-    fn row_owner(&self, project: &Project, layer: Layer) -> Option<Element> {
-        let trace = self.effective_trace(project)?;
-        let id = if layer == Layer::Oa {
-            trace.oa
-        } else {
-            trace.sa
-        };
-        if layer == self.direction.target_layer()
-            && let Ok(value) = self.combined_value(project, true)
-            && let Ok(element) = serde_json::from_value(value)
-        {
-            return Some(element);
-        }
-        project.elements.get(&id).cloned()
-    }
-
-    pub(super) fn annotation_choices(
-        &self,
-        project: &Project,
-        layer: Layer,
-    ) -> Result<Vec<FieldPathChoice>, String> {
-        let element = self.row_owner(project, layer).ok_or("Choose a trace.")?;
-        let Some(SharedBody::Occurrence {
-            body:
-                OccurrenceBody::Exchange {
-                    exchange: Some(exchange),
-                    message_kind,
-                    ..
-                },
-            ..
-        }) = element.shared()
-        else {
-            return Err(
-                "Choose an exchange on this message before selecting a carried field.".into(),
-            );
-        };
-        let exchange = project
-            .relations
-            .get(exchange)
-            .ok_or("The message exchange is unavailable.")?;
-        crate::data_values::at_scope(
-            project,
-            exchange,
-            message_kind,
-            self.annotation_address(layer).scope.as_ref(),
-        )
-    }
-
-    pub(super) fn binding_choices(
-        &self,
-        project: &Project,
-        layer: Layer,
-        referenced: bool,
-    ) -> Vec<Choice> {
-        let Some(element) = self.row_owner(project, layer) else {
-            return vec![];
-        };
-        let scenario = if referenced {
-            match element.shared() {
-                Some(SharedBody::Occurrence {
-                    body: OccurrenceBody::ScenarioUse { scenario, .. },
-                    ..
-                }) => *scenario,
-                _ => None,
-            }
-        } else {
-            element
-                .parent
-                .and_then(|parent| validation::ancestor_of_kind(project, parent, Kind::Scenario))
-        };
-        let mut choices: Vec<_> = project
-            .elements
-            .values()
-            .filter(|e| {
-                e.kind() == Kind::Lifeline
-                    && e.layer() == layer
-                    && scenario.is_some()
-                    && e.parent == scenario
-            })
-            .map(|e| view::choice(project, e.id))
-            .collect();
-        choices.sort_by_cached_key(|c| c.label.to_lowercase());
-        choices
-    }
-
-    pub(super) fn stage_row_references(&mut self, facet: &FacetSelector) -> Result<(), String> {
-        let pairs: Vec<_> = match facet {
-            FacetSelector::Annotation(KeyPair {
-                oa: Some(oa),
-                sa: Some(sa),
-            }) => {
-                if oa.path.len() != sa.path.len() {
-                    return Err("Paired annotation paths must have the same depth; review distinct addresses separately.".into());
-                }
-                oa.path
-                    .iter()
-                    .chain(std::iter::once(&oa.field))
-                    .copied()
-                    .zip(sa.path.iter().chain(std::iter::once(&sa.field)).copied())
-                    .collect()
-            }
-            FacetSelector::Binding(KeyPair {
-                oa: Some(oa),
-                sa: Some(sa),
-            }) => vec![(*oa, *sa)],
-            _ => vec![],
-        };
-        // A repeated recursive field may occur several times in one address.
-        // Never let the last occurrence silently replace a conflicting pair.
-        let mut supplied = BTreeMap::new();
-        for (oa, sa) in pairs {
-            if supplied.insert(oa, sa).is_some_and(|prior| prior != sa) {
-                return Err(
-                    "This address pairs the same Operational field with different System fields."
-                        .into(),
-                );
-            }
-        }
-        self.references.extend(supplied);
-        Ok(())
-    }
-
-    pub(super) fn initialize_row(&mut self, project: &Project, facet: &FacetSelector) {
-        if self.row_drafts.contains_key(facet) {
-            return;
-        }
-        let value = self
-            .effective_trace(project)
-            .and_then(|t| capture_facet(project, t.oa, t.sa, facet).ok())
-            .and_then(|f| scalar::value(&f, self.direction.target_layer()));
-        let present = value.as_ref().is_some_and(|v| !v.is_null());
-        let mut draft = RowDraft::default();
-        if let Some(value) = value {
-            draft.expression = value["expression"].as_str().unwrap_or_default().into();
-            draft.editor = text_editor::Content::with_text(&draft.expression);
-            draft.local = value["local"]
-                .as_str()
-                .and_then(|v| v.parse().ok())
-                .map(|id| view::choice(project, id));
-        }
-        self.presence.entry(facet.clone()).or_insert(present);
-        self.row_drafts.insert(facet.clone(), draft);
-    }
-
-    pub(super) fn edit_row(
-        &mut self,
-        facet: &FacetSelector,
-        action: impl FnOnce(&mut RowDraft),
-    ) -> Result<(), String> {
-        if !supported(facet)
-            || self.selected.as_ref() != Some(facet)
-            || self.decisions.get(facet) != Some(&SemanticDecision::Candidate)
-        {
-            return Err("Select this row and choose Set final value before editing it.".into());
-        }
-        action(
-            self.row_drafts
-                .get_mut(facet)
-                .ok_or("The row draft is unavailable.")?,
-        );
-        Ok(())
-    }
-
-    pub(super) fn project_row(
-        &self,
-        project: &Project,
-        trace: &Trace,
-        value: &mut Value,
-        facet: &FacetSelector,
-        decision: SemanticDecision,
-    ) -> Result<(), String> {
-        if decision == SemanticDecision::KeepTarget {
-            return Ok(());
-        }
-        let source_layer = self.direction.source_layer();
-        let target_layer = self.direction.target_layer();
-        if decision == SemanticDecision::TakeSource && keyed::key(facet, source_layer).is_none() {
-            return Ok(());
-        }
-        let target_key = keyed::key(facet, target_layer)
-            .ok_or("Choose the destination row address before setting or taking its value.")?;
-        let row = if decision == SemanticDecision::Candidate {
-            if !self.presence.get(facet).copied().unwrap_or(false) {
-                Value::Null
-            } else {
-                let draft = self
-                    .row_drafts
-                    .get(facet)
-                    .ok_or("Set the final row value.")?;
-                match facet {
-                    FacetSelector::Annotation(_) => {
-                        let key: AnnotationKey = serde_json::from_value(target_key.clone())
-                            .map_err(|e| e.to_string())?;
-                        serde_json::to_value(MessageValue {
-                            path: key.path,
-                            field: key.field,
-                            expression: draft.expression.clone(),
-                        })
-                        .expect("Message value")
-                    }
-                    FacetSelector::Binding(_) => {
-                        serde_json::json!({"referenced": target_key, "local": draft.local.as_ref().ok_or("Choose the destination scenario's local lifeline.")?.id})
-                    }
-                    _ => return Err("Unsupported row.".into()),
-                }
-            }
-        } else {
-            let fact = capture_facet(project, trace.oa, trace.sa, facet)?;
-            let row = scalar::value(&fact, source_layer)
-                .ok_or("Source row collection is not applicable; review its constructor first.")?;
-            if row.is_null() {
-                row
-            } else {
-                let map = |id: Id| -> Result<Id, String> {
-                    if source_layer == Layer::Oa {
-                        self.references.get(&id).copied().ok_or_else(|| {
-                            format!("Choose a reference counterpart for {}.", project.named(id))
-                        })
-                    } else {
-                        let matches: Vec<_> = self
-                            .references
-                            .iter()
-                            .filter(|(_, sa)| **sa == id)
-                            .map(|(oa, _)| *oa)
-                            .collect();
-                        if matches.len() == 1 {
-                            Ok(matches[0])
-                        } else {
-                            Err(format!(
-                                "Choose one unambiguous reference counterpart for {}.",
-                                project.named(id)
-                            ))
-                        }
-                    }
-                };
-                match facet {
-                    FacetSelector::Annotation(_) => {
-                        let mut row: MessageValue =
-                            serde_json::from_value(row).map_err(|e| e.to_string())?;
-                        row.path = row.path.into_iter().map(map).collect::<Result<_, _>>()?;
-                        row.field = map(row.field)?;
-                        if serde_json::to_value(AnnotationKey::from(&row)).expect("key")
-                            != target_key
-                        {
-                            return Err("Mapped annotation address disagrees with the selected destination address.".into());
-                        }
-                        serde_json::to_value(row).expect("row")
-                    }
-                    FacetSelector::Binding(_) => {
-                        let row: LifelineBinding =
-                            serde_json::from_value(row).map_err(|e| e.to_string())?;
-                        let mapped = LifelineBinding {
-                            referenced: map(row.referenced)?,
-                            local: map(row.local)?,
-                        };
-                        if serde_json::to_value(mapped.referenced).expect("Id") != target_key {
-                            return Err("Mapped binding key disagrees with the selected destination lifeline.".into());
-                        }
-                        serde_json::to_value(mapped).expect("row")
-                    }
-                    _ => return Err("Unsupported row.".into()),
-                }
-            }
-        };
-        let family = keyed::family(facet).ok_or("Unsupported row.")?;
-        let path = keyed::path(value, family)
-            .ok_or("The destination constructor has no collection for this row.")?;
-        let rows = value
-            .pointer_mut(&path)
-            .and_then(Value::as_array_mut)
-            .ok_or("Destination rows are unavailable.")?;
-        let position = rows.iter().position(|row| match facet {
-            FacetSelector::Annotation(_) => {
-                serde_json::json!({"path": row["path"], "field": row["field"]}) == target_key
-            }
-            FacetSelector::Binding(_) => row["referenced"] == target_key,
-            _ => false,
-        });
-        match (position, row.is_null()) {
-            (Some(index), false) => rows[index] = row,
-            (Some(index), true) => {
-                rows.remove(index);
-            }
-            (None, false) => rows.push(row),
-            (None, true) => {}
-        }
-        Ok(())
-    }
-}
+//! Atomic message-value and lifeline-binding rows with exact, immutable keys.
+use super::*;
+use crate::data_values::{FieldPathChoice, FieldPathKey};
+
+#[derive(Default)]
+pub struct AddressDraft {
+    pub selected: Option<FieldPathKey>,
+    pub scope: Option<FieldPathKey>,
+    pub page: usize,
+}
+
+#[derive(Default)]
+pub struct RowDraft {
+    pub expression: String,
+    pub editor: text_editor::Content,
+    pub local: Option<Choice>,
+}
+
+pub(super) fn supported(facet: &FacetSelector) -> bool {
+    matches!(
+        facet,
+        FacetSelector::Annotation(_) | FacetSelector::Binding(_)
+    )
+}
+
+pub(super) fn target_selector(facet: &FacetSelector, layer: Layer) -> FacetSelector {
+    match facet {
+        FacetSelector::Annotation(keys) => FacetSelector::Annotation(KeyPair {
+            oa: (layer == Layer::Oa).then(|| keys.oa.clone()).flatten(),
+            sa: (layer == Layer::Sa).then(|| keys.sa.clone()).flatten(),
+        }),
+        FacetSelector::Binding(keys) => FacetSelector::Binding(KeyPair {
+            oa: if layer == Layer::Oa { keys.oa } else { None },
+            sa: if layer == Layer::Sa { keys.sa } else { None },
+        }),
+        _ => facet.clone(),
+    }
+}
+
+impl ReviewRow {
+    pub(super) fn annotation_address(&self, layer: Layer) -> &AddressDraft {
+        if layer == Layer::Oa {
+            &self.annotation_oa
+        } else {
+            &self.annotation_sa
+        }
+    }
+
+    pub(super) fn annotation_address_mut(&mut self, layer: Layer) -> &mut AddressDraft {
+        if layer == Layer::Oa {
+            &mut self.annotation_oa
+        } else {
+            &mut self.annotation_sa
+        }
+    }
+
+    fn row_owner(&self, project: &Project, layer: Layer) -> Option<Element> {
+        let trace = self.effective_trace(project)?;
+        let id = if layer == Layer::Oa {
+            trace.oa
+        } else {
+            trace.sa
+        };
+        if layer == self.direction.target_layer()
+            && let Ok(value) = self.combined_value(project, true)
+            && let Ok(element) = serde_json::from_value(value)
+        {
+            return Some(element);
+        }
+        project.elements.get(&id).cloned()
+    }
+
+    pub(super) fn annotation_choices(
+        &self,
+        project: &Project,
+        layer: Layer,
+    ) -> Result<Vec<FieldPathChoice>, String> {
+        let element = self.row_owner(project, layer).ok_or("Choose a trace.")?;
+        let Some(SharedBody::Occurrence {
+            body:
+                OccurrenceBody::Exchange {
+                    exchange: Some(exchange),
+                    message_kind,
+                    ..
+                },
+            ..
+        }) = element.shared()
+        else {
+            return Err(
+                "Choose an exchange on this message before selecting a carried field.".into(),
+            );
+        };
+        let exchange = project
+            .relations
+            .get(exchange)
+            .ok_or("The message exchange is unavailable.")?;
+        crate::data_values::at_scope(
+            project,
+            exchange,
+            message_kind,
+            self.annotation_address(layer).scope.as_ref(),
+        )
+    }
+
+    pub(super) fn binding_choices(
+        &self,
+        project: &Project,
+        layer: Layer,
+        referenced: bool,
+    ) -> Vec<Choice> {
+        let Some(element) = self.row_owner(project, layer) else {
+            return vec![];
+        };
+        let scenario = if referenced {
+            match element.shared() {
+                Some(SharedBody::Occurrence {
+                    body: OccurrenceBody::ScenarioUse { scenario, .. },
+                    ..
+                }) => *scenario,
+                _ => None,
+            }
+        } else {
+            element
+                .parent
+                .and_then(|parent| validation::ancestor_of_kind(project, parent, Kind::Scenario))
+        };
+        let mut choices: Vec<_> = project
+            .elements
+            .values()
+            .filter(|e| {
+                e.kind() == Kind::Lifeline
+                    && e.layer() == layer
+                    && scenario.is_some()
+                    && e.parent == scenario
+            })
+            .map(|e| view::choice(project, e.id))
+            .collect();
+        choices.sort_by_cached_key(|c| c.label.to_lowercase());
+        choices
+    }
+
+    pub(super) fn stage_row_references(&mut self, facet: &FacetSelector) -> Result<(), String> {
+        let pairs: Vec<_> = match facet {
+            FacetSelector::Annotation(KeyPair {
+                oa: Some(oa),
+                sa: Some(sa),
+            }) => {
+                if oa.path.len() != sa.path.len() {
+                    return Err("Paired annotation paths must have the same depth; review distinct addresses separately.".into());
+                }
+                oa.path
+                    .iter()
+                    .chain(std::iter::once(&oa.field))
+                    .copied()
+                    .zip(sa.path.iter().chain(std::iter::once(&sa.field)).copied())
+                    .collect()
+            }
+            FacetSelector::Binding(KeyPair {
+                oa: Some(oa),
+                sa: Some(sa),
+            }) => vec![(*oa, *sa)],
+            _ => vec![],
+        };
+        // A repeated recursive field may occur several times in one address.
+        // Never let the last occurrence silently replace a conflicting pair.
+        let mut supplied = BTreeMap::new();
+        for (oa, sa) in pairs {
+            if supplied.insert(oa, sa).is_some_and(|prior| prior != sa) {
+                return Err(
+                    "This address pairs the same Operational field with different System fields."
+                        .into(),
+                );
+            }
+        }
+        self.references.extend(supplied);
+        Ok(())
+    }
+
+    pub(super) fn initialize_row(&mut self, project: &Project, facet: &FacetSelector) {
+        if self.row_drafts.contains_key(facet) {
+            return;
+        }
+        let value = self
+            .effective_trace(project)
+            .and_then(|t| capture_facet(project, t.oa, t.sa, facet).ok())
+            .and_then(|f| scalar::value(&f, self.direction.target_layer()));
+        let present = value.as_ref().is_some_and(|v| !v.is_null());
+        let mut draft = RowDraft::default();
+        if let Some(value) = value {
+            draft.expression = value["expression"].as_str().unwrap_or_default().into();
+            draft.editor = text_editor::Content::with_text(&draft.expression);
+            draft.local = value["local"]
+                .as_str()
+                .and_then(|v| v.parse().ok())
+                .map(|id| view::choice(project, id));
+        }
+        self.presence.entry(facet.clone()).or_insert(present);
+        self.row_drafts.insert(facet.clone(), draft);
+    }
+
+    pub(super) fn edit_row(
+        &mut self,
+        facet: &FacetSelector,
+        action: impl FnOnce(&mut RowDraft),
+    ) -> Result<(), String> {
+        if !supported(facet)
+            || self.selected.as_ref() != Some(facet)
+            || self.decisions.get(facet) != Some(&SemanticDecision::Candidate)
+        {
+            return Err("Select this row and choose Set final value before editing it.".into());
+        }
+        action(
+            self.row_drafts
+                .get_mut(facet)
+                .ok_or("The row draft is unavailable.")?,
+        );
+        Ok(())
+    }
+
+    pub(super) fn project_row(
+        &self,
+        project: &Project,
+        trace: &Trace,
+        value: &mut Value,
+        facet: &FacetSelector,
+        decision: SemanticDecision,
+    ) -> Result<(), String> {
+        if decision == SemanticDecision::KeepTarget {
+            return Ok(());
+        }
+        let source_layer = self.direction.source_layer();
+        let target_layer = self.direction.target_layer();
+        if decision == SemanticDecision::TakeSource && keyed::key(facet, source_layer).is_none() {
+            return Ok(());
+        }
+        let target_key = keyed::key(facet, target_layer)
+            .ok_or("Choose the destination row address before setting or taking its value.")?;
+        let row = if decision == SemanticDecision::Candidate {
+            if !self.presence.get(facet).copied().unwrap_or(false) {
+                Value::Null
+            } else {
+                let draft = self
+                    .row_drafts
+                    .get(facet)
+                    .ok_or("Set the final row value.")?;
+                match facet {
+                    FacetSelector::Annotation(_) => {
+                        let key: AnnotationKey = serde_json::from_value(target_key.clone())
+                            .map_err(|e| e.to_string())?;
+                        serde_json::to_value(MessageValue {
+                            path: key.path,
+                            field: key.field,
+                            expression: draft.expression.clone(),
+                        })
+                        .expect("Message value")
+                    }
+                    FacetSelector::Binding(_) => {
+                        serde_json::json!({"referenced": target_key, "local": draft.local.as_ref().ok_or("Choose the destination scenario's local lifeline.")?.id})
+                    }
+                    _ => return Err("Unsupported row.".into()),
+                }
+            }
+        } else {
+            let fact = capture_facet(project, trace.oa, trace.sa, facet)?;
+            let row = scalar::value(&fact, source_layer)
+                .ok_or("Source row collection is not applicable; review its constructor first.")?;
+            if row.is_null() {
+                row
+            } else {
+                let map = |id: Id| -> Result<Id, String> {
+                    if source_layer == Layer::Oa {
+                        self.references.get(&id).copied().ok_or_else(|| {
+                            format!("Choose a reference counterpart for {}.", project.named(id))
+                        })
+                    } else {
+                        let matches: Vec<_> = self
+                            .references
+                            .iter()
+                            .filter(|(_, sa)| **sa == id)
+                            .map(|(oa, _)| *oa)
+                            .collect();
+                        if matches.len() == 1 {
+                            Ok(matches[0])
+                        } else {
+                            Err(format!(
+                                "Choose one unambiguous reference counterpart for {}.",
+                                project.named(id)
+                            ))
+                        }
+                    }
+                };
+                match facet {
+                    FacetSelector::Annotation(_) => {
+                        let mut row: MessageValue =
+                            serde_json::from_value(row).map_err(|e| e.to_string())?;
+                        row.path = row.path.into_iter().map(map).collect::<Result<_, _>>()?;
+                        row.field = map(row.field)?;
+                        if serde_json::to_value(AnnotationKey::from(&row)).expect("key")
+                            != target_key
+                        {
+                            return Err("Mapped annotation address disagrees with the selected destination address.".into());
+                        }
+                        serde_json::to_value(row).expect("row")
+                    }
+                    FacetSelector::Binding(_) => {
+                        let row: LifelineBinding =
+                            serde_json::from_value(row).map_err(|e| e.to_string())?;
+                        let mapped = LifelineBinding {
+                            referenced: map(row.referenced)?,
+                            local: map(row.local)?,
+                        };
+                        if serde_json::to_value(mapped.referenced).expect("Id") != target_key {
+                            return Err("Mapped binding key disagrees with the selected destination lifeline.".into());
+                        }
+                        serde_json::to_value(mapped).expect("row")
+                    }
+                    _ => return Err("Unsupported row.".into()),
+                }
+            }
+        };
+        let family = keyed::family(facet).ok_or("Unsupported row.")?;
+        let path = keyed::path(value, family)
+            .ok_or("The destination constructor has no collection for this row.")?;
+        let rows = value
+            .pointer_mut(&path)
+            .and_then(Value::as_array_mut)
+            .ok_or("Destination rows are unavailable.")?;
+        let position = rows.iter().position(|row| match facet {
+            FacetSelector::Annotation(_) => {
+                serde_json::json!({"path": row["path"], "field": row["field"]}) == target_key
+            }
+            FacetSelector::Binding(_) => row["referenced"] == target_key,
+            _ => false,
+        });
+        match (position, row.is_null()) {
+            (Some(index), false) => rows[index] = row,
+            (Some(index), true) => {
+                rows.remove(index);
+            }
+            (None, false) => rows.push(row),
+            (None, true) => {}
+        }
+        Ok(())
+    }
+}
@@ -1,254 +1,254 @@
-//! Independent membership and complete final order; the core validates every proposal.
-use super::*;
-
-pub(super) fn collection(which: OrderedCollection) -> ReferenceCollection {
-    match which {
-        OrderedCollection::Steps => ReferenceCollection::Steps,
-        OrderedCollection::FragmentBranches => ReferenceCollection::FragmentBranches,
-    }
-}
-pub(super) fn ordered(which: ReferenceCollection) -> Option<OrderedCollection> {
-    match which {
-        ReferenceCollection::Steps => Some(OrderedCollection::Steps),
-        ReferenceCollection::FragmentBranches => Some(OrderedCollection::FragmentBranches),
-        _ => None,
-    }
-}
-pub(super) fn read(value: &Value, which: OrderedCollection) -> Result<Vec<Id>, String> {
-    let path = keyed::path(value, keyed::Family::Member(collection(which)))
-        .ok_or("This ordered collection is unavailable on the destination.")?;
-    serde_json::from_value(value.pointer(&path).unwrap().clone()).map_err(|e| e.to_string())
-}
-fn write(value: &mut Value, which: OrderedCollection, ids: Vec<Id>) -> Result<(), String> {
-    let path = keyed::path(value, keyed::Family::Member(collection(which)))
-        .ok_or("This ordered collection is unavailable on the destination.")?;
-    *value.pointer_mut(&path).unwrap() = serde_json::to_value(ids).expect("Ordered identities");
-    Ok(())
-}
-
-impl ReviewRow {
-    pub(super) fn ordered_members(
-        &self,
-        project: &Project,
-        which: OrderedCollection,
-    ) -> Result<Vec<Id>, String> {
-        read(&self.combine(project, true, true)?, which)
-    }
-
-    pub(super) fn initialize_order(
-        &mut self,
-        project: &Project,
-        which: OrderedCollection,
-    ) -> Result<(), String> {
-        if !self.order_drafts.contains_key(&which) {
-            let ids = self.ordered_members(project, which)?;
-            self.order_drafts.insert(which, ids);
-        }
-        Ok(())
-    }
-
-    pub(super) fn reconcile_order(
-        &mut self,
-        project: &Project,
-        which: OrderedCollection,
-    ) -> Result<(), String> {
-        self.require_order_candidate(which)?;
-        let members = self.ordered_members(project, which)?;
-        let draft = self
-            .order_drafts
-            .get_mut(&which)
-            .ok_or("Choose a final order first.")?;
-        // This is an explicit user action. Ordinary refresh never discards an authored order.
-        let mut seen = BTreeSet::new();
-        draft.retain(|id| members.contains(id) && seen.insert(*id));
-        for id in members {
-            if seen.insert(id) {
-                draft.push(id);
-            }
-        }
-        Ok(())
-    }
-
-    fn require_order_candidate(&self, which: OrderedCollection) -> Result<(), String> {
-        let facet = FacetSelector::Order(which);
-        if self.selected.as_ref() != Some(&facet)
-            || self.decisions.get(&facet) != Some(&SemanticDecision::Candidate)
-        {
-            return Err("Select Set final value for this order before changing it.".into());
-        }
-        Ok(())
-    }
-
-    pub(super) fn move_order(
-        &mut self,
-        which: OrderedCollection,
-        index: usize,
-        delta: i32,
-    ) -> Result<(), String> {
-        self.require_order_candidate(which)?;
-        let ids = self
-            .order_drafts
-            .get_mut(&which)
-            .ok_or("Choose a final order first.")?;
-        let destination = match delta {
-            -1 => index.checked_sub(1),
-            1 => index.checked_add(1),
-            _ => None,
-        };
-        let destination = destination
-            .filter(|i| index < ids.len() && *i < ids.len())
-            .ok_or("Choose an existing adjacent position in the final order.")?;
-        ids.swap(index, destination);
-        Ok(())
-    }
-
-    pub(super) fn project_order(
-        &self,
-        project: &Project,
-        trace: &Trace,
-        value: &mut Value,
-        which: OrderedCollection,
-        decision: SemanticDecision,
-    ) -> Result<(), String> {
-        let current = read(value, which)?;
-        let supplied = match decision {
-            SemanticDecision::KeepTarget => return Ok(()),
-            SemanticDecision::Candidate => self
-                .order_drafts
-                .get(&which)
-                .cloned()
-                .ok_or("Choose a final order.")?,
-            SemanticDecision::TakeSource => {
-                let fact =
-                    capture_facet(project, trace.oa, trace.sa, &FacetSelector::Order(which))?;
-                let source: Vec<Id> = serde_json::from_value(
-                    scalar::value(&fact, self.direction.source_layer())
-                        .ok_or("The source has no applicable order.")?,
-                )
-                .map_err(|e| e.to_string())?;
-                let map = self.order_reference_map()?;
-                source
-                    .into_iter()
-                    .map(|id| {
-                        map.get(&id).copied().ok_or_else(|| {
-                            format!(
-                                "Pair source order member {} explicitly in Reference pairs.",
-                                project.named(id)
-                            )
-                        })
-                    })
-                    .collect::<Result<Vec<_>, _>>()?
-            }
-        };
-        let actual: BTreeSet<_> = current.iter().copied().collect();
-        let desired: BTreeSet<_> = supplied.iter().copied().collect();
-        if desired.len() != supplied.len() {
-            return Err(
-                "The final order contains a duplicate identity; reconcile its members explicitly."
-                    .into(),
-            );
-        }
-        if desired != actual {
-            if decision == SemanticDecision::TakeSource
-                && desired.is_subset(&actual)
-                && current
-                    .iter()
-                    .filter(|id| desired.contains(id))
-                    .copied()
-                    .collect::<Vec<_>>()
-                    == supplied
-            {
-                return Ok(());
-            }
-            return Err("Final order must contain every surviving destination member exactly once. Reconcile members, then choose their positions; membership is reviewed separately.".into());
-        }
-        write(value, which, supplied)
-    }
-
-    fn order_reference_map(&self) -> Result<BTreeMap<Id, Id>, String> {
-        let mut map = BTreeMap::new();
-        for (oa, sa) in &self.references {
-            let (a, b) = if self.direction == TransitionDirection::OaToSa {
-                (*oa, *sa)
-            } else {
-                (*sa, *oa)
-            };
-            if map.insert(a, b).is_some_and(|old| old != b) {
-                return Err("Reverse reference correspondence is ambiguous.".into());
-            }
-        }
-        Ok(map)
-    }
-
-    pub(super) fn project_ordered_member(
-        &self,
-        project: &Project,
-        trace: &Trace,
-        value: &mut Value,
-        facet: &FacetSelector,
-        decision: SemanticDecision,
-        form_context: bool,
-    ) -> Result<(), String> {
-        let FacetSelector::Member {
-            collection: member_collection,
-            keys,
-        } = facet
-        else {
-            unreachable!()
-        };
-        let which = ordered(*member_collection).expect("Ordered member");
-        let before = read(value, which)?;
-        self.keyed_value(project, trace, value, facet, decision)?;
-        let after = read(value, which)?;
-        let explicit = self
-            .decisions
-            .get(&FacetSelector::Order(which))
-            .is_some_and(|d| *d != SemanticDecision::KeepTarget);
-        if decision != SemanticDecision::TakeSource || explicit || after.len() <= before.len() {
-            return Ok(());
-        }
-        let (source_key, target_key) = if self.direction == TransitionDirection::OaToSa {
-            (keys.oa, keys.sa)
-        } else {
-            (keys.sa, keys.oa)
-        };
-        let (Some(source_key), Some(target_key)) = (source_key, target_key) else {
-            return Ok(());
-        };
-        let fact = capture_facet(project, trace.oa, trace.sa, &FacetSelector::Order(which))?;
-        let source: Vec<Id> = serde_json::from_value(
-            scalar::value(&fact, self.direction.source_layer())
-                .ok_or("Source order is unavailable.")?,
-        )
-        .map_err(|e| e.to_string())?;
-        let position = source
-            .iter()
-            .position(|id| *id == source_key)
-            .ok_or("Source member is absent.")?;
-        let map = self.order_reference_map()?;
-        let anchor = |id: &Id| {
-            map.get(id)
-                .and_then(|mapped| before.iter().position(|id| id == mapped))
-        };
-        let left = source[..position].iter().rev().find_map(anchor);
-        let right = source[position + 1..].iter().find_map(anchor);
-        let at = match (left, right) {
-            (Some(a), Some(b)) if a + 1 == b => Some(b),
-            (Some(a), None) if a + 1 == before.len() => Some(a + 1),
-            (None, Some(0)) => Some(0),
-            (None, None) if before.is_empty() => Some(0),
-            _ => None,
-        };
-        if let Some(at) = at {
-            let mut ordered = before;
-            ordered.insert(at, target_key);
-            write(value, which, ordered)
-        } else if form_context {
-            // An uncommitted membership list lets the user author a final order.
-            // The actual request still rejects ambiguous placement until explicitly decided.
-            Ok(())
-        } else {
-            Err("Ordered member insertion has no unique unchanged anchor; select an explicit final Order in Properties.".into())
-        }
-    }
-}
+//! Independent membership and complete final order; the core validates every proposal.
+use super::*;
+
+pub(super) fn collection(which: OrderedCollection) -> ReferenceCollection {
+    match which {
+        OrderedCollection::Steps => ReferenceCollection::Steps,
+        OrderedCollection::FragmentBranches => ReferenceCollection::FragmentBranches,
+    }
+}
+pub(super) fn ordered(which: ReferenceCollection) -> Option<OrderedCollection> {
+    match which {
+        ReferenceCollection::Steps => Some(OrderedCollection::Steps),
+        ReferenceCollection::FragmentBranches => Some(OrderedCollection::FragmentBranches),
+        _ => None,
+    }
+}
+pub(super) fn read(value: &Value, which: OrderedCollection) -> Result<Vec<Id>, String> {
+    let path = keyed::path(value, keyed::Family::Member(collection(which)))
+        .ok_or("This ordered collection is unavailable on the destination.")?;
+    serde_json::from_value(value.pointer(&path).unwrap().clone()).map_err(|e| e.to_string())
+}
+fn write(value: &mut Value, which: OrderedCollection, ids: Vec<Id>) -> Result<(), String> {
+    let path = keyed::path(value, keyed::Family::Member(collection(which)))
+        .ok_or("This ordered collection is unavailable on the destination.")?;
+    *value.pointer_mut(&path).unwrap() = serde_json::to_value(ids).expect("Ordered identities");
+    Ok(())
+}
+
+impl ReviewRow {
+    pub(super) fn ordered_members(
+        &self,
+        project: &Project,
+        which: OrderedCollection,
+    ) -> Result<Vec<Id>, String> {
+        read(&self.combine(project, true, true)?, which)
+    }
+
+    pub(super) fn initialize_order(
+        &mut self,
+        project: &Project,
+        which: OrderedCollection,
+    ) -> Result<(), String> {
+        if !self.order_drafts.contains_key(&which) {
+            let ids = self.ordered_members(project, which)?;
+            self.order_drafts.insert(which, ids);
+        }
+        Ok(())
+    }
+
+    pub(super) fn reconcile_order(
+        &mut self,
+        project: &Project,
+        which: OrderedCollection,
+    ) -> Result<(), String> {
+        self.require_order_candidate(which)?;
+        let members = self.ordered_members(project, which)?;
+        let draft = self
+            .order_drafts
+            .get_mut(&which)
+            .ok_or("Choose a final order first.")?;
+        // This is an explicit user action. Ordinary refresh never discards an authored order.
+        let mut seen = BTreeSet::new();
+        draft.retain(|id| members.contains(id) && seen.insert(*id));
+        for id in members {
+            if seen.insert(id) {
+                draft.push(id);
+            }
+        }
+        Ok(())
+    }
+
+    fn require_order_candidate(&self, which: OrderedCollection) -> Result<(), String> {
+        let facet = FacetSelector::Order(which);
+        if self.selected.as_ref() != Some(&facet)
+            || self.decisions.get(&facet) != Some(&SemanticDecision::Candidate)
+        {
+            return Err("Select Set final value for this order before changing it.".into());
+        }
+        Ok(())
+    }
+
+    pub(super) fn move_order(
+        &mut self,
+        which: OrderedCollection,
+        index: usize,
+        delta: i32,
+    ) -> Result<(), String> {
+        self.require_order_candidate(which)?;
+        let ids = self
+            .order_drafts
+            .get_mut(&which)
+            .ok_or("Choose a final order first.")?;
+        let destination = match delta {
+            -1 => index.checked_sub(1),
+            1 => index.checked_add(1),
+            _ => None,
+        };
+        let destination = destination
+            .filter(|i| index < ids.len() && *i < ids.len())
+            .ok_or("Choose an existing adjacent position in the final order.")?;
+        ids.swap(index, destination);
+        Ok(())
+    }
+
+    pub(super) fn project_order(
+        &self,
+        project: &Project,
+        trace: &Trace,
+        value: &mut Value,
+        which: OrderedCollection,
+        decision: SemanticDecision,
+    ) -> Result<(), String> {
+        let current = read(value, which)?;
+        let supplied = match decision {
+            SemanticDecision::KeepTarget => return Ok(()),
+            SemanticDecision::Candidate => self
+                .order_drafts
+                .get(&which)
+                .cloned()
+                .ok_or("Choose a final order.")?,
+            SemanticDecision::TakeSource => {
+                let fact =
+                    capture_facet(project, trace.oa, trace.sa, &FacetSelector::Order(which))?;
+                let source: Vec<Id> = serde_json::from_value(
+                    scalar::value(&fact, self.direction.source_layer())
+                        .ok_or("The source has no applicable order.")?,
+                )
+                .map_err(|e| e.to_string())?;
+                let map = self.order_reference_map()?;
+                source
+                    .into_iter()
+                    .map(|id| {
+                        map.get(&id).copied().ok_or_else(|| {
+                            format!(
+                                "Pair source order member {} explicitly in Reference pairs.",
+                                project.named(id)
+                            )
+                        })
+                    })
+                    .collect::<Result<Vec<_>, _>>()?
+            }
+        };
+        let actual: BTreeSet<_> = current.iter().copied().collect();
+        let desired: BTreeSet<_> = supplied.iter().copied().collect();
+        if desired.len() != supplied.len() {
+            return Err(
+                "The final order contains a duplicate identity; reconcile its members explicitly."
+                    .into(),
+            );
+        }
+        if desired != actual {
+            if decision == SemanticDecision::TakeSource
+                && desired.is_subset(&actual)
+                && current
+                    .iter()
+                    .filter(|id| desired.contains(id))
+                    .copied()
+                    .collect::<Vec<_>>()
+                    == supplied
+            {
+                return Ok(());
+            }
+            return Err("Final order must contain every surviving destination member exactly once. Reconcile members, then choose their positions; membership is reviewed separately.".into());
+        }
+        write(value, which, supplied)
+    }
+
+    fn order_reference_map(&self) -> Result<BTreeMap<Id, Id>, String> {
+        let mut map = BTreeMap::new();
+        for (oa, sa) in &self.references {
+            let (a, b) = if self.direction == TransitionDirection::OaToSa {
+                (*oa, *sa)
+            } else {
+                (*sa, *oa)
+            };
+            if map.insert(a, b).is_some_and(|old| old != b) {
+                return Err("Reverse reference correspondence is ambiguous.".into());
+            }
+        }
+        Ok(map)
+    }
+
+    pub(super) fn project_ordered_member(
+        &self,
+        project: &Project,
+        trace: &Trace,
+        value: &mut Value,
+        facet: &FacetSelector,
+        decision: SemanticDecision,
+        form_context: bool,
+    ) -> Result<(), String> {
+        let FacetSelector::Member {
+            collection: member_collection,
+            keys,
+        } = facet
+        else {
+            unreachable!()
+        };
+        let which = ordered(*member_collection).expect("Ordered member");
+        let before = read(value, which)?;
+        self.keyed_value(project, trace, value, facet, decision)?;
+        let after = read(value, which)?;
+        let explicit = self
+            .decisions
+            .get(&FacetSelector::Order(which))
+            .is_some_and(|d| *d != SemanticDecision::KeepTarget);
+        if decision != SemanticDecision::TakeSource || explicit || after.len() <= before.len() {
+            return Ok(());
+        }
+        let (source_key, target_key) = if self.direction == TransitionDirection::OaToSa {
+            (keys.oa, keys.sa)
+        } else {
+            (keys.sa, keys.oa)
+        };
+        let (Some(source_key), Some(target_key)) = (source_key, target_key) else {
+            return Ok(());
+        };
+        let fact = capture_facet(project, trace.oa, trace.sa, &FacetSelector::Order(which))?;
+        let source: Vec<Id> = serde_json::from_value(
+            scalar::value(&fact, self.direction.source_layer())
+                .ok_or("Source order is unavailable.")?,
+        )
+        .map_err(|e| e.to_string())?;
+        let position = source
+            .iter()
+            .position(|id| *id == source_key)
+            .ok_or("Source member is absent.")?;
+        let map = self.order_reference_map()?;
+        let anchor = |id: &Id| {
+            map.get(id)
+                .and_then(|mapped| before.iter().position(|id| id == mapped))
+        };
+        let left = source[..position].iter().rev().find_map(anchor);
+        let right = source[position + 1..].iter().find_map(anchor);
+        let at = match (left, right) {
+            (Some(a), Some(b)) if a + 1 == b => Some(b),
+            (Some(a), None) if a + 1 == before.len() => Some(a + 1),
+            (None, Some(0)) => Some(0),
+            (None, None) if before.is_empty() => Some(0),
+            _ => None,
+        };
+        if let Some(at) = at {
+            let mut ordered = before;
+            ordered.insert(at, target_key);
+            write(value, which, ordered)
+        } else if form_context {
+            // An uncommitted membership list lets the user author a final order.
+            // The actual request still rejects ambiguous placement until explicitly decided.
+            Ok(())
+        } else {
+            Err("Ordered member insertion has no unique unchanged anchor; select an explicit final Order in Properties.".into())
+        }
+    }
+}
@@ -166,6 +166,14 @@ impl ReviewRow {
    pub fn update(&mut self, project: &Project, event: RowEvent) {
        let mut replan = true;
        let result = match event {
+            // Browser messages belong to the app overlay and must never replan.
+            RowEvent::ReferenceOpen(_) | RowEvent::ReferenceEvent(_) => return,
+            RowEvent::ReferenceSet(intent) => {
+                let path = intent.context.path.clone();
+                self.edit(project, &path, |draft| {
+                    draft.reference_set(project, &intent)
+                })
+            }
            RowEvent::OperationOmission(enabled) => {
                self.operation_omission =
                    enabled.then(|| self.operation_omission.clone().unwrap_or_default());
@@ -518,6 +526,25 @@ impl ReviewRow {
        }
    }

+    pub(super) fn reference_draft(
+        &self,
+        project: &Project,
+        facet: &FacetSelector,
+        path: &str,
+    ) -> Option<&Draft> {
+        if self.selected.as_ref() != Some(facet)
+            || self.decisions.get(facet) != Some(&SemanticDecision::Candidate)
+            || matches!(path, "/id" | "/alias" | "/body" | "/layer")
+            || !self
+                .candidate_roots(project, facet)?
+                .iter()
+                .any(|root| path == root || path.starts_with(&format!("{root}/")))
+        {
+            return None;
+        }
+        self.candidate_draft(facet)
+    }
+
    fn edit(
        &mut self,
        project: &Project,
@@ -895,6 +922,8 @@ pub fn form_event(message: Message) -> Message {
        Message::FieldReferenceBrowse(path, query, page) => {
            RowEvent::ReferenceBrowse(path, query, page)
        }
+        Message::FieldReferenceOpen(request) => RowEvent::ReferenceOpen(request),
+        Message::FieldReferenceEvent(event) => RowEvent::ReferenceEvent(event),
        _ => RowEvent::Preview,
    };
    Message::Workflow(crate::workflow::Event::Semantic(Event::Editor(event)))
@@ -867,7 +867,13 @@ impl ReviewRow {
        ) {
            detail = detail.push(text("Attached facts are separate from referenced definitions. Removing membership never implies deleting a semantic object.").size(11).color(style::MUTED));
        }
-        detail.into()
+        if self.decisions.get(&fact.selector) == Some(&SemanticDecision::Candidate)
+            && let Some(draft) = self.candidate_draft(&fact.selector)
+        {
+            crate::forms::reference_chooser::trigger::scope(detail, draft.reference_session())
+        } else {
+            detail.into()
+        }
    }

    fn members_view<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
@@ -1,9 +1,4 @@
 //! Literal source search and line navigation, independent of accepted model state.
-mod controller;
-pub mod interaction;
-pub mod query;
-pub mod symbols;
-pub use controller::*;
 use iced::widget::text_editor::{Cursor, Position};

 #[derive(Debug, Clone)]
@@ -1,125 +0,0 @@
-//! Ephemeral editor navigation; no model commands or filesystem operations.
-use super::query;
-use iced::widget::text_editor::{Cursor, Position};
-use oa_core::Id;
-use std::sync::Arc;
-use std::sync::atomic::AtomicU64;
-
-#[derive(Debug, Clone)]
-pub enum SymbolEvent {
-    Query(query::Action),
-    Back,
-    Close,
-    Choose {
-        stamp: query::QueryStamp,
-        reference: bool,
-        index: usize,
-    },
-}
-
-/// Identity of the mounted source view that emitted an action. Message queues
-/// may outlive that view; request-time stamping alone cannot detect replay.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SymbolContext {
-    pub session: Id,
-    pub path: String,
-}
-
-#[derive(Debug, Clone)]
-pub struct HistoryEntry {
-    pub session: Id,
-    pub path: String,
-    pub generation: u64,
-    pub cursor: Cursor,
-}
-
-#[derive(Debug, Clone)]
-pub struct Request {
-    pub job: Id,
-    pub interaction: Id,
-    pub raw_interaction: u64,
-    pub stamp: query::QueryStamp,
-    pub path: String,
-    pub offset: usize,
-    pub cursor: Cursor,
-    pub action: query::Action,
-}
-
-#[derive(Debug, Clone)]
-pub struct Completion {
-    pub request: Request,
-    pub result: Result<(Arc<query::Snapshot>, Arc<query::Results>), String>,
-}
-
-pub struct Reveal {
-    pub ticket: Id,
-    pub interaction: Id,
-    pub raw_interaction: u64,
-    pub snapshot: query::SnapshotKey,
-    pub path: String,
-}
-
-pub struct SymbolState {
-    pub open: bool,
-    pub interaction: Id,
-    pub raw_interaction: Arc<AtomicU64>,
-    pub serial: u64,
-    pub in_flight: Option<Id>,
-    pub request: Option<Request>,
-    pub cache: Option<Arc<query::Snapshot>>,
-    pub results: Option<Arc<query::Results>>,
-    pub notice: Option<String>,
-    pub back: Vec<HistoryEntry>,
-    pub reveal: Option<Reveal>,
-}
-
-impl Default for SymbolState {
-    fn default() -> Self {
-        Self {
-            open: false,
-            interaction: Id::new_v4(),
-            raw_interaction: Arc::new(AtomicU64::new(0)),
-            serial: 0,
-            in_flight: None,
-            request: None,
-            cache: None,
-            results: None,
-            notice: None,
-            back: Vec::new(),
-            reveal: None,
-        }
-    }
-}
-
-/// Iced uses zero-based UTF-8 byte columns. Reject stale or split-codepoint
-/// coordinates; do not normalize CRLF or silently clamp query destinations.
-pub fn byte_offset(text: &str, position: Position) -> Option<usize> {
-    let start = if position.line == 0 {
-        0
-    } else {
-        text.match_indices('\n').nth(position.line - 1)?.0 + 1
-    };
-    let end = text[start..]
-        .find('\n')
-        .map_or(text.len(), |end| start + end);
-    let offset = start.checked_add(position.column)?;
-    (offset <= end && text.is_char_boundary(offset)).then_some(offset)
-}
-
-pub fn cursor_offset(text: &str, cursor: Cursor) -> Option<usize> {
-    let position = cursor.selection.map_or(cursor.position, |selection| {
-        if (selection.line, selection.column) < (cursor.position.line, cursor.position.column) {
-            selection
-        } else {
-            cursor.position
-        }
-    });
-    byte_offset(text, position)
-}
-
-pub fn exact_cursor(text: &str, cursor: Cursor) -> bool {
-    byte_offset(text, cursor.position).is_some()
-        && cursor
-            .selection
-            .is_none_or(|position| byte_offset(text, position).is_some())
-}
@@ -1,284 +0,0 @@
-//! Raw input invalidation and focus checks at widget-operation execution time.
-use iced::advanced::{Clipboard, Layout, Shell, Widget, layout, overlay, renderer, widget};
-use iced::{Element, Event, Length, Rectangle, Size, Task, Vector, keyboard, mouse, touch};
-use std::sync::{
-    Arc,
-    atomic::{AtomicU64, Ordering},
-};
-
-/// Exhaustion fails closed: a saturated clock can never authorize navigation.
-/// Replace the clock with a new workspace/controller, rather than wrapping it.
-pub fn is_current(clock: &AtomicU64, expected: u64) -> bool {
-    expected != u64::MAX && clock.load(Ordering::Acquire) == expected
-}
-
-fn invalidate(clock: &AtomicU64, event: &Event) {
-    if matches!(
-        event,
-        Event::Keyboard(keyboard::Event::KeyPressed { .. })
-            | Event::Mouse(mouse::Event::ButtonPressed(_) | mouse::Event::WheelScrolled { .. })
-            | Event::Touch(touch::Event::FingerPressed { .. })
-            | Event::Window(iced::window::Event::Unfocused)
-    ) {
-        let _ = clock.fetch_update(Ordering::AcqRel, Ordering::Acquire, |value| {
-            Some(value.saturating_add(1))
-        });
-    }
-}
-
-/// Transparent, including overlays: invalidate before the child can capture input.
-pub fn observe<'a, Message: 'a, Theme: 'a, Renderer: renderer::Renderer + 'a>(
-    content: Element<'a, Message, Theme, Renderer>,
-    clock: Arc<AtomicU64>,
-) -> Element<'a, Message, Theme, Renderer> {
-    Element::new(Observed { content, clock })
-}
-
-struct Observed<'a, Message, Theme, Renderer> {
-    content: Element<'a, Message, Theme, Renderer>,
-    clock: Arc<AtomicU64>,
-}
-
-impl<Message, Theme, Renderer: renderer::Renderer> Widget<Message, Theme, Renderer>
-    for Observed<'_, Message, Theme, Renderer>
-{
-    fn size(&self) -> Size<Length> {
-        self.content.as_widget().size()
-    }
-    fn size_hint(&self) -> Size<Length> {
-        self.content.as_widget().size_hint()
-    }
-    fn tag(&self) -> widget::tree::Tag {
-        self.content.as_widget().tag()
-    }
-    fn state(&self) -> widget::tree::State {
-        self.content.as_widget().state()
-    }
-    fn children(&self) -> Vec<widget::Tree> {
-        self.content.as_widget().children()
-    }
-    fn diff(&self, tree: &mut widget::Tree) {
-        self.content.as_widget().diff(tree);
-    }
-    fn layout(
-        &mut self,
-        tree: &mut widget::Tree,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        self.content.as_widget_mut().layout(tree, renderer, limits)
-    }
-    fn draw(
-        &self,
-        tree: &widget::Tree,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        viewport: &Rectangle,
-    ) {
-        self.content
-            .as_widget()
-            .draw(tree, renderer, theme, style, layout, cursor, viewport);
-    }
-    fn operate(
-        &mut self,
-        tree: &mut widget::Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn widget::Operation,
-    ) {
-        self.content
-            .as_widget_mut()
-            .operate(tree, layout, renderer, operation);
-    }
-    fn update(
-        &mut self,
-        tree: &mut widget::Tree,
-        event: &Event,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-        viewport: &Rectangle,
-    ) {
-        invalidate(&self.clock, event);
-        self.content.as_widget_mut().update(
-            tree, event, layout, cursor, renderer, clipboard, shell, viewport,
-        );
-    }
-    fn mouse_interaction(
-        &self,
-        tree: &widget::Tree,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        viewport: &Rectangle,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.content
-            .as_widget()
-            .mouse_interaction(tree, layout, cursor, viewport, renderer)
-    }
-    fn overlay<'a>(
-        &'a mut self,
-        tree: &'a mut widget::Tree,
-        layout: Layout<'a>,
-        renderer: &Renderer,
-        viewport: &Rectangle,
-        translation: Vector,
-    ) -> Option<overlay::Element<'a, Message, Theme, Renderer>> {
-        let clock = self.clock.clone();
-        self.content
-            .as_widget_mut()
-            .overlay(tree, layout, renderer, viewport, translation)
-            .map(|content| overlay::Element::new(Box::new(ObservedOverlay { content, clock })))
-    }
-}
-
-struct ObservedOverlay<'a, Message, Theme, Renderer> {
-    content: overlay::Element<'a, Message, Theme, Renderer>,
-    clock: Arc<AtomicU64>,
-}
-impl<Message, Theme, Renderer: renderer::Renderer> overlay::Overlay<Message, Theme, Renderer>
-    for ObservedOverlay<'_, Message, Theme, Renderer>
-{
-    fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
-        self.content.as_overlay_mut().layout(renderer, bounds)
-    }
-    fn draw(
-        &self,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-    ) {
-        self.content
-            .as_overlay()
-            .draw(renderer, theme, style, layout, cursor);
-    }
-    fn operate(
-        &mut self,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn widget::Operation,
-    ) {
-        self.content
-            .as_overlay_mut()
-            .operate(layout, renderer, operation);
-    }
-    fn update(
-        &mut self,
-        event: &Event,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-    ) {
-        invalidate(&self.clock, event);
-        self.content
-            .as_overlay_mut()
-            .update(event, layout, cursor, renderer, clipboard, shell);
-    }
-    fn mouse_interaction(
-        &self,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.content
-            .as_overlay()
-            .mouse_interaction(layout, cursor, renderer)
-    }
-    fn overlay<'a>(
-        &'a mut self,
-        layout: Layout<'a>,
-        renderer: &Renderer,
-    ) -> Option<overlay::Element<'a, Message, Theme, Renderer>> {
-        let clock = self.clock.clone();
-        self.content
-            .as_overlay_mut()
-            .overlay(layout, renderer)
-            .map(|content| overlay::Element::new(Box::new(ObservedOverlay { content, clock })))
-    }
-    fn index(&self) -> f32 {
-        self.content.as_overlay().index()
-    }
-}
-
-/// Inspect all focus owners, then focus only the mounted target. Iced executes
-/// Operation::Chain synchronously, without an intervening input event. Both
-/// traversals recheck the raw clock; no result message authorizes later focus.
-pub fn guarded_focus<Message: Send + 'static>(
-    target: widget::Id,
-    clock: Arc<AtomicU64>,
-    expected: u64,
-) -> Task<Message> {
-    widget::operate(GuardedFocus::new(target, clock, expected))
-}
-
-struct GuardedFocus {
-    target: widget::Id,
-    clock: Arc<AtomicU64>,
-    expected: u64,
-    target_count: usize,
-    foreign_focus: bool,
-    apply: bool,
-}
-impl GuardedFocus {
-    fn new(target: widget::Id, clock: Arc<AtomicU64>, expected: u64) -> Self {
-        Self {
-            target,
-            clock,
-            expected,
-            target_count: 0,
-            foreign_focus: false,
-            apply: false,
-        }
-    }
-}
-impl<Message: 'static> widget::Operation<Message> for GuardedFocus {
-    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn widget::Operation<Message>)) {
-        if is_current(&self.clock, self.expected) {
-            visit(self);
-        }
-    }
-    fn focusable(
-        &mut self,
-        id: Option<&widget::Id>,
-        _: Rectangle,
-        state: &mut dyn widget::operation::Focusable,
-    ) {
-        if !is_current(&self.clock, self.expected) {
-            return;
-        }
-        if id == Some(&self.target) {
-            self.target_count += 1;
-            if self.apply {
-                state.focus();
-            }
-        } else if state.is_focused() {
-            self.foreign_focus = true;
-        }
-    }
-    fn finish(&self) -> widget::operation::Outcome<Message> {
-        if !self.apply
-            && self.target_count == 1
-            && !self.foreign_focus
-            && is_current(&self.clock, self.expected)
-        {
-            widget::operation::Outcome::Chain(Box::new(Self {
-                apply: true,
-                ..Self::new(self.target.clone(), self.clock.clone(), self.expected)
-            }))
-        } else {
-            widget::operation::Outcome::None
-        }
-    }
-}
-
-#[cfg(all(test, debug_assertions))]
-mod tests;
@@ -1,190 +0,0 @@
-use super::*;
-use iced::advanced::widget::operation::{Focusable, Outcome};
-use iced::widget::{column, text_input};
-use iced::{Point, Theme};
-
-#[derive(Default)]
-struct FocusMap(Vec<(Option<widget::Id>, Rectangle, bool)>);
-impl widget::Operation for FocusMap {
-    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn widget::Operation)) {
-        visit(self);
-    }
-    fn focusable(&mut self, id: Option<&widget::Id>, bounds: Rectangle, state: &mut dyn Focusable) {
-        self.0.push((id.cloned(), bounds, state.is_focused()));
-    }
-}
-
-struct Mounted {
-    element: Element<'static, (), Theme, ()>,
-    tree: widget::Tree,
-    node: layout::Node,
-}
-impl Mounted {
-    fn new(clock: Arc<AtomicU64>) -> Self {
-        let content = column![
-            text_input("Editor", "source")
-                .id("editor")
-                .on_input(|_| ())
-                .padding(12),
-            text_input("Find", "")
-                .id("find")
-                .on_input(|_| ())
-                .padding(12),
-        ]
-        .spacing(10)
-        .into();
-        let mut element = observe(content, clock);
-        let mut tree = widget::Tree::new(element.as_widget());
-        let node = element.as_widget_mut().layout(
-            &mut tree,
-            &(),
-            &layout::Limits::new(Size::ZERO, Size::new(400., 200.)),
-        );
-        Self {
-            element,
-            tree,
-            node,
-        }
-    }
-    fn pass(&mut self, operation: &mut dyn widget::Operation) {
-        self.element.as_widget_mut().operate(
-            &mut self.tree,
-            Layout::new(&self.node),
-            &(),
-            operation,
-        );
-    }
-    fn run(&mut self, operation: impl widget::Operation + 'static) {
-        let mut next: Box<dyn widget::Operation> = Box::new(operation);
-        loop {
-            self.pass(next.as_mut());
-            match next.finish() {
-                Outcome::Chain(chained) => next = chained,
-                Outcome::None => break,
-                Outcome::Some(()) => panic!("focus must not publish an application message"),
-            }
-        }
-    }
-    fn focus(&mut self) -> FocusMap {
-        let mut focus = FocusMap::default();
-        self.pass(&mut focus);
-        focus
-    }
-    fn click(&mut self, id: &str) {
-        let bounds = self
-            .focus()
-            .0
-            .into_iter()
-            .find(|(found, _, _)| found.as_ref() == Some(&widget::Id::from(id.to_owned())))
-            .unwrap()
-            .1;
-        let mut messages = Vec::new();
-        let mut shell = Shell::new(&mut messages);
-        self.element.as_widget_mut().update(
-            &mut self.tree,
-            &Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
-            Layout::new(&self.node),
-            mouse::Cursor::Available(bounds.center()),
-            &(),
-            &mut iced::advanced::clipboard::Null,
-            &mut shell,
-            &Rectangle::with_size(Size::new(400., 200.)),
-        );
-        assert!(shell.is_event_captured());
-        assert!(
-            messages.is_empty(),
-            "focus-only click must not rely on App messages"
-        );
-    }
-    fn focused(&mut self, id: &str) -> bool {
-        self.focus()
-            .0
-            .into_iter()
-            .find(|(found, _, _)| found.as_ref() == Some(&widget::Id::from(id.to_owned())))
-            .unwrap()
-            .2
-    }
-}
-
-#[test]
-fn captured_find_click_invalidates_without_app_message_and_preserves_focus() {
-    let clock = Arc::new(AtomicU64::new(0));
-    let mut ui = Mounted::new(clock.clone());
-    ui.run(GuardedFocus::new("editor".into(), clock.clone(), 0));
-    assert!(ui.focused("editor"));
-    ui.click("find");
-    assert!(!is_current(&clock, 0));
-    assert!(ui.focused("find"));
-    ui.run(GuardedFocus::new("editor".into(), clock.clone(), 0));
-    assert!(ui.focused("find"));
-    // Even a matching clock cannot authorize stealing another widget's focus.
-    ui.run(GuardedFocus::new(
-        "editor".into(),
-        clock.clone(),
-        clock.load(Ordering::Acquire),
-    ));
-    assert!(ui.focused("find"));
-    assert!(!ui.focused("editor"));
-}
-
-#[test]
-fn focus_rechecks_clock_between_inspection_and_application_and_missing_target_is_inert() {
-    let clock = Arc::new(AtomicU64::new(0));
-    let mut ui = Mounted::new(clock.clone());
-    let mut operation = GuardedFocus::new("editor".into(), clock.clone(), 0);
-    ui.pass(&mut operation);
-    let Outcome::Chain(mut apply) = <GuardedFocus as widget::Operation<()>>::finish(&operation)
-    else {
-        panic!("mounted, unopposed target must be eligible");
-    };
-    clock.store(1, Ordering::Release);
-    ui.pass(apply.as_mut());
-    assert!(!ui.focused("editor"));
-    ui.run(GuardedFocus::new("editor".into(), clock.clone(), 1));
-    assert!(ui.focused("editor"));
-    ui.run(GuardedFocus::new("removed-editor".into(), clock, 1));
-    assert!(ui.focused("editor"));
-}
-
-#[test]
-fn raw_navigation_inputs_advance_but_passive_geometry_does_not_and_exhaustion_refuses() {
-    let clock = AtomicU64::new(0);
-    let events = [
-        Event::Keyboard(keyboard::Event::KeyPressed {
-            key: keyboard::Key::Named(keyboard::key::Named::ArrowLeft),
-            modified_key: keyboard::Key::Named(keyboard::key::Named::ArrowLeft),
-            physical_key: keyboard::key::Physical::Code(keyboard::key::Code::ArrowLeft),
-            location: keyboard::Location::Standard,
-            modifiers: keyboard::Modifiers::empty(),
-            text: None,
-            repeat: false,
-        }),
-        Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
-        Event::Mouse(mouse::Event::WheelScrolled {
-            delta: mouse::ScrollDelta::Lines { x: 0., y: 1. },
-        }),
-        Event::Touch(touch::Event::FingerPressed {
-            id: touch::Finger(1),
-            position: Point::ORIGIN,
-        }),
-        Event::Window(iced::window::Event::Unfocused),
-    ];
-    for (index, event) in events.iter().enumerate() {
-        invalidate(&clock, event);
-        assert_eq!(clock.load(Ordering::Acquire), index as u64 + 1);
-    }
-    invalidate(
-        &clock,
-        &Event::Mouse(mouse::Event::CursorMoved {
-            position: Point::ORIGIN,
-        }),
-    );
-    invalidate(&clock, &Event::Window(iced::window::Event::Focused));
-    assert!(is_current(&clock, 5));
-    clock.store(u64::MAX - 1, Ordering::Release);
-    invalidate(&clock, &events[0]);
-    assert!(!is_current(&clock, u64::MAX));
-    invalidate(&clock, &events[0]);
-    assert_eq!(clock.load(Ordering::Acquire), u64::MAX);
-    assert!(!is_current(&clock, 0));
-}
@@ -1,989 +0,0 @@
-use super::*;
-
-const PROJECT: &str = "00000000-0000-0000-0000-000000000001";
-const PUMP: &str = "00000000-0000-0000-0000-000000000002";
-const LINK: &str = "00000000-0000-0000-0000-000000000003";
-
-#[derive(Clone)]
-struct Fixture {
-    entry: String,
-    files: Vec<(String, String)>,
-}
-
-impl Fixture {
-    fn standard() -> Self {
-        Self {
-            entry: "project.arcadia".into(),
-            files: vec![
-                (
-                    "project.arcadia".into(),
-                    format!(
-                        "arcadia 7;\r\nproject model \"Harbour\" id \"{PROJECT}\" {{\r\n include \"模块/活動.arcadia\";\r\n include \"links.arcadia\";\r\n}}\r\n"
-                    ),
-                ),
-                (
-                    "模块/活動.arcadia".into(),
-                    format!(
-                        "// 原文 remains exact\r\noa_activity pump \"泵 🚀\" id \"{PUMP}\" {{}}\r\n"
-                    ),
-                ),
-                (
-                    "links.arcadia".into(),
-                    format!(
-                        "// 航海\r\ninteraction connection \"流れ\" id \"{LINK}\" {{\r\n source @ // separator @pump\r\n   pump;\r\n description \"船 @pump\"; target @pump;\r\n}}\r\n"
-                    ),
-                ),
-            ],
-        }
-    }
-
-    fn borrowed(&self) -> Vec<DraftFile<'_>> {
-        self.files
-            .iter()
-            .map(|(path, text)| DraftFile { path, text })
-            .collect()
-    }
-
-    fn text(&self, path: &str) -> &str {
-        &self
-            .files
-            .iter()
-            .find(|(candidate, _)| candidate == path)
-            .unwrap()
-            .1
-    }
-
-    fn text_mut(&mut self, path: &str) -> &mut String {
-        &mut self
-            .files
-            .iter_mut()
-            .find(|(candidate, _)| candidate == path)
-            .unwrap()
-            .1
-    }
-
-    fn snapshot(&self, validated: Option<&Self>, applied: bool, limits: Limits) -> Snapshot {
-        let current = self.borrowed();
-        let old = validated.map(Self::borrowed);
-        capture(
-            Input {
-                key: key(1),
-                entry: &self.entry,
-                files: &current,
-                applied,
-                validation: old.as_ref().map(|files| ValidatedSources {
-                    entry: &validated.unwrap().entry,
-                    files,
-                }),
-            },
-            limits,
-        )
-        .unwrap()
-    }
-}
-
-fn key(revision: u64) -> SnapshotKey {
-    SnapshotKey {
-        workspace: Id::from_u128(100),
-        revision,
-    }
-}
-
-fn query(snapshot: &Snapshot, path: &str, byte_offset: usize, action: Action) -> Results {
-    snapshot
-        .query(Query {
-            stamp: QueryStamp {
-                snapshot: snapshot.key(),
-                serial: 37,
-            },
-            path,
-            byte_offset,
-            action,
-        })
-        .unwrap()
-}
-
-fn reference_offset(fixture: &Fixture) -> usize {
-    fixture.text("links.arcadia").find("source @").unwrap() + "source ".len()
-}
-
-#[test]
-fn exact_multifile_unicode_crlf_definition_and_repeated_lexical_references() {
-    let fixture = Fixture::standard();
-    let original = fixture.files.clone();
-    let snapshot = fixture.snapshot(Some(&fixture), true, Limits::default());
-    assert!(snapshot.scope().closure_complete && snapshot.scope().validated);
-    assert_eq!(
-        (
-            snapshot.scope().included_files,
-            snapshot.scope().detached_files
-        ),
-        (3, 0)
-    );
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&fixture),
-        Action::Definition,
-    );
-    assert_eq!(result.disposition, Disposition::Direct);
-    assert_eq!(
-        (result.total_definitions, result.omitted_definitions),
-        (1, 0)
-    );
-    let definition = &result.definitions[0];
-    assert_eq!(definition.path, "模块/活動.arcadia");
-    assert_eq!(definition.declaration.kind, "oa_activity");
-    assert_eq!(definition.declaration.name.as_deref(), Some("泵 🚀"));
-    assert_eq!(
-        definition.declaration.authored_id,
-        Some(Id::parse_str(PUMP).unwrap())
-    );
-    assert_eq!(
-        definition.position,
-        Position {
-            line: 1,
-            byte_column: "oa_activity ".len()
-        }
-    );
-    assert_eq!(
-        &fixture.text(&definition.path)[definition.span.start..definition.span.end],
-        "pump"
-    );
-    let uses = query(
-        &snapshot,
-        &definition.path,
-        definition.span.start,
-        Action::References,
-    );
-    assert_eq!(uses.disposition, Disposition::LexicalReferences);
-    assert_eq!((uses.total_references, uses.omitted_references), (2, 0));
-    assert_eq!(
-        uses.references[0].position,
-        Position {
-            line: 3,
-            byte_column: 3
-        }
-    );
-    let target_prefix = " description \"船 @pump\"; target @";
-    assert_ne!(target_prefix.len(), target_prefix.chars().count());
-    assert_eq!(
-        uses.references[1].position,
-        Position {
-            line: 4,
-            byte_column: target_prefix.len()
-        }
-    );
-    for row in &uses.references {
-        let text = fixture.text(&row.path);
-        assert_eq!(&text[row.span.start..row.span.end], "pump");
-        assert_eq!(&text[row.marker.start..row.marker.end], "@");
-        let context = row.context.as_ref().unwrap();
-        assert_eq!(context.alias, "connection");
-        assert_eq!(context.kind, "interaction");
-        assert_eq!(context.name.as_deref(), Some("流れ"));
-        assert_eq!(row.evidence, Evidence::Validated);
-    }
-    assert_eq!(
-        uses.stamp,
-        QueryStamp {
-            snapshot: key(1),
-            serial: 37
-        }
-    );
-    assert_eq!(
-        fixture.files, original,
-        "no stabilization, newline rewrite or accepted adoption"
-    );
-    for (index, (path, text)) in original.iter().enumerate() {
-        let owned = snapshot.file(index).unwrap();
-        assert_eq!((owned.path, owned.text), (path.as_str(), text.as_str()));
-    }
-}
-
-#[test]
-fn comments_strings_and_comment_gap_are_not_navigation_hits() {
-    let fixture = Fixture::standard();
-    let snapshot = fixture.snapshot(None, true, Limits::default());
-    let text = fixture.text("links.arcadia");
-    for offset in [
-        text.find("separator @pump").unwrap() + "separator ".len(),
-        text.find("船 @pump").unwrap() + "船 ".len(),
-        text.find("@ //").unwrap() + 1,
-    ] {
-        let result = query(&snapshot, "links.arcadia", offset, Action::Definition);
-        assert_eq!(result.disposition, Disposition::NoSymbol);
-        assert_eq!(result.total_definitions, 0);
-    }
-    assert_eq!(
-        query(
-            &snapshot,
-            "links.arcadia",
-            text.find("   pump;").unwrap() + 3,
-            Action::Definition
-        )
-        .total_definitions,
-        1
-    );
-    let inside_utf8 = text.find('船').unwrap() + 1;
-    assert_eq!(
-        snapshot.query(Query {
-            stamp: QueryStamp {
-                snapshot: key(1),
-                serial: 1
-            },
-            path: "links.arcadia",
-            byte_offset: inside_utf8,
-            action: Action::Definition
-        }),
-        Err(QueryError::Query(symbols::QueryError::InvalidBytePosition))
-    );
-}
-
-#[test]
-fn dirty_but_parseable_text_has_current_names_and_no_validated_fallback() {
-    let original = Fixture::standard();
-    let mut dirty = original.clone();
-    *dirty.text_mut("模块/活動.arcadia") = dirty
-        .text("模块/活動.arcadia")
-        .replace("泵 🚀", "Edited 泵\\nwith detail");
-    let snapshot = dirty.snapshot(Some(&original), true, Limits::default());
-    assert!(snapshot.scope().closure_complete);
-    assert!(!snapshot.scope().validated);
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&dirty),
-        Action::Definition,
-    );
-    assert_eq!(result.disposition, Disposition::Choices);
-    assert_eq!(
-        result.definitions[0].declaration.name.as_deref(),
-        Some("Edited 泵\nwith detail")
-    );
-    assert_eq!(result.definitions[0].evidence, Evidence::Draft);
-    assert_eq!(
-        snapshot.file(1).unwrap().text,
-        dirty.text("模块/活動.arcadia")
-    );
-    assert_ne!(
-        snapshot.file(1).unwrap().text,
-        original.text("模块/活動.arcadia")
-    );
-}
-
-#[test]
-fn invalid_include_syntax_never_borrows_the_old_reachable_file_set() {
-    let original = Fixture::standard();
-    let mut invalid = original.clone();
-    *invalid.text_mut("project.arcadia") = invalid
-        .text("project.arcadia")
-        .replace("include \"links.arcadia\";", "include \"links.arcadia\"");
-    let snapshot = invalid.snapshot(Some(&original), true, Limits::default());
-    assert!(snapshot.scope().partial());
-    assert!(!snapshot.scope().validated);
-    assert!(
-        snapshot
-            .scope()
-            .issues
-            .iter()
-            .any(|issue| issue.kind == ScopeIssueKind::InvalidIncludes)
-    );
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&invalid),
-        Action::Definition,
-    );
-    assert_eq!(result.total_definitions, 1);
-    assert_eq!(result.disposition, Disposition::Choices);
-    assert_eq!(result.definitions[0].membership, Membership::Unverified);
-}
-
-#[test]
-fn missing_include_partial_scope_does_not_resurrect_witness_text() {
-    let original = Fixture::standard();
-    let mut missing = original.clone();
-    missing
-        .files
-        .retain(|(path, _)| path != "模块/活動.arcadia");
-    let snapshot = missing.snapshot(Some(&original), true, Limits::default());
-    assert!(snapshot.scope().partial());
-    assert!(
-        snapshot
-            .scope()
-            .issues
-            .iter()
-            .any(|issue| issue.kind == ScopeIssueKind::MissingInclude)
-    );
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&missing),
-        Action::Definition,
-    );
-    assert_eq!(result.disposition, Disposition::NoDefinition);
-    assert!(result.definitions.is_empty());
-    assert!(
-        result.scope.partial(),
-        "zero means no loaded definition, not no project definition"
-    );
-    assert!(snapshot.file(2).is_none());
-}
-
-#[test]
-fn detached_alias_and_identity_collisions_never_auto_select() {
-    let accepted = Fixture::standard();
-    for (alias, id) in [
-        ("pump", "00000000-0000-0000-0000-000000000099"),
-        ("other", PUMP),
-    ] {
-        let mut loaded = accepted.clone();
-        loaded.files.push((
-            "detached.arcadia".into(),
-            format!("oa_activity {alias} \"Detached\" id \"{id}\" {{}}"),
-        ));
-        let snapshot = loaded.snapshot(Some(&accepted), true, Limits::default());
-        assert!(snapshot.scope().validated);
-        assert_eq!(snapshot.scope().detached_files, 1);
-        let result = query(
-            &snapshot,
-            "links.arcadia",
-            reference_offset(&loaded),
-            Action::Definition,
-        );
-        assert_eq!(result.disposition, Disposition::Choices);
-        if alias == "pump" {
-            assert_eq!(result.total_definitions, 2);
-            assert!(result.definitions.iter().any(
-                |row| row.membership == Membership::Detached && row.evidence == Evidence::Draft
-            ));
-        } else {
-            assert_eq!(result.total_definitions, 1);
-            assert_eq!(
-                result.definitions[0].declaration.identity,
-                Identity::Collision { count: 2 }
-            );
-        }
-    }
-}
-
-#[test]
-fn sole_detached_candidate_and_unapplied_equal_bytes_require_choice() {
-    let accepted = Fixture::standard();
-    let mut detached = accepted.clone();
-    *detached.text_mut("project.arcadia") = detached
-        .text("project.arcadia")
-        .replace(" include \"模块/活動.arcadia\";\r\n", "");
-    let snapshot = detached.snapshot(None, true, Limits::default());
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&detached),
-        Action::Definition,
-    );
-    assert_eq!(result.disposition, Disposition::Choices);
-    assert_eq!(result.definitions[0].membership, Membership::Detached);
-    let unapplied = accepted.snapshot(Some(&accepted), false, Limits::default());
-    assert!(unapplied.scope().closure_complete && unapplied.scope().partial());
-    assert!(!unapplied.scope().validated);
-    assert_eq!(
-        query(
-            &unapplied,
-            "links.arcadia",
-            reference_offset(&accepted),
-            Action::Definition
-        )
-        .disposition,
-        Disposition::Choices
-    );
-}
-
-#[test]
-fn include_cycle_depth_and_aggregate_edges_are_explicit_partial_outcomes() {
-    let mut fixture = Fixture::standard();
-    fixture
-        .text_mut("模块/活動.arcadia")
-        .push_str("include \"../project.arcadia\";\r\n");
-    let cycle = fixture.snapshot(None, true, Limits::default());
-    assert!(
-        cycle
-            .scope()
-            .issues
-            .iter()
-            .any(|issue| issue.kind == ScopeIssueKind::IncludeCycle)
-    );
-    let fixture = Fixture::standard();
-    for (depth, edges, expected) in [
-        (0, 1024, ScopeIssueKind::IncludeDepth),
-        (32, 1, ScopeIssueKind::IncludeBudget),
-    ] {
-        let snapshot = fixture.snapshot(
-            None,
-            true,
-            Limits {
-                include_depth: depth,
-                include_edges: edges,
-                ..Limits::default()
-            },
-        );
-        assert!(snapshot.scope().partial());
-        assert!(
-            snapshot
-                .scope()
-                .issues
-                .iter()
-                .any(|issue| issue.kind == expected)
-        );
-        assert_eq!(
-            query(
-                &snapshot,
-                "links.arcadia",
-                reference_offset(&fixture),
-                Action::Definition
-            )
-            .disposition,
-            Disposition::Choices
-        );
-    }
-}
-
-#[test]
-fn exact_snapshot_readback_rejects_same_key_byte_membership_and_evidence_changes() {
-    let fixture = Fixture::standard();
-    let files = fixture.borrowed();
-    let validation = Some(ValidatedSources {
-        entry: &fixture.entry,
-        files: &files,
-    });
-    let input = Input {
-        key: key(1),
-        entry: &fixture.entry,
-        files: &files,
-        applied: true,
-        validation,
-    };
-    let snapshot = capture(input, Limits::default()).unwrap();
-    assert!(snapshot.matches(input));
-    assert!(!snapshot.matches(Input {
-        key: key(2),
-        ..input
-    }));
-    assert!(!snapshot.matches(Input {
-        validation: None,
-        ..input
-    }));
-    assert!(!snapshot.matches(Input {
-        applied: false,
-        ..input
-    }));
-    let mut reversed = files.clone();
-    reversed.reverse();
-    assert!(snapshot.matches(Input {
-        files: &reversed,
-        ..input
-    }));
-    let mut changed = fixture.clone();
-    changed.text_mut("links.arcadia").push(' ');
-    let altered = changed.borrowed();
-    assert!(!snapshot.matches(Input {
-        files: &altered,
-        ..input
-    }));
-    let missing = &files[..files.len() - 1];
-    assert!(!snapshot.matches(Input {
-        files: missing,
-        ..input
-    }));
-    let duplicated = [files[0], files[0], files[2]];
-    assert!(!snapshot.matches(Input {
-        files: &duplicated,
-        ..input
-    }));
-    assert_eq!(
-        snapshot.query(Query {
-            stamp: QueryStamp {
-                snapshot: key(2),
-                serial: 37
-            },
-            path: "links.arcadia",
-            byte_offset: 0,
-            action: Action::Definition
-        }),
-        Err(QueryError::Query(symbols::QueryError::StaleSnapshot))
-    );
-}
-
-#[test]
-fn omitted_rows_are_counted_before_result_allocation_and_never_confer_uniqueness() {
-    let fixture = Fixture::standard();
-    let snapshot = fixture.snapshot(
-        Some(&fixture),
-        true,
-        Limits {
-            result_rows: 2,
-            ..Limits::default()
-        },
-    );
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&fixture),
-        Action::References,
-    );
-    assert_eq!((result.total_definitions, result.total_references), (1, 2));
-    assert_eq!(
-        (
-            result.definitions.len(),
-            result.references.len(),
-            result.omitted_references
-        ),
-        (1, 1, 1)
-    );
-    let zero = fixture.snapshot(
-        Some(&fixture),
-        true,
-        Limits {
-            result_rows: 0,
-            ..Limits::default()
-        },
-    );
-    let result = query(
-        &zero,
-        "links.arcadia",
-        reference_offset(&fixture),
-        Action::Definition,
-    );
-    assert_eq!(
-        (
-            result.definitions.len(),
-            result.total_definitions,
-            result.omitted_definitions
-        ),
-        (0, 1, 1)
-    );
-    assert_eq!(result.disposition, Disposition::Choices);
-    let envelope = fixture.snapshot(
-        Some(&fixture),
-        true,
-        Limits {
-            result_bytes: 0,
-            ..Limits::default()
-        },
-    );
-    assert_eq!(
-        envelope.query(Query {
-            stamp: QueryStamp {
-                snapshot: key(1),
-                serial: 1
-            },
-            path: "links.arcadia",
-            byte_offset: reference_offset(&fixture),
-            action: Action::Definition
-        }),
-        Err(QueryError::ResultEnvelopeLimit)
-    );
-}
-
-#[test]
-fn large_display_name_cannot_escape_the_owned_row_string_budget() {
-    let mut fixture = Fixture::standard();
-    *fixture.text_mut("模块/活動.arcadia") = fixture
-        .text("模块/活動.arcadia")
-        .replace("泵 🚀", &"長".repeat(8192));
-    let original = fixture.files.clone();
-    let snapshot = fixture.snapshot(
-        None,
-        true,
-        Limits {
-            result_bytes: 64,
-            ..Limits::default()
-        },
-    );
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&fixture),
-        Action::Definition,
-    );
-    assert_eq!(
-        (result.total_definitions, result.omitted_definitions),
-        (1, 1)
-    );
-    assert!(result.definitions.is_empty());
-    assert_eq!(result.disposition, Disposition::Choices);
-    assert_eq!(fixture.files, original);
-}
-
-#[test]
-fn validation_witness_must_match_entry_and_complete_included_file_set() {
-    let fixture = Fixture::standard();
-    for mutation in 0..3 {
-        let mut witness = fixture.clone();
-        match mutation {
-            0 => witness.entry = "other.arcadia".into(),
-            1 => {
-                witness.files.pop();
-            }
-            _ => witness.files.push(("unused.arcadia".into(), String::new())),
-        }
-        let snapshot = fixture.snapshot(Some(&witness), true, Limits::default());
-        assert!(snapshot.scope().closure_complete);
-        assert!(!snapshot.scope().validated);
-        assert_eq!(
-            query(
-                &snapshot,
-                "links.arcadia",
-                reference_offset(&fixture),
-                Action::Definition
-            )
-            .disposition,
-            Disposition::Choices
-        );
-    }
-}
-
-#[test]
-fn raw_aggregate_limits_refuse_before_outline_or_copied_snapshot() {
-    // Token budget zero and malformed paths/text would fail later. Raw byte/path
-    // limits must win, including a large second file; no partial Snapshot exists.
-    let large = "not a model \0".repeat(16_384);
-    let files = [
-        DraftFile {
-            path: "../bad.arcadia",
-            text: "?",
-        },
-        DraftFile {
-            path: "large.arcadia",
-            text: &large,
-        },
-    ];
-    let input = Input {
-        key: key(1),
-        entry: "project.arcadia",
-        files: &files,
-        applied: true,
-        validation: None,
-    };
-    for (resource, files_limit, bytes_limit, paths_limit) in [
-        (symbols::Resource::Files, 1, usize::MAX, usize::MAX),
-        (symbols::Resource::SourceBytes, 8, 1, usize::MAX),
-        (symbols::Resource::PathBytes, 8, usize::MAX, 1),
-    ] {
-        let limits = Limits {
-            index: symbols::Limits {
-                files: files_limit,
-                source_bytes: bytes_limit,
-                path_bytes: paths_limit,
-                tokens: 0,
-                records: 0,
-            },
-            ..Limits::default()
-        };
-        assert!(
-            matches!(capture(input, limits), Err(AdmissionError::Index(symbols::BuildError::Limit { resource: actual, .. })) if actual == resource)
-        );
-    }
-    assert_eq!(files[1].text, large);
-}
-
-#[test]
-fn token_declaration_and_live_reference_limits_are_aggregate_not_per_file() {
-    let files = [
-        DraftFile {
-            path: "a.arcadia",
-            text: "oa_activity a \"A\" {}",
-        },
-        DraftFile {
-            path: "b.arcadia",
-            text: "oa_activity b \"B\" {}",
-        },
-    ];
-    let input = Input {
-        key: key(1),
-        entry: "a.arcadia",
-        files: &files,
-        applied: false,
-        validation: None,
-    };
-    let limits = Limits {
-        index: symbols::Limits {
-            tokens: 10,
-            ..Limits::default().index
-        },
-        ..Limits::default()
-    };
-    assert!(matches!(
-        capture(input, limits),
-        Err(AdmissionError::Outline {
-            file: 1,
-            error: language::OutlineLimit {
-                resource: language::OutlineResource::Tokens,
-                ..
-            }
-        })
-    ));
-    let limits = Limits {
-        index: symbols::Limits {
-            records: 1,
-            ..Limits::default().index
-        },
-        ..Limits::default()
-    };
-    assert!(matches!(
-        capture(input, limits),
-        Err(AdmissionError::Outline {
-            file: 1,
-            error: language::OutlineLimit {
-                resource: language::OutlineResource::Declarations,
-                ..
-            }
-        })
-    ));
-    let use_files = [
-        files[0],
-        DraftFile {
-            path: "uses.arcadia",
-            text: "source @a; target @a; // @a ignored\n",
-        },
-    ];
-    let limits = Limits {
-        index: symbols::Limits {
-            records: 2,
-            ..Limits::default().index
-        },
-        ..Limits::default()
-    };
-    assert!(matches!(
-        capture(
-            Input {
-                files: &use_files,
-                ..input
-            },
-            limits
-        ),
-        Err(AdmissionError::Index(symbols::BuildError::Limit {
-            resource: symbols::Resource::Records,
-            observed_at_least: 3,
-            ..
-        }))
-    ));
-}
-
-#[test]
-fn missing_and_noncanonical_authored_ids_remain_draft_spans_without_generated_anchors() {
-    let fixture = Fixture::standard();
-    for replacement in [
-        String::new(),
-        " id \"00000000000000000000000000000002\"".into(),
-    ] {
-        let mut draft = fixture.clone();
-        let original_id = format!(" id \"{PUMP}\"");
-        *draft.text_mut("模块/活動.arcadia") = draft
-            .text("模块/活動.arcadia")
-            .replace(&original_id, &replacement);
-        draft
-            .text_mut("模块/活動.arcadia")
-            .push_str(&format!("// Historical UUID {PUMP} and @pump\r\n"));
-        let before = draft.files.clone();
-        let snapshot = draft.snapshot(None, false, Limits::default());
-        let result = query(
-            &snapshot,
-            "links.arcadia",
-            reference_offset(&draft),
-            Action::Definition,
-        );
-        assert_eq!(result.definitions[0].declaration.authored_id, None);
-        assert_eq!(
-            result.definitions[0].declaration.identity,
-            Identity::Missing
-        );
-        assert_eq!(result.disposition, Disposition::Choices);
-        assert_eq!(draft.files, before);
-        assert_eq!(
-            snapshot.file(1).unwrap().text,
-            draft.text("模块/活動.arcadia")
-        );
-    }
-}
-
-#[test]
-fn keyword_alias_and_loaded_path_case_collisions_use_reviewed_index_rules() {
-    let mut fixture = Fixture::standard();
-    for (_, text) in &mut fixture.files {
-        *text = text.replace("pump", "source");
-    }
-    let snapshot = fixture.snapshot(None, true, Limits::default());
-    let result = query(
-        &snapshot,
-        "links.arcadia",
-        reference_offset(&fixture),
-        Action::Definition,
-    );
-    assert_eq!(result.alias.as_deref(), Some("source"));
-    assert_eq!(result.total_definitions, 1);
-    fixture.files.push(("LINKS.arcadia".into(), String::new()));
-    let files = fixture.borrowed();
-    assert!(matches!(
-        capture(
-            Input {
-                key: key(1),
-                entry: &fixture.entry,
-                files: &files,
-                applied: true,
-                validation: None
-            },
-            Limits::default()
-        ),
-        Err(AdmissionError::Index(symbols::BuildError::Input {
-            problem: symbols::InputProblem::DuplicateOrCaseCollidingPath,
-            ..
-        }))
-    ));
-}
-
-#[test]
-fn owned_request_moves_exact_text_into_worker_snapshot_and_matches_sync_results() {
-    let fixture = Fixture::standard();
-    let files = fixture.borrowed();
-    let input = Input {
-        key: key(1),
-        entry: &fixture.entry,
-        files: &files,
-        applied: true,
-        validation: Some(ValidatedSources {
-            entry: &fixture.entry,
-            files: &files,
-        }),
-    };
-    let owned = admit_owned(input, Limits::default()).unwrap();
-    let allocations: Vec<_> = owned.files.iter().map(|file| file.text.as_ptr()).collect();
-    let snapshot = owned.capture().unwrap();
-    for (file, allocation) in allocations.iter().enumerate() {
-        assert_eq!(
-            snapshot.file(file).unwrap().text.as_ptr(),
-            *allocation,
-            "worker moves the one current-text copy"
-        );
-    }
-    assert!(snapshot.matches(input));
-    let synchronous = capture(input, Limits::default()).unwrap();
-    assert_eq!(
-        query(
-            &snapshot,
-            "links.arcadia",
-            reference_offset(&fixture),
-            Action::References
-        ),
-        query(
-            &synchronous,
-            "links.arcadia",
-            reference_offset(&fixture),
-            Action::References
-        )
-    );
-    let mut edited = fixture.clone();
-    edited
-        .text_mut("links.arcadia")
-        .push_str("// edited after request\r\n");
-    let changed = edited.borrowed();
-    assert!(!snapshot.matches(Input {
-        files: &changed,
-        ..input
-    }));
-    assert!(!snapshot.matches(Input {
-        validation: None,
-        ..input
-    }));
-}
-
-#[test]
-fn owned_request_checks_raw_limits_immediately_and_extracts_only_on_worker() {
-    let fixture = Fixture::standard();
-    let files = fixture.borrowed();
-    let input = Input {
-        key: key(1),
-        entry: &fixture.entry,
-        files: &files,
-        applied: true,
-        validation: None,
-    };
-    let no_tokens = Limits {
-        index: symbols::Limits {
-            tokens: 0,
-            ..Limits::default().index
-        },
-        ..Limits::default()
-    };
-    let owned = admit_owned(input, no_tokens).expect("request admission does not lex or parse");
-    assert!(matches!(
-        owned.capture(),
-        Err(AdmissionError::Outline {
-            file: 0,
-            error: language::OutlineLimit {
-                resource: language::OutlineResource::Tokens,
-                ..
-            }
-        })
-    ));
-    let no_bytes = Limits {
-        index: symbols::Limits {
-            source_bytes: 1,
-            ..Limits::default().index
-        },
-        ..Limits::default()
-    };
-    assert!(matches!(
-        admit_owned(input, no_bytes),
-        Err(AdmissionError::Index(symbols::BuildError::Limit {
-            resource: symbols::Resource::SourceBytes,
-            ..
-        }))
-    ));
-    assert_eq!(files[1].text, fixture.text("模块/活動.arcadia"));
-}
-
-#[test]
-fn owned_validation_proof_preserves_full_witness_count_and_partial_scope() {
-    let accepted = Fixture::standard();
-    for missing_include in [false, true] {
-        let mut current = accepted.clone();
-        current
-            .files
-            .retain(|(path, _)| path != "模块/活動.arcadia");
-        if !missing_include {
-            *current.text_mut("project.arcadia") = current
-                .text("project.arcadia")
-                .replace(" include \"模块/活動.arcadia\";\r\n", "");
-        }
-        let files = current.borrowed();
-        let old = accepted.borrowed();
-        let input = Input {
-            key: key(1),
-            entry: &current.entry,
-            files: &files,
-            applied: true,
-            validation: Some(ValidatedSources {
-                entry: &accepted.entry,
-                files: &old,
-            }),
-        };
-        let snapshot = admit_owned(input, Limits::default())
-            .unwrap()
-            .capture()
-            .unwrap();
-        assert_eq!(snapshot.scope().closure_complete, !missing_include);
-        assert!(
-            !snapshot.scope().validated,
-            "the old witness is not silently reduced to matching loaded files"
-        );
-        let result = query(
-            &snapshot,
-            "links.arcadia",
-            reference_offset(&current),
-            Action::Definition,
-        );
-        assert_eq!(result.disposition, Disposition::NoDefinition);
-        assert!(snapshot.matches(input));
-    }
-}
@@ -1,7 +1,7 @@
 //! Per-file drafts and navigation. Accepted model/source history lives in Document.
 use iced::widget::text_editor::Cursor;
 use oa_core::{
-    Id, language,
+    language,
    source_project::{self, CompiledSourceProject, ProjectLimits, SourceBundle, SourceDiagnostic},
 };
 use std::collections::{BTreeMap, BTreeSet};
@@ -86,7 +86,6 @@ pub struct Buffer {
    pub cursor: Cursor,
    past: Vec<String>,
    future: Vec<String>,
-    generation: u64,
 }

 impl Buffer {
@@ -100,20 +99,14 @@ impl Buffer {
            },
            past: Vec::new(),
            future: Vec::new(),
-            generation: 0,
        }
    }
    pub fn dirty(&self) -> bool {
        self.text != self.baseline
    }
-    pub fn generation(&self) -> u64 {
-        self.generation
-    }
 }

 pub struct Workspace {
-    session: Id,
-    revision: u64,
    pub entry: String,
    pub active: String,
    pub files: BTreeMap<String, Buffer>,
@@ -124,35 +117,6 @@ pub struct Workspace {
 }

 impl Workspace {
-    /// Ephemeral editor identity, never a model identity or recovery payload.
-    pub fn session(&self) -> Id {
-        self.session
-    }
-    pub fn revision(&self) -> u64 {
-        self.revision
-    }
-    fn advance(&mut self) -> u64 {
-        if let Some(revision) = self.revision.checked_add(1) {
-            self.revision = revision;
-        } else {
-            self.reset_navigation_session();
-        }
-        self.revision
-    }
-    /// A changed filesystem root must not reuse queued navigation from Save As.
-    pub fn reset_navigation_session(&mut self) {
-        self.session = Id::new_v4();
-        self.revision = 0;
-        for buffer in self.files.values_mut() {
-            buffer.generation = 0;
-        }
-    }
-    pub fn set_reachable(&mut self, reachable: BTreeSet<String>) {
-        if self.reachable != reachable {
-            self.advance();
-            self.reachable = reachable;
-        }
-    }
    pub fn recovery_snapshot(&self) -> RecoveryWorkspace {
        RecoveryWorkspace {
            entry: self.entry.clone(),
@@ -172,8 +136,6 @@ impl Workspace {
    pub fn from_recovery(saved: RecoveryWorkspace) -> Result<Self, String> {
        saved.validate()?;
        Ok(Self {
-            session: Id::new_v4(),
-            revision: 0,
            entry: saved.entry,
            active: saved.active,
            files: saved
@@ -192,8 +154,6 @@ impl Workspace {
    }
    pub fn new(bundle: &SourceBundle, applied: bool) -> Self {
        Self {
-            session: Id::new_v4(),
-            revision: 0,
            entry: bundle.entry.clone(),
            active: bundle.entry.clone(),
            files: bundle
@@ -231,20 +191,11 @@ impl Workspace {
        }
    }
    pub fn edit(&mut self, text: String, cursor: Cursor) {
-        let changed = self.files.get(&self.active).is_none_or(|b| b.text != text);
-        let generation = if changed {
-            self.advance()
-        } else {
-            self.revision
-        };
        let buffer = self
            .files
            .entry(self.active.clone())
            .or_insert_with(|| Buffer::new(String::new()));
        buffer.cursor = cursor;
-        if changed {
-            buffer.generation = generation;
-        }
        if text != buffer.text {
            buffer.past.push(std::mem::replace(&mut buffer.text, text));
            if buffer.past.len() > 100 {
@@ -317,8 +268,6 @@ impl Workspace {
        } else {
            buffer.future.push(previous);
        }
-        let generation = self.advance();
-        self.files.get_mut(&self.active).unwrap().generation = generation;
        self.trim_history(DRAFT_HISTORY_BYTES);
        true
    }
@@ -332,7 +281,6 @@ impl Workspace {
        }
    }
    pub fn accept(&mut self, bundle: &SourceBundle) {
-        let generation = self.advance();
        if self.entry != bundle.entry
            && !bundle.files.contains_key(&self.entry)
            && self.files.get(&self.entry).is_some_and(|b| !b.dirty())
@@ -343,13 +291,7 @@ impl Workspace {
        self.reachable = bundle.files.keys().cloned().collect();
        for (path, text) in &bundle.files {
            let cursor = self.files.get(path).map(|b| b.cursor);
-            let previous_generation = self
-                .files
-                .get(path)
-                .filter(|b| b.text == *text)
-                .map(|b| b.generation);
            let mut buffer = Buffer::new(text.clone());
-            buffer.generation = previous_generation.unwrap_or(generation);
            if let Some(cursor) = cursor {
                buffer.cursor = cursor;
            }
@@ -361,22 +303,10 @@ impl Workspace {
        self.applied = true;
    }
    pub fn discovered(&mut self, bundle: &SourceBundle, reachable: BTreeSet<String>) {
-        let changed = self.reachable != reachable
-            || bundle
-                .files
-                .keys()
-                .any(|path| !self.files.contains_key(path));
-        let generation = if changed {
-            self.advance()
-        } else {
-            self.revision
-        };
        for (path, text) in &bundle.files {
-            self.files.entry(path.clone()).or_insert_with(|| {
-                let mut buffer = Buffer::new(text.clone());
-                buffer.generation = generation;
-                buffer
-            });
+            self.files
+                .entry(path.clone())
+                .or_insert_with(|| Buffer::new(text.clone()));
        }
        self.reachable = reachable;
    }
@@ -384,7 +314,6 @@ impl Workspace {
        if self.reachable.contains(path) || self.files.get(path).is_none_or(Buffer::dirty) {
            return false;
        }
-        self.advance();
        self.files.remove(path);
        if self.active == path {
            self.active = self.entry.clone();
@@ -447,148 +376,6 @@ pub fn lint(bundle: &SourceBundle) -> Vec<SourceDiagnostic> {
 mod tests {
    use super::*;
    use oa_core::Project;
-
-    #[test]
-    fn fresh_session_cannot_reuse_a_retained_buffer_generation() {
-        let bundle = SourceBundle {
-            entry: "main.arcadia".into(),
-            files: BTreeMap::from([
-                ("main.arcadia".into(), "first".into()),
-                ("other.arcadia".into(), "other".into()),
-            ]),
-        };
-        let mut workspace = Workspace::new(&bundle, true);
-        let cursor = workspace.files["main.arcadia"].cursor;
-        workspace.edit("second".into(), cursor);
-        workspace.reset_navigation_session();
-        let before = workspace.files["main.arcadia"].generation();
-        workspace.edit("third".into(), cursor);
-        assert_ne!(workspace.files["main.arcadia"].generation(), before);
-        workspace.switch("other.arcadia", cursor);
-        workspace.revision = u64::MAX;
-        workspace.edit("changed other".into(), cursor);
-        let after_wrap = workspace.files["main.arcadia"].generation();
-        workspace.switch("main.arcadia", cursor);
-        workspace.edit("fourth".into(), cursor);
-        assert_ne!(workspace.files["main.arcadia"].generation(), after_wrap);
-        assert!(workspace.undo(false));
-        assert_eq!(workspace.text(), "third");
-    }
-
-    #[test]
-    fn navigation_versions_distinguish_reopened_recovered_and_changed_drafts() {
-        let bundle = SourceBundle {
-            entry: "project.arcadia".into(),
-            files: BTreeMap::from([
-                ("project.arcadia".into(), "entry\r\n".into()),
-                ("part.arcadia".into(), "雨 draft\r\n".into()),
-            ]),
-        };
-        let mut workspace = Workspace::new(&bundle, true);
-        let reopened = Workspace::new(&bundle, true);
-        let recovered = Workspace::from_recovery(workspace.recovery_snapshot()).unwrap();
-        assert_ne!(workspace.session(), reopened.session());
-        assert_ne!(workspace.session(), recovered.session());
-        assert_eq!(workspace.bundle(), recovered.bundle());
-        let saved = serde_json::to_value(workspace.recovery_snapshot()).unwrap();
-        assert!(saved.get("session").is_none() && saved.get("revision").is_none());
-
-        let cursor = Cursor {
-            position: iced::widget::text_editor::Position { line: 0, column: 3 },
-            selection: None,
-        };
-        let revision = workspace.revision();
-        workspace.edit(workspace.text().into(), cursor);
-        assert_eq!(
-            workspace.revision(),
-            revision,
-            "selection is not a text change"
-        );
-        workspace.switch("part.arcadia", cursor);
-        assert_eq!(
-            workspace.revision(),
-            revision,
-            "switching retains the snapshot"
-        );
-        let untouched = workspace.files["project.arcadia"].generation();
-        workspace.edit("雨 unfinished !\r\n".into(), cursor);
-        let edited = workspace.files["part.arcadia"].generation();
-        assert!(workspace.revision() > revision);
-        assert_eq!(workspace.files["project.arcadia"].generation(), untouched);
-        assert!(workspace.undo(false));
-        assert_eq!(workspace.bundle(), bundle);
-        assert!(workspace.files["part.arcadia"].generation() > edited);
-        assert!(workspace.undo(true));
-        assert_eq!(workspace.text(), "雨 unfinished !\r\n");
-        let previous_session = workspace.session();
-        let previous_text = workspace.bundle();
-        workspace.reset_navigation_session();
-        assert_ne!(workspace.session(), previous_session);
-        assert_eq!(workspace.bundle(), previous_text);
-        assert!(
-            workspace.undo(false),
-            "session reset preserves text history"
-        );
-    }
-
-    #[test]
-    fn navigation_scope_changes_invalidate_without_changing_unchanged_positions() {
-        let bundle = SourceBundle {
-            entry: "project.arcadia".into(),
-            files: BTreeMap::from([
-                ("project.arcadia".into(), "entry".into()),
-                ("part.arcadia".into(), "part".into()),
-            ]),
-        };
-        let mut workspace = Workspace::new(&bundle, true);
-        let entry_generation = workspace.files[&bundle.entry].generation();
-        let initial_revision = workspace.revision();
-        workspace.set_reachable(BTreeSet::from([bundle.entry.clone()]));
-        assert!(workspace.revision() > initial_revision);
-        let membership_revision = workspace.revision();
-        workspace.set_reachable(workspace.reachable.clone());
-        assert_eq!(workspace.revision(), membership_revision);
-        assert!(workspace.discard_detached("part.arcadia"));
-        assert!(workspace.revision() > membership_revision);
-        let closed_revision = workspace.revision();
-        workspace.discovered(&bundle, BTreeSet::from([bundle.entry.clone()]));
-        assert!(workspace.revision() > closed_revision);
-        assert_eq!(
-            workspace.files[&bundle.entry].generation(),
-            entry_generation
-        );
-        assert!(workspace.files["part.arcadia"].generation() > closed_revision);
-        let discovered_revision = workspace.revision();
-        workspace.discovered(&bundle, workspace.reachable.clone());
-        assert_eq!(workspace.revision(), discovered_revision);
-        workspace.accept(&bundle);
-        assert!(
-            workspace.revision() > discovered_revision,
-            "validation evidence changed"
-        );
-        assert_eq!(
-            workspace.files[&bundle.entry].generation(),
-            entry_generation
-        );
-        assert_eq!(workspace.bundle(), bundle);
-    }
-
-    #[test]
-    fn navigation_revision_wrap_cannot_reuse_an_old_workspace_key() {
-        let bundle = SourceBundle {
-            entry: "project.arcadia".into(),
-            files: BTreeMap::from([("project.arcadia".into(), "original".into())]),
-        };
-        let mut workspace = Workspace::new(&bundle, true);
-        workspace.revision = u64::MAX;
-        let before = workspace.session();
-        let cursor = workspace.files[&bundle.entry].cursor;
-        workspace.edit("changed".into(), cursor);
-        assert_ne!(workspace.session(), before);
-        assert_eq!(workspace.revision(), 0);
-        assert!(workspace.undo(false));
-        assert_eq!(workspace.bundle(), bundle);
-    }
    #[test]
    fn draft_history_budget_covers_inactive_files_without_discarding_drafts() {
        let bundle = SourceBundle {
@@ -377,8 +377,7 @@ fn source_navigation_waits_for_editor_layout_and_cancels_on_edit() {
    send(&mut app, Message::SourceForSelection);
    assert_eq!(app.page, Page::Text);
    assert!(app.source_jump.is_some());
-    let ticket = app.source_reveal_ticket();
-    send(&mut app, Message::SourceViewport(ticket));
+    send(&mut app, Message::SourceViewport);
    assert!(app.source_jump.is_none());
    send(&mut app, Message::SourceForSelection);
    assert!(app.source_jump.is_some());
@@ -410,8 +409,7 @@ fn source_find_navigates_an_invalid_draft_without_applying_or_losing_it() {
        cursor.selection,
        Some(text_editor::Position { line: 0, column: 9 })
    );
-    let ticket = app.source_reveal_ticket();
-    send(&mut app, Message::SourceViewport(ticket));
+    send(&mut app, Message::SourceViewport);
    assert_eq!(app.source_editor.cursor(), cursor);
    send(
        &mut app,
@@ -1,4 +1,3 @@
-mod source_symbols;
 pub(crate) mod traceability;
 use crate::{
    app::{App, Choice, FileOperation, Message, Page, Pending},
@@ -1020,7 +1019,7 @@ fn source(app: &App) -> View<'_, Message> {
                ),
                action("Next", Message::SourceNavigation(SourceEvent::Next(false))),
                label(app.source_navigation.label()),
-                action("Close", app.source_find_close_message()),
+                action("Close", Message::SourceNavigation(SourceEvent::Close)),
            ]
            .spacing(6)
            .align_y(iced::Center),
@@ -1114,12 +1113,8 @@ fn source(app: &App) -> View<'_, Message> {
        }
    }
    let editor = widget::text_editor(&app.source_editor)
-        .id(app.source_editor_id())
+        .id("source-editor")
        .on_action(Message::SourceEdit)
-        .key_binding({
-            let context = app.source_symbol_context();
-            move |press| source_binding(press, &context)
-        })
        .font(Font::MONOSPACE)
        .size(14)
        .padding(16)
@@ -1128,7 +1123,8 @@ fn source(app: &App) -> View<'_, Message> {
            app.source_snapshot.clone(),
            crate::highlight::format,
        );
-    let header = container(
+    column![
+        container(
            column![
                row![
                    container(heading(
@@ -1171,500 +1167,17 @@ fn source(app: &App) -> View<'_, Message> {
                    "Undo text affects this file's draft. Model Undo restores accepted files together (100 changes / about 32 MiB)."
                }),
                navigation,
-                row![
-                    action("Definition · F12", app.source_symbol_message(crate::source_navigation::SymbolEvent::Query(crate::source_navigation::query::Action::Definition))),
-                    action("References · Shift F12", app.source_symbol_message(crate::source_navigation::SymbolEvent::Query(crate::source_navigation::query::Action::References))),
-                    button(text("Back · Alt ←").size(12)).padding([8, 10]).style(style::nav)
-                        .on_press_maybe((app.source_symbols.back.iter().any(|entry| entry.session == app.source_workspace.session())).then(|| app.source_symbol_message(crate::source_navigation::SymbolEvent::Back))),
-                ].spacing(7),
                scrollable(diagnostics)
                    .height((visible_diagnostics as f32 * 32.).min(132.))
            ]
            .spacing(12)
        )
-        .padding(18);
-    let editor = widget::sensor(editor)
-        .key((
-            app.source_workspace.active.clone(),
-            app.source_reveal_ticket(),
-        ))
-        .on_show({
-            let ticket = app.source_reveal_ticket();
-            move |_| Message::SourceViewport(ticket)
-        })
-        .on_resize({
-            let ticket = app.source_reveal_ticket();
-            move |_| Message::SourceViewport(ticket)
-        });
-    let workspace: View<'_, Message> = if app.source_symbols.open {
-        row![
-            container(editor).width(Fill).height(Fill),
-            container(scrollable(source_symbols::panel(app)))
-                .width(300)
-                .height(Fill),
-        ]
-        .height(Fill)
-        .into()
-    } else {
-        container(editor).width(Fill).height(Fill).into()
-    };
-    source_layout(header.into(), workspace, app.window_size.height)
-}
-
-fn source_layout<'a, Renderer: iced::advanced::text::Renderer + 'a>(
-    header: View<'a, Message, iced::Theme, Renderer>,
-    workspace: View<'a, Message, iced::Theme, Renderer>,
-    window_height: f32,
-) -> View<'a, Message, iced::Theme, Renderer> {
-    // Lint clears and repopulates diagnostics asynchronously. Reserve the same
-    // outer slot so a pointer aimed at the editor cannot land in the header.
-    column![
-        container(scrollable(header).id("source-header")).height((window_height * 0.42).max(180.)),
-        workspace,
+        .padding(18),
+        widget::sensor(editor).key((app.source_workspace.active.clone(),app.source_jump))
+            .on_show(|_| Message::SourceViewport).on_resize(|_| Message::SourceViewport)
    ]
-    .height(Fill)
    .into()
 }
-fn source_binding(
-    press: widget::text_editor::KeyPress,
-    context: &crate::source_navigation::SymbolContext,
-) -> Option<widget::text_editor::Binding<Message>> {
-    use crate::source_navigation::{SymbolEvent, query::Action};
-    use iced::keyboard::{Key, key::Named};
-    use widget::text_editor::{Binding, Status};
-    // Windows owns Alt+Space for its window menu. Iced's default binding would
-    // otherwise insert a supplied space payload, even after that menu closes.
-    // Keep Ctrl+Alt (AltGr), shifted input, and ordinary Space unchanged.
-    #[cfg(target_os = "windows")]
-    if matches!(press.status, Status::Focused { .. })
-        && press.modifiers == iced::keyboard::Modifiers::ALT
-        && matches!(
-            press.key.as_ref(),
-            Key::Named(Named::Space) | Key::Character(" ")
-        )
-    {
-        return None;
-    }
-    if matches!(press.status, Status::Focused { .. })
-        && !press.modifiers.control()
-        && !press.modifiers.logo()
-    {
-        let event = match &press.key {
-            Key::Named(Named::F12) if !press.modifiers.alt() => {
-                Some(SymbolEvent::Query(if press.modifiers.shift() {
-                    Action::References
-                } else {
-                    Action::Definition
-                }))
-            }
-            Key::Named(Named::ArrowLeft) if press.modifiers.alt() && !press.modifiers.shift() => {
-                Some(SymbolEvent::Back)
-            }
-            _ => None,
-        };
-        if let Some(event) = event {
-            return Some(Binding::Custom(Message::SourceSymbols(
-                context.clone(),
-                event,
-            )));
-        }
-    }
-    Binding::from_key_press(press)
-}
-
-#[cfg(all(test, debug_assertions))]
-mod source_tests {
-    use super::*;
-    use iced::advanced::{
-        Layout, Shell, graphics, layout, renderer, text as shaped, widget as core_widget,
-    };
-    use iced::widget::column;
-    use iced::{Background, Color, Pixels, Point, Rectangle, Size, Transformation, Vector};
-
-    // Measure real Iced paragraphs/editor text without constructing a window or GPU.
-    struct FontLayout;
-    impl renderer::Renderer for FontLayout {
-        fn start_layer(&mut self, _: Rectangle) {}
-        fn end_layer(&mut self) {}
-        fn start_transformation(&mut self, _: Transformation) {}
-        fn end_transformation(&mut self) {}
-        fn reset(&mut self, _: Rectangle) {}
-        fn fill_quad(&mut self, _: renderer::Quad, _: impl Into<Background>) {}
-        fn allocate_image(
-            &mut self,
-            handle: &iced::advanced::image::Handle,
-            callback: impl FnOnce(
-                Result<iced::advanced::image::Allocation, iced::advanced::image::Error>,
-            ) + Send
-            + 'static,
-        ) {
-            renderer::Renderer::allocate_image(&mut (), handle, callback);
-        }
-    }
-    impl shaped::Renderer for FontLayout {
-        type Font = Font;
-        type Paragraph = graphics::text::Paragraph;
-        type Editor = graphics::text::Editor;
-        const ICON_FONT: Font = Font::DEFAULT;
-        const CHECKMARK_ICON: char = '0';
-        const ARROW_DOWN_ICON: char = '0';
-        const SCROLL_UP_ICON: char = '0';
-        const SCROLL_DOWN_ICON: char = '0';
-        const SCROLL_LEFT_ICON: char = '0';
-        const SCROLL_RIGHT_ICON: char = '0';
-        const ICED_LOGO: char = '0';
-        fn default_font(&self) -> Font {
-            Font::DEFAULT
-        }
-        fn default_size(&self) -> Pixels {
-            Pixels(16.)
-        }
-        fn fill_paragraph(&mut self, _: &Self::Paragraph, _: Point, _: Color, _: Rectangle) {}
-        fn fill_editor(&mut self, _: &Self::Editor, _: Point, _: Color, _: Rectangle) {}
-        fn fill_text(&mut self, _: shaped::Text, _: Point, _: Color, _: Rectangle) {}
-    }
-
-    #[derive(Default)]
-    struct Geometry {
-        header: Option<(Rectangle, Rectangle, Vector)>,
-        editor: Option<Rectangle>,
-    }
-    impl core_widget::Operation for Geometry {
-        fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn core_widget::Operation)) {
-            visit(self);
-        }
-        fn container(&mut self, id: Option<&core_widget::Id>, bounds: Rectangle) {
-            if id == Some(&core_widget::Id::new("test-source-editor")) {
-                self.editor = Some(bounds);
-            }
-        }
-        fn scrollable(
-            &mut self,
-            id: Option<&core_widget::Id>,
-            bounds: Rectangle,
-            content: Rectangle,
-            offset: Vector,
-            _: &mut dyn core_widget::operation::Scrollable,
-        ) {
-            if id == Some(&core_widget::Id::new("source-header")) {
-                self.header = Some((bounds, content, offset));
-            }
-        }
-    }
-
-    fn mounted_source<'a>(
-        content: &'a widget::text_editor::Content<FontLayout>,
-        diagnostics: usize,
-        find: bool,
-        window_height: f32,
-    ) -> View<'a, Message, iced::Theme, FontLayout> {
-        let mut notices = column![].spacing(5);
-        for index in 0..diagnostics {
-            notices = notices.push(button(text(format!(
-                "救援/assess.arcadia:{}:5 · Warning: verify this participant's engineering allocation", index + 1,
-            )).size(12)).padding([4, 6]).width(Fill));
-        }
-        let find: View<'_, Message, iced::Theme, FontLayout> = if find {
-            column![
-                text_input("Find literal text", "assess").on_input(|s| Message::SourceNavigation(
-                    crate::source_navigation::Event::Query(s)
-                )),
-                text_input("Line", "1").on_input(|s| Message::SourceNavigation(
-                    crate::source_navigation::Event::Line(s)
-                )),
-            ]
-            .spacing(8)
-            .into()
-        } else {
-            Space::new().into()
-        };
-        let header = container(
-            column![
-                text("Textual model").size(24),
-                text("Edit the current file. Apply text validates the complete included model.")
-                    .size(11),
-                row![
-                    button(text("Apply text")),
-                    button(text("Undo text")),
-                    button(text("Model Undo"))
-                ]
-                .spacing(8),
-                text("救援/assess.arcadia · All files applied to the accepted model").size(11),
-                text("Undo text affects this draft. Model Undo restores accepted files together.")
-                    .size(11),
-                find,
-                row![
-                    button(text("Definition · F12")),
-                    button(text("References · Shift F12")),
-                    button(text("Back"))
-                ]
-                .spacing(7),
-                scrollable(notices).height((diagnostics as f32 * 32.).min(132.)),
-            ]
-            .spacing(12),
-        )
-        .padding(18);
-        let editor = container(
-            widget::text_editor(content)
-                .on_action(Message::SourceEdit)
-                .font(Font::MONOSPACE)
-                .size(14)
-                .padding(16)
-                .height(Fill),
-        )
-        .id("test-source-editor")
-        .height(Fill)
-        .width(Fill);
-        source_layout(header.into(), editor.into(), window_height)
-    }
-
-    #[test]
-    fn source_header_keeps_editor_bounds_stable_through_lint_and_find_rebuilds() {
-        for (host, window_height) in [
-            (Size::new(720., 540.), 700.),
-            (Size::new(1180., 890.), 1080.),
-        ] {
-            let content = widget::text_editor::Content::<FontLayout>::with_text(
-                "// is excluded\r\n// 雨\r\n",
-            );
-            let mut tree = core_widget::Tree::empty();
-            let mut baseline = None;
-            for (diagnostics, find) in [
-                (0, false),
-                (6, false),
-                (0, false),
-                (6, true),
-                (1, true),
-                (0, false),
-            ] {
-                let mut ui = mounted_source(&content, diagnostics, find, window_height);
-                tree.diff(ui.as_widget());
-                let node = ui.as_widget_mut().layout(
-                    &mut tree,
-                    &FontLayout,
-                    &layout::Limits::new(Size::ZERO, host),
-                );
-                let mut geometry = Geometry::default();
-                ui.as_widget_mut().operate(
-                    &mut tree,
-                    Layout::new(&node),
-                    &FontLayout,
-                    &mut geometry,
-                );
-                let editor = geometry.editor.unwrap();
-                let (header, _, _) = geometry.header.unwrap();
-                let slot = node.children()[0].bounds();
-                assert_eq!(slot.height, (window_height * 0.42).max(180.));
-                assert!(
-                    header.height <= slot.height,
-                    "short content may shrink inside the fixed slot"
-                );
-                assert!(
-                    editor.height >= 240.,
-                    "remaining editor must stay usable: {editor:?}"
-                );
-                assert_eq!(editor.y, slot.y + slot.height);
-                if let Some(expected) = baseline {
-                    assert_eq!(editor, expected, "diagnostics={diagnostics}, find={find}");
-                } else {
-                    baseline = Some(editor);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn source_header_remains_scrollable_and_preserves_offset_across_diagnostic_refresh() {
-        let content = widget::text_editor::Content::<FontLayout>::with_text("// 雨\r\n");
-        let host = Size::new(720., 540.);
-        let mut tree = core_widget::Tree::empty();
-        let mut saved = None;
-        for diagnostics in [6, 7] {
-            let mut ui = mounted_source(&content, diagnostics, true, 700.);
-            tree.diff(ui.as_widget());
-            let node = ui.as_widget_mut().layout(
-                &mut tree,
-                &FontLayout,
-                &layout::Limits::new(Size::ZERO, host),
-            );
-            let mut geometry = Geometry::default();
-            ui.as_widget_mut()
-                .operate(&mut tree, Layout::new(&node), &FontLayout, &mut geometry);
-            let (bounds, contents, _) = geometry.header.unwrap();
-            assert!(
-                contents.height > bounds.height,
-                "fixture must actually overflow"
-            );
-            if saved.is_none() {
-                let mut messages = Vec::new();
-                let mut shell = Shell::new(&mut messages);
-                ui.as_widget_mut().update(
-                    &mut tree,
-                    &iced::Event::Mouse(iced::mouse::Event::WheelScrolled {
-                        delta: iced::mouse::ScrollDelta::Pixels { x: 0., y: -45. },
-                    }),
-                    Layout::new(&node),
-                    iced::mouse::Cursor::Available(Point::new(bounds.x + 8., bounds.y + 8.)),
-                    &FontLayout,
-                    &mut iced::advanced::clipboard::Null,
-                    &mut shell,
-                    &Rectangle::with_size(host),
-                );
-                assert!(shell.is_event_captured());
-            }
-            let mut geometry = Geometry::default();
-            ui.as_widget_mut()
-                .operate(&mut tree, Layout::new(&node), &FontLayout, &mut geometry);
-            let offset = geometry.header.unwrap().2;
-            assert!(offset.y > 0., "the actual mounted Scrollable must move");
-            if let Some(before) = saved {
-                assert_eq!(offset, before);
-            } else {
-                saved = Some(offset);
-            }
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    #[test]
-    fn source_editor_windows_menu_payload_is_inert_but_space_and_altgr_still_edit() {
-        use core_widget::operation::Focusable;
-        use iced::keyboard::{
-            self, Key, Modifiers,
-            key::{Code, Named, Physical},
-        };
-        use widget::text_editor::{Binding, Content, KeyPress, State, Status};
-        let baseline = "// is excluded\r\n// 雨\r\n";
-        let context = crate::source_navigation::SymbolContext {
-            session: Id::new_v4(),
-            path: "救援/assess.arcadia".into(),
-        };
-        for (key, physical_key, modifiers, payload, inserted) in [
-            (
-                Key::Named(Named::Space),
-                Physical::Code(Code::Space),
-                Modifiers::ALT,
-                " ",
-                false,
-            ),
-            (
-                Key::Character(" ".into()),
-                Physical::Code(Code::Space),
-                Modifiers::ALT,
-                " ",
-                false,
-            ),
-            (
-                Key::Named(Named::Space),
-                Physical::Code(Code::Space),
-                Modifiers::empty(),
-                " ",
-                true,
-            ),
-            (
-                Key::Named(Named::Space),
-                Physical::Code(Code::Space),
-                Modifiers::CTRL | Modifiers::ALT,
-                " ",
-                true,
-            ),
-            (
-                Key::Character("e".into()),
-                Physical::Code(Code::KeyE),
-                Modifiers::CTRL | Modifiers::ALT,
-                "€",
-                true,
-            ),
-            (
-                Key::Named(Named::Space),
-                Physical::Code(Code::Space),
-                Modifiers::ALT | Modifiers::SHIFT,
-                " ",
-                true,
-            ),
-        ] {
-            let mut content = Content::<FontLayout>::with_text(baseline);
-            content.move_to(widget::text_editor::Cursor {
-                position: widget::text_editor::Position { line: 0, column: 5 },
-                selection: None,
-            });
-            let press = KeyPress {
-                key: key.clone(),
-                modified_key: key.clone(),
-                physical_key,
-                modifiers,
-                text: Some(payload.into()),
-                status: Status::Focused { is_hovered: false },
-            };
-            assert!(
-                matches!(
-                    Binding::<Message>::from_key_press(press),
-                    Some(Binding::Insert(_))
-                ),
-                "the supplied event must expose the default insertion path"
-            );
-            let mut messages = Vec::new();
-            {
-                let mut editor: View<'_, Message, iced::Theme, FontLayout> =
-                    widget::text_editor(&content)
-                        .on_action(Message::SourceEdit)
-                        .font(Font::MONOSPACE)
-                        .size(14)
-                        .padding(16)
-                        .height(Fill)
-                        .key_binding(|press| source_binding(press, &context))
-                        .into();
-                let mut tree = core_widget::Tree::new(editor.as_widget());
-                let size = Size::new(600., 240.);
-                let node = editor.as_widget_mut().layout(
-                    &mut tree,
-                    &FontLayout,
-                    &layout::Limits::new(Size::ZERO, size),
-                );
-                tree.state
-                    .downcast_mut::<State<shaped::highlighter::PlainText>>()
-                    .focus();
-                let event = iced::Event::Keyboard(keyboard::Event::KeyPressed {
-                    key: key.clone(),
-                    modified_key: key,
-                    physical_key,
-                    location: keyboard::Location::Standard,
-                    modifiers,
-                    text: Some(payload.into()),
-                    repeat: false,
-                });
-                let mut shell = Shell::new(&mut messages);
-                editor.as_widget_mut().update(
-                    &mut tree,
-                    &event,
-                    Layout::new(&node),
-                    iced::mouse::Cursor::Unavailable,
-                    &FontLayout,
-                    &mut iced::advanced::clipboard::Null,
-                    &mut shell,
-                    &Rectangle::with_size(size),
-                );
-            }
-            assert_eq!(
-                messages.len(),
-                usize::from(inserted),
-                "modifiers={modifiers:?}"
-            );
-            for message in messages {
-                let Message::SourceEdit(action) = message else {
-                    panic!("unexpected navigation action");
-                };
-                content.perform(action);
-            }
-            let expected = if inserted {
-                format!("// is{payload} excluded\r\n// 雨\r\n")
-            } else {
-                baseline.into()
-            };
-            assert_eq!(content.text(), expected);
-        }
-    }
-}
 fn checks(app: &App) -> View<'_, Message> {
    let issues = &app.model_issues;
    let mut out = column![heading(
@@ -1,260 +0,0 @@
-use crate::{
-    app::{App, Message},
-    source_navigation::{
-        SymbolEvent,
-        query::{self, Declaration, Disposition, Evidence, Identity, Membership, Position},
-    },
-    style,
-};
-use iced::{
-    Element, Fill,
-    widget::{Space, button, column, container, row, scrollable, text, tooltip},
-};
-
-pub(super) fn panel(app: &App) -> Element<'_, Message> {
-    let state = &app.source_symbols;
-    if !state.open
-        || (state.results.is_none() && state.in_flight.is_none() && state.notice.is_none())
-    {
-        return column![].into();
-    }
-    let title = state.results.as_ref().map_or_else(
-        || "Source symbols".to_owned(),
-        |results| {
-            let action = match results.action {
-                query::Action::Definition => "Definitions",
-                query::Action::References => "References",
-            };
-            results.alias.as_ref().map_or_else(
-                || action.to_owned(),
-                |alias| format!("{action} · @{}", preview(alias, 40)),
-            )
-        },
-    );
-    let mut content = column![
-        row![
-            text(title).size(13),
-            Space::new().width(Fill),
-            button(text("Close").size(11))
-                .padding([3, 8])
-                .style(style::nav)
-                .on_press(app.source_symbol_message(SymbolEvent::Close)),
-        ]
-        .align_y(iced::Center)
-    ]
-    .spacing(5);
-
-    if let Some(notice) = &state.notice {
-        content = content.push(super::label(preview(notice, 240)));
-    }
-    if state.in_flight.is_some() {
-        content = content.push(super::label("Finding source symbols…"));
-    } else if let Some(results) = &state.results {
-        let stale = results.stamp.snapshot != app.source_key();
-        if stale {
-            content = content.push(super::label(
-                "Stale results — source changed. Run Definition or References again.",
-            ));
-        }
-        let scope = &results.scope;
-        content = content.push(super::label(format!(
-            "{} · {} · {} included / {} detached / {} unverified files · {} scope issues",
-            if scope.partial() {
-                "Partial scope"
-            } else {
-                "Complete include scope"
-            },
-            if !scope.applied {
-                "Unapplied drafts"
-            } else if scope.validated {
-                "Validated sources"
-            } else {
-                "Draft sources"
-            },
-            scope.included_files,
-            scope.detached_files,
-            scope.unverified_files,
-            scope.issues.len(),
-        )));
-        let explanation = match results.disposition {
-            Disposition::NoSymbol => "Place the caret on a declaration alias or an @reference.",
-            Disposition::NoDefinition => "No matching declaration in the loaded sources.",
-            Disposition::Choices => {
-                "Choose a declaration; draft and detached candidates need an explicit choice."
-            }
-            Disposition::Direct => "Definition in the current sources.",
-            Disposition::LexicalReferences => {
-                "Lexical uses of this alias; these do not establish a semantic target."
-            }
-        };
-        content = content.push(super::label(explanation));
-        if results.total_definitions > 1 {
-            content = content.push(super::label(format!(
-                "Alias collision: {} declarations. Uses are not attributed to a single declaration.",
-                results.total_definitions,
-            )));
-        }
-        let enabled = !stale && !app.busy;
-        let mut rows = column![super::label(counts(
-            "Declarations",
-            results.definitions.len(),
-            results.total_definitions,
-            results.omitted_definitions,
-        ))]
-        .spacing(4);
-        for (index, definition) in results.definitions.iter().enumerate() {
-            rows = rows.push(location_row(
-                declaration_title(&definition.declaration),
-                &definition.path,
-                definition.position,
-                provenance(
-                    definition.membership,
-                    definition.evidence,
-                    definition.declaration.identity,
-                    false,
-                ),
-                enabled.then(|| {
-                    app.source_symbol_message(SymbolEvent::Choose {
-                        stamp: results.stamp,
-                        reference: false,
-                        index,
-                    })
-                }),
-            ));
-        }
-        rows = rows.push(super::label(counts(
-            "Lexical uses",
-            results.references.len(),
-            results.total_references,
-            results.omitted_references,
-        )));
-        for (index, reference) in results.references.iter().enumerate() {
-            let title = reference.context.as_ref().map_or_else(
-                || format!("@{} · lexical use", preview(&reference.alias, 48)),
-                |context| {
-                    format!(
-                        "@{} · inside {}",
-                        preview(&reference.alias, 48),
-                        declaration_title(context)
-                    )
-                },
-            );
-            rows = rows.push(location_row(
-                title,
-                &reference.path,
-                reference.position,
-                provenance(
-                    reference.membership,
-                    reference.evidence,
-                    reference
-                        .context
-                        .as_ref()
-                        .map_or(Identity::Missing, |context| context.identity),
-                    true,
-                ),
-                enabled.then(|| {
-                    app.source_symbol_message(SymbolEvent::Choose {
-                        stamp: results.stamp,
-                        reference: true,
-                        index,
-                    })
-                }),
-            ));
-        }
-        let row_count = results.definitions.len() + results.references.len();
-        content =
-            content.push(scrollable(rows).height((44.0 + row_count as f32 * 48.0).min(180.0)));
-    }
-    container(content)
-        .padding(8)
-        .width(Fill)
-        .style(style::subtle)
-        .into()
-}
-
-fn counts(label: &str, shown: usize, total: usize, omitted: usize) -> String {
-    format!("{label}: {total} total · {shown} shown · {omitted} omitted")
-}
-
-fn declaration_title(declaration: &Declaration) -> String {
-    let name = declaration
-        .name
-        .as_ref()
-        .map_or_else(String::new, |name| format!(" \"{}\"", preview(name, 48)));
-    format!(
-        "{}{} · @{}",
-        preview(&declaration.kind, 24),
-        name,
-        preview(&declaration.alias, 48)
-    )
-}
-
-fn provenance(
-    membership: Membership,
-    evidence: Evidence,
-    identity: Identity,
-    context: bool,
-) -> String {
-    let membership = match membership {
-        Membership::Included => "Included",
-        Membership::Detached => "Detached",
-        Membership::Unverified => "Unverified",
-    };
-    let evidence = match evidence {
-        Evidence::Validated => "Validated",
-        Evidence::Draft => "Draft",
-    };
-    let collision = match identity {
-        Identity::Collision { count } => format!(
-            " · {}ID collision ({count})",
-            if context { "Context " } else { "" },
-        ),
-        Identity::Missing | Identity::Unique(_) => String::new(),
-    };
-    format!("{membership} · {evidence}{collision}")
-}
-
-fn location_row(
-    title: String,
-    path: &str,
-    position: Position,
-    status: String,
-    event: Option<Message>,
-) -> Element<'static, Message> {
-    let line = position.line.saturating_add(1);
-    let column = position.byte_column.saturating_add(1);
-    let location = format!("{}:{line}:{column}", preview(path, 72));
-    tooltip(
-        button(
-            column![
-                text(title).size(12),
-                super::label(format!("{location} · {status}"))
-            ]
-            .spacing(2),
-        )
-        .padding([4, 6])
-        .width(Fill)
-        .style(style::nav)
-        .on_press_maybe(event),
-        text(format!(
-            "{path}:{line}:{column} (1-based line and UTF-8 byte column)"
-        ))
-        .size(11),
-        tooltip::Position::Top,
-    )
-    .into()
-}
-
-/// Keep headings compact without copying the remainder of a long admitted value.
-fn preview(value: &str, limit: usize) -> String {
-    let mut chars = value.chars();
-    let mut result: String = chars
-        .by_ref()
-        .take(limit)
-        .map(|ch| if ch.is_whitespace() { ' ' } else { ch })
-        .collect();
-    if chars.next().is_some() {
-        result.push('…');
-    }
-    result
-}
@@ -2,7 +2,8 @@

 Run from any directory with Python 3: semantic_schema.py [--check] [--validate].
 --validate additionally runs source-7 structural fixtures with jsonschema.
-This generates documentation only, never runtime selectors or model mutations.
+The desktop stored-history editor reads the checked-in descriptor for field
+shapes. Core types and validation remain authoritative for model mutations.
 """
 import copy
 import json
@@ -2054,25 +2054,6 @@ retains its own unapplied draft across file navigation. Located lint diagnostics
 refer to the raw draft bytes rather than an identity-stabilized intermediate.
 Property editing MUST NOT silently discard a pending source draft.

-In Textual model, place the caret on a declaration alias or an ``@reference``
-and choose **Definition** (``F12``) or **References** (``Shift+F12``).
-**Back** (``Alt+Left``) returns to the previous source location in this
-workspace. These shortcuts act while the source editor has focus; the Text
-toolbar also exposes the actions. If the previous draft changed, Back restores
-its current cursor rather than reusing an obsolete selection.
-
-Symbol navigation reads bounded snapshots of the currently loaded source
-drafts. It does not apply drafts or load missing included files. The results
-identify partial scope, draft evidence, detached or unverified files, alias
-ambiguity and authored-ID collisions. Draft, detached and ambiguous definition
-candidates require an explicit row choice. References are lexical uses of an
-alias, not a list of resolved typed relationships; comments and strings are
-excluded. Declaration and use counts include any rows omitted by the result
-limits. If sources change, stale rows cannot navigate: run the query again.
-Navigation MUST preserve the accepted model and every source draft, and select
-locations in the original UTF-8 bytes. Displayed locations use one-based lines
-and UTF-8 byte columns.
-
 Changing a graphical UUID must atomically update map keys and every reference.
 Alias changes preserve UUID identity. Deletion must account for owned elements,
 incident relationships, ordered occurrences, and diagram placements without
@@ -278,3 +278,139 @@ This is a selected design under implementation, not a native acceptance claim.
 Native reverse scenario Apply selected a dependency and inserted five overlapping behavior placements into an unrelated architecture view. Core transition correctness did not make that presentation useful. Select the counterpart of the explicit request root and resolve its nearest scenario/process/chain/state owner. Without an explicit destination diagram, keep the exact core candidate and open Behavior; preserve unrelated architecture views. Retain ordinary architecture transition placement and honor explicit diagram choices.

 Automatically creating another architecture view would retain the wrong editing workspace and introduce unrequested model state. Merely navigating to Behavior after adding placements would conceal the presentation damage. Both alternatives are rejected. The selected correction retains one source transaction and Undo operation and guards stale canvas events. Revisit if mixed-root requests or realistic explicit destination workflows require a separate user choice; do not infer such a choice from dependency ordering. Test/build/native acceptance is recorded separately in release-behavior-transition-context-20260906.md.
+
+## Property baselines and explicit alternative cases — 2026-09-11
+
+Problem: complete independent bindings repeat shared engineering assumptions in
+every ordinary study case. The user requires practical text-only development and
+reduced cognitive load for small and large models. Evaluator implementation
+simplicity alone cannot justify that authoring cost.
+
+Select property-owned base values/formulas and one-level case overrides as the next
+active-study contract to formalize. Every evaluator caller explicitly requests
+ModelBaseline or a particular Case identity; no active UI selection, unnamed
+default case or case-to-case inheritance determines meaning. The baseline is the
+model's explicit property values, not a mandatory extra record for entering the
+first value. Inherited formulas read the requested effective case. An explicit
+Unbound override shadows a known base; clearing an override uses the base.
+
+The [executed comparison](release-analysis-context-experiment-20260911.md) passed
+218 assertions. Twenty cases with20 fixed/two varying inputs used62 binding rows
+under B versus480 under D, with identical results. Updating one shared assumption
+required one B binding versus20 D bindings. Reusable predicates eliminated D's
+threshold-edit disadvantage, so repeated formulas are not the reason for selection.
+
+Retain an explicit complete independent freeze/export for intentionally separate
+assumptions. It must capture effective values/formulas and the full exact definition
+environment, including package pins; copying only case rows leaves hidden live
+dependencies. Captured revisions and per-input origins must make propagation
+visible. Effective dependency/cycle validation and stale result handling must cover
+the whole requested context.
+
+Reject compulsory complete cases for ordinary shared-assumption modeling; retain
+their useful isolation as an explicit independent snapshot. Reject arbitrary
+inheritance and UI-dependent evaluation. Do not import the tiny experiment
+interpreter as production architecture. Exact check identity, type/operator
+algebra, source syntax, library closure/compatibility, transitions and public
+snapshot formats still require the coordinated precise contract. Current source7
+does not implement this decision.
+
+Revisit if complete text/native tasks expose unacceptable hidden propagation,
+wrong-context edits or inability to preserve reproducible independent studies.
+The comparison establishes semantic/text maintenance evidence, not human task
+timings or full quantity/library integration acceptance.
+
+## Analysis and library contract convergence — 2026-09-11
+
+Root Codex-956atf read the complete [baseline refinement](release-analysis-baseline-contract-20260911.md),
+[library refinement](release-library-compatibility-contract-20260911.md), their
+complete fixtures and [independent review](release-refined-contracts-review-20260911.md).
+Select the following architecture for production implementation:
+
+- Required property-owned Binding values, explicit ModelBaseline/Case selection,
+  one level of complete-case override maps and shared root checks. Clear removes
+  an override; Unbound masks the base. Inherited formulas evaluate dependencies
+  in the requested context. Pure calculations see only explicit parameters.
+- Same-layer property dependencies and case targets, with explicit analysis
+  selection for transitions and exports. Check/case subjects may be absent;
+  architectural containment must not infer their selection. Validate every
+  effective dependency graph, including statically referenced unused branches.
+- The refined R6 closed algebra, exact rational R7 literal/AST preservation,
+  affine point/difference distinction and declared-output kind anchoring.
+  Strict expression operands gather actual missing/failure causes; Boolean
+  control flow evaluates only the selected branch. Supported domain failures
+  are distinct from violated predicates and missing values.
+- Whole accepted PortableDocument freeze with exact SourceBundle, local
+  definitions, all imported package contents/pins and validated provenance.
+  Replay resolves only that immutable private capture. A result report, shallow
+  case copy or current cache is not a reproducible freeze.
+- Exact archive/reference/history identity alongside verified same-origin
+  typed-contract equivalence. Different nominal origins remain distinct.
+  Compatibility supplies a scoped expected/actual field-path and operation
+  correspondence; it never advances a pin or rewrites outside record identities.
+  Keep qualified neutral definitions, immutable mapped layered definitions and
+  ordinary editable pattern instances for the first coherent implementation.
+- Explicit source preparation/acceptance with complete version-controlled
+  package/base/map/lineage state, recomputed admission and stale-input rejection.
+  Exact three-way facets retain independent local edits. Mounted OA/SA transfer
+  requires a verified exact target-layer export or an explicitly independent
+  editable local derivative; no relabeling or silent mutation of a mount.
+
+These are architecture decisions, not claims that the proposed schema8 examples
+are admitted by current source7. Before real consumer integration, enumerate and
+implement the class-specific canonical contract over all interpretation-bearing
+fields and use sites, exact transitive archive closure and full source/history
+boundaries. Retain the frozen120-assertion prototype with its documented C2
+threshold-unit coverage gap; production typing must check every operand.
+
+Close independent C1 before evaluator expansion: a request-local, profile-versioned
+logical work meter must bound dynamic expression visits, calls, list traversal
+and exact-number work. Static acyclicity/depth/node limits do not bound expanded
+execution. Cache warmth must not change outcomes; terminal exhaustion stops
+further traversal and marks collected causes as incomplete. Numeric ceilings and
+the precise charging table require measured foundation implementation before
+publishing the profile. The333-node/31-level counterexample and a nearby successful
+case are mandatory tests across direct/API/frozen replay.
+
+The exact numeric foundation is the next bounded core implementation. Ordinary
+engineering approximations, a complete low-noise text workflow, two-project
+library maintenance and native/API/source parity remain required release work.
+An exact-only slice cannot complete the user's first release.
+
+## Analysis production staging — 2026-09-11
+
+Root accepts the concrete [production integration sequence](release-analysis-production-integration-plan-20260911.md).
+Allocate schema8 to the next coherent production analysis integration. Start with
+the actual Project's neutral definition catalog, three analysis element kinds,
+typed expressions and a closed Local definition-reference environment. Imported
+references will be admitted only with the real package environment; no placeholder
+resolver, guessed pin, implicit type compatibility or competing package format.
+This stages implementation and does not defer the required maintained libraries.
+
+The first useful gate is the complete persisted/source-authored response budget,
+shared two-parameter calculation and check: baseline7/4 seconds versus degraded9/4,
+with explicit request context and the same core result through CLI and REST.
+Required property fields cannot come from generic factory guesses. Existing
+descriptive expressions/unit labels retain their exact old meaning and bytes.
+Freeze older top-level wire DTOs before making definitions required in schema8;
+reject new fields/constructors in older versions instead of silently dropping them.
+Global, scoped parameter, imported and historical identities remain distinct.
+
+Implement pure static numeric type helpers once and reuse them for admission and
+runtime. Validate every effective case graph and unused branch before accepting a
+candidate; deleting dependencies requires explicit same-batch repair. Numeric
+domain failure is not a static type failure. Full evaluator traversal and actual
+C1 input, provenance, terminal incomplete causes and immutable replay are required
+before claiming evaluated engineering behavior. Until explicit analysis review/
+transition facets exist, those entry points must reject unsupported analysis with
+a clear capability error, including manual-trace paths that could otherwise appear
+to reconcile headers alone.
+
+Logical expression depth128 must be reconciled with bounded actual JSON/source
+decoding; do not simply disable recursion limits. Raw byte, decoded string and
+aggregate literal/graph/case-admission limits are separate from evaluation fuel.
+Concrete decoder/admission ceilings remain subject to bounded boundary and timing
+experiments; the implementer must surface those choices before locking the profile.
+The current local numeric gate runs against frozen root source. New core contract
+work proceeds in an isolated checkout, preserving root's Cargo/native leases and
+the other hosts' CLI, staged-source and B4 ownership.
@@ -1,135 +1,84 @@
-> Historical record — superseded on 2026-09-11. Live plans, ownership and blockers
-> were migrated once to [Gitea issue 1, comment 408](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/1#issuecomment-408)
-> and [issue 2](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/2).
-> Do not update this as a live ledger. [STATE.md](STATE.md) links the verified integrated result.
-> The historical text below is preserved; its old active-status wording is not current guidance.
-
 # First release execution plan

-Updated 2026-09-11, Codex-9e8r6t `/root`.
-[PROJECT_GOAL.md](../PROJECT_GOAL.md) defines the outcome;
-[TASK_LEDGER.md](TASK_LEDGER.md) separates evidence from assumptions;
-[STATE.md](STATE.md) owns active leases and results.
+Updated 2026-09-11. [PROJECT_GOAL.md](../PROJECT_GOAL.md) is the authoritative
+current objective. [STATE.md](STATE.md) records exact execution/evidence and leases;
+[TASK_LEDGER.md](TASK_LEDGER.md) separates facts, assumptions and decisions.
+The complete previous plan is [preserved byte-for-byte](history/2026-09-10-ledgers-before-continuation-refresh/PLAN.md).
+Its earlier goal paths, active-process claims and Escape pauses are historical.

-Resumed after the user's virtualization/reboot update. STATE.md supersedes the
-historical [RESTART_HANDOFF.md](RESTART_HANDOFF.md) for live status. Postboot
-focused3 ran25 passing tests and one failing overflow-fixture assertion; its
-test-only correction passed all26 focused4 tests. Strict Clippy, formatting and
-matching GUI5657 build also passed; fresh native acceptance continues.
-Nondeleting compression completed across282 generated binaries with identical
-hashes and11.78GB free; supported Ubuntu26.04 installation passed exit0. Actual
-root shell identifies Ubuntu26.04/WSL2. User328 replaces failed mirrored mode
-with VirtioProxy; the VPN is immutable. Both new guest startups timed out before
-execution, then the distinct WslService restart failed at OS access permissions.
-All60 apt archives and five Rust components are downloaded and hash-verified;
-guest signature verification/install and Linux Cargo remain pending. No compiler
-or WSL client lease is active. The user has now paused Linux builds/checking
-until they report WSL networking resolved; do not schedule more Linux setup,
-launches, diagnostics or checks before that notice (Gitea comment356).
-Lifeline/Chain history and Machine Create/Undo/postboot reopen passed on GUI52;
-Fresh GUI5657 cancellation/recovery, Lifeline direct creation/history and Machine
-minimum-size owner/Create/Undo/Redo/reopen now pass; full679 desktop tests pass.
+## Outcome and working principles

-## Immediate implementation and acceptance
+Deliver usable, complete OA/SA engineering workflows on Windows and Linux, with
+one precise reST contract and equivalent graphical, textual and REST editing.
+Constraints/calculations, quantities/units and reusable libraries are explicit
+requirements alongside behavior/state modeling, traceability and navigable help.
+Small and large models must be practical to author entirely in uncluttered text;
+evaluate complete authored and stabilized models, not abbreviated grammar sketches.
+Later Arcadia layers remain future scope. Compilation, metadata fields and polished
+screens alone do not satisfy this outcome.

-1. Preserve and publish the completed native acceptance of GUI `5657BAB5…D3846CE` using
-   the [v2 plan](release-contextual-source-native-v2-plan-20260911.md). All26
-   affected tests, strict all-target Clippy, formatting and matching build pass;
-   the full679 immutable Windows test run also passed. Minimum-size
-   child visibility, exact recovery/cancel and direct Lifeline Create/Undo/Redo
-   now pass, along with Machine owner visibility/Create/Undo/Redo/reopen. Preserve
-   independent first UUID carriers and serialize future compiler/source leases.
-   Prepare an updated Windows prerelease only with honest per-binary source
-   identity, package verification and clean packaged runtime checks.
-2. Exercise the implemented source subform for Lifeline, process/chain Work and
-   machine owner, plus semantic first-action prompts. Verify parent-draft
-   retention, explicit prerequisite and consumer adoption, exact source/history,
-   cancellation and recovery against the independent staged-source oracle.
-   Final source guards and guide corrections are complete and reviewed; native
-   acceptance remains; source/evidence are integrated in `df6f595`. Named creation, nine-file reopen and
-   SA pending-draft recovery already have their separate native passes.
-3. Complete local SA B2 and the saved basic
-   supplementary move/camera/invalid-draft and minimum-size story; the main basic
-   model and explicit transition passed full Project+SourceBundle, Undo/Redo and
-   reopen on candidate 3 at wide size. OA B2 Action, State, bound Reuse and Fragment
-   now pass complete model/two-source Create, one Undo, one Redo and final OA
-   reopen/Save with exact original identities. Preserve the existing B3 layer/size
-   scope; do not infer SA B2 or broader camera/focus coverage from these passes.
-4. Integrate standalone B4 scenario lifetimes and the external independent
-   scenario contract without overwriting local layout work. Resolve source-derived
-   lifetime versus insertion bounds, activation-after-Delete and lane-map issues.
-   Close remaining
-   contextual operand, missing-source and state-naming workflow gaps identified
-   by the current behavior audit and native study.
+Retain the shared typed core, stable identity, semantic ownership/allocation distinct
+from geometry, validated atomic commands and exact source/history. Persistent
+extensions need coherent references/deletion, transition, source/migration,
+API/schema and reachable graphical authoring. Define observable acceptance before
+broad downstream changes. Do not silently promote a design proposal to a decision.

-## Foundational semantic additions
+## Capability milestones

-The updated objective explicitly requires functional constraints/calculations,
-quantities/units and maintained model libraries. Current metadata/includes are
-insufficient. This work runs independently of useful behavior improvements.
+| Milestone | Work and acceptance | Dependency/current limit |
+| --- | --- | --- |
+| 1. Reliable direct authoring | Exercise actual minimum/wide native creation, allocation, editing, rejection, cancellation and history without implicit draft application or placement drift. Integrate compact named behavior creation after its coherent external gate. | Named creation4bb4aaf is imported; combined desktop676/676, format and strict Clippy pass at2cc4d11. Native80cf197 passes all four OA creations/history/reopen; new workspace fixes and production chooser await compilation. Workspace/B3/palette/recovery/packages are imported. Root owns this host's Cargo/native lease. |
+| 2. Coherent process/scenario work | Interactive ordered/explicit process editing; clicked root/nested scenario insertion; exact reuse bindings and caller return; measured canvas/zoom/scroll; visible scoped Create/Delete lifetimes. Validate model/source/identity and no unintended edit during navigation, including stale/deleted/retargeted references and recovery. | B1/B2/B3 regressions pass in the full suite. Local B4 remains cfg(test); Codex-ytr83r owns production Scene integration and its independent native gate. Use the independently self-checked oracle for native checkpoints. |
+| 3. Precise engineering analysis | Compare owned properties, analysis contexts and existing-data/external alternatives; settle quantity kind/unit/value, numerical policy, calculation/binding and Boolean/error/unknown semantics through falsifying examples. Implement mixed-unit budgets and reusable calculation/constraint definitions with full UI/source/REST parity and exact history/recovery. | B/shared-check/full-capture and R6/R7 architecture ratified after complete fixtures and criticism. Exact numeric/work-meter foundation is undeclared and under independent review. Approximate profile and full evaluator parity remain required. |
+| 4. Maintained reusable libraries | Compare package/definition/instance alternatives. Establish pinned identity/version/dependency closure, local edits, import bindings, detach and explicit three-way updates. Demonstrate two projects, two independent instances, offline reopen, conflicting updates and stable unaffected identities. | Exact pins plus verified same-origin typed compatibility, explicit source preparation/acceptance and three-way editable updates are ratified. Finite120-assertion experiment is not production contract/archive/consumer implementation. |
+| 5. Understandable complete engineering tasks | Close teaching, OA↔SA transition/reconciliation, typed state/data/interface, artifact, saved-view and hosted workflows. Establish complete text-only creation/refactoring/modular maintenance with stable identity. Replace concrete long homogeneous selectors with contextual/searchable bounded choices; verify large models, keyboard access, minimum sizes and failure/recovery. Keep offline guide/examples aligned. | A complete warning-free text-only model probe passes source/identity/rename/reparent/file-move checks; measure usability separately. Anchored chooser passes13 isolated mounted tests under cfg(test); production inspector/review integration is active; its compile/native gates remain open. Separate-host CLI is coherent at01b76a1 and awaits import here. Reassess current goal rather than copying historical scope exclusions. |
+| 6. Release confidence and delivery | Fresh current Windows/Linux suites, strict Clippy/format, normative reST/OpenAPI/migration/examples; actual GUI/service transport, optimized builds, runtime/notices/archive/provenance/checksums and clean-environment launch. Fresh independent requirements/domain/parity/architecture/UX/runtime review; resolve material findings, then final handoff. | Integrates all preceding capabilities. Linux runtime remains open; use an approved supported environment, preserving historical failed/denied experiments. Historical previews are not final distributions. |

-Peer comment 231 ratifies schema 8/local-definition core steps in an isolated
-worktree. Coordinate those actual shared types and ownership before local
-integration; the current local core remains descriptive. Source grammar,
-evaluation, server/CLI/UI representation and acceptance are separate unfinished
-steps. Peer956 now reports focus regression5/5 and isolated numeric26/26 plus
-analysis28/28; their codec/lifecycle work remains isolated. Local integration and
-coherent union gates remain necessary. Do not replace peer efforts with a
-parallel local implementation. Comment338 separately reserves our bounded
-syntax-only outline seam for current-text navigation; its private query module
-and prepared tests remain uncompiled pending review.
+Milestones are capability gates, not a rigid serial schedule. Root can continue
+build/native acceptance while independent foundational investigations compare
+alternatives. Libraries and analysis share definition-resolution assumptions and
+must converge coherently before broad model/schema edits. User workflows and
+cross-representation evaluators guide implementation boundaries.

-The newest objective also requires complete uncluttered text-only workflows.
-Combine the local three-task usability audit with the other host's language/
-identity/API design. Two concise current-grammar recipes now pass their bounded
-REST identity/source/persistence experiment. The published CLI now covers checked
-stabilization and typed alias rename with exact source-preserving preview/write.
-Next evaluate cross-file definitions/references and engineering task completion
-on repeated-name modular models. Do not equate shorter examples
-or parser throughput with task usability, and do not silently change omissions.
+## Immediate execution sequence

- Compare real candidate semantics before large changes. Use primary Capella,
-  SysML and quantity/unit evidence, with explicit compatibility limits.
- Falsify candidates through mass/power/latency budgets, mixed/affine units,
-  unknown/error/false results, dependency cycles, reference identity and bounded
-  evaluation. Separate descriptive existing text from executable declarations.
- Probe libraries through two projects/two instances, pinned offline content,
-  exports/dependency closure, bindings, distinct origin/local identities, updates
-  with local divergence, detachment and exact transactional rollback.
- Review and test the peer-ratified pure core and its explicit migration/admission
-  boundaries before local integration. Retain independent falsifiers and current
-  typed Project, Command and source-writer guarantees across representations.
- Implement the ratified contracts across validation, visitors, deletion,
-  identity, OA/SA transitions, source/reST, schema/REST, ergonomic graphical
-  authoring and help. Add real examples and independent parity acceptance.
+1. Complete the coherent workspace/production chooser build and focused gates,
+   then stage a new GUI for real engineering tasks. Full676/format/Clippy passed
+   for2cc4d11; working changes require their own verification.
+2. Implement the user-required common canvas interactions for Process and Scenario
+   in issue2 after the bounded shared-viewport/domain-constraint design decision.
+   Treat this as direct-manipulation acceptance, not a tool-shelf restyle.
+3. Exchange exact verified commits with the separate host, preserving its workspace
+   ownership. Direct authenticated publication works. CLI01b and exact evidence2ec
+   are imported; next contextual-source and B4 handoffs retain their owners.
+4. Use the self-checked [scenario oracle](scenario-authoring-contract.rs), follow
+   its [native procedure](fixtures/scenario-authoring/README.md), and compare exact
+   whole snapshots for Undo/Redo/reopen at minimum/wide sizes.
+5. Exact numeric/unit/work-meter foundation26/26 unit tests pass at7d14bd0; complete
+   its strict gate while actual schema8 core work proceeds in an isolated worktree.
+   Extend actual model/source/API/GUI under the ratified
+   B/R6/R7/full-capture and exact-pin/typed-compatibility contracts. Preserve explicit
+   approximate numeric, complete consumer/archive and two-project release gates.
+6. Update current ledgers and durable decisions when evidence changes the plan.
+   Reassess unresolved assumptions before expanding downstream implementation.

-## Integration and release
+## Coordination and evidence rules

- GUI/server release 1, `v0.2.0-preview.authoring.20260911`, and standalone CLI
-  release 2, `cli-v0.2.0-preview.authoring.20260911`, are published and read back.
-  Their exact notices, archive, runtime and uploaded-asset evidence is preserved.
-  CLI packaging is integrated at `27df4a3`; instruction sync `07eb3cd` and
-  contextual source checkpoint `df6f595` and its raw evidence are integrated.
-  CLI publication `d95b1ab` and OA native checkpoint `c4bad4b` are also integrated;
-  then publish later coherent milestones under the assigned owner. Preserve each
-  artifact's source/profile/native scope and complete final-release gates separately.
- Publish coherent commits and verified bundle transfers through Gitea; keep
-  concise host-scoped handoffs and Wiki. Do not overwrite another host's branch.
- Refresh relevant source/schema/example/doc gates and run current core,
-  desktop/server and real REST transport/restart/ETag/draft-conflict workflows.
- Build matching optimized desktop/server packages. Regenerate complete notices
-  for actual inputs and verify archive contents, hashes and clean-runtime launch.
-  Historical ELF fixtures and build preparation do not replace execution.
- Follow the external owner's supported Linux guest route and run current
-  GUI/server workflows when viable. This local host has no usable Linux runtime;
-  supported WSL2 failed. Preserve failed attempts rather than repeating rejected
-  workarounds, and continue independent Windows/semantic work.
- After the user reboot, check local Ubuntu registration and launch first. A
-  version2 default alone is not an installed/running Linux environment.
- Conduct fresh independent requirements, semantic, usability, architecture,
-  correctness, runtime and documentation reviews. Resolve all material findings,
-  reverify affected behavior and only then declare release completion.
+Use Gitea issue #1 and Wiki for current ownership/handoffs; read before resuming.
+Codex-956atf, Codex-9e8r6t and Codex-ytr83r are distinct hosts. Cargo/native leases
+are host-local; shared source ownership is coordinated.9e8r6t owns the next runnable
+Windows named-authoring prerelease and contextual-source/CLI; ytr83r owns B4 Scene
+and its platform gates. Root owns local chooser/numeric/workspace integration.
+Updated AGENTS requires runnable milestone prereleases. User#178 authorizes existing
+MCP credential reuse for Git/REST; secrets must never be printed or committed.
+Direct branch publication replaces bundle work when available; old exact bundles
+remain valid evidence and transfer branches must not be merged.

-Historical milestones and evidence remain intact in
-[the dated plan archive](history/2026-09-10-ledgers-before-second-consolidation/PLAN.md).
-They do not supersede current user scope or imply current-tree acceptance.
+Record exact source/binary, command exit, test scope and native model/source oracle.
+Do not add focused reruns to full-suite totals or transfer old binary acceptance.
+Older denied Linux workaround instructions remain applicable to that action; do
+not bypass them. Older stopped native sessions do not prevent currently authorized
+native work. The [archived plan](history/2026-09-10-ledgers-before-continuation-refresh/PLAN.md)
+and [archived progress](history/2026-09-10-ledgers-before-continuation-refresh/STATE.md)
+preserve all previous strategy and scoped evidence; archive report links resolve
+from their original `harness/` directory.
@@ -1,63 +0,0 @@
-# Restart handoff — 2026-09-11
-
-Historical reboot checkpoint. User has returned and enabled virtualization;
-current STATE.md and the postboot native/layout/WSL reports supersede the pause
-and pending-result wording below. Preserve this record for exact resume history.
-
-Codex-9e8r6t /root. User explicitly requested a reboot pause to make WSL2/Ubuntu
-available. Full PROJECT_GOAL remains active and incomplete. Resume only after
-the user returns; do not schedule automatic work during the reboot.
-
-## Saved state
-
- Branch `codex/release1-9e8r6t`: contextual source `df6f595`, CLI publication
-  evidence `d95b1ab` and complete local OA scenario evidence `c4bad4b` were pushed
-  and read back. The following reboot commit also preserves reviewed WIP below.
- Both Windows Studio/server and standalone CLI prereleases remain published.
-  This checkpoint does not update either release or establish Linux acceptance.
- Immutable GUI52DE82 native source trial: Lifeline Save-adoption and Chain
-  direct Create each passed complete model/source, one Undo and one Redo with
-  original IDs. Machine direct Create/Save passed six exact files; one Undo/Save
-  passed four reachable/six physical files. Machine Redo/reopen remain pending.
-  Test GUI closed normally, and its returned window was absent at 13:38 UTC.
-  `work` contains the saved Machine Undo state. Do not infer persistent history;
-  use preserved first machine checkpoint for isolated reopen and a fresh trial
-  for missing history coverage. See release-contextual-source-native-20260911.md
-  and experiments/contextual-source-native-20260911/README.md.
- Reviewed WIP: source_draft.rs essentials-first layout, explicit wrapped kinds
-  before unbounded parent text, plus creation.rs staged-owner caption fix.
-  Three real Paragraph tests are prepared. First compile failed in test helpers
-  (ambiguous macro and wrong Id constructor); corrected only those helpers.
-  Corrected focused2 was interrupted for this reboot before any tests ran;
-  Clippy/fmt/GUI did not launch. There is NO new passing suite or matching GUI.
- Worker release_audit stopped its command with Ctrl+C; all Cargo/rustc/linker
-  processes were absent. All 238 frozen input hashes were unchanged.
-  Final source_draft SHA prefix C8D36BD6; creation SHA prefix 0FB19BE3.
-  Exact freeze inputs3 SHA256
-  `6B3F3088FF18AF3899C3764B3F3671DA9240A5DE184D871BF08F8012456E556B`.
-
-## Next actions after reboot
-
-1. Read AGENTS, PROJECT_GOAL, STATE, PLAN and latest Gitea issue 1/2 comments and
-   relevant Wiki. Preserve Codex-956atf canvas/chooser/schema8 and Codex-ytr83r
-   B4/Linux ownership. User issue2 comment250 allows domain-constrained diagram
-   manipulation; arbitrary free movement is not required.
-2. Recheck `wsl --list --verbose`. Before reboot it reported no installed
-   distribution despite default version2. Launch/setup Ubuntu as needed with
-   the user handling any authentication. Verify a real usable Linux environment
-   before claiming a build. Do not repeat rejected VM workarounds.
-3. Validate the frozen input manifest, then resume a new focused3 run. Keep
-   focused1 failure and focused2 interrupted evidence. On a pass, run strict
-   desktop all-target Clippy, formatting and matching GUI build; use a distinct
-   immutable stage. No broad full-suite repeat without a new reason.
-4. Root alone performs native Computer Use with @oai/sky. Relaunch the corrected
-   artifact in a fresh profile and verify initial Name/kind/parent visibility at
-   1100×700, the owner label, direct Lifeline Create, remaining cancellation/
-   recovery and machine history/reopen using independent expected contracts.
-5. Continue SA B2, basic supplementary workflows, peer integration, complete
-   semantic/text/REST/library work, Windows/Linux packaging and fresh final
-   cross-disciplinary acceptance. The full release remains unfinished.
-
-Private runtime and build stages under `.local` are retained; no temporary
-binary, token or credential was committed. Raw interruption/native records are
-archived separately with exact hashes. All workers are idle for the reboot.
@@ -1,107 +1,202 @@
-# Integrated checkpoint — first release
+# Progress Ledger — first release

-Updated 2026-09-11 by Codex-9e8r6t `/root`, Windows host.
-**Full OA/SA release acceptance is incomplete. Linux work remains user-paused.**
+Updated 2026-09-11, coordination through Gitea #245 and issue2. This ledger describes the
+Codex-956atf checkout; external-host evidence is labeled separately. The entire
+previous ledger is preserved [byte-for-byte](history/2026-09-10-ledgers-before-continuation-refresh/STATE.md).
+Historical dates, binaries, process IDs and stopped-session instructions in that
+archive are evidence history, not current status or authorization.

-[PROJECT_GOAL.md](../PROJECT_GOAL.md) owns the application requirements.
-Current objective attachment `9467fa86-4606-4fe2-93ec-122137d03079` was read in full.
-Instruction synchronization `b70bf1d` preserves the user specification and
-[AGENTS.md](../AGENTS.md). It changes instructions, not the verified package inputs.
+## Current objective and source

-## Delivered Windows milestone
+Deliver the complete, usable OA/SA first release in [PROJECT_GOAL.md](../PROJECT_GOAL.md),
+including graphical/source/REST parity, constraints/calculations, quantities/units,
+reusable model libraries, traceability, offline guidance and Windows/Linux release
+acceptance. Direct behavior/scenario authoring and reduced cognitive load remain
+immediate priorities. Complete small and large models must be practical to develop
+through uncluttered text alone. The release is incomplete.

-[Contextual authoring prerelease](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/releases/tag/v0.2.0-preview.contextual.20260911)
-was published and read back at 17:03:29 UTC. Extract the whole ZIP and run
-`arcadia-studio.exe`; keep its sibling `libunwind.dll`. Studio, the optional REST
-server, examples, offline help and dependency notices are included.
+Local branch: `codex/behavior-authoring-20260910`. Last compiled source checkpoint
+is `2cc4d115d0ff28423c7ed87fd5f4065efb011f2d`, including external named creation
+`4bb4aaf` as `1516949`, the isolated chooser and final baseline/library contracts.
+Full desktop676/676, formatting and strict Clippy pass at that source. The active
+native GUI remains immutable80cf197. New workspace and production chooser changes
+are outside those artifacts and await a coherent build. Current committed source
+adds exact numeric foundation7d14bd0, imported CLIbc311bc and evidence/native
+dc0f2e1. Numeric26/26 unit tests and strict core all-target Clippy pass. Shared
+instruction ancestrycab01c3 is merged asc7ed894, retaining the exact uploaded goal.
+The authoritative goal was copied byte-identically from attachment
+`a49d1780-25d5-4778-ad68-6140c60e4207/goal-objective.md`; SHA256
+`DD58F75C93D55FE16ED141A23D834898FB6EBC625AE7E7AE379DA552A8312435`.
+See [Task Ledger](TASK_LEDGER.md) for knowledge/decisions and [Plan](PLAN.md)
+for capability acceptance. Older goal paths are superseded.

-The tag points to verified source checkpoint **b2c3e540**. Exact raw-input
-reconstruction **d5650309** is distinct from the original build commit. The
-package pairs GUI5657 with the unchanged, separately verified EFEE server.
-All 559 package files and all three downloaded release assets were verified.
-The binaries use the development profile; this is a prerelease.
+## Completed work and evidence

-The GUI supports named behavior creation and contextual missing-source creation
-without abandoning the parent draft. All 679 desktop tests passed, with focused
-layout checks, strict desktop Clippy, formatting and a matching build. Real
-Windows workflows verified minimum-size layout, recovery/cancellation, lifeline
-and state-machine creation, one-step Undo/Redo and exact source/identity reopen.
-Fresh package acceptance additionally verified Home/help, native Open and
-contextual Create/Save/Close with complete model/source/identity comparison.
-Independent packaged-server checks cover exact API content and persistence
-across process restart. These are bounded milestone results.
+The creation bundle was fetched anonymously and verified at105022 bytes,
+SHA256 `0DEFAE91A56430076C432758F923BC0675911DA9FA7588C9961FF15F47EAEBF6`.
+Its coherent commit adds named Process/Chain/Scenario/Machine drafts, bounded
+owner search, recovery/selection guards, offline guide and measured textual
+examples. The duplicate Sensor correction was not reapplied. Both hosts' report
+additions and exact experiment bytes are retained; this host's goal and ledgers
+remain authoritative locally. External653-test/native evidence is attributed in
+[its integrated report](release-integrated-gates-20260910.md), not claimed as a
+local run. The separate isolated chooser at `c4e1580` passed13/13 mounted tests
+under cfg(test); it is not a production selector yet.

-Authoritative records:
+| Scope | Current evidence and limits |
+| --- | --- |
+| Reproducible local toolchain | Ignored `.local/toolchain/env.ps1` selects Rust/Cargo 1.98.1 GNU/LLVM and verified LLVM-MinGW 20260908 (clang 23.1.1), with one Cargo job. First cold desktop test build completed in 58m03s; one unused import warning was corrected separately. |
+| B1 process authoring | `01bb52a` includes interactive empty/ordered/explicit topology and presentation-only inferred paths; first conversion preserves ordered adjacency atomically. All topology regressions pass within the current full desktop suite. Native acceptance is pending. |
+| B2 scenario authoring | Clicked root/operand/slot and optional lifeline feed Action/State/Reuse/Fragment adapters. Pointer-to-App, cancellation, stale-event, recovery and history tests pass within the current full desktop suite. |
+| B3 caller navigation and workspace | External `3978bbe` imported as `865cd55` fixes visible-owner restoration, pending-draft guards and remaining-height workspace. Root `80cf197` keys the viewport Sensor by document/scenario; a real mounted regression failed before the fix and now passes. The full suite is green; actual OA caller return and source-neutral navigation pass. Remaining native scope is explicit below. |
+| Architecture palette | External palette commit `7d1df4f` was cherry-picked as `aed40d7`, retaining local invariant tests. Captured Escape, stale Submit/raw retention and bounded card fixes are source-integrated. External native results do not transfer to this checkout. |
+| Typed stored-history F1 | `b6b76ef` fixes nullable constructor cache discrimination; `4ecad78` fixes NotApplicable seeding by checking actual enum alternatives. Thirteen focused tests passed and are included in the current full suite; core validation remains authoritative. |
+| Lifeline lifecycle B4 | `eb5161b` adds pure local/scope-aware lifecycle projection with ten tests, declared under `cfg(test)` only. It is not production Scene wiring or native acceptance. [Design](release-scenario-lifecycle-design-20260910.md). |
+| Native scenario oracle | [Independent checker](scenario-authoring-contract.rs) compiled/self-checked and verified the generated62-element/two-source baseline. Native OA Action/State/Reuse/ALT-fragment, each exact Save/Undo/Redo, and final native reopen pass at minimum size; caller identity/scroll return and source-neutral navigation pass. Remaining prescribed checkpoints are open. [Native scope](release-scenario-native-20260911.md), [oracle inputs](fixtures/scenario-authoring/README.md). |
+| Normative documentation | Strict Docutils 0.22.2 language HTML regeneration passed. `semantic_schema.py --check --validate` passed 72 source7 fixtures, 204 schemas, 14 families/90 scalar leaves. These are documentation/schema gates, not a Rust build or runtime pass. |
+| Comparable-product study | Actual isolated Capella 7.1 scenario/activity/lifeline/LOOP creation was saved and XML inspected, then closed normally. [Report](release-capella-scenario-benchmark-20260910.md). Current Studio native evidence is recorded separately. |
+| New requirement audit | [Independent delta report](release-requirements-delta-20260910.md) establishes that current expressions/unit labels are descriptive and source includes are not maintained cross-project libraries. Refined B/R6/R7 and exact-pin/same-origin compatibility contracts are ratified; current source7 does not implement them. |
+| Packaging integration | External `b98f135` imported as `6d2b961`; all 25 checked-in exact notices match the manifest. `scripts/test-package-artifacts.py` passes 11/11 and `scripts/test-windows-notices.ps1` passes synthetic package/runtime/source/font checks. Actual optimized distributions and clean-environment launches remain open. |

- [Publication, artifacts and limitations](release-contextual-source-prerelease-published-20260911.md)
- [Per-binary preparation](release-contextual-source-prerelease-preparation-20260911.md)
-  and [independent archive/server review](release-contextual-source-prerelease-review-20260911.md)
- [Fresh native package acceptance](release-contextual-source-prerelease-gui-20260911.md)
-  and [broader GUI5657 native acceptance](release-contextual-source-native-v2-20260911.md)
- [Verified code/evidence checkpoint](release-postboot-checkpoint-review-20260911.md)
- [Standalone CLI prerelease](release-cli-prerelease-published-20260911.md),
-  supplying checked source stabilization and typed alias rename separately
+## Active work, ownership and unresolved findings

-## Material unfinished scope
+Root Codex-956atf owns this host's integration, serialized Cargo and native UI.
+The source2cc4d11 gate completed with exit0: **676 passed, zero failed/ignored**,
+tests611.24 seconds after warning-free compilation10m47s. Command:
+`cargo test --locked -p oa-desktop --bin arcadia-studio -- --test-threads=1`.
+Log `.local/logs/desktop-creation-chooser-20260911.log`. Immutable executable
+`.local/creation-chooser-20260911/tests-2cc4d11/arcadia-studio-tests.exe`, SHA256
+`8D7FB35071F155B3BD07CE1885A1136B2D2EF71C4FF8C704665202499C86A721`.
+Its manifest pins256 tracked input hashes. Format passed; strict all-target desktop
+Clippy passed7m18s after the isolated manual-clamp correction. Final logs are copied
+beside the immutable binary. These gates supersede the historical642 total, not the
+current uncompiled working changes. Focused counts are included, never additive.

-Current-draft Definition/References/Back is implemented in source checkpoint
-**[36db9356](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/commit/36db9356cce3c7614ae37eec9fe17678ca210afe)**.
-The [initial native trial](release-text-navigation-native-initial-20260911.md)
-found four interaction defects. Their [correction](release-text-navigation-native-corrections-20260911.md)
-at **eeeaa126** passed 188 focused tests, the full 750-test desktop suite and
-strict Clippy, with exact input readback and independent review. Matching GUI5478
-[native evaluation](release-text-navigation-native-v3-20260911.md) verified those
-fixes, ambiguous/partial source navigation, and the 30-file engineering workflow;
-explicit Save preserved complete models, identities and source bytes. It also
-found a repair-mode false-clean status against the prior saved destination.
-Its [saved-baseline correction](release-text-repair-save-state-20260911.md)
-passes the full 755-test suite, strict Clippy and matching GUI B183 build;
-new native repair/closing and package acceptance remain required.
-The [integrated evaluation](release-text-navigation-integrated-20260911.md) links
-exact input archives, earlier full-test scope and independent findings.
-The published contextual preview remains unchanged.
+Actual native Studio remains `.local/native-qa/studio-80cf197/`, GUI SHA256
+`A5ED6DF334B1BFB620425AFDF3E863F0B522990E6FB47C6C401A71CF4443954A`.
+That GUI build passed3m28s. At1100x700, all four OA creation checkpoints and final
+reopen now pass complete Project/two-source prediction and exact UUID restoration.
+Preserved OA snapshots end in `oa-reopened/`; separate SA Action Save/Undo/Redo
+also passes complete oracle/history comparisons, ending in `sa-action-redo/`,
+63objects. The GUI is saved at SA A caller, no active form. SA State/Reuse/Fragment
+and final reopen remain. No new-fix acceptance is inferred.
+[Native report](release-scenario-native-20260911.md) records details and two real
+workspace findings: new forms retain downward scroll, and opening a form can hide
+its clicked marker below the reduced canvas. Root has written a fresh form-session
+key, guarded Name focus, one-time marker reveal and three meaningful mounted/App
+regressions. They are not yet compiled. The isolated chooser's corrected realistic
+typing/paste/IME gate passes13/13; production inspector/review integration is now
+source is now frozen, with exact row/facet/group/attachment guards. Independent
+review exposed and closed three focus defects at source level, including the
+legitimate Review rationale input. Fourteen new App/mounted tests await execution;
+the earlier isolated13 is separately scoped. [Review](release-reference-chooser-production-review-20260911.md).

-The integrated release does not yet contain newer peer canvas/chooser and
-scenario-lifetime work, complete constraints/calculations, dimensional quantities,
-maintained model libraries, or the new source-navigation contribution.
-Those additions require coherent graphical/text/REST realization and validation.
-Some scenario forms retain old scroll positions and dense labels remain crowded.
-Local SA action/state/reuse/fragment and supplementary camera/focus tasks retain
-explicit unfinished scopes in [scenario evidence](release-scenario-native-local-20260911.md).
+User [issue2](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/2)
+requires Process and Scenario to behave as actual canvases like architecture/state
+diagrams. Current scrollable diagrams/tool shelves do not close that requirement.
+behavior_audit owns a bounded shared-canvas design; root re-observed the saved
+native scenario and its restricted viewport, without new model input.

-Optimized builds, remaining real engineering workflows and a fresh independent
-cross-disciplinary end-state review remain necessary. Old MVP exclusions and
-individual passing tests do not reduce the user's full requirements.
+The [baseline contract](release-analysis-baseline-contract-20260911.md) supplies a
+complete17-UUID proposed model,11 exact fixtures, explicit ModelBaseline/Case,
+property bases and shared checks. Its transport fixtures are not parser/evaluator
+acceptance. The [library contract](release-library-compatibility-contract-20260911.md)
+has120 executed finite-prototype assertions, separate-process reopen and11 complete
+expected/reopened file comparisons. Final81-file manifest was independently
+verified; preliminary output is retained and labeled superseded. All166 experiment
+files retain exact Git bytes. Root ratified B/R6/R7/full private capture, nominal
+typed compatibility alongside exact pins, explicit source normalization and OA/SA
+dispositions in [DECISIONS](DECISIONS.md).

-Ubuntu/WSL setup and all Linux diagnostics/builds/checks are paused until the user
-explicitly reports networking resolved. Preserve existing configuration, caches
-and evidence. [WSL readiness](release-wsl-readiness-9e8r6t-20260911.md) owns the
-historical attempts; it is not a current Linux application acceptance claim.
+The [independent refined review](release-refined-contracts-review-20260911.md)
+passes292 fixture/identity checks but finds C1:333 stored AST nodes can expand to
+over2billion calls. Request-local dynamic/numeric work accounting is mandatory;
+static depth/node limits alone fail. C2 is a finite-prototype threshold-unit gap,
+not a passing production type-checker. Exact arithmetic, unit/dimension operations
+and terminal work meter are declared/committed at7d14bd0; their26/26 unit gate has
+[exact source/artifact evidence](release-analysis-numeric-gate-20260911.md).
+requirements_delta now owns actual schema8 definitions, expressions, commands,
+references, migration and static admission in the isolated
+`.local/analysis-core-worktree-20260911/`, based at7d14bd0. It remains uncompiled.
+semantics_critic reviews the bounded decoder strategy separately; existing default
+recursion rejection stays until a full allocation/lifecycle gate is justified.
+Root owns compilation. Numeric/runtime and static-admission ceilings remain
+explicitly provisional pending measured gates. Approximate engineering calculations,
+full evaluator/model/source/REST/GUI parity and actual library maintenance are open.

-## Coordination and history
+Codex-9e8r6t and Codex-ytr83r are separate hosts/teams. The former owns contextual
+prerequisite creation and source CLI. CLI01b76a1 is imported asbc311bc; exact
+corrected evidence2ec72d4 is imported atdc0f2e1, preserving root's separate native
+report. External675 staged-source and CLI12/183-assertion results remain externally
+attributed. Its runnable Studio/server preview release1 and standalone CLI preview
+release2 are published; see their release notes for exact source/runtime limits.
+Strict language/API HTML regeneration and the72-fixture source7 schema gate pass
+locally after that evidence import. Codex-ytr83r owns B4
+production Scene wiring, independent native oracle and local Linux route. Its
+rendering source has independent criticism but no passing build/native gate yet.
+Do not duplicate these changes. Preserve root's distinct scenario-scroll/focus hook
+when integrating other hosts' small App/behavior bridges.

-The user requested splitting oversized [issue 1](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/1).
-Live coordination now uses focused [behavior/canvas](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/2),
-[activity movement](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/3),
-[child work](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/4),
-[lifecycle Windows acceptance](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/5),
-[source navigation](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/6),
-[quantities/calculations](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/7),
-[maintained libraries](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/8),
-and [Text alias rename](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/9).
-Read current comments for ownership and execution state; this checkpoint does
-not track active leases.
-[Authoring Wiki](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/wiki/Authoring20260911)
-is the shared entrypoint. Durable decisions remain in [DECISIONS.md](DECISIONS.md)
-and topic reports; the [text-navigation design](release-text-navigation-design-20260911.md)
-records the current bounded design and its falsifiers.
-The [Text alias-rename proposal](release-source-alias-rename-design-20260911.md)
-and its [critique](release-source-alias-rename-critique-20260911.md) are design
-preparation, not implemented or verified Text capability.
+Updated AGENTS4b8465c8 adds concise shared maintenance to milestone releases. Gitea
+user#178 explicitly authorizes programmatic reuse of existing MCP credentials for
+Git/REST and relevant commits/tags/prereleases, without printing or committing them.
+Direct authenticated push/readback passed on this host, most recently publishing
+dc0f2e1. The subsequent owner's instruction commitcab01c3 has been fetched and
+merged locally; no force push or additional credentials are required.
+Historical verified bundle exchange remains reproducible: c6d296a bundle on
+`codex/behavior-transfer-20260910`,334830 decoded bytes, SHA256
+`526A80E2D32ED0E57A7B2372B5F02D4652E8751DFEBA81953C4F045225D6AACB`,
+prerequisite1797516. Both other hosts received it. Never merge transfer branches.
+Older bundles/logs retain historical scope in Git and the archived ledger.

-Legacy TASK_LEDGER/PLAN live content was migrated once in
-[comment 408](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/1#issuecomment-408).
-Those files are marked historical. Previous detailed STATE was preserved
-[byte-for-byte](history/2026-09-11-state-before-gitea-migration/STATE.md), including
-failed attempts, prior releases, transfer paths and earlier evidence links.
-Do not restore historical active-status or environment-next-step wording.
+## Remaining gates and highest-value next actions
+
+1. Freeze and compile the new workspace/chooser integration, resolve focused
+   failures, then build an immutable GUI and verify both native workspace fixes.
+   The676-test gate is complete for2cc4d11; new changes require their own evidence.
+2. Publish coherent checkpoints directly; integrate9e8r6t's next staged-source
+   work, then ytr83r B4 only after its coherent handoff. CLI/evidence import is done.
+   Preserve ownership and distinguish every external versus local gate.
+3. Use the self-checked independent oracle to exercise current Studio at
+   minimum/wide sizes: named creation, direct process/scenario edits, nested reuse,
+   caller return, lifeline lifecycle, invalid/cancel/recovery, Save/Undo/Redo/reopen.
+   Compare complete model/source and exact identities, not screenshots alone.
+4. Compile/review/measure the numeric foundation, then implement the ratified
+   analysis/library contracts with shared-core/source/API/graphical parity. Use real
+   budgets, unit/kind failures, complete text-only and two-project update workflows.
+   Integrate the bounded chooser and run its actual keyboard/minimum-size gates.
+5. Complete current teaching, transitions, semantic review, state/data, saved-view,
+   artifact, hosted transport and migration acceptance. Historical scoped passes
+   remain useful references, never blanket current acceptance.
+6. Complete Windows/Linux build/test/native/runtime and optimized package gates,
+   notices, provenance and clean-environment launch. WSL has no installed distro
+   here; Linux acceptance remains open. Historical denied guest workarounds must
+   not be retried or split to bypass review. No host restart is authorized.
+7. Run fresh independent cross-disciplinary end-state review, resolve material
+   findings and reconcile specification/help/coverage before final handoff.
+
+## Reassessment
+
+Meaningful progress continues: concrete interaction defects have been found and
+corrected,676 desktop tests pass and all four OA native creation/history/reopen
+checks pass. Contracts have converged through independent falsification; numeric
+implementation now addresses the exposed dynamic-work risk. The revised semantic
+requirements are no longer hidden behind metadata.
+Passing older suites or accumulating prose would not close the user problem.
+Current highest information gain comes from actual build/native results and
+independently criticized foundational examples, while preserving existing identity,
+source and atomicity contracts. Replan when those results falsify a proposal.
+
+## Historical evidence access
+
+The [complete prior STATE](history/2026-09-10-ledgers-before-continuation-refresh/STATE.md)
+retains exact historical binary hashes, counts, logs, process closure, bundle hashes
+and all report links. Links inside the byte-preserved archive retain their original
+`harness/` context; resolve those relative report paths from `harness/`.
+Useful direct entries: [source7 native](release-source7-native-acceptance-20260907.md),
+[teaching](release-teaching-native-20260906.md),
+[artifact native](release-artifacts-native-20260906.md),
+[coverage baseline](release-current-coverage-20260906.md),
+[Linux gate](release-source7-linux-gate-20260907.md),
+[Linux cross-build](release-source7-linux-gui-cross-build-20260907.md),
+[denied boot experiment](release-source7-linux-server-corrected-gate-20260907.md).
@@ -1,196 +1,223 @@
-> Historical record — superseded on 2026-09-11. Live plans, ownership and blockers
-> were migrated once to [Gitea issue 1, comment 408](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/1#issuecomment-408)
-> and [issue 2](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/2).
-> Do not update this as a live ledger. [STATE.md](STATE.md) links the verified integrated result.
-> The historical text below is preserved; its old active-status wording is not current guidance.
-
 # Task Ledger — first release

-Updated 2026-09-11 by Codex-9e8r6t `/root`. Full release not accepted.
+Updated 2026-09-11. [STATE.md](STATE.md) owns current execution/evidence;
+[PLAN.md](PLAN.md) owns capability milestones. The entire former Task Ledger is
+[preserved byte-for-byte](history/2026-09-10-ledgers-before-continuation-refresh/TASK_LEDGER.md).
+Its old goal references, aggregate test claims and stopped-session directives retain
+historical scope. New semantic decisions are recorded explicitly in DECISIONS.md;
+prototype results retain their separate scope.

-User resumed after enabling virtualization and explicitly authorized installing
-Ubuntu26.04 in WSL2. [RESTART_HANDOFF.md](RESTART_HANDOFF.md) is the historical
-pause; STATE.md owns current capacity, compiler and native status.
-User also explicitly permits disk cleanup including caches. Both scoped cache
-deletion commands were rejected before execution; nondeleting compression
-recovered space with all282 generated-binary hashes unchanged. Ordinary Ubuntu
-installation and an initial actual WSL2 root shell passed. Current VirtioProxy
-startups fail before guest execution, and a distinct WslService restart was
-denied by OS permissions. Owner328 remains the newest WSL solution after the
-latest issue check through348; its exact configuration is already applied.
-Five Rust components and60 apt packages are downloaded and hash-verified;
-guest signature verification/install and application acceptance remain pending.
-The user's latest direction pauses Linux work until they notify us that WSL
-networking is resolved. Continue Windows/product work; preserve existing Linux
-configuration, verified inputs and evidence without further setup/checks.
+Current compiled checkpoint2cc4d11 includes external creation4bb4aaf as1516949,
+isolated chooser13, and final baseline/library contracts. Local full676/format/
+strict Clippy pass; native80cf197 now passes four OA creations, exact history and
+reopen. Separate native SA Action/history also passes. Exact numeric foundation
+is declared at7d14bd0 and passes26/26 unit tests plus strict core all-target Clippy.
+Working workspace/production chooser changes remain outside compiled artifacts;
+independent chooser source review closed three focus findings,14 new host tests
+are prepared. Schema8 core implementation is isolated and uncompiled. External
+results retain their host/source attribution.

 ## Goal and success criteria

-[PROJECT_GOAL.md](../PROJECT_GOAL.md), copied from attachment
-`815ff7b9-73c4-41a2-a809-635ecf8389d6/goal-objective.md`, is authoritative.
-Deliver a usable, substantially complete OA/SA systems modeling product in
-Rust/Iced on Windows and Linux, with equivalent graphical/textual/REST editing,
-strict reST semantics/API, arbitrary development-artifact traceability and
-navigable offline help. Constraints/calculations, quantities/units and reusable
-model libraries and complete uncluttered text-only small/large modeling are
-explicit requirements. Later Arcadia layers remain future
-releases. Completion requires real engineering tasks, sound semantics, relevant
-passing checks and fresh independent cross-disciplinary review.
+Deliver the usable, feature-complete OA/SA first release specified in
+[PROJECT_GOAL.md](../PROJECT_GOAL.md). It is the exact copy of the user's revised
+`a49d1780-25d5-4778-ad68-6140c60e4207/goal-objective.md`, SHA256
+`DD58F75C93D55FE16ED141A23D834898FB6EBC625AE7E7AE379DA552A8312435`.
+
+Success requires coherent explicit semantics, practical engineering workflows,
+equivalent graphical/textual/REST behavior, real Windows/Linux runtime evidence,
+recoverable authoring, relevant automated evaluators, precise documentation,
+reproducible packages and fresh independent cross-disciplinary end-state review.
+No known blocker or high-impact finding may remain unresolved. Later Arcadia
+layers remain future scope. Code, a passing slice or an attractive screen alone
+cannot establish completion.

 ## Given facts

- User prioritizes Capella's domain capability and useful visual nesting while
-  rejecting clutter, intrusive creation rows, static behavior diagrams and long
-  homogeneous option lists. Reduce cognitive load in small and large models.
- Source must be understandable to engineers and AI, work with Git and preserve
-  full parity. OA/SA transitions in both directions must be clear and reviewed.
- User authorizes autonomous reversible work, research, native Computer Use and
-  parallel agents. Use GPT-6 Astra exclusively with task-appropriate effort.
- Gitea coordination and shared Wiki updates are required. Identify host and
-  worker consistently and preserve overlapping work. Explicit project messages
-  are authorized; unrelated external messages are not.
- Updated AGENTS requires runnable versioned milestone prereleases. User
-  issue 1 comment 178 authorizes reusing existing MCP credentials programmatically for
-  Git push and REST asset upload, without printing or committing credentials.
- Remote AGENTS.md, blob `4b8465c8993107062ad2974c15a958d449530e92`, adds concise
-  harness/Gitea maintenance and preservation of useful historical knowledge
-  (user comment 229). Root's instruction sync `07eb3cd` is integrated;
-  contextual source `df6f595`, CLI publication `d95b1ab` and OA native evidence
-  `c4bad4b` are committed and pushed.
+- Rust/Iced desktop and a deployable REST service serve system engineers. OA/SA
+  transitions in both directions must be understandable, explicit and useful.
+- The revised goal explicitly requires constraints/calculations, quantities/units,
+  reusable model libraries, state/behavior modeling and strong standardized
+  specification/API, as well as textual/graphical notation and artifact traceability.
+- Human/AI/Git-friendly source and a concrete unambiguous reST specification must
+  match graphical editing. The source editor needs highlighting/linting; help must
+  be offline, concise and navigable.
+- The newest explicit goal requires uncluttered notation that reduces cognitive
+  load and supports development of complete small and large models using text alone.
+- Direct behavior/scenario diagram authoring and reduced cognitive load are current
+  priorities. Long homogeneous selectors and bloated persistent creation controls
+  are rejected. Study actual Capella's useful domain workflows and nesting without
+  mechanically copying its interaction problems.
+- The user authorizes autonomous bounded engineering, native Capella/Studio
+  evaluation and explicit independent delegation, exclusively with GPT-6 Astra
+  at effort appropriate to the question. Root owns synthesis/integration.
+- Project instructions require Gitea coordination, ownership preservation and
+  durable handoffs. Current root reserves one Cargo/native operator per host.
+  Updated AGENTS4b8465c8 requires coordinated runnable milestone prereleases and
+  concise current shared maintenance with unique historical evidence preserved;
+  user Gitea#178 authorizes programmatic existing-MCP-credential reuse for relevant
+  Git/REST publication without printing/committing secrets. Restart and usage reset
+  remain unauthorized.
+- Gitea issue2 explicitly requires actual Process/Scenario canvases with the same
+  interaction approach as architecture/state diagrams. Existing pointer edits
+  inside scrollable projections do not by themselves satisfy that requirement.

 ## Verified facts

-[STATE.md](STATE.md) records exact commits, live leases and scoped verification.
-The current model has one typed core, validated atomic commands and coordinated
-Project/SourceBundle history shared by desktop and REST. Included files share
-one global namespace. Current Constraint expressions are strings; numeric unit
-strings do not convert values or establish dimensional compatibility. There is
-no locally integrated package/version/instance/update contract for cross-project
-libraries; peer implementation is tracked separately below.
+- The independent scenario checker compiled with warnings denied and passed its
+  self-check, deterministic fixture generation and complete baseline check on this
+  host. Its eight OA/SA checkpoints and exact UUID/source restoration comparisons
+  are evaluator evidence, not native Studio acceptance. Exact inputs/hashes are in
+  [the fixture instructions](fixtures/scenario-authoring/README.md).

-The main basic/transition/history/reopen story passed exact independent model
-and four/six-source checks; supplementary native cases remain. Named creation
-passed 7/8/9-source oracles, one Undo/Redo and byte-exact reopen at actual minimum
-size. Cancellation retained its six-file baseline; SA draft recovery retained
-fields/identities, autofocus and Escape/Save As behavior. The D4D9 blank-canvas
-finding motivated the newer first-action implementation. Detailed historical
-suite and native scopes remain in [STATE.md](STATE.md) and its linked reports.
-Mounted geometry and bounded package passes do not establish full release
-acceptance. This local host has installed Ubuntu26.04 but lacks a currently
-usable guest session, installed build prerequisites or Linux application pass.
-
-Current grammar supports omitted initial IDs/defaults, lexical ownership, forward
-references and preserved source. The earlier desktop audit found no exposed
-project-wide reference navigation/alias refactor; its Find searched the active
-buffer. The later CLI supplies typed alias rename. The audited process example
-had 128 lines, 14 UUIDs and 31 empty-default lines, while meaningful shorter
-source is possible. Two concise snippets passed 26 real REST requests,
-including identity-only normalization, exact name-only edits, rejected writes and
-restart persistence. Counts and this small trial prove neither improved native
-usability nor large-project performance.
-
-CLI tooling is implemented, integrated and published: semantic source `01b76a1`,
-packaging assembly `a0a48e8`, release integration `27df4a3`. Author 12 tests and
-independent 183 semantic assertions pass; independent clean-package review adds
-156 assertions across 10 processes. This is a bounded source-editing tool, not
-proof of complete large-model language ergonomics.
-
-GUI/server release 1 and standalone CLI release 2 are published with runnable
-Windows artifacts, full dependency notices and downloaded asset verification.
-Independent archive/source and clean runtime checks pass in their declared scopes.
-See [CLI publication evidence](release-cli-prerelease-published-20260911.md).
-The newer 13-file contextual-source slice is committed/pushed as `df6f595`,
-with its independent oracle and exact raw evidence. It passed focused 23, guide 3, strict
-Clippy, matching GUI build and formatting. The full 675 suite covers only its
-predecessor; no full 676 suite has run. Root launched the exact 52DE82 GUI in
-isolation: Lifeline Save-adoption and Chain direct Create pass complete source,
-one Undo and one Redo. Machine direct Create and one Undo pass; Redo/reopen are
-pending for Redo. An isolated postboot real Open/SA view/Save passed the complete
-machine prediction and exact six-file equality; the app closed normally.
-Later layout/caption source was independently reviewed. Postboot focused3 ran25
-passing tests and one overflowing-fixture assertion failure. The stronger
-test-only fixture is frozen; its execution and new GUI remain pending.
-
-Local OA B2 now passes all four Action/State/explicitly bound Reuse/Fragment
-Create, one Undo/Save, one Redo/Save and final OA reopen/Save against independent
-complete model/two-source predictions and original exact identities. SA B2 is
-pending locally. Existing B3 OA wide/minimum and SA minimum return scopes remain
-unchanged; neither these passes nor mounted geometry tests imply broader acceptance.
+- The historical native implementation is `80cf197` on `codex/behavior-authoring-20260910`, following
+  baseline `1797516`. Local commits cover B1/B2/B3 authoring, nullable history cache
+  (`b6b76ef`), external palette integration (`aed40d7`), cfg(test) lifecycle projection
+  (`eb5161b`), history seed correction (`4ecad78`) and exact-identity native oracle.
+  Later imports add focus recovery, exact packaging notices and scenario workspace/
+  owner restoration. Root80cf197 fixes document/scenario viewport Sensor identity
+  with a real mounted red-before/green-after regression.
+- This fresh host has task-local Rust/Cargo 1.98.1 GNU/LLVM and verified LLVM-MinGW.
+  The integrated2cc4d11 desktop suite passes676/676, zero failed/ignored, with a
+  warning-free build; formatting and strict Clippy pass. History, pure lifecycle,
+  creation and isolated chooser are included. New working code still needs its
+  own gate. Native80cf197 evidence is separate. [Exact hashes/logs](STATE.md).
+- Strict language HTML regeneration and the source7 OpenAPI checker passed locally:
+  72 fixtures, 204 schemas and 90 scalar leaves. Actual isolated Capella scenario,
+  activity/lifeline and LOOP creation was saved/inspected; this is reference study,
+  not Studio acceptance. [Native benchmark](release-capella-scenario-benchmark-20260910.md).
+- Core/source7 already implements substantial direct behavior, typed data/ports,
+  contextual chain links, maintained message-operation identity, semantic reviews,
+  artifacts, hosted source envelopes and recovery. Historical absence claims must
+  be checked against code and newer scoped evidence, not copied forward.
+- [Requirements audit](release-requirements-delta-20260910.md): Constraint and other
+  expression strings are descriptive, with no calculation/binding/result evaluator;
+  unit strings persist/inherit without dimensional compatibility or conversion;
+  named types/sequence/scenario reuse and includes exist, but there is no maintained
+  cross-project package/version/instance/update contract. These are explicit gaps.
+- The same audit identifies concrete unbounded Constraint target choices and generic
+  expanded collection editors. Explorer already has hierarchy/search/paging; the
+  problem is targeted, not a claim that all selection is flat.
+- Gitea #79's same-selected-ID/visible-owner defect is fixed in the imported
+  scenario checkpoint; owner restoration and pending-draft guards pass current
+  tests. B4 independent review #114 adds Scene integration requirements for actual
+  lifetime extents, branch-local activation clipping, incomplete lanes and self arrows.
+- Codex-9e8r6t and Codex-ytr83r have independent host-local Cargo/native leases.
+  Named creation/workspace/palette/package integration is imported here.9e8r6t's
+  coherent CLI/evidence checkpoint01b76a1 awaits import; it owns staged-source and
+  the next runnable Windows prerelease. ytr83r owns production B4 and its native
+  oracle.9e8r6t successfully reused existing credentials for direct push; this
+  host is setting up the same authorized publication path.
+- Current Linux acceptance is open; this host has no installed WSL distribution.
+  Historical Linux core/server/cross-build results have exact older snapshot scope.
+  The earlier denied guest workaround did not run and must not be bypassed.

 ## Assumptions
- Contextual named creation, remaining-height canvas and local source insertion
-  can reduce actual authoring detours. Native engineer tasks must establish this.
- A bounded pure calculation/quantity model and pinned library content may fit
-  the existing typed core better than a general-purpose metamodel rewrite.
-  Peer-ratified core staging must still be checked against independent engineering
-  tasks and integrated across all required representations.
- Existing OA/SA semantics provide a useful foundation; neither their presence
-  nor old acceptance proves full conformance to the updated release objective.
+
+- Compact contextual tools and an adequately sized scenario workspace can reduce
+  friction; only actual engineering tasks at minimum/wide sizes can validate this.
+- The ratified bounded pure analysis and pinned-library architecture can satisfy
+  real engineering work without full language/runtime adoption. This remains a
+  product adequacy assumption until actual budgets, approximate calculations and
+  two-project/source/API/native workflows pass; metadata is insufficient.
+- Existing shared core/source/history boundaries remain suitable for additions;
+  foundational examples and independent criticism must test that assumption.

 ## Open questions

- Which precise calculation, quantity-kind/unit and library contracts satisfy
-  practical budgets, reuse and update workflows without ambiguous defaults or
-  implicit execution? How should they migrate and participate in transitions?
- Which behavior workflows still force cancellation/navigation to create missing
-  context, and which local actions best remove those detours?
- Which text-only assistance best preserves engineering context and identity:
-  native language services, external-editor services, source recipes or explicit
-  reviewed patch operations? Which grammar changes are actually necessary?
- Does the new scenario pane remain readable and editable through actual native
-  window sizes, camera changes, nested fragments and reopened caller contexts?
- Which viable Linux environment can run current GUI/server acceptance? Current
-  VM limitation does not block remaining Windows, semantics or source work.
+- Do the ratified owned-value/shared-check/R6/R7 contracts meet real engineering
+  budgets once implemented, including approximate numeric requirements? What
+  measured ceilings keep work bounded without rejecting ordinary studies?
+- Does actual package closure/canonical consumer typing/source preparation and
+  three-way update preserve every stable identity and local engineering edit?
+- What migration and OA↔SA treatment follows from those contracts without guessing
+  executable meaning from old strings or silently changing old models?
+- How can text-only creation establish library instance bases/maps, preserve
+  compatibility across cosmetic package revisions, export subjectless cases, and
+  transition mounted OA/SA data without hidden GUI normalization or silent forks?
+- Will full evaluator and private-capture replay preserve effective-case and
+  deterministic work-limit behavior across direct, REST and cache-warm execution?
+- Which source-preserving refactoring/navigation and grammar changes reduce actual
+  engineering effort while retaining stable identity and cross-file ownership?
+- Do current real gestures, exact caller return, nested scopes and lifecycle markers
+  remain usable and correct under minimum sizing, scrolling, zoom and dirty drafts?
+- Which uncovered teaching, traceability, transition, saved-view, state/data, hosted
+  and platform cases remain after current-binary acceptance? What supported Linux
+  environment can complete the remaining actual runtime gate?
+- Does "standardized" require any external conformance beyond the project's precise
+  interoperable spec/API? Full OMG conformance is not inferred merely from comparison
+  to SysML v2; explicit claims require a mapped and verified contract.

-## Candidate designs and decisions
+## Candidate hypotheses / designs

- Behavior creation: compact New → three task choices → focused name/owner/
-  viewpoint card, explicit missing inputs, atomic creation and reserved recovery
-  IDs. Implemented, reviewed and scoped native creation/history/reopen passed.
- Contextual prerequisite creation: stage an explicit typed source inside the
-  current parent draft, then validate/adopt source and consumer atomically. This
-  preserves intent and one-step history; a separate Architecture excursion or
-  early source commit loses those guarantees. Initial Lifeline/process Work/
-  machine-owner adapters and semantic first-action prompts are implemented,
-  reviewed and integrated with focused gates passed; scoped native results are
-  above, with remaining acceptance still open. See the
-  [bounded plan](release-contextual-source-creation-plan-20260911.md).
- Scenario workspace: compact header, optional Tools/Selection shelves, actual
-  remaining-height canvas/form, pinned actions, independent scrolling and
-  explicit Fit/Focus. Mounted tests support this choice; native proof pending.
- User issue2/comment250 clarifies that diagram manipulation may respect
-  sequence/domain constraints. Codex-956atf owns a shared canvas-shell redesign;
-  the existing controls and supporting source-card fixes do not close the issue.
- Quantities/calculations: peer comment 231 records ratified schema 8/local
-  definitions and actual shared analysis/core types under implementation in
-  isolated `codex/analysis-core-20260911`. This is not a local schema admission,
-  evaluator or graphical/source/API parity pass; the local core remains descriptive.
- Libraries: compare copied source, live references, generic definition/usages
-  and pinned typed packages with explicit mappings and reviewed updates.
-  [Falsification brief](release-library-candidate-review-20260910.md) records
-  identity, dependency, offline and conflict requirements. Refined peer baseline,
-  Case, full-freeze and exact-pin/equivalence contracts are ratified externally;
-  their local integration and executable lifecycle acceptance remain pending.
- Text authoring: use existing omission/default/identity contracts for concise
-  experiments; compare source navigation/refactoring/patch assistance before
-  grammar redesign. No namespace, hidden identity or omission change ratified.
- Reference chooser: peer comment 224's corrected focus ownership, nested-scroll
-  reveal and mounted regressions are prepared, not executed. Preserve that
-  ownership and wait for its source/test handoff.
+The [requirements delta](release-requirements-delta-20260910.md) compares metadata/
+snippets, bounded pure engineering analysis with maintained pinned libraries,
+external evaluators, and full standards adoption. Metadata alone fails the explicit
+new semantics; external tools alone still need binding/result contracts. The report
+recommends the bounded route for root synthesis, not as a ratified decision.

-Long-lived decisions remain in [DECISIONS.md](DECISIONS.md). New user scope and
-normative contracts supersede older prototype exclusions.
+Independent maximum-reasoning tracks now compare owned engineering properties
+versus analysis contexts; calculation definitions/applications; numeric/unit rules;
+and copy, linked-definition, live-instance or pinned-definition/editable-instance
+library architectures. Require concrete falsifiers, source/API migration effects,
+identity/history/recovery behavior and independent critique before convergence.
+These alternatives converged after concrete experiments and independent review:
+B property bases/shared checks/full capture, R6/R7, exact pins with same-origin
+typed compatibility and explicit portable normalization are now ratified. Complete
+11-file proposed baseline and120-assertion finite library prototype remain distinct
+from production admission. Independent292-check review exposed C1 dynamic-work
+expansion and a C2 prototype threshold-unit gap; implementation must close both.
+The text-only40-identity fixture and13 mounted chooser tests pass. Production
+numeric foundation and inspector/review chooser are active, with gates pending.
+
+The subsequent context experiment passed218 assertions: shared property baselines
+and one-level overrides reduce repeated input maintenance while retaining explicit
+independent freeze. Root selected that B direction for precise contract refinement;
+quantity/library/source details remain open. [Decision](DECISIONS.md),
+[experiment and limits](release-analysis-context-experiment-20260911.md).
+
+## Decisions retained
+
+- Keep explicit Rust crate responsibilities and one authoritative typed Project
+  with validated atomic Commands. A thin source CLI reuses the shared core. Separate semantic identity/ownership, allocation/reference/order and
+  diagram geometry. Forms are closed adapters, not a second metamodel. New persistent
+  semantics require core/source/UI/API/reference/transition parity. [Decisions](DECISIONS.md).
+- Preserve authored source ownership/comments/includes, exact identity and accepted
+  model/source history. Source writeback must succeed before adoption. Raw invalid,
+  excluded or rejected drafts survive; navigation/tools must not implicitly accept
+  another editor. Recovery validates/replans rather than trusting serialized commands.
+- Semantic reconciliation uses finite typed facets, frozen baselines, explicit
+  mappings, actual destination slots and a single atomic candidate. Do not infer
+  identity by name or apply reviewed rows as sequential independent edits.
+  [Foundation](release-semantic-batch-foundation-design.md),
+  [artifact contract](release-semantic-artifacts.md).
+- Layer transitions are explicit engineering decisions, not automatic propagation.
+  Behavior-root navigation must establish the requested owner while preserving
+  unrelated architecture presentation. Ports/allocation and contextual occurrences
+  retain their distinct domain meaning. [Source7 contract](release-source7-integration-decision-20260906.md).
+- Hosted revision/source envelopes and ETag checks remain atomic; credentials stay
+  out of persisted models and repository. Linux journal publication retains the
+  selected no-replace invariant, with measured limits, not an overwrite fallback.
+  [Journal decision](release-linux-journal-publication.md).
+- Repair/evaluate the compact palette informed by native Capella evidence; do not
+  return to the rejected horizontal toolbar. Lifecycle projection remains isolated
+  under cfg(test) until coordinated Scene integration and actual acceptance.
+- Preserve historical scope decisions as history. In particular, architecture-only
+  SVG is implemented and behavior SVG was deferred; that is not proof of satisfying
+  the revised release objective. Reassess older exclusions against current scope.

 ## Current strategy

-Finish coherent creation gates and test the rebuilt product against independent
-saved-source oracles. Close remaining scenario lifecycle integration boundaries.
-Use the native Capella study and independent criticism to address real authoring
-friction. In parallel, resolve foundational semantic additions and text-only
-authoring through bounded competing designs and executable experiments. Then implement all representations,
-verify real REST and Windows/Linux workflows, build actual optimized packages
-and conduct fresh end-state review. Do not weaken acceptance to match current
-implementation or stop because a narrow technical milestone passed.
+Finish the new workspace/chooser compile and native loop; independently review
+and measure the numeric foundation before expanding the ratified semantics.
+Integrate coherent external CLI/staged-source/B4 checkpoints while preserving
+ownership and source attribution. Use independent complete model/source oracles
+and exact identity/history comparisons. Publish coordinated runnable milestone
+prereleases; close actual analysis/library/source/API/native, cross-platform,
+service/package and independent end-state gates before the final handoff.

-Pre-consolidation content is preserved byte-for-byte in
-[the dated archive](history/2026-09-10-ledgers-before-second-consolidation/TASK_LEDGER.md).
+The [archived Task Ledger](history/2026-09-10-ledgers-before-continuation-refresh/TASK_LEDGER.md)
+and [archived STATE](history/2026-09-10-ledgers-before-continuation-refresh/STATE.md)
+preserve all older claims, decisions and evidence links exactly. Relative report
+links inside those byte-preserved files resolve from their original `harness/`
+context. Their historical test totals and process holds are not live status.
@@ -0,0 +1,15 @@
+# Baseline contract fixtures
+
+Companion to [the candidate contract](../../release-analysis-baseline-contract-20260911.md). This is proposed schema/source/JSON, not implemented Studio syntax.
+
+- active.arcadia.proposed is a complete UUID-bearing local model with four base bindings, two cases and one shared check.
+- evaluate-*.json are complete candidate REST request bodies.
+- portable-document.json.proposed exposes the complete candidate Project, exact source, local definitions and explicitly empty library collections.
+- freeze-degraded.json.proposed retains those exact document bytes, a SHA256 commitment, complete effective bindings/checks, and private definition inventory.
+- expected-observations.json records hand-derived arithmetic/context expectations, not evaluator output.
+- r7-literal-boundaries.json contains full exact JSON literal nodes and their expected canonical source, including 301-digit and 4096-bit boundaries.
+- fixture-integrity.json records only transport/source/UUID checks and size counts.
+
+Run build-fixtures.ps1 with PowerShell 7 to regenerate the JSON fixtures. It writes only within this directory. The script constructs the proposed typed data; it does not parse source, evaluate expressions, run Rust, or establish Project/source semantic equality. Changing the fixture file's exact line endings changes the captured document and digest; preserve these snapshot bytes when publishing.
+
+The full local capture has no imports, so empty pins/package content are complete for this example. Nonempty pinned-package capture and offline replay remain a required paired library/evaluator acceptance test, not something this local transport fixture has proved.
@@ -0,0 +1,55 @@
+arcadia 8;
+project response_budget "Response budget" id "4210b9f2-7046-47f0-aa3b-153f626a579d" {
+    description "A complete proposed analysis model. Schema 8 and the new declarations are not implemented source7 syntax.";
+
+    quantity_kind duration "Duration" id "188b911c-5f8b-431c-9eea-2d41f3953767" {
+        dimension { time: 1; }
+        algebra Linear;
+    }
+    unit second "Second" id "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce" {
+        kind @duration; scale 1; offset 0; symbol "s";
+    }
+    unit millisecond "Millisecond" id "39053f37-fec9-4708-9f0a-3959d223f891" {
+        kind @duration; scale ratio(1, 1000); offset 0; symbol "ms";
+    }
+    calculation combine "Combine durations" id "fd7ce7ab-f789-40bc-b699-0c37f1b6902f" {
+        input a id "28ff40b0-1b8f-4735-8536-5a6ab21b56cb" : Quantity(@duration);
+        input b id "7a47cc1e-8ae5-4551-b2d8-8a68108e0976" : Quantity(@duration);
+        result Quantity(@duration);
+        body $a + $b;
+    }
+
+    oa_activity respond "Respond" id "cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59" {
+        oa_activity receive "Receive" id "4ab9a8a7-7552-488d-9862-e14b89e7b353" {}
+        oa_activity dispatch "Dispatch" id "6df991ba-4c5e-4535-99e2-524ae274ee8b" {}
+    }
+    oa_property receive_time "Receive time" id "63a931c2-675a-4fce-89e5-04361cb99450" {
+        subject @receive; type Quantity(@duration); display_unit @millisecond;
+        base 750 [@millisecond];
+    }
+    oa_property dispatch_time "Dispatch time" id "c33fc772-2a60-4044-9af9-73c61c563ace" {
+        subject @dispatch; type Quantity(@duration); display_unit @second;
+        base 1 [@second];
+    }
+    oa_property total_time "Total time" id "bd5b68e8-65fc-4e35-9071-a73061316a4b" {
+        subject @respond; type Quantity(@duration); display_unit @second;
+        // The formula is shared. Every read uses the requested evaluation context.
+        base @combine(a: @receive_time, b: @dispatch_time);
+    }
+    oa_property limit "Allowed duration" id "437bedbb-2cf4-44ee-a139-6563cc5086ec" {
+        subject @respond; type Quantity(@duration); display_unit @second;
+        base 2 [@second];
+    }
+    oa_check budget "Response budget" id "bac0de99-9d2f-4e53-9158-d424ecac61bf" {
+        subject none; documented_constraint none;
+        predicate @total_time <= @limit;
+    }
+    oa_analysis degraded "Degraded radio" id "38036c65-16d4-449c-837b-91eb141c1d93" {
+        subject none; base ModelBaseline;
+        overrides { @receive_time = 1250 [@millisecond]; }
+    }
+    oa_analysis unmeasured "Unmeasured radio" id "99d3e09a-0ec3-4194-9dd4-9f3de6625cde" {
+        subject none; base ModelBaseline;
+        overrides { @receive_time = unbound; }
+    }
+}
@@ -0,0 +1,216 @@
+# Fixture construction only. This does not parse/evaluate the proposed language.
+$ErrorActionPreference = 'Stop'
+$taskDir = $PSScriptRoot
+$ids = @{
+    project = '4210b9f2-7046-47f0-aa3b-153f626a579d'
+    duration = '188b911c-5f8b-431c-9eea-2d41f3953767'
+    second = '534f4672-1ba5-4157-8b0a-b9cf41d0a3ce'
+    millisecond = '39053f37-fec9-4708-9f0a-3959d223f891'
+    combine = 'fd7ce7ab-f789-40bc-b699-0c37f1b6902f'
+    input_a = '28ff40b0-1b8f-4735-8536-5a6ab21b56cb'
+    input_b = '7a47cc1e-8ae5-4551-b2d8-8a68108e0976'
+    respond = 'cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59'
+    receive = '4ab9a8a7-7552-488d-9862-e14b89e7b353'
+    dispatch = '6df991ba-4c5e-4535-99e2-524ae274ee8b'
+    receive_time = '63a931c2-675a-4fce-89e5-04361cb99450'
+    dispatch_time = 'c33fc772-2a60-4044-9af9-73c61c563ace'
+    total_time = 'bd5b68e8-65fc-4e35-9071-a73061316a4b'
+    limit = '437bedbb-2cf4-44ee-a139-6563cc5086ec'
+    degraded = '38036c65-16d4-449c-837b-91eb141c1d93'
+    unmeasured = '99d3e09a-0ec3-4194-9dd4-9f3de6625cde'
+    budget = 'bac0de99-9d2f-4e53-9158-d424ecac61bf'
+}
+function Exact([string]$n, [string]$d = '1') {
+    return @{ numerator = $n; denominator = $d }
+}
+function Local([string]$name) { return @{ Local = $ids[$name] } }
+function ReadProperty([string]$name) { return @{ Property = $ids[$name] } }
+function Literal([string]$n, [string]$unit) {
+    return @{ Quantity = @{ magnitude = (Exact $n); unit = (Local $unit) } }
+}
+function Bound($expr) { return @{ Expression = $expr } }
+function Record([string]$key, [string]$name, $body) {
+    return @{
+        id = $ids[$key]; alias = $key; name = $name; description = ''; body = $body
+    }
+}
+function Element([string]$key, [string]$name, $body, $parent = $null) {
+    $r = Record $key $name $body
+    $r.parent = $parent
+    return $r
+}
+function Property([string]$key, [string]$name, [string]$subject, [string]$unit, $binding) {
+    return Element $key $name @{ Oa = @{ Shared = @{ EngineeringProperty = @{
+        subject = @{ Element = $ids[$subject] }
+        value_type = $quantityType
+        display_unit = (Local $unit)
+        base = $binding
+    } } } }
+}
+function OrderedCopy($value) {
+    if ($null -eq $value) { return $null }
+    if ($value -is [Collections.IDictionary]) {
+        $copy = [ordered]@{}
+        [string[]]$keys = @($value.Keys)
+        [Array]::Sort($keys, [StringComparer]::Ordinal)
+        foreach ($key in $keys) { $copy[$key] = OrderedCopy $value[$key] }
+        return $copy
+    }
+    if ($value -is [Collections.IEnumerable] -and $value -isnot [string]) {
+        $copy = @()
+        foreach ($item in $value) { $copy += ,(OrderedCopy $item) }
+        return ,$copy
+    }
+    return $value
+}
+function JsonBytes($value) {
+    $json = (OrderedCopy $value) | ConvertTo-Json -Depth 100
+    $json = $json.Replace([string][char]13 + [string][char]10, [string][char]10)
+    return [Text.UTF8Encoding]::new($false).GetBytes($json + [string][char]10)
+}
+function SaveBytes([string]$name, [byte[]]$bytes) {
+    [IO.File]::WriteAllBytes((Join-Path $taskDir $name), $bytes)
+}
+$quantityType = @{ Scalar = @{ Quantity = (Local 'duration') } }
+$definitions = @{}
+$definitions[$ids.duration] = Record 'duration' 'Duration' @{ QuantityKind = @{
+    dimension = @(0, 0, 1, 0, 0, 0, 0); algebra = 'Linear'
+} }
+$definitions[$ids.second] = Record 'second' 'Second' @{ Unit = @{
+    kind = (Local 'duration'); scale = (Exact '1'); offset = (Exact '0'); symbol = 's'
+} }
+$definitions[$ids.millisecond] = Record 'millisecond' 'Millisecond' @{ Unit = @{
+    kind = (Local 'duration'); scale = (Exact '1' '1000'); offset = (Exact '0'); symbol = 'ms'
+} }
+$definitions[$ids.combine] = Record 'combine' 'Combine durations' @{ Calculation = @{
+    parameters = @(
+        @{ id = $ids.input_a; name = 'a'; value_type = $quantityType },
+        @{ id = $ids.input_b; name = 'b'; value_type = $quantityType }
+    )
+    result = $quantityType
+    body = (Bound @{ Binary = @{
+        op = 'Add'; left = @{ Parameter = $ids.input_a }; right = @{ Parameter = $ids.input_b }
+    } })
+} }
+$receiveBase = Bound (Literal '750' 'millisecond')
+$dispatchBase = Bound (Literal '1' 'second')
+$totalBase = Bound @{ Call = @{
+    definition = (Local 'combine')
+    arguments = @{
+        $ids.input_a = (ReadProperty 'receive_time')
+        $ids.input_b = (ReadProperty 'dispatch_time')
+    }
+} }
+$limitBase = Bound (Literal '2' 'second')
+$degradedBinding = Bound (Literal '1250' 'millisecond')
+$predicate = Bound @{ Binary = @{
+    op = 'LessOrEqual'; left = (ReadProperty 'total_time'); right = (ReadProperty 'limit')
+} }
+$elements = @{}
+$elements[$ids.respond] = Element 'respond' 'Respond' @{ Oa = 'Activity' }
+$elements[$ids.receive] = Element 'receive' 'Receive' @{ Oa = 'Activity' } $ids.respond
+$elements[$ids.dispatch] = Element 'dispatch' 'Dispatch' @{ Oa = 'Activity' } $ids.respond
+$elements[$ids.receive_time] = Property 'receive_time' 'Receive time' 'receive' 'millisecond' $receiveBase
+$elements[$ids.dispatch_time] = Property 'dispatch_time' 'Dispatch time' 'dispatch' 'second' $dispatchBase
+$elements[$ids.total_time] = Property 'total_time' 'Total time' 'respond' 'second' $totalBase
+$elements[$ids.limit] = Property 'limit' 'Allowed duration' 'respond' 'second' $limitBase
+$elements[$ids.budget] = Element 'budget' 'Response budget' @{ Oa = @{ Shared = @{ AnalysisCheck = @{
+    subject = $null; documented_constraint = $null; predicate = $predicate
+} } } }
+$elements[$ids.degraded] = Element 'degraded' 'Degraded radio' @{ Oa = @{ Shared = @{ AnalysisCase = @{
+    subject = $null; base = 'ModelBaseline'; overrides = @{ $ids.receive_time = $degradedBinding }
+} } } }
+$elements[$ids.unmeasured] = Element 'unmeasured' 'Unmeasured radio' @{ Oa = @{ Shared = @{ AnalysisCase = @{
+    subject = $null; base = 'ModelBaseline'; overrides = @{ $ids.receive_time = 'Unbound' }
+} } } }
+$sourceBytes = [IO.File]::ReadAllBytes((Join-Path $taskDir 'active.arcadia.proposed'))
+$source = [Text.UTF8Encoding]::new($false, $true).GetString($sourceBytes)
+$project = @{
+    schema_version = 8; id = $ids.project; alias = 'response_budget'; name = 'Response budget'
+    description = 'A complete proposed analysis model. Schema 8 and the new declarations are not implemented source7 syntax.'
+    elements = $elements; relations = @{}; diagrams = @{}; artifact_links = @{}; traces = @{}
+    definitions = $definitions; imports = @{}; definition_mounts = @{}; library_instances = @{}
+}
+$document = @{
+    model = $project
+    source = @{ entry = 'active.arcadia'; files = @{ 'active.arcadia' = $source } }
+    packages = @{}
+}
+[byte[]]$documentBytes = JsonBytes $document
+SaveBytes 'portable-document.json.proposed' $documentBytes
+$documentDigest = [Convert]::ToHexString([Security.Cryptography.SHA256]::HashData($documentBytes)).ToLowerInvariant()
+$manifest = @(
+    @{ property = $ids.receive_time; binding = $degradedBinding; origin = @{ CaseOverride = $ids.degraded } },
+    @{ property = $ids.dispatch_time; binding = $dispatchBase; origin = 'ModelBaseline' },
+    @{ property = $ids.total_time; binding = $totalBase; origin = 'ModelBaseline' },
+    @{ property = $ids.limit; binding = $limitBase; origin = 'ModelBaseline' }
+) | Sort-Object { $_.property }
+$freeze = @{
+    format = 'arcadia-analysis-freeze-1-proposal'
+    captured_document = @{
+        media_type = 'application/vnd.arcadia.portable-document+json'
+        sha256 = $documentDigest
+        bytes_base64 = [Convert]::ToBase64String($documentBytes)
+    }
+    origin = @{ Local = @{
+        document_instance = 'd911a3c0-8adb-4203-850c-b16e9b4e4d0a'; accepted_revision = 1
+    } }
+    model_id = $ids.project
+    context = @{ Case = $ids.degraded }
+    targets = @{ properties = @($ids.total_time); checks = @($ids.budget) }
+    numeric_profile = 'Q1-exact-1'
+    effective_bindings = @($manifest)
+    check_predicates = @(@{ check = $ids.budget; predicate = $predicate })
+    definition_capture = @{
+        document_sha256 = $documentDigest
+        local_definitions = @($ids.duration, $ids.second, $ids.millisecond, $ids.combine | Sort-Object)
+        imports = @()
+    }
+}
+SaveBytes 'freeze-degraded.json.proposed' (JsonBytes $freeze)
+$expected = @{
+    status = 'Hand-derived expectations, not evaluator output'
+    baseline = @{ total_canonical_seconds = (Exact '7' '4'); check = 'Satisfied' }
+    degraded = @{ total_canonical_seconds = (Exact '9' '4'); check = 'Violated' }
+    unmeasured = @{ total = 'Missing'; input = $ids.receive_time; check = 'Unresolved' }
+    after_clear_unmeasured_override = @{ total_canonical_seconds = (Exact '7' '4'); check = 'Satisfied' }
+    after_baseline_dispatch_changes_to_two_seconds = @{
+        active_degraded_total = (Exact '13' '4'); frozen_degraded_total = (Exact '9' '4')
+    }
+}
+SaveBytes 'expected-observations.json' (JsonBytes $expected)
+$largeInteger = [Numerics.BigInteger]::Pow([Numerics.BigInteger]10, 300).ToString()
+$smallDenominator = [Numerics.BigInteger]::Pow([Numerics.BigInteger]2, 4095).ToString()
+$boundInteger = ([Numerics.BigInteger]::Pow([Numerics.BigInteger]2, 4096) - 1).ToString()
+$literalFixtures = @(
+    @{ name = 'ten_to_300'; expression = @{ Number = (Exact $largeInteger) }; canonical_source = $largeInteger },
+    @{ name = 'one_over_two_to_4095'; expression = @{ Number = (Exact '1' $smallDenominator) }; canonical_source = ('ratio(1, ' + $smallDenominator + ')') },
+    @{ name = 'negative_4096_bit_bound'; expression = @{ Number = (Exact ('-' + $boundInteger)) }; canonical_source = ('ratio(-' + $boundInteger + ', 1)') }
+)
+SaveBytes 'r7-literal-boundaries.json' (JsonBytes $literalFixtures)
+# Verify only JSON transport, UUID completeness, raw source retention and hashes.
+$parsed = Get-Content -LiteralPath (Join-Path $taskDir 'freeze-degraded.json.proposed') -Raw | ConvertFrom-Json
+$decoded = [Convert]::FromBase64String($parsed.captured_document.bytes_base64)
+if ([Convert]::ToBase64String($decoded) -cne [Convert]::ToBase64String($documentBytes)) { throw 'Document capsule differs' }
+$parsedDoc = [Text.Encoding]::UTF8.GetString($decoded) | ConvertFrom-Json
+if ($parsedDoc.source.files.'active.arcadia' -cne $source) { throw 'Source changed' }
+if ($ids.Count -ne (@($ids.Values | Sort-Object -Unique)).Count) { throw 'Duplicate fixture UUID' }
+foreach ($value in $ids.Values) {
+    [void][guid]::ParseExact($value, 'D')
+    if (-not $source.Contains('id "' + $value + '"')) { throw "Missing source identity $value" }
+}
+$stats = @{
+    source_lines = ($source -split [string][char]10).Count - 1
+    source_utf8_bytes = $sourceBytes.Length
+    explicit_source_uuids = $ids.Count
+    project_elements = $elements.Count
+    local_definitions = $definitions.Count
+    scoped_parameters = 2
+    base_bindings = 4
+    override_bindings = 2
+    shared_checks = 1
+    portable_document_sha256 = $documentDigest
+    verified = 'JSON transport, 17 syntactically valid distinct UUIDs, exact source bytes, capsule equality. No proposed parser/evaluator execution.'
+}
+SaveBytes 'fixture-integrity.json' (JsonBytes $stats)
+$stats | ConvertTo-Json
@@ -0,0 +1,8 @@
+{
+  "context": "ModelBaseline",
+  "targets": {
+    "properties": ["bd5b68e8-65fc-4e35-9071-a73061316a4b"],
+    "checks": ["bac0de99-9d2f-4e53-9158-d424ecac61bf"]
+  },
+  "numeric_profile": "Q1-exact-1"
+}
@@ -0,0 +1,8 @@
+{
+  "context": {"Case": "38036c65-16d4-449c-837b-91eb141c1d93"},
+  "targets": {
+    "properties": ["bd5b68e8-65fc-4e35-9071-a73061316a4b"],
+    "checks": ["bac0de99-9d2f-4e53-9158-d424ecac61bf"]
+  },
+  "numeric_profile": "Q1-exact-1"
+}
@@ -0,0 +1,8 @@
+{
+  "context": {"Case": "99d3e09a-0ec3-4194-9dd4-9f3de6625cde"},
+  "targets": {
+    "properties": ["bd5b68e8-65fc-4e35-9071-a73061316a4b"],
+    "checks": ["bac0de99-9d2f-4e53-9158-d424ecac61bf"]
+  },
+  "numeric_profile": "Q1-exact-1"
+}
@@ -0,0 +1,39 @@
+{
+  "after_baseline_dispatch_changes_to_two_seconds": {
+    "active_degraded_total": {
+      "denominator": "4",
+      "numerator": "13"
+    },
+    "frozen_degraded_total": {
+      "denominator": "4",
+      "numerator": "9"
+    }
+  },
+  "after_clear_unmeasured_override": {
+    "check": "Satisfied",
+    "total_canonical_seconds": {
+      "denominator": "4",
+      "numerator": "7"
+    }
+  },
+  "baseline": {
+    "check": "Satisfied",
+    "total_canonical_seconds": {
+      "denominator": "4",
+      "numerator": "7"
+    }
+  },
+  "degraded": {
+    "check": "Violated",
+    "total_canonical_seconds": {
+      "denominator": "4",
+      "numerator": "9"
+    }
+  },
+  "status": "Hand-derived expectations, not evaluator output",
+  "unmeasured": {
+    "check": "Unresolved",
+    "input": "63a931c2-675a-4fce-89e5-04361cb99450",
+    "total": "Missing"
+  }
+}
@@ -0,0 +1,13 @@
+{
+  "base_bindings": 4,
+  "explicit_source_uuids": 17,
+  "local_definitions": 4,
+  "override_bindings": 2,
+  "portable_document_sha256": "6667773d90f83626f760b2faa2bf7d57638947d95574e3fa3e80b64416f01497",
+  "project_elements": 10,
+  "scoped_parameters": 2,
+  "shared_checks": 1,
+  "source_lines": 55,
+  "source_utf8_bytes": 2678,
+  "verified": "JSON transport, 17 syntactically valid distinct UUIDs, exact source bytes, capsule equality. No proposed parser/evaluator execution."
+}
@@ -0,0 +1,425 @@
+{
+  "model": {
+    "alias": "response_budget",
+    "artifact_links": {},
+    "definition_mounts": {},
+    "definitions": {
+      "188b911c-5f8b-431c-9eea-2d41f3953767": {
+        "alias": "duration",
+        "body": {
+          "QuantityKind": {
+            "algebra": "Linear",
+            "dimension": [
+              0,
+              0,
+              1,
+              0,
+              0,
+              0,
+              0
+            ]
+          }
+        },
+        "description": "",
+        "id": "188b911c-5f8b-431c-9eea-2d41f3953767",
+        "name": "Duration"
+      },
+      "39053f37-fec9-4708-9f0a-3959d223f891": {
+        "alias": "millisecond",
+        "body": {
+          "Unit": {
+            "kind": {
+              "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+            },
+            "offset": {
+              "denominator": "1",
+              "numerator": "0"
+            },
+            "scale": {
+              "denominator": "1000",
+              "numerator": "1"
+            },
+            "symbol": "ms"
+          }
+        },
+        "description": "",
+        "id": "39053f37-fec9-4708-9f0a-3959d223f891",
+        "name": "Millisecond"
+      },
+      "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce": {
+        "alias": "second",
+        "body": {
+          "Unit": {
+            "kind": {
+              "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+            },
+            "offset": {
+              "denominator": "1",
+              "numerator": "0"
+            },
+            "scale": {
+              "denominator": "1",
+              "numerator": "1"
+            },
+            "symbol": "s"
+          }
+        },
+        "description": "",
+        "id": "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce",
+        "name": "Second"
+      },
+      "fd7ce7ab-f789-40bc-b699-0c37f1b6902f": {
+        "alias": "combine",
+        "body": {
+          "Calculation": {
+            "body": {
+              "Expression": {
+                "Binary": {
+                  "left": {
+                    "Parameter": "28ff40b0-1b8f-4735-8536-5a6ab21b56cb"
+                  },
+                  "op": "Add",
+                  "right": {
+                    "Parameter": "7a47cc1e-8ae5-4551-b2d8-8a68108e0976"
+                  }
+                }
+              }
+            },
+            "parameters": [
+              {
+                "id": "28ff40b0-1b8f-4735-8536-5a6ab21b56cb",
+                "name": "a",
+                "value_type": {
+                  "Scalar": {
+                    "Quantity": {
+                      "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+                    }
+                  }
+                }
+              },
+              {
+                "id": "7a47cc1e-8ae5-4551-b2d8-8a68108e0976",
+                "name": "b",
+                "value_type": {
+                  "Scalar": {
+                    "Quantity": {
+                      "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+                    }
+                  }
+                }
+              }
+            ],
+            "result": {
+              "Scalar": {
+                "Quantity": {
+                  "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+                }
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "fd7ce7ab-f789-40bc-b699-0c37f1b6902f",
+        "name": "Combine durations"
+      }
+    },
+    "description": "A complete proposed analysis model. Schema 8 and the new declarations are not implemented source7 syntax.",
+    "diagrams": {},
+    "elements": {
+      "38036c65-16d4-449c-837b-91eb141c1d93": {
+        "alias": "degraded",
+        "body": {
+          "Oa": {
+            "Shared": {
+              "AnalysisCase": {
+                "base": "ModelBaseline",
+                "overrides": {
+                  "63a931c2-675a-4fce-89e5-04361cb99450": {
+                    "Expression": {
+                      "Quantity": {
+                        "magnitude": {
+                          "denominator": "1",
+                          "numerator": "1250"
+                        },
+                        "unit": {
+                          "Local": "39053f37-fec9-4708-9f0a-3959d223f891"
+                        }
+                      }
+                    }
+                  }
+                },
+                "subject": null
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "38036c65-16d4-449c-837b-91eb141c1d93",
+        "name": "Degraded radio",
+        "parent": null
+      },
+      "437bedbb-2cf4-44ee-a139-6563cc5086ec": {
+        "alias": "limit",
+        "body": {
+          "Oa": {
+            "Shared": {
+              "EngineeringProperty": {
+                "base": {
+                  "Expression": {
+                    "Quantity": {
+                      "magnitude": {
+                        "denominator": "1",
+                        "numerator": "2"
+                      },
+                      "unit": {
+                        "Local": "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce"
+                      }
+                    }
+                  }
+                },
+                "display_unit": {
+                  "Local": "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce"
+                },
+                "subject": {
+                  "Element": "cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59"
+                },
+                "value_type": {
+                  "Scalar": {
+                    "Quantity": {
+                      "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "437bedbb-2cf4-44ee-a139-6563cc5086ec",
+        "name": "Allowed duration",
+        "parent": null
+      },
+      "4ab9a8a7-7552-488d-9862-e14b89e7b353": {
+        "alias": "receive",
+        "body": {
+          "Oa": "Activity"
+        },
+        "description": "",
+        "id": "4ab9a8a7-7552-488d-9862-e14b89e7b353",
+        "name": "Receive",
+        "parent": "cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59"
+      },
+      "63a931c2-675a-4fce-89e5-04361cb99450": {
+        "alias": "receive_time",
+        "body": {
+          "Oa": {
+            "Shared": {
+              "EngineeringProperty": {
+                "base": {
+                  "Expression": {
+                    "Quantity": {
+                      "magnitude": {
+                        "denominator": "1",
+                        "numerator": "750"
+                      },
+                      "unit": {
+                        "Local": "39053f37-fec9-4708-9f0a-3959d223f891"
+                      }
+                    }
+                  }
+                },
+                "display_unit": {
+                  "Local": "39053f37-fec9-4708-9f0a-3959d223f891"
+                },
+                "subject": {
+                  "Element": "4ab9a8a7-7552-488d-9862-e14b89e7b353"
+                },
+                "value_type": {
+                  "Scalar": {
+                    "Quantity": {
+                      "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "63a931c2-675a-4fce-89e5-04361cb99450",
+        "name": "Receive time",
+        "parent": null
+      },
+      "6df991ba-4c5e-4535-99e2-524ae274ee8b": {
+        "alias": "dispatch",
+        "body": {
+          "Oa": "Activity"
+        },
+        "description": "",
+        "id": "6df991ba-4c5e-4535-99e2-524ae274ee8b",
+        "name": "Dispatch",
+        "parent": "cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59"
+      },
+      "99d3e09a-0ec3-4194-9dd4-9f3de6625cde": {
+        "alias": "unmeasured",
+        "body": {
+          "Oa": {
+            "Shared": {
+              "AnalysisCase": {
+                "base": "ModelBaseline",
+                "overrides": {
+                  "63a931c2-675a-4fce-89e5-04361cb99450": "Unbound"
+                },
+                "subject": null
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "99d3e09a-0ec3-4194-9dd4-9f3de6625cde",
+        "name": "Unmeasured radio",
+        "parent": null
+      },
+      "bac0de99-9d2f-4e53-9158-d424ecac61bf": {
+        "alias": "budget",
+        "body": {
+          "Oa": {
+            "Shared": {
+              "AnalysisCheck": {
+                "documented_constraint": null,
+                "predicate": {
+                  "Expression": {
+                    "Binary": {
+                      "left": {
+                        "Property": "bd5b68e8-65fc-4e35-9071-a73061316a4b"
+                      },
+                      "op": "LessOrEqual",
+                      "right": {
+                        "Property": "437bedbb-2cf4-44ee-a139-6563cc5086ec"
+                      }
+                    }
+                  }
+                },
+                "subject": null
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "bac0de99-9d2f-4e53-9158-d424ecac61bf",
+        "name": "Response budget",
+        "parent": null
+      },
+      "bd5b68e8-65fc-4e35-9071-a73061316a4b": {
+        "alias": "total_time",
+        "body": {
+          "Oa": {
+            "Shared": {
+              "EngineeringProperty": {
+                "base": {
+                  "Expression": {
+                    "Call": {
+                      "arguments": {
+                        "28ff40b0-1b8f-4735-8536-5a6ab21b56cb": {
+                          "Property": "63a931c2-675a-4fce-89e5-04361cb99450"
+                        },
+                        "7a47cc1e-8ae5-4551-b2d8-8a68108e0976": {
+                          "Property": "c33fc772-2a60-4044-9af9-73c61c563ace"
+                        }
+                      },
+                      "definition": {
+                        "Local": "fd7ce7ab-f789-40bc-b699-0c37f1b6902f"
+                      }
+                    }
+                  }
+                },
+                "display_unit": {
+                  "Local": "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce"
+                },
+                "subject": {
+                  "Element": "cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59"
+                },
+                "value_type": {
+                  "Scalar": {
+                    "Quantity": {
+                      "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "bd5b68e8-65fc-4e35-9071-a73061316a4b",
+        "name": "Total time",
+        "parent": null
+      },
+      "c33fc772-2a60-4044-9af9-73c61c563ace": {
+        "alias": "dispatch_time",
+        "body": {
+          "Oa": {
+            "Shared": {
+              "EngineeringProperty": {
+                "base": {
+                  "Expression": {
+                    "Quantity": {
+                      "magnitude": {
+                        "denominator": "1",
+                        "numerator": "1"
+                      },
+                      "unit": {
+                        "Local": "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce"
+                      }
+                    }
+                  }
+                },
+                "display_unit": {
+                  "Local": "534f4672-1ba5-4157-8b0a-b9cf41d0a3ce"
+                },
+                "subject": {
+                  "Element": "6df991ba-4c5e-4535-99e2-524ae274ee8b"
+                },
+                "value_type": {
+                  "Scalar": {
+                    "Quantity": {
+                      "Local": "188b911c-5f8b-431c-9eea-2d41f3953767"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "description": "",
+        "id": "c33fc772-2a60-4044-9af9-73c61c563ace",
+        "name": "Dispatch time",
+        "parent": null
+      },
+      "cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59": {
+        "alias": "respond",
+        "body": {
+          "Oa": "Activity"
+        },
+        "description": "",
+        "id": "cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59",
+        "name": "Respond",
+        "parent": null
+      }
+    },
+    "id": "4210b9f2-7046-47f0-aa3b-153f626a579d",
+    "imports": {},
+    "library_instances": {},
+    "name": "Response budget",
+    "relations": {},
+    "schema_version": 8,
+    "traces": {}
+  },
+  "packages": {},
+  "source": {
+    "entry": "active.arcadia",
+    "files": {
+      "active.arcadia": "arcadia 8;\nproject response_budget \"Response budget\" id \"4210b9f2-7046-47f0-aa3b-153f626a579d\" {\n    description \"A complete proposed analysis model. Schema 8 and the new declarations are not implemented source7 syntax.\";\n\n    quantity_kind duration \"Duration\" id \"188b911c-5f8b-431c-9eea-2d41f3953767\" {\n        dimension { time: 1; }\n        algebra Linear;\n    }\n    unit second \"Second\" id \"534f4672-1ba5-4157-8b0a-b9cf41d0a3ce\" {\n        kind @duration; scale 1; offset 0; symbol \"s\";\n    }\n    unit millisecond \"Millisecond\" id \"39053f37-fec9-4708-9f0a-3959d223f891\" {\n        kind @duration; scale ratio(1, 1000); offset 0; symbol \"ms\";\n    }\n    calculation combine \"Combine durations\" id \"fd7ce7ab-f789-40bc-b699-0c37f1b6902f\" {\n        input a id \"28ff40b0-1b8f-4735-8536-5a6ab21b56cb\" : Quantity(@duration);\n        input b id \"7a47cc1e-8ae5-4551-b2d8-8a68108e0976\" : Quantity(@duration);\n        result Quantity(@duration);\n        body $a + $b;\n    }\n\n    oa_activity respond \"Respond\" id \"cabec6a1-7d5d-48f3-8d2d-a7fc8cf78f59\" {\n        oa_activity receive \"Receive\" id \"4ab9a8a7-7552-488d-9862-e14b89e7b353\" {}\n        oa_activity dispatch \"Dispatch\" id \"6df991ba-4c5e-4535-99e2-524ae274ee8b\" {}\n    }\n    oa_property receive_time \"Receive time\" id \"63a931c2-675a-4fce-89e5-04361cb99450\" {\n        subject @receive; type Quantity(@duration); display_unit @millisecond;\n        base 750 [@millisecond];\n    }\n    oa_property dispatch_time \"Dispatch time\" id \"c33fc772-2a60-4044-9af9-73c61c563ace\" {\n        subject @dispatch; type Quantity(@duration); display_unit @second;\n        base 1 [@second];\n    }\n    oa_property total_time \"Total time\" id \"bd5b68e8-65fc-4e35-9071-a73061316a4b\" {\n        subject @respond; type Quantity(@duration); display_unit @second;\n        // The formula is shared. Every read uses the requested evaluation context.\n        base @combine(a: @receive_time, b: @dispatch_time);\n    }\n    oa_property limit \"Allowed duration\" id \"437bedbb-2cf4-44ee-a139-6563cc5086ec\" {\n        subject @respond; type Quantity(@duration); display_unit @second;\n        base 2 [@second];\n    }\n    oa_check budget \"Response budget\" id \"bac0de99-9d2f-4e53-9158-d424ecac61bf\" {\n        subject none; documented_constraint none;\n        predicate @total_time <= @limit;\n    }\n    oa_analysis degraded \"Degraded radio\" id \"38036c65-16d4-449c-837b-91eb141c1d93\" {\n        subject none; base ModelBaseline;\n        overrides { @receive_time = 1250 [@millisecond]; }\n    }\n    oa_analysis unmeasured \"Unmeasured radio\" id \"99d3e09a-0ec3-4194-9dd4-9f3de6625cde\" {\n        subject none; base ModelBaseline;\n        overrides { @receive_time = unbound; }\n    }\n}\n"
+    }
+  }
+}
@@ -0,0 +1,32 @@
+[
+  {
+    "canonical_source": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "expression": {
+      "Number": {
+        "denominator": "1",
+        "numerator": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+      }
+    },
+    "name": "ten_to_300"
+  },
+  {
+    "canonical_source": "ratio(1, 522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168)",
+    "expression": {
+      "Number": {
+        "denominator": "522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168",
+        "numerator": "1"
+      }
+    },
+    "name": "one_over_two_to_4095"
+  },
+  {
+    "canonical_source": "ratio(-1044388881413152506691752710716624382579964249047383780384233483283953907971557456848826811934997558340890106714439262837987573438185793607263236087851365277945956976543709998340361590134383718314428070011855946226376318839397712745672334684344586617496807908705803704071284048740118609114467977783598029006686938976881787785946905630190260940599579453432823469303026696443059025015972399867714215541693835559885291486318237914434496734087811872639496475100189041349008417061675093668333850551032972088269550769983616369411933015213796825837188091833656751221318492846368125550225998300412344784862595674492194617023806505913245610825731835380087608622102834270197698202313169017678006675195485079921636419370285375124784014907159135459982790513399611551794271106831134090584272884279791554849782954323534517065223269061394905987693002122963395687782878948440616007412945674919823050571642377154816321380631045902916136926708342856440730447899971901781465763473223850267253059899795996090799469201774624817718449867455659250178329070473119433165550807568221846571746373296884912819520317457002440926616910874148385078411929804522981857338977648103126085903001302413467189726673216491511131602920781738033436090243804708340403154190335, 1)",
+    "expression": {
+      "Number": {
+        "denominator": "1",
+        "numerator": "-1044388881413152506691752710716624382579964249047383780384233483283953907971557456848826811934997558340890106714439262837987573438185793607263236087851365277945956976543709998340361590134383718314428070011855946226376318839397712745672334684344586617496807908705803704071284048740118609114467977783598029006686938976881787785946905630190260940599579453432823469303026696443059025015972399867714215541693835559885291486318237914434496734087811872639496475100189041349008417061675093668333850551032972088269550769983616369411933015213796825837188091833656751221318492846368125550225998300412344784862595674492194617023806505913245610825731835380087608622102834270197698202313169017678006675195485079921636419370285375124784014907159135459982790513399611551794271106831134090584272884279791554849782954323534517065223269061394905987693002122963395687782878948440616007412945674919823050571642377154816321380631045902916136926708342856440730447899971901781465763473223850267253059899795996090799469201774624817718449867455659250178329070473119433165550807568221846571746373296884912819520317457002440926616910874148385078411929804522981857338977648103126085903001302413467189726673216491511131602920781738033436090243804708340403154190335"
+      }
+    },
+    "name": "negative_4096_bit_bound"
+  }
+]
@@ -0,0 +1,840 @@
+{
+  "source_commit": "7d14bd0dd1cf4a2293c00c185573fd4a7fc364ae",
+  "command": "cargo test --locked -p oa-core --lib analysis_numeric::tests -- --test-threads=1",
+  "exit_code": 0,
+  "passed": 26,
+  "failed": 0,
+  "ignored": 0,
+  "filtered_out": 42,
+  "test_seconds": 0.29,
+  "build_seconds": 385,
+  "scope": "Exact numeric foundation unit tests only; no schema8 model/evaluator or desktop acceptance.",
+  "toolchain": "Rust/Cargo1.98.1 x86_64-pc-windows-gnullvm; LLVM-MinGW20260908; jobs1",
+  "prior_attempt": "The broader command without --lib was intentionally stopped before tests while compiling unrelated integration executables. It supplies no pass result.",
+  "artifacts": {
+    "oa-core-tests.exe": {
+      "bytes": 24529920,
+      "sha256": "F92A4C4CF01DB0AD4810527F0D8AC2212196AEB3A4907E8EEA12FD5EDEADDB0D"
+    },
+    "libunwind.dll": {
+      "bytes": 190464,
+      "sha256": "AA282FA47BB2C4E210CEA5E470CDBDCA58568F0BE0BC73E404D86AB9CD95EF6A"
+    },
+    "numeric-unit.log": {
+      "bytes": 2754,
+      "sha256": "DF7F71D037CF2B3D38234C834F9F399F3BB30CC4757F453D72833DE9A9C3C063"
+    }
+  },
+  "input_files": [
+    {
+      "path": "Cargo.lock",
+      "bytes": 119973,
+      "sha256": "065C23C94908FE499D32ED91D55A70946ED5B08ECFDA3B483EC1E635572257BF"
+    },
+    {
+      "path": "Cargo.toml",
+      "bytes": 400,
+      "sha256": "369F5B4B2B60705A94623C8C0B68F8E0B048F263280CE07AE0629AD353797D62"
+    },
+    {
+      "path": "crates/oa-core/Cargo.toml",
+      "bytes": 408,
+      "sha256": "6B5C062474EBB62D5082E07DABED99EE85E4A833EDF26690FB4F887028D3416F"
+    },
+    {
+      "path": "crates/oa-core/build.rs",
+      "bytes": 45,
+      "sha256": "AB1BE6AE1FD8BF3EBAEEF6348347A9D5E666BDE693126F199E041659E0B094A9"
+    },
+    {
+      "path": "crates/oa-core/examples/generate_demo.rs",
+      "bytes": 795,
+      "sha256": "E26F432C95331AECA50985DBB3AD2C558AFFD43023B585811F0F7BFAA59F6661"
+    },
+    {
+      "path": "crates/oa-core/examples/generate_release1.rs",
+      "bytes": 1798,
+      "sha256": "1D5F11165D74893E4BC18DBF3A2F2111F4026BD89FD06EE7F0BAE69E45C4D4B5"
+    },
+    {
+      "path": "crates/oa-core/examples/release_dense_views.rs",
+      "bytes": 14664,
+      "sha256": "A83158488EF9B7394F136C52B1496719BE935C4E5BDFE457CAB5C9894F5F9412"
+    },
+    {
+      "path": "crates/oa-core/examples/routing_workshop.rs",
+      "bytes": 17248,
+      "sha256": "571307B18B6D4FA04700C5A4D4B0C2154C419E93A21292B2028E7B6F46A2FAA7"
+    },
+    {
+      "path": "crates/oa-core/src/analysis_numeric.rs",
+      "bytes": 3735,
+      "sha256": "6C88EEF3119162AEB6C07B9E75812C3AF9FBFE75554B0503AD00F103CB478408"
+    },
+    {
+      "path": "crates/oa-core/src/analysis_numeric/dimension.rs",
+      "bytes": 3045,
+      "sha256": "D4AD8E5307A1620E31791D724A0E31FDBA860D00DC83E3E1F2209D9C5E22A340"
+    },
+    {
+      "path": "crates/oa-core/src/analysis_numeric/exact.rs",
+      "bytes": 17338,
+      "sha256": "4EB8CB0F66B10E5DA204899AF82EE26ADFEC74BAB47B1A6C9842B5488EE04C4D"
+    },
+    {
+      "path": "crates/oa-core/src/analysis_numeric/fixtures/r7-literal-boundaries.json",
+      "bytes": 6085,
+      "sha256": "3B959DEC5E100A6F03817F5314BEF497347BA579EBD235476516D4BD83399181"
+    },
+    {
+      "path": "crates/oa-core/src/analysis_numeric/meter.rs",
+      "bytes": 7129,
+      "sha256": "1F7174BEB992935B4C399ACDEF91114AF73FAF041070FEAB968455AC827E8EE4"
+    },
+    {
+      "path": "crates/oa-core/src/analysis_numeric/quantity.rs",
+      "bytes": 12257,
+      "sha256": "EAD5142D6EEEA8F99399D57E02D8F7D819980923DE76387CD454694D6A747AEE"
+    },
+    {
+      "path": "crates/oa-core/src/analysis_numeric/tests.rs",
+      "bytes": 27486,
+      "sha256": "323CE82FC057D36F44463569FD8EA324C7D700FDDFBF32BCE15E04BD2A66970B"
+    },
+    {
+      "path": "crates/oa-core/src/data.rs",
+      "bytes": 42696,
+      "sha256": "7F9C7C7DD8353CB5A38597B92CDE6D3E890203D392473187EB387D41FF37414A"
+    },
+    {
+      "path": "crates/oa-core/src/demo.rs",
+      "bytes": 20657,
+      "sha256": "AD62123F96C20FF023CAFC1A9849B0FA06BC62EDD1FB9701799E4599B458600C"
+    },
+    {
+      "path": "crates/oa-core/src/language.rs",
+      "bytes": 99938,
+      "sha256": "638F08A42E9CF4996B5D07F69B4D6F517A518369F3604D25BE1006E40E080765"
+    },
+    {
+      "path": "crates/oa-core/src/language/semantic_source.rs",
+      "bytes": 7326,
+      "sha256": "584B5BB59D87A7B8D44D5DD2D124C3A1323B21492B138A17BC9526C0087C9E29"
+    },
+    {
+      "path": "crates/oa-core/src/language_nesting_tests.rs",
+      "bytes": 20639,
+      "sha256": "BD061611E8CB6F28AB203C73E544AC98BF275EB464CD314AD5FBD25F773DF33B"
+    },
+    {
+      "path": "crates/oa-core/src/lib.rs",
+      "bytes": 549,
+      "sha256": "EA1D9BF5ACBA8381BA204DB12FF5B5FE1F320417D17AF517E46B90FD6BCB241C"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/README.md",
+      "bytes": 1515,
+      "sha256": "FB61D3FAA33D7BDFBA73415415A0882C0FBD3E0B45DF42F972A19AEC6DA927B9"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/adapter.rs",
+      "bytes": 9490,
+      "sha256": "66741B4C8354A23B8A932ECC5BF1BC3BB6E74279558757B8C35BC2157A7E51B5"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/mod.rs",
+      "bytes": 1158,
+      "sha256": "857D8BB13B6814DABA6780CA770C16352943C01CB130245D055F11B3B957B3E9"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/model.rs",
+      "bytes": 52059,
+      "sha256": "8AC63EB59B2E57BDECFF2477EE0634096090924D3DD1851E1C454880A889DACB"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/references.rs",
+      "bytes": 13369,
+      "sha256": "33A6819ABC83139FDAEBEEBD1B553238A328637106CCE7DD5A535F1791D43E20"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/source.rs",
+      "bytes": 21946,
+      "sha256": "74FEE9B24E7C912182C998AB9D9AEEC125E2009C3214959229E844C67AFE2BF6"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/state_validation.rs",
+      "bytes": 15769,
+      "sha256": "E29EF071BAB0A68460DDF55C46131C6F66C022D52C3C602C37C013C3649DA1B0"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/transitions.rs",
+      "bytes": 704,
+      "sha256": "F74174C532BA56B57C80B719A11FB4ADEA0A78CCC2828FFF72FE2B9EDA5A10B1"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v2/validation.rs",
+      "bytes": 98736,
+      "sha256": "6D5E4A4E2805AE5045BF789A0485E14A61C63346587BACE2B4A91173A688F780"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v3/README.md",
+      "bytes": 2128,
+      "sha256": "3755A63F840D7F0EADF68AFA7A9D587877A9468FF982D3610539E8A0BB067A82"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v3/mod.rs",
+      "bytes": 23023,
+      "sha256": "F4EDB6A0B50ECFE8670973776D703047B064420CB1F05913129C00FC656B3722"
+    },
+    {
+      "path": "crates/oa-core/src/migration_v4.rs",
+      "bytes": 4020,
+      "sha256": "50C652964F0F309E7F3F54B6EF12C40D42FCECC0490F005995C713DF1179AF70"
+    },
+    {
+      "path": "crates/oa-core/src/model.rs",
+      "bytes": 66352,
+      "sha256": "4585C895C64C4A183941C92CF047A9E52FF0CBE41971E16E78D229EA9DC101FB"
+    },
+    {
+      "path": "crates/oa-core/src/operations.rs",
+      "bytes": 11405,
+      "sha256": "A5FFBBF54CD440316A106D1188BFB699B57DAE59F466EDCB33618C333CD19F41"
+    },
+    {
+      "path": "crates/oa-core/src/persistence.rs",
+      "bytes": 31774,
+      "sha256": "1C01474F906A63E552C0D590B272C95821C00A100B3E79E58E67DBBEAC341A14"
+    },
+    {
+      "path": "crates/oa-core/src/ports.rs",
+      "bytes": 45413,
+      "sha256": "5CAC12EEA70A54EBEBBD6BE77B63CE92E3195325C4BC7D27705C518686CBAC80"
+    },
+    {
+      "path": "crates/oa-core/src/projection.rs",
+      "bytes": 21374,
+      "sha256": "69ED12BACE2CC5024E151752A174AB14034AC2D05EB741FCF13E9A27521C059B"
+    },
+    {
+      "path": "crates/oa-core/src/projection/port_layout.rs",
+      "bytes": 13474,
+      "sha256": "A08D17D10A58BB8B206DD001B19B91D5AA3A9F743B298A4DA57D503223C20079"
+    },
+    {
+      "path": "crates/oa-core/src/projection/state.rs",
+      "bytes": 5233,
+      "sha256": "73A607BAC713EC7FF49A509FEFB1A53C7686DCA93EE241FFC835564D743AFB28"
+    },
+    {
+      "path": "crates/oa-core/src/references.rs",
+      "bytes": 21957,
+      "sha256": "93553C234F32DA35F1F41A7B83AD81C471C9803EFA78CA222CF7DE3C2F86C0BB"
+    },
+    {
+      "path": "crates/oa-core/src/routing.rs",
+      "bytes": 50309,
+      "sha256": "C5EBB350BA76F731F5C48D968BFBBA4B6EF68EC046EB5893D116C4637EF15080"
+    },
+    {
+      "path": "crates/oa-core/src/semantic.rs",
+      "bytes": 540,
+      "sha256": "F9895DD5B8FB27D10D4CFBB41C3542EF2018365A589B8D5778E5674AE5A1F239"
+    },
+    {
+      "path": "crates/oa-core/src/semantic/catalog.rs",
+      "bytes": 49407,
+      "sha256": "1FF74FCCA18084D178681D7FF38EE1CCAC632C27C4DE0595BA1CEAB8067AB3A4"
+    },
+    {
+      "path": "crates/oa-core/src/semantic/historical.rs",
+      "bytes": 15271,
+      "sha256": "EAF3284BF234312698514CDB636BC8348E1B5D746CB16B18DF777E77D312ABFB"
+    },
+    {
+      "path": "crates/oa-core/src/semantic/linked.rs",
+      "bytes": 6035,
+      "sha256": "6F335B14E809AECFC35DEFCAF77CB821B080D1506DBC46297912B25AF98C07A2"
+    },
+    {
+      "path": "crates/oa-core/src/semantic/mutate.rs",
+      "bytes": 22683,
+      "sha256": "DC2B4C4A6EB156FE468EAA8C85FD37A505C0CD8EA1F226CB69CD01689AFD3D9D"
+    },
+    {
+      "path": "crates/oa-core/src/semantic/review.rs",
+      "bytes": 51116,
+      "sha256": "0C157D2C327E72E89CCA3B423E71EE73798105C5BB7271439C1A101642C91E3E"
+    },
+    {
+      "path": "crates/oa-core/src/semantic/types.rs",
+      "bytes": 10405,
+      "sha256": "6922FE35089F12FAD43AB0CE1C6886D01A3855F90B8E2543E99802AC5E6F1BBB"
+    },
+    {
+      "path": "crates/oa-core/src/session.rs",
+      "bytes": 35237,
+      "sha256": "1EB77B329B2986FC6F5DC0171E77FD860375CDFD8C769A1367B445D6C49EBE00"
+    },
+    {
+      "path": "crates/oa-core/src/source_files.rs",
+      "bytes": 74803,
+      "sha256": "669491DBDDB8E8E6556161426DFFA1A49AC1C826D31020BFF0956D81A4D84683"
+    },
+    {
+      "path": "crates/oa-core/src/source_project.rs",
+      "bytes": 61843,
+      "sha256": "1394370BCC5908873B830C2C11312E6E1611AF41F46C4F43CA0A6BCB713BB466"
+    },
+    {
+      "path": "crates/oa-core/src/source_project/source_migration.rs",
+      "bytes": 4700,
+      "sha256": "ADD463AE85C420F853D324B00A221F0F874164CC3F3ED6BBB07557A9ED7A8C95"
+    },
+    {
+      "path": "crates/oa-core/src/source_project/source_structure.rs",
+      "bytes": 20225,
+      "sha256": "9F1F83315856A7025FE662C0FBB13452F31613224A03663150D6225D1DDC162F"
+    },
+    {
+      "path": "crates/oa-core/src/state_validation.rs",
+      "bytes": 15665,
+      "sha256": "E28D7F74385E2A78763716B34491BD73A00BFECCC085970CEB130627E3FAEE18"
+    },
+    {
+      "path": "crates/oa-core/src/topology_context.rs",
+      "bytes": 13734,
+      "sha256": "16DE69B297DE95D93C73808621607833B713AF811DD082F0169186AE1E5C3E2D"
+    },
+    {
+      "path": "crates/oa-core/src/topology_context/analysis.rs",
+      "bytes": 20036,
+      "sha256": "DEAD6194F0AA60CC46045C0E5EE10DBDBB689158C38634DFBBBC45D2BA88AC65"
+    },
+    {
+      "path": "crates/oa-core/src/topology_context/analysis_tests.rs",
+      "bytes": 5258,
+      "sha256": "17839263410815E96FE027D4EBA3AAE0A9AB3B82B16947E2B29EBE0D09782B56"
+    },
+    {
+      "path": "crates/oa-core/src/transitions.rs",
+      "bytes": 51998,
+      "sha256": "FADD1B07B89CAE4117B91ABB4F1AC9EA81FF818EF20F2175E76EE8CF21FB708D"
+    },
+    {
+      "path": "crates/oa-core/src/transitions/communication.rs",
+      "bytes": 8634,
+      "sha256": "2B476630A88EDD9021B9156CA12A5402E01604095F0D4002AFB452671903A028"
+    },
+    {
+      "path": "crates/oa-core/src/validation.rs",
+      "bytes": 112792,
+      "sha256": "7C1B4AE5E4EBBA13E99AF9158CCDE138DFC5E9A7AFB580E76FBA72D0B64BA74E"
+    },
+    {
+      "path": "crates/oa-core/src/validation/coverage.rs",
+      "bytes": 6478,
+      "sha256": "B08E4B344ECAD055714168C83BEFF7FE29BA4EDC53EDBFFA2EAE04E5580A4D5F"
+    },
+    {
+      "path": "crates/oa-core/src/view_options.rs",
+      "bytes": 24481,
+      "sha256": "421EDE0A04C593CA1DF0E6E0D06FABCFCC8113CDBCFB0ADC7F5C8EF4D1724208"
+    },
+    {
+      "path": "crates/oa-core/src/view_options_tests.rs",
+      "bytes": 21433,
+      "sha256": "64AAC44DE2DF42A1012239A3DD75C473DAF0C8990B3170B7BF7E78A556080208"
+    },
+    {
+      "path": "crates/oa-core/tests/communication_boundary_scenarios.rs",
+      "bytes": 8816,
+      "sha256": "E1100B8F363910A487D90C73ACC7DF543DC6D532158C3C63AD11CD3D40D8E12B"
+    },
+    {
+      "path": "crates/oa-core/tests/communication_means.rs",
+      "bytes": 18102,
+      "sha256": "A25F2749180BC6F4BEB1445BFAD3351EEDF0669131A7439B633AB804439E95A4"
+    },
+    {
+      "path": "crates/oa-core/tests/coverage_diagnostics.rs",
+      "bytes": 20527,
+      "sha256": "E2E9C3996DAAB47F2BD23F5D8C48B4E372AF33331152F5FC85B76F06D04FCDF4"
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.arcadia",
+      "bytes": 29220,
+      "sha256": "F0DF129C1914BFC01D0B047B0CD4B520D8CF0C249EA9CED085DE400C0BE87FF3"
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.json",
+      "bytes": 43990,
+      "sha256": "3ED53508EB544BBD788832F7BEBEA2EC31B3D66191F24F45098CC9750EC4C005"
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v3-data-contract.arcadia",
+      "bytes": 2450,
+      "sha256": "305F19D1B79F99F8D4CF627BA2E9CA6836BB7959CC0070227815937A699EAFEA"
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v3-data-contract.json",
+      "bytes": 8240,
+      "sha256": "1B41299C53204E6232397D25A58D5BCCDBBC16E770C75E8EDB55CE36CCFE58A2"
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia",
+      "bytes": 1222,
+      "sha256": "5FA53A26A5AD010C8E59EB56D9B2B52003569E66C0377FFB58840590168AD0C1"
+    },
+    {
+      "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.json",
+      "bytes": 1734,
+      "sha256": "2808088AFCC165F4BD6DA5129151143411C997041C3DE61D600AB76E05D24A47"
+    },
+    {
+      "path": "crates/oa-core/tests/language.rs",
+      "bytes": 56482,
+      "sha256": "77F6CB2A69976BFB5F60B243B71C07FB0EDC7505002C1E9E73FCD6DDF6D9496E"
+    },
+    {
+      "path": "crates/oa-core/tests/port_anchors.rs",
+      "bytes": 26893,
+      "sha256": "EFBC0FA18733B1AAAC501F9785A4C392FC49C05C45A5778D26E9B5DD951CA6FA"
+    },
+    {
+      "path": "crates/oa-core/tests/port_migration.rs",
+      "bytes": 15620,
+      "sha256": "1801C376A5435AC7EFB2A8342348B2C7FFEF930BBA65DECA4ACB66B06E0483D7"
+    },
+    {
+      "path": "crates/oa-core/tests/port_source.rs",
+      "bytes": 4858,
+      "sha256": "8D2DDACA4045D330F6EDA2591561497B858AAD53769A823249D0BEA4F5916E12"
+    },
+    {
+      "path": "crates/oa-core/tests/prepared_commands.rs",
+      "bytes": 9555,
+      "sha256": "52CAB1C668064777412DF0A6A3C20D74D579B33794B4B00525B9F151C06EAC9B"
+    },
+    {
+      "path": "crates/oa-core/tests/process_diagnostics.rs",
+      "bytes": 1104,
+      "sha256": "1DBBC590239EF7542BE4A2BDC9543AAA64D108417B03DD312A0894E364745906"
+    },
+    {
+      "path": "crates/oa-core/tests/r3_constructor_ack.rs",
+      "bytes": 24163,
+      "sha256": "E5C44676EA0AAB97F2E091DDAC2F4BC4A4A90F5877F7BBF08B61229600944DD0"
+    },
+    {
+      "path": "crates/oa-core/tests/r3_migration.rs",
+      "bytes": 6590,
+      "sha256": "EBD04120F5215B3956FDC79EE78F6E38734C7D13392F1FC28AABA957912265BD"
+    },
+    {
+      "path": "crates/oa-core/tests/r3_semantic.rs",
+      "bytes": 77473,
+      "sha256": "49C3763EAF2131070A7C46CC23A84F917D292D41610B6404510E5607F8890C32"
+    },
+    {
+      "path": "crates/oa-core/tests/r3_source.rs",
+      "bytes": 15311,
+      "sha256": "F31F60659DF3C7EF601650D1CFF140589D8729F01A3F65A4A6A6C2272F15C408"
+    },
+    {
+      "path": "crates/oa-core/tests/r6_data.rs",
+      "bytes": 41437,
+      "sha256": "5F7FFB3BC73C3C85423623FE56F8680646DC97040327BDBEAD9D47A37E80F155"
+    },
+    {
+      "path": "crates/oa-core/tests/r6_migration.rs",
+      "bytes": 9174,
+      "sha256": "81519BC1512F5E069432E9A1CDAD04C10216D492DF01B4B75B02102480EBD6A1"
+    },
+    {
+      "path": "crates/oa-core/tests/r6_source.rs",
+      "bytes": 9519,
+      "sha256": "88A0AA087A7678E2898FF6057538072CA92072190712F05FFF08372CC56EBED6"
+    },
+    {
+      "path": "crates/oa-core/tests/release1_teaching.rs",
+      "bytes": 10010,
+      "sha256": "BE179290D871125DC97CFD2A3067C7AC89C8A538FDB0AFAFC5B825BCDFB2BEF2"
+    },
+    {
+      "path": "crates/oa-core/tests/release_capabilities.rs",
+      "bytes": 19422,
+      "sha256": "B92CBA2A562E78287DDD7DC3E94557848D17FAA0C8A102601B50286B9AF48A30"
+    },
+    {
+      "path": "crates/oa-core/tests/release_diagrams.rs",
+      "bytes": 7689,
+      "sha256": "CEFCC0582D91266D5DE6EE5DAEFCFE41B606AB971AB235B59034A8E1DBC24B7D"
+    },
+    {
+      "path": "crates/oa-core/tests/release_language_limits.rs",
+      "bytes": 5204,
+      "sha256": "8578DA4F76BBD2D0E1BFE295AB1259E2162A3FE3D0D2BA8901915D7A40942806"
+    },
+    {
+      "path": "crates/oa-core/tests/release_ports.rs",
+      "bytes": 32740,
+      "sha256": "506E62BEAB0C7EC0CECE83E9E0C1A810FA1F99285C9E1CAB0C77F06DE55A40E1"
+    },
+    {
+      "path": "crates/oa-core/tests/release_routing.rs",
+      "bytes": 23165,
+      "sha256": "AE168FAABA23769B7CA1FD65F217B9DB671726E67276EB5A04E5E72B1447A462"
+    },
+    {
+      "path": "crates/oa-core/tests/release_scenarios.rs",
+      "bytes": 41067,
+      "sha256": "0F5D876BADEEC653FC7B12610A77D867E9A53582E605253DEFF8D379DA21572F"
+    },
+    {
+      "path": "crates/oa-core/tests/release_states.rs",
+      "bytes": 26873,
+      "sha256": "B1A26ACEE95EABA7F9920F9DA738A1E33606552EB078E6D298895DAFF7E3D811"
+    },
+    {
+      "path": "crates/oa-core/tests/release_topology.rs",
+      "bytes": 17643,
+      "sha256": "C51DBE5AA5A038F9ED830DAA02AA67714472179EB7FD6DA5CE36DC6931C8B3A9"
+    },
+    {
+      "path": "crates/oa-core/tests/review_regressions.rs",
+      "bytes": 21823,
+      "sha256": "F154E5C88D35E31512E2B07733A1327EA3E2FCFD1EF8EB23066A4E9573F387C1"
+    },
+    {
+      "path": "crates/oa-core/tests/route_source.rs",
+      "bytes": 7270,
+      "sha256": "1A73FDBAC0D0AE0E84D8D67B6AD398E11223958F5DCA007F73757C91827DECFB"
+    },
+    {
+      "path": "crates/oa-core/tests/routing_geometry.rs",
+      "bytes": 31890,
+      "sha256": "2D8EEA4A2BBA535ED0EA6DAABCCDAF87B375828C404BAA10518C7BD7FD6253D3"
+    },
+    {
+      "path": "crates/oa-core/tests/routing_labels.rs",
+      "bytes": 5530,
+      "sha256": "DFF884D799C3C5C9257210248C55767E294E3CB317C605CBD0DDC9600C216EB6"
+    },
+    {
+      "path": "crates/oa-core/tests/semantic_artifact_absence_oracle.rs",
+      "bytes": 4640,
+      "sha256": "D93EAF9667F4221232168BEF0FE9F069E5BE1B1F23410BDA5DD67010B96E5C8A"
+    },
+    {
+      "path": "crates/oa-core/tests/semantic_attachments_gui_oracle.rs",
+      "bytes": 14957,
+      "sha256": "7F526D363BA05E7AC89FAF0FEAD0796E419C34EE204EDF44A1B46C78308B0970"
+    },
+    {
+      "path": "crates/oa-core/tests/source6_view_contract.rs",
+      "bytes": 14307,
+      "sha256": "FA566DE53946D40BBBD9033EDFEED177180C4DC44AFA2F2F4667FFDC622EB3BB"
+    },
+    {
+      "path": "crates/oa-core/tests/source7_contract.rs",
+      "bytes": 43262,
+      "sha256": "CAD4F1A135DDBD947BDF3C71D1B44F1E438725095EA8C4D893464BC721C2363F"
+    },
+    {
+      "path": "crates/oa-core/tests/source_files.rs",
+      "bytes": 13168,
+      "sha256": "F0429A0B89A443458EA9AF7083C1E4E7411417A7E6B47E618BFBB9266DC164F9"
+    },
+    {
+      "path": "crates/oa-core/tests/source_identity_updates.rs",
+      "bytes": 5139,
+      "sha256": "F52AA38B4D317E532C641AD7463472E4B40E802E60052CF0017556FFC63DA06C"
+    },
+    {
+      "path": "crates/oa-core/tests/source_nested_updates.rs",
+      "bytes": 16892,
+      "sha256": "9AC3390936C0D250651EA94A1B8FAF0ADFB680F061ECECC56F2A52909B5BA855"
+    },
+    {
+      "path": "crates/oa-core/tests/source_project.rs",
+      "bytes": 45910,
+      "sha256": "CEF58ADB16AA4D2527DDC0628AEC3E26F0B42B4BE70014A7E360FAFDAC13A942"
+    },
+    {
+      "path": "crates/oa-core/tests/state_diagrams.rs",
+      "bytes": 23973,
+      "sha256": "6B02B387A3AE559CB3AD72DE24292A5ABCB76AAAC0ADBAB5D2AA5211B22CD2E5"
+    },
+    {
+      "path": "crates/oa-core/tests/workflows.rs",
+      "bytes": 33426,
+      "sha256": "BD843DFDDBD5724EC08F657571F887496203056FE2FA5864EF50A168A613B89B"
+    },
+    {
+      "path": "docs/language.rst",
+      "bytes": 130753,
+      "sha256": "AC6B1D982C55F246DE2F3C844B24B874599A3C20CFBD7ED22EFE4561AC622B83"
+    },
+    {
+      "path": "examples/coastal-rescue.arcadia",
+      "bytes": 33107,
+      "sha256": "7E183EF9FD8154D3074303F1956CD0D9871C19E3FFC630D333B0BFFBD6E30E17"
+    },
+    {
+      "path": "examples/coastal-rescue.json",
+      "bytes": 49715,
+      "sha256": "242F0B031229A87AF5C4EBE5D651DEFE59C191A6B7A69DC0A77F7E203411F195"
+    },
+    {
+      "path": "examples/legacy-v1-coastal-rescue.arcadia",
+      "bytes": 3449,
+      "sha256": "4DBBBDF8BC7E6CB8E0A81DD678069DAE585A9E5187C59BC3665E1FDAB3F1A86A"
+    },
+    {
+      "path": "examples/legacy-v1-coastal-rescue.oa.json",
+      "bytes": 5976,
+      "sha256": "FD0E9DEDFB7ADB922DC0575CC2B820D40344D639F1D8052BD70363AA59DE9C24"
+    },
+    {
+      "path": "examples/release1/README.md",
+      "bytes": 11137,
+      "sha256": "113CFB1CF38A98B51BFF60442D86A35D636A3D80EF206BECE7D53D0AAE67F2D5"
+    },
+    {
+      "path": "examples/release1/evidence/repair-check.md",
+      "bytes": 1419,
+      "sha256": "F4DB17BDCA4ECBB1BF0CAEF01B2DA5F1F7F798AB3152B648CE6DD8696A6A68E5"
+    },
+    {
+      "path": "examples/release1/expected-diagnostics.json",
+      "bytes": 288,
+      "sha256": "3700393D76B940CFC076BF52861BD7B1F43370F8EABCE3594531BD0BF1FC851E"
+    },
+    {
+      "path": "examples/release1/model.json",
+      "bytes": 134520,
+      "sha256": "EF0EF4006C3E09D5DB6E1B621256B3F7D6642F3A7B09CC34607CFBCCA830C727"
+    },
+    {
+      "path": "examples/release1/model.rs",
+      "bytes": 28762,
+      "sha256": "15F30F6BDE655808FE754665C26D560E36F2A9BAD340F346B09137D0D05045F5"
+    },
+    {
+      "path": "examples/release1/oa/activities/activity_oa_restore_work.arcadia",
+      "bytes": 1307,
+      "sha256": "83E73D0A013D5C3E1A4AF0D9139AB0CFA362D25A846671FC2DAC59181061A9D4"
+    },
+    {
+      "path": "examples/release1/oa/behavior/process_oa_assessment_procedure.arcadia",
+      "bytes": 697,
+      "sha256": "172C32C044EF4B5BC58A1F4635CC81F48DABB4014479B47DCE7B25FEDF2DBD0D"
+    },
+    {
+      "path": "examples/release1/oa/behavior/process_oa_field_procedure.arcadia",
+      "bytes": 1781,
+      "sha256": "D2552DC5383E2E91CB302A790364E197F663C2EDC013A2AB1978789825C9C324"
+    },
+    {
+      "path": "examples/release1/oa/behavior/process_oa_response.arcadia",
+      "bytes": 3225,
+      "sha256": "CF86F46FA5C5D70592EF43F1BC1CB4D968EFD8ADD384BA88036BEF6B88AA4ABC"
+    },
+    {
+      "path": "examples/release1/oa/behavior/scenario_oa_conversation.arcadia",
+      "bytes": 1795,
+      "sha256": "B25BE524E98A35EBAC5E4481B7609C027B32BAF9605E8097F807560F94A77CA6"
+    },
+    {
+      "path": "examples/release1/oa/behavior/scenario_oa_full_scenario.arcadia",
+      "bytes": 1261,
+      "sha256": "00A1EDF2C9707A0EB62AC070C2D02467874F2C9C1F273CC6DDB53D6D65999A1C"
+    },
+    {
+      "path": "examples/release1/oa/behavior/state_machine_oa_monitor.arcadia",
+      "bytes": 2022,
+      "sha256": "447C9AD1359F4A31ECF975AD07C0B08D8E7E03191FB0858E2FC56F377B223CD5"
+    },
+    {
+      "path": "examples/release1/oa/capabilities.arcadia",
+      "bytes": 781,
+      "sha256": "FC8012E5554350B12E1CB80080F8FEAB80D933C9B33C0F2A7BB500CB7D609936"
+    },
+    {
+      "path": "examples/release1/oa/model.arcadia",
+      "bytes": 661,
+      "sha256": "F7CF914766EA73EC53B85E32D117EA9A9DBA52D3E038246863541AE7069B1A15"
+    },
+    {
+      "path": "examples/release1/oa/participants.arcadia",
+      "bytes": 1834,
+      "sha256": "951764C14179F27C10E315ACF2EA37D1FFF54C77B8441E23ADDD239E8C715CE3"
+    },
+    {
+      "path": "examples/release1/oa/types.arcadia",
+      "bytes": 788,
+      "sha256": "9D0396FB82DD5733EDD8D1CF52F968CA84906927C704F9CF0944A7FAE215CF49"
+    },
+    {
+      "path": "examples/release1/project.arcadia",
+      "bytes": 1958,
+      "sha256": "B2674E6BF77CFE0F6F0BA79C81D2E96D92F39C02CA2C6266D80E91723BFB9FDA"
+    },
+    {
+      "path": "examples/release1/sa/behavior/process_sa_assessment_procedure.arcadia",
+      "bytes": 706,
+      "sha256": "73928CED61C06CBC08728D7956676A50FD4C05AA5B7F1FF4F29CE27A0B0F2088"
+    },
+    {
+      "path": "examples/release1/sa/behavior/process_sa_field_procedure.arcadia",
+      "bytes": 1790,
+      "sha256": "886D462AF83110CBFA55DD232A667EA1446761234471357CBB878794E98E8768"
+    },
+    {
+      "path": "examples/release1/sa/behavior/process_sa_response.arcadia",
+      "bytes": 3234,
+      "sha256": "041785FC22842423822431BD5E6E8D16094EBD0716965E7C765FB8C1D7549E8A"
+    },
+    {
+      "path": "examples/release1/sa/behavior/scenario_sa_conversation.arcadia",
+      "bytes": 2127,
+      "sha256": "97276F5757EE9AA12A0DBD9D3CCD58174B3091162BB8BCCE357CEC20A45F5D85"
+    },
+    {
+      "path": "examples/release1/sa/behavior/scenario_sa_full_scenario.arcadia",
+      "bytes": 1256,
+      "sha256": "E12FC406B99D60A2F7768AAA0B25BA560E8605F0B8E37F3A7CDD3B8443562B74"
+    },
+    {
+      "path": "examples/release1/sa/behavior/state_machine_sa_monitor.arcadia",
+      "bytes": 2022,
+      "sha256": "05CE29AF99424C491C47FE2450DC6F5F8CE995511C01EC7E17BB5855BE3C9736"
+    },
+    {
+      "path": "examples/release1/sa/capabilities.arcadia",
+      "bytes": 781,
+      "sha256": "B6912FB3ECE439912345FA71724ACD462E716A1E5A88203A1058A5C3B2C20A4F"
+    },
+    {
+      "path": "examples/release1/sa/functions/function_sa_audit_thresholds.arcadia",
+      "bytes": 297,
+      "sha256": "E5A04325D52183956DCA814DD90F4E56C96C6B7DB0F4F202F203ECB49C3E0F4F"
+    },
+    {
+      "path": "examples/release1/sa/functions/function_sa_restore_work.arcadia",
+      "bytes": 2576,
+      "sha256": "FDDEB67308051325041FEE641FE758DDF43345B7C47B66D433616AD07FDCCDD6"
+    },
+    {
+      "path": "examples/release1/sa/model.arcadia",
+      "bytes": 661,
+      "sha256": "D431509251ACB859FBB98733B6D18ADD952495E10A78703FBE8F31E40BC083C4"
+    },
+    {
+      "path": "examples/release1/sa/participants.arcadia",
+      "bytes": 4012,
+      "sha256": "780D2EB08B217B67B55FEBB3D34846F727B8EE9018DF6C5741748647E36B2FF8"
+    },
+    {
+      "path": "examples/release1/sa/types.arcadia",
+      "bytes": 1227,
+      "sha256": "101FC0FBD99F1101514AA7B6DA4F8E535AAE0BB94C9E2B9E7E6C151135B28660"
+    },
+    {
+      "path": "examples/release1/traceability.arcadia",
+      "bytes": 29506,
+      "sha256": "48A96F543456C9B5A5798FC795594E4119147FE45F11A6F109F141B7F514560F"
+    },
+    {
+      "path": "examples/release1/transition-before.json",
+      "bytes": 35801,
+      "sha256": "2253E6434F741687E22327C37D520ED15C043BC36025498650BC2366BB6A874D"
+    },
+    {
+      "path": "examples/release1/transition-request.json",
+      "bytes": 4276,
+      "sha256": "43B9A22E5F95AD3BC0EBD2478EAD0E14406854ABC989AE94DED9367B013D812A"
+    },
+    {
+      "path": "examples/release1/views/diagram_oa_allocation_view.arcadia",
+      "bytes": 2176,
+      "sha256": "DFC0EB61E0E2AA5BDA45524571FBFA3494F44CE19696F3E15E07438074A07BC7"
+    },
+    {
+      "path": "examples/release1/views/diagram_sa_allocation_view.arcadia",
+      "bytes": 2173,
+      "sha256": "B78B43A26A82EFB8FBD5374B09C329FA341F57B29F635D397B9EF8AEDE71D389"
+    },
+    {
+      "path": "examples/release1/views/diagram_sa_capability_view.arcadia",
+      "bytes": 1620,
+      "sha256": "75E8DC9FB30F25D6F8FD3C6B595593AB4F98958A25798F961E336E0FAC557649"
+    },
+    {
+      "path": "examples/release1/views/diagram_sa_service_view.arcadia",
+      "bytes": 2209,
+      "sha256": "B08C84F3EA633E7C78DFDAD3272F75415F6256CF3614B6D99BFD4F0269076C9B"
+    },
+    {
+      "path": "examples/release1/views/diagram_sa_state_view.arcadia",
+      "bytes": 1931,
+      "sha256": "5F42F4C605E57B817D8400ED21F2B14BFC4E1592AEBE941FF113767504C2B869"
+    },
+    {
+      "path": "examples/routing-workshop.arcadia",
+      "bytes": 66431,
+      "sha256": "DC6B75DA72884D399132ED9E300FA5A26B73D802BB526C9AF986AE9EEB0A646A"
+    },
+    {
+      "path": "examples/routing-workshop.json",
+      "bytes": 100281,
+      "sha256": "8592714F75B271133F21CE017D87896B6CF91EA0E4837F1C2ED453E21BE26B14"
+    },
+    {
+      "path": "examples/source-project/oa.arcadia",
+      "bytes": 2142,
+      "sha256": "5F60642F211B2D352A951092FAEEB7503D4FB7F6F7FCA99E810347231101D31C"
+    },
+    {
+      "path": "examples/source-project/project.arcadia",
+      "bytes": 606,
+      "sha256": "787F6B67B179FFD221F7E5FAF1A4EDD74CFD116AA1E3B5E9ED9F22FBFF612D8D"
+    },
+    {
+      "path": "examples/source-project/sa/assurance.arcadia",
+      "bytes": 682,
+      "sha256": "AB76044836E4DCD42A82D316846EC87DA2108939AA2037640C5BCA1D2ECDEE0F"
+    },
+    {
+      "path": "examples/source-project/sa/participants.arcadia",
+      "bytes": 1231,
+      "sha256": "1ABAD579812E77877B45A3D8E3C3E9DA734BE2D04A0254CC730A5257EBD2DC88"
+    },
+    {
+      "path": "examples/source-project/sa/reporting.arcadia",
+      "bytes": 2839,
+      "sha256": "F0B7443F728912CA163DE39B6055876B533A77FEAA3219B2D40A2DD65712E058"
+    },
+    {
+      "path": "examples/source-project/views.arcadia",
+      "bytes": 3508,
+      "sha256": "E29AD3F406A6A50D2F0AE2CA2A53EE3B0C18222CD4098704A46D4F48B64EA17F"
+    },
+    {
+      "path": "examples/text-first/README.md",
+      "bytes": 1367,
+      "sha256": "4EC8250D5ED556F1D496E8C85137E973E802ECB11DF1A36488411E8CDC5A9F9E"
+    },
+    {
+      "path": "examples/text-first/project.arcadia",
+      "bytes": 480,
+      "sha256": "F441535C623E0CF20E1875EB2CD33B587ED00E078C37AF39CB36D89BB5EDC19A"
+    },
+    {
+      "path": "rust-toolchain.toml",
+      "bytes": 66,
+      "sha256": "A6A0BBD29FFAA8182DC22D1D9149709F1091E47DF40ED96EB8A78A711C66A4CE"
+    }
+  ]
+}
@@ -1,18 +0,0 @@
-# Authoring prerelease evidence
-
-Exact preserved producer, independent reviewer and root native evidence for
-Windows preview `v0.2.0-preview.authoring.20260911`. `hashes.json` records each
-copied artifact's original private path, length and SHA256. Git must retain these
-measured bytes. The executable ZIP and validation notes are release assets.
-
-The preserved Python files are the original host-specific harnesses. Their
-relative paths and source/toolchain prerequisites refer to the recorded original
-`.local` layout; they are not portable standalone tests when run from this archive.
-To reproduce them, restore that layout in a disposable checkout and use fresh
-output directories. They never contain Gitea credentials. The GUI launch script
-only launches the application; native actions were performed using Computer Use.
-
-See the three `harness/release-authoring-prerelease-*-20260911.md` reports for
-methods, initial GUI harness failure, passed checks, source provenance and limits.
-`published-verified.json` records the final release readback; upload records bind
-the exact downloaded assets. Publication does not complete the wider OA/SA goal.
@@ -1,9 +0,0 @@
-{
-  "pid": 10800,
-  "exe": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\authoring-prerelease-gui-20260911-v2\\extracted\\ArcadiaStudio-0.2.0-preview.authoring.20260911-x86_64-pc-windows-gnullvm\\arcadia-studio.exe",
-  "archive_sha256": "664f30b6217689aca1492eb263b3d15777067d732fa890eeb028f435209dadfa",
-  "files": 559,
-  "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\authoring-prerelease-gui-20260911-v2\\extracted\\ArcadiaStudio-0.2.0-preview.authoring.20260911-x86_64-pc-windows-gnullvm;C:\\Windows\\System32;C:\\Windows",
-  "local_appdata": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\authoring-prerelease-gui-20260911-v2\\profile\\local",
-  "appdata": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\authoring-prerelease-gui-20260911-v2\\profile\\roaming"
-}
@@ -1,37 +0,0 @@
-from pathlib import Path
-import hashlib
-import json
-import os
-import subprocess
-import zipfile
-
-root = Path.cwd()
-name = 'ArcadiaStudio-0.2.0-preview.authoring.20260911-x86_64-pc-windows-gnullvm'
-archive = root / '.local/authoring-prerelease-20260911/packages' / (name + '.zip')
-assert hashlib.sha256(archive.read_bytes()).hexdigest() == '664f30b6217689aca1492eb263b3d15777067d732fa890eeb028f435209dadfa'
-trial = root / '.local/authoring-prerelease-gui-20260911-v2'
-trial.mkdir(exist_ok=False)
-extract = trial / 'extracted'
-extract.mkdir()
-with zipfile.ZipFile(archive) as z:
-    names = z.namelist()
-    assert len(names) == len(set(n.casefold() for n in names)) == 559
-    assert all(n.startswith(name + '/') and '..' not in Path(n).parts for n in names)
-    z.extractall(extract)
-package = extract / name
-for line in (package / 'SHA256SUMS.txt').read_text().splitlines():
-    digest, path = line.split('  ', 1)
-    assert hashlib.sha256((package / path).read_bytes()).hexdigest() == digest, path
-for folder in ['profile/local', 'profile/roaming']:
-    (trial / folder).mkdir(parents=True)
-env = os.environ.copy()
-env['LOCALAPPDATA'] = str(trial / 'profile/local')
-env['APPDATA'] = str(trial / 'profile/roaming')
-env['PATH'] = os.pathsep.join([str(package), str(Path(env['SYSTEMROOT']) / 'System32'), env['SYSTEMROOT']])
-exe = package / 'arcadia-studio.exe'
-assert hashlib.sha256(exe.read_bytes()).hexdigest() == 'd4d9c2bd937e301ff1009d7cb93a34ee5aa6dfc837ff7e87d468c85371b20c31'
-with (trial / 'stdout.log').open('wb') as out, (trial / 'stderr.log').open('wb') as err:
-    process = subprocess.Popen([str(exe)], cwd=package, env=env, stdout=out, stderr=err)
-result = {'pid': process.pid, 'exe': str(exe), 'archive_sha256': hashlib.sha256(archive.read_bytes()).hexdigest(), 'files': len(names), 'path': env['PATH'], 'local_appdata': env['LOCALAPPDATA'], 'appdata': env['APPDATA']}
-(trial / 'launch.json').write_text(json.dumps(result, indent=2), encoding='utf-8')
-print(json.dumps(result, indent=2))
@@ -1,64 +0,0 @@
-[
-  "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\authoring-prerelease-gui-20260911-v2\\extracted\\ArcadiaStudio-0.2.0-preview.authoring.20260911-x86_64-pc-windows-gnullvm\\arcadia-studio.exe",
-  "C:\\Windows\\SYSTEM32\\ntdll.dll",
-  "C:\\Windows\\System32\\KERNEL32.DLL",
-  "C:\\Windows\\System32\\KERNELBASE.dll",
-  "C:\\Windows\\SYSTEM32\\apphelp.dll",
-  "C:\\Windows\\System32\\user32.dll",
-  "C:\\Windows\\System32\\win32u.dll",
-  "C:\\Windows\\System32\\GDI32.dll",
-  "C:\\Windows\\System32\\gdi32full.dll",
-  "C:\\Windows\\System32\\msvcp_win.dll",
-  "C:\\Windows\\System32\\ucrtbase.dll",
-  "C:\\Windows\\System32\\ole32.dll",
-  "C:\\Windows\\System32\\combase.dll",
-  "C:\\Windows\\System32\\RPCRT4.dll",
-  "C:\\Windows\\System32\\advapi32.dll",
-  "C:\\Windows\\System32\\msvcrt.dll",
-  "C:\\Windows\\System32\\sechost.dll",
-  "C:\\Windows\\System32\\bcryptprimitives.dll",
-  "C:\\Windows\\System32\\shell32.dll",
-  "C:\\Windows\\System32\\imm32.dll",
-  "C:\\Windows\\System32\\ws2_32.dll",
-  "C:\\Windows\\System32\\oleaut32.dll",
-  "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\authoring-prerelease-gui-20260911-v2\\extracted\\ArcadiaStudio-0.2.0-preview.authoring.20260911-x86_64-pc-windows-gnullvm\\libunwind.dll",
-  "C:\\Windows\\SYSTEM32\\bcrypt.dll",
-  "C:\\Windows\\SYSTEM32\\dwmapi.dll",
-  "C:\\Windows\\SYSTEM32\\uxtheme.dll",
-  "C:\\Windows\\SYSTEM32\\opengl32.dll",
-  "C:\\Windows\\SYSTEM32\\GLU32.dll",
-  "C:\\Windows\\SYSTEM32\\CRYPTBASE.DLL",
-  "C:\\Windows\\SYSTEM32\\dxcore.dll",
-  "C:\\Windows\\System32\\MSCTF.dll",
-  "C:\\Windows\\SYSTEM32\\kernel.appcore.dll",
-  "C:\\Windows\\System32\\clbcatq.dll",
-  "C:\\Windows\\system32\\dataexchange.dll",
-  "C:\\Windows\\system32\\twinapi.appcore.dll",
-  "C:\\Windows\\system32\\explorerframe.dll",
-  "C:\\Windows\\System32\\SHCORE.dll",
-  "C:\\Windows\\System32\\SHLWAPI.dll",
-  "C:\\Windows\\System32\\Windows.Storage.dll",
-  "C:\\Windows\\SYSTEM32\\powrprof.dll",
-  "C:\\Windows\\SYSTEM32\\UMPDC.dll",
-  "C:\\Windows\\SYSTEM32\\CFGMGR32.dll",
-  "C:\\Windows\\system32\\dxgi.dll",
-  "C:\\Windows\\SYSTEM32\\windows.staterepositorycore.dll",
-  "C:\\Windows\\SYSTEM32\\directxdatabasehelper.dll",
-  "C:\\Windows\\SYSTEM32\\d3d12.dll",
-  "C:\\Windows\\SYSTEM32\\d3dcompiler_47.dll",
-  "C:\\Windows\\SYSTEM32\\cryptsp.dll",
-  "C:\\Windows\\System32\\DriverStore\\FileRepository\\vm3d.inf_amd64_39d3dfd189710365\\vm3dgl64.dll",
-  "C:\\Windows\\System32\\DriverStore\\FileRepository\\vm3d.inf_amd64_39d3dfd189710365\\vm3dglhelper64.dll",
-  "C:\\Windows\\SYSTEM32\\WINMM.dll",
-  "C:\\Windows\\SYSTEM32\\D3D12Core.dll",
-  "C:\\Windows\\SYSTEM32\\d3d10warp.dll",
-  "C:\\Windows\\SYSTEM32\\D3DSCache.dll",
-  "C:\\Windows\\SYSTEM32\\USERENV.dll",
-  "C:\\Windows\\SYSTEM32\\dxilconv.dll",
-  "C:\\Windows\\SYSTEM32\\dcomp.dll",
-  "C:\\Windows\\SYSTEM32\\Microsoft.Internal.WarpPal.dll",
-  "C:\\Windows\\SYSTEM32\\textinputframework.dll",
-  "C:\\Windows\\SYSTEM32\\uiautomationcore.dll",
-  "C:\\Windows\\SYSTEM32\\OLEACC.dll",
-  "C:\\Windows\\System32\\threadpoolwinrt.dll"
-]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
sorokin.oleg.edu	fad1f5f33b	Sync agent instructions from main	2026-09-13 11:38:37 +03:00
sorokin.oleg.edu	9d7e311320	Sync agent instructions from main	2026-09-12 13:43:14 +03:00
sorokin.oleg.edu	9cc8194d7b	Sync agent instructions from main	2026-09-12 13:39:57 +03:00
sorokin.oleg.edu	3ee5aa6809	Sync agent instructions from main	2026-09-12 13:15:27 +03:00
sorokin.oleg.edu	ca19ad277a	Merge commit '113fb8b7a98c6a63bf67e77ebe5974555d033c62' into codex/behavior-canvas-20260911	2026-09-11 11:14:23 -07:00
sorokin.oleg.edu	fb1da912c9	Implement reviewed shared behavior canvas controls and focus	2026-09-11 10:34:29 -07:00
sorokin.oleg.edu	113fb8b7a9	Sync agent instructions from main	2026-09-11 19:51:38 +03:00
Codex	e511c4153f	WIP checkpoint shared behavior canvas before user reboot	2026-09-11 06:44:13 -07:00
sorokin.oleg.edu	c0e66f94e3	Stage explicit prerequisite sources inside behavior creation forms	2026-09-11 06:26:16 -07:00
Codex	7f081ad457	Integrate scoped reference chooser and scenario form focus and reveal	2026-09-11 06:24:20 -07:00
Codex	c7ed894900	Merge shared instruction checkpoint preserving exact authoritative goal	2026-09-11 06:14:11 -07:00
Codex	98427b9620	Adopt shared Gitea and harness maintenance instructions	2026-09-11 06:14:05 -07:00
sorokin.oleg.edu	cab01c3d7f	Sync agent instructions from main	2026-09-11 15:55:34 +03:00
Codex	7d14bd0dd1	Add exact analysis numbers units and bounded request work	2026-09-11 05:50:45 -07:00
Codex	dc0f2e12f3	Import corrected creation oracle and record exact SA action history	2026-09-11 05:41:06 -07:00
sorokin.oleg.edu	bc311bc076	Add source-first CLI with guarded writes and reviewed evidence	2026-09-11 05:27:16 -07:00
Codex	a34558d3be	Record OA native history and ratified analysis library decisions	2026-09-11 05:21:37 -07:00
Codex	2cc4d115d0	Specify baseline analysis and verified library contract compatibility	2026-09-11 04:48:44 -07:00
sorokin.oleg.edu	1516949567	Add named behavior creation and verified textual authoring examples	2026-09-11 04:26:56 -07:00
Codex	c4e1580bb0	Exercise bounded reference chooser with mounted input tests	2026-09-11 02:29:15 -07:00
Codex	c6d296a7e2	Preserve native authoring evidence and compared semantic contracts	2026-09-11 02:04:38 -07:00
Codex	80cf197be6	Remeasure scenario Fit viewport after owner or document changes	2026-09-11 01:27:48 -07:00
sorokin.oleg.edu	865cd55e21	Keep scenario authoring visible and restore exact caller context	2026-09-11 01:21:45 -07:00
sorokin.oleg.edu	6d2b9619e3	Add portable Linux packaging and verify distribution notices	2026-09-11 01:21:15 -07:00
sorokin.oleg.edu	65a1fef17c	Restore inline naming focus after recovery	2026-09-10 12:12:16 -07:00
Codex	ef1a4478c5	Validate scenario oracle and record first local behavior test results	2026-09-10 12:10:59 -07:00
Codex	632c8feb36	Consolidate active release ledgers and preserve exact historical evidence	2026-09-10 12:02:47 -07:00
Codex	aa40345281	Record semantic release gaps and remove unused palette import	2026-09-10 11:57:29 -07:00
Codex	8547b85825	Record revised release requirements and native scenario oracle	2026-09-10 11:44:35 -07:00
Codex	4ecad78433	Seed optional history values from explicit constructors	2026-09-10 11:38:44 -07:00
Codex	eb5161b207	Prepare scoped lifecycle projection and align authoring guide	2026-09-10 11:24:18 -07:00
sorokin.oleg.edu	aed40d7464	Fix inline architecture naming and captured Escape cancellation	2026-09-10 11:14:20 -07:00